rpc

type AccountGetQuotaRequest struct {
	// GitHub token for per-user quota lookup. When provided, resolves this token to determine
	// the user's quota instead of using the global auth.
	GitHubToken *string `json:"gitHubToken,omitempty"`
}

type AccountGetQuotaResult struct {
	// Quota snapshots keyed by type (e.g., chat, completions, premium_interactions)
	QuotaSnapshots map[string]AccountQuotaSnapshot `json:"quotaSnapshots"`
}

type AccountQuotaSnapshot struct {
	// Number of requests included in the entitlement
	EntitlementRequests int64 `json:"entitlementRequests"`
	// Whether the user has an unlimited usage entitlement
	IsUnlimitedEntitlement bool `json:"isUnlimitedEntitlement"`
	// Number of overage requests made this period
	Overage float64 `json:"overage"`
	// Whether overage is allowed when quota is exhausted
	OverageAllowedWithExhaustedQuota bool `json:"overageAllowedWithExhaustedQuota"`
	// Percentage of entitlement remaining
	RemainingPercentage float64 `json:"remainingPercentage"`
	// Date when the quota resets (ISO 8601 string)
	ResetDate *string `json:"resetDate,omitempty"`
	// Whether usage is still permitted after quota exhaustion
	UsageAllowedWithExhaustedQuota bool `json:"usageAllowedWithExhaustedQuota"`
	// Number of requests used so far this period
	UsedRequests int64 `json:"usedRequests"`
}

type AgentApi sessionApi

type AgentDeselectResult struct {
}

type AgentGetCurrentResult struct {
	// Currently selected custom agent, or null if using the default agent
	Agent *AgentInfo `json:"agent,omitempty"`
}

type AgentInfo struct {
	// Description of the agent's purpose
	Description string `json:"description"`
	// Human-readable display name
	DisplayName string `json:"displayName"`
	// Unique identifier of the custom agent
	Name string `json:"name"`
	// Absolute local file path of the agent definition. Only set for file-based agents loaded
	// from disk; remote agents do not have a path.
	Path *string `json:"path,omitempty"`
}

type AgentList struct {
	// Available custom agents
	Agents []AgentInfo `json:"agents"`
}

type AgentReloadResult struct {
	// Reloaded custom agents
	Agents []AgentInfo `json:"agents"`
}

type AgentSelectRequest struct {
	// Name of the custom agent to select
	Name string `json:"name"`
}

type AgentSelectResult struct {
	// The newly selected custom agent
	Agent AgentInfo `json:"agent"`
}

type AuthApi sessionApi

type AuthInfoType string

type ClientSessionApiHandlers struct {
	SessionFs SessionFsHandler
}

type CommandsApi sessionApi

type CommandsHandlePendingCommandRequest struct {
	// Error message if the command handler failed
	Error *string `json:"error,omitempty"`
	// Request ID from the command invocation event
	RequestID string `json:"requestId"`
}

type CommandsHandlePendingCommandResult struct {
	// Whether the command was handled successfully
	Success bool `json:"success"`
}

type CommandsRespondToQueuedCommandRequest struct {
	// Request ID from the queued command event
	RequestID string `json:"requestId"`
	// Result of the queued command execution
	Result QueuedCommandResult `json:"result"`
}

type CommandsRespondToQueuedCommandResult struct {
	// Whether the response was accepted (false if the requestId was not found or already
	// resolved)
	Success bool `json:"success"`
}

type ConnectRequest struct {
	// Connection token; required when the server was started with COPILOT_CONNECTION_TOKEN
	Token *string `json:"token,omitempty"`
}

type ConnectResult struct {
	// Always true on success
	Ok bool `json:"ok"`
	// Server protocol version number
	ProtocolVersion int64 `json:"protocolVersion"`
	// Server package version
	Version string `json:"version"`
}

type CurrentModel struct {
	// Currently active model identifier
	ModelID *string `json:"modelId,omitempty"`
}

type DiscoveredMcpServer struct {
	// Whether the server is enabled (not in the disabled list)
	Enabled bool `json:"enabled"`
	// Server name (config key)
	Name string `json:"name"`
	// Configuration source
	Source DiscoveredMcpServerSource `json:"source"`
	// Server transport type: stdio, http, sse, or memory (local configs are normalized to stdio)
	Type *DiscoveredMcpServerType `json:"type,omitempty"`
}

type DiscoveredMcpServerSource string

type DiscoveredMcpServerType string

type EmbeddedBlobResourceContents struct {
	// Base64-encoded binary content of the resource
	Blob string `json:"blob"`
	// MIME type of the blob content
	MIMEType *string `json:"mimeType,omitempty"`
	// URI identifying the resource
	URI string `json:"uri"`
}

type EmbeddedTextResourceContents struct {
	// MIME type of the text content
	MIMEType *string `json:"mimeType,omitempty"`
	// Text content of the resource
	Text string `json:"text"`
	// URI identifying the resource
	URI string `json:"uri"`
}

type Extension struct {
	// Source-qualified ID (e.g., 'project:my-ext', 'user:auth-helper')
	ID string `json:"id"`
	// Extension name (directory name)
	Name string `json:"name"`
	// Process ID if the extension is running
	Pid *int64 `json:"pid,omitempty"`
	// Discovery source: project (.github/extensions/) or user (~/.copilot/extensions/)
	Source ExtensionSource `json:"source"`
	// Current status: running, disabled, failed, or starting
	Status ExtensionStatus `json:"status"`
}

type ExtensionList struct {
	// Discovered extensions and their current status
	Extensions []Extension `json:"extensions"`
}

type ExtensionSource string

type ExtensionStatus string

type ExtensionsApi sessionApi

type ExtensionsDisableRequest struct {
	// Source-qualified extension ID to disable
	ID string `json:"id"`
}

type ExtensionsDisableResult struct {
}

type ExtensionsEnableRequest struct {
	// Source-qualified extension ID to enable
	ID string `json:"id"`
}

type ExtensionsEnableResult struct {
}

type ExtensionsReloadResult struct {
}

type ExternalToolResult interface {
	// contains filtered or unexported methods
}

type ExternalToolStringResult string

type ExternalToolTextResultForLlm struct {
	// Structured content blocks from the tool
	Contents []ExternalToolTextResultForLlmContent `json:"contents,omitempty"`
	// Optional error message for failed executions
	Error *string `json:"error,omitempty"`
	// Execution outcome classification. Optional for back-compat; normalized to 'success' (or
	// 'failure' when error is present) when missing or unrecognized.
	ResultType *string `json:"resultType,omitempty"`
	// Detailed log content for timeline display
	SessionLog *string `json:"sessionLog,omitempty"`
	// Text result returned to the model
	TextResultForLlm string `json:"textResultForLlm"`
	// Optional tool-specific telemetry
	ToolTelemetry map[string]any `json:"toolTelemetry,omitempty"`
}

type ExternalToolTextResultForLlmContent interface {
	Type() ExternalToolTextResultForLlmContentType
	// contains filtered or unexported methods
}

type ExternalToolTextResultForLlmContentAudio struct {
	// Base64-encoded audio data
	Data string `json:"data"`
	// MIME type of the audio (e.g., audio/wav, audio/mpeg)
	MIMEType string `json:"mimeType"`
}

type ExternalToolTextResultForLlmContentImage struct {
	// Base64-encoded image data
	Data string `json:"data"`
	// MIME type of the image (e.g., image/png, image/jpeg)
	MIMEType string `json:"mimeType"`
}

type ExternalToolTextResultForLlmContentResource struct {
	// The embedded resource contents, either text or base64-encoded binary
	Resource ExternalToolTextResultForLlmContentResourceDetails `json:"resource"`
}

type ExternalToolTextResultForLlmContentResourceDetails interface {
	// contains filtered or unexported methods
}

type ExternalToolTextResultForLlmContentResourceLink struct {
	// Human-readable description of the resource
	Description *string `json:"description,omitempty"`
	// Icons associated with this resource
	Icons []ExternalToolTextResultForLlmContentResourceLinkIcon `json:"icons,omitempty"`
	// MIME type of the resource content
	MIMEType *string `json:"mimeType,omitempty"`
	// Resource name identifier
	Name string `json:"name"`
	// Size of the resource in bytes
	Size *float64 `json:"size,omitempty"`
	// Human-readable display title for the resource
	Title *string `json:"title,omitempty"`
	// URI identifying the resource
	URI string `json:"uri"`
}

type ExternalToolTextResultForLlmContentResourceLinkIcon struct {
	// MIME type of the icon image
	MIMEType *string `json:"mimeType,omitempty"`
	// Available icon sizes (e.g., ['16x16', '32x32'])
	Sizes []string `json:"sizes,omitempty"`
	// URL or path to the icon image
	Src string `json:"src"`
	// Theme variant this icon is intended for
	Theme *ExternalToolTextResultForLlmContentResourceLinkIconTheme `json:"theme,omitempty"`
}

type ExternalToolTextResultForLlmContentResourceLinkIconTheme string

type ExternalToolTextResultForLlmContentTerminal struct {
	// Working directory where the command was executed
	Cwd *string `json:"cwd,omitempty"`
	// Process exit code, if the command has completed
	ExitCode *float64 `json:"exitCode,omitempty"`
	// Terminal/shell output text
	Text string `json:"text"`
}

type ExternalToolTextResultForLlmContentText struct {
	// The text content
	Text string `json:"text"`
}

type ExternalToolTextResultForLlmContentType string

type FilterMapping interface {
	// contains filtered or unexported methods
}

type FilterMappingEnumMap map[string]FilterMappingValue

type FilterMappingString string

type FilterMappingValue string

type FleetApi sessionApi

type FleetStartRequest struct {
	// Optional user prompt to combine with fleet instructions
	Prompt *string `json:"prompt,omitempty"`
}

type FleetStartResult struct {
	// Whether fleet mode was successfully activated
	Started bool `json:"started"`
}

type HandlePendingToolCallRequest struct {
	// Error message if the tool call failed
	Error *string `json:"error,omitempty"`
	// Request ID of the pending tool call
	RequestID string `json:"requestId"`
	// Tool call result (string or expanded result object)
	Result ExternalToolResult `json:"result,omitempty"`
}

type HandlePendingToolCallResult struct {
	// Whether the tool call result was handled successfully
	Success bool `json:"success"`
}

type HistoryApi sessionApi

type HistoryCompactContextWindow struct {
	// Token count from non-system messages (user, assistant, tool)
	ConversationTokens *int64 `json:"conversationTokens,omitempty"`
	// Current total tokens in the context window (system + conversation + tool definitions)
	CurrentTokens int64 `json:"currentTokens"`
	// Current number of messages in the conversation
	MessagesLength int64 `json:"messagesLength"`
	// Token count from system message(s)
	SystemTokens *int64 `json:"systemTokens,omitempty"`
	// Maximum token count for the model's context window
	TokenLimit int64 `json:"tokenLimit"`
	// Token count from tool definitions
	ToolDefinitionsTokens *int64 `json:"toolDefinitionsTokens,omitempty"`
}

type HistoryCompactResult struct {
	// Post-compaction context window usage breakdown
	ContextWindow *HistoryCompactContextWindow `json:"contextWindow,omitempty"`
	// Number of messages removed during compaction
	MessagesRemoved int64 `json:"messagesRemoved"`
	// Whether compaction completed successfully
	Success bool `json:"success"`
	// Number of tokens freed by compaction
	TokensRemoved int64 `json:"tokensRemoved"`
}

type HistoryTruncateRequest struct {
	// Event ID to truncate to. This event and all events after it are removed from the session.
	EventID string `json:"eventId"`
}

type HistoryTruncateResult struct {
	// Number of events that were removed
	EventsRemoved int64 `json:"eventsRemoved"`
}

type InstructionsApi sessionApi

type InstructionsGetSourcesResult struct {
	// Instruction sources for the session
	Sources []InstructionsSources `json:"sources"`
}

type InstructionsSources struct {
	// Glob pattern from frontmatter — when set, this instruction applies only to matching files
	ApplyTo *string `json:"applyTo,omitempty"`
	// Raw content of the instruction file
	Content string `json:"content"`
	// Short description (body after frontmatter) for use in instruction tables
	Description *string `json:"description,omitempty"`
	// Unique identifier for this source (used for toggling)
	ID string `json:"id"`
	// Human-readable label
	Label string `json:"label"`
	// Where this source lives — used for UI grouping
	Location InstructionsSourcesLocation `json:"location"`
	// File path relative to repo or absolute for home
	SourcePath string `json:"sourcePath"`
	// Category of instruction source — used for merge logic
	Type InstructionsSourcesType `json:"type"`
}

type InstructionsSourcesLocation string

type InstructionsSourcesType string

type InternalServerRpc struct {
	// contains filtered or unexported fields
}

type LogRequest struct {
	// When true, the message is transient and not persisted to the session event log on disk
	Ephemeral *bool `json:"ephemeral,omitempty"`
	// Log severity level. Determines how the message is displayed in the timeline. Defaults to
	// "info".
	Level *SessionLogLevel `json:"level,omitempty"`
	// Human-readable message
	Message string `json:"message"`
	// Optional URL the user can open in their browser for more details
	URL *string `json:"url,omitempty"`
}

type LogResult struct {
	// The unique identifier of the emitted session event
	EventID string `json:"eventId"`
}

type McpApi sessionApi

type McpConfigAddRequest struct {
	// MCP server configuration (local/stdio or remote/http)
	Config McpServerConfig `json:"config"`
	// Unique name for the MCP server
	Name string `json:"name"`
}

type McpConfigAddResult struct {
}

type McpConfigDisableRequest struct {
	// Names of MCP servers to disable. Each server is added to the persisted disabled list so
	// new sessions skip it. Already-disabled names are ignored. Active sessions keep their
	// current connections until they end.
	Names []string `json:"names"`
}

type McpConfigDisableResult struct {
}

type McpConfigEnableRequest struct {
	// Names of MCP servers to enable. Each server is removed from the persisted disabled list
	// so new sessions spawn it. Unknown or already-enabled names are ignored.
	Names []string `json:"names"`
}

type McpConfigEnableResult struct {
}

type McpConfigList struct {
	// All MCP servers from user config, keyed by name
	Servers map[string]McpServerConfig `json:"servers"`
}

type McpConfigRemoveRequest struct {
	// Name of the MCP server to remove
	Name string `json:"name"`
}

type McpConfigRemoveResult struct {
}

type McpConfigUpdateRequest struct {
	// MCP server configuration (local/stdio or remote/http)
	Config McpServerConfig `json:"config"`
	// Name of the MCP server to update
	Name string `json:"name"`
}

type McpConfigUpdateResult struct {
}

type McpDisableRequest struct {
	// Name of the MCP server to disable
	ServerName string `json:"serverName"`
}

type McpDisableResult struct {
}

type McpDiscoverRequest struct {
	// Working directory used as context for discovery (e.g., plugin resolution)
	WorkingDirectory *string `json:"workingDirectory,omitempty"`
}

type McpDiscoverResult struct {
	// MCP servers discovered from all sources
	Servers []DiscoveredMcpServer `json:"servers"`
}

type McpEnableRequest struct {
	// Name of the MCP server to enable
	ServerName string `json:"serverName"`
}

type McpEnableResult struct {
}

type McpOauthApi sessionApi

type McpOauthLoginRequest struct {
	// Optional override for the body text shown on the OAuth loopback callback success page.
	// When omitted, the runtime applies a neutral fallback; callers driving interactive auth
	// should pass surface-specific copy telling the user where to return.
	CallbackSuccessMessage *string `json:"callbackSuccessMessage,omitempty"`
	// Optional override for the OAuth client display name shown on the consent screen. Applies
	// to newly registered dynamic clients only — existing registrations keep the name they were
	// created with. When omitted, the runtime applies a neutral fallback; callers driving
	// interactive auth should pass their own surface-specific label so the consent screen
	// matches the product the user sees.
	ClientName *string `json:"clientName,omitempty"`
	// When true, clears any cached OAuth token for the server and runs a full new
	// authorization. Use when the user explicitly wants to switch accounts or believes their
	// session is stuck.
	ForceReauth *bool `json:"forceReauth,omitempty"`
	// Name of the remote MCP server to authenticate
	ServerName string `json:"serverName"`
}

type McpOauthLoginResult struct {
	// URL the caller should open in a browser to complete OAuth. Omitted when cached tokens
	// were still valid and no browser interaction was needed — the server is already
	// reconnected in that case. When present, the runtime starts the callback listener before
	// returning and continues the flow in the background; completion is signaled via
	// session.mcp_server_status_changed.
	AuthorizationURL *string `json:"authorizationUrl,omitempty"`
}

type McpReloadResult struct {
}

type McpServer struct {
	// Error message if the server failed to connect
	Error *string `json:"error,omitempty"`
	// Server name (config key)
	Name string `json:"name"`
	// Configuration source: user, workspace, plugin, or builtin
	Source *McpServerSource `json:"source,omitempty"`
	// Connection status: connected, failed, needs-auth, pending, disabled, or not_configured
	Status McpServerStatus `json:"status"`
}

type McpServerConfig interface {
	// contains filtered or unexported methods
}

type McpServerConfigHTTP struct {
	FilterMapping     FilterMapping                      `json:"filterMapping,omitempty"`
	Headers           map[string]string                  `json:"headers,omitempty"`
	IsDefaultServer   *bool                              `json:"isDefaultServer,omitempty"`
	OauthClientID     *string                            `json:"oauthClientId,omitempty"`
	OauthGrantType    *McpServerConfigHTTPOauthGrantType `json:"oauthGrantType,omitempty"`
	OauthPublicClient *bool                              `json:"oauthPublicClient,omitempty"`
	// Timeout in milliseconds for tool calls to this server.
	Timeout *int64 `json:"timeout,omitempty"`
	// Tools to include. Defaults to all tools if not specified.
	Tools []string `json:"tools,omitempty"`
	// Remote transport type. Defaults to "http" when omitted.
	Type *McpServerConfigHTTPType `json:"type,omitempty"`
	URL  string                   `json:"url"`
}

type McpServerConfigHTTPOauthGrantType string

type McpServerConfigHTTPType string

type McpServerConfigLocal struct {
	Args            []string          `json:"args"`
	Command         string            `json:"command"`
	Cwd             *string           `json:"cwd,omitempty"`
	Env             map[string]string `json:"env,omitempty"`
	FilterMapping   FilterMapping     `json:"filterMapping,omitempty"`
	IsDefaultServer *bool             `json:"isDefaultServer,omitempty"`
	// Timeout in milliseconds for tool calls to this server.
	Timeout *int64 `json:"timeout,omitempty"`
	// Tools to include. Defaults to all tools if not specified.
	Tools []string                  `json:"tools,omitempty"`
	Type  *McpServerConfigLocalType `json:"type,omitempty"`
}

type McpServerConfigLocalType string

type McpServerList struct {
	// Configured MCP servers
	Servers []McpServer `json:"servers"`
}

type McpServerSource string

type McpServerStatus string

type ModeApi sessionApi

type ModeSetRequest struct {
	// The agent mode. Valid values: "interactive", "plan", "autopilot".
	Mode SessionMode `json:"mode"`
}

type ModeSetResult struct {
}

type Model struct {
	// Billing information
	Billing *ModelBilling `json:"billing,omitempty"`
	// Model capabilities and limits
	Capabilities ModelCapabilities `json:"capabilities"`
	// Default reasoning effort level (only present if model supports reasoning effort)
	DefaultReasoningEffort *string `json:"defaultReasoningEffort,omitempty"`
	// Model identifier (e.g., "claude-sonnet-4.5")
	ID string `json:"id"`
	// Model capability category for grouping in the model picker
	ModelPickerCategory *ModelPickerCategory `json:"modelPickerCategory,omitempty"`
	// Relative cost tier for token-based billing users
	ModelPickerPriceCategory *ModelPickerPriceCategory `json:"modelPickerPriceCategory,omitempty"`
	// Display name
	Name string `json:"name"`
	// Policy state (if applicable)
	Policy *ModelPolicy `json:"policy,omitempty"`
	// Supported reasoning effort levels (only present if model supports reasoning effort)
	SupportedReasoningEfforts []string `json:"supportedReasoningEfforts,omitempty"`
}

type ModelApi sessionApi

type ModelBilling struct {
	// Billing cost multiplier relative to the base rate
	Multiplier *float64 `json:"multiplier,omitempty"`
}

type ModelCapabilities struct {
	// Token limits for prompts, outputs, and context window
	Limits *ModelCapabilitiesLimits `json:"limits,omitempty"`
	// Feature flags indicating what the model supports
	Supports *ModelCapabilitiesSupports `json:"supports,omitempty"`
}

type ModelCapabilitiesLimits struct {
	// Maximum total context window size in tokens
	MaxContextWindowTokens *int64 `json:"max_context_window_tokens,omitempty"`
	// Maximum number of output/completion tokens
	MaxOutputTokens *int64 `json:"max_output_tokens,omitempty"`
	// Maximum number of prompt/input tokens
	MaxPromptTokens *int64 `json:"max_prompt_tokens,omitempty"`
	// Vision-specific limits
	Vision *ModelCapabilitiesLimitsVision `json:"vision,omitempty"`
}

type ModelCapabilitiesLimitsVision struct {
	// Maximum number of images per prompt
	MaxPromptImages int64 `json:"max_prompt_images"`
	// Maximum image size in bytes
	MaxPromptImageSize int64 `json:"max_prompt_image_size"`
	// MIME types the model accepts
	SupportedMediaTypes []string `json:"supported_media_types"`
}

type ModelCapabilitiesOverride struct {
	// Token limits for prompts, outputs, and context window
	Limits *ModelCapabilitiesOverrideLimits `json:"limits,omitempty"`
	// Feature flags indicating what the model supports
	Supports *ModelCapabilitiesOverrideSupports `json:"supports,omitempty"`
}

type ModelCapabilitiesOverrideLimits struct {
	// Maximum total context window size in tokens
	MaxContextWindowTokens *int64                                 `json:"max_context_window_tokens,omitempty"`
	MaxOutputTokens        *int64                                 `json:"max_output_tokens,omitempty"`
	MaxPromptTokens        *int64                                 `json:"max_prompt_tokens,omitempty"`
	Vision                 *ModelCapabilitiesOverrideLimitsVision `json:"vision,omitempty"`
}

type ModelCapabilitiesOverrideLimitsVision struct {
	// Maximum number of images per prompt
	MaxPromptImages *int64 `json:"max_prompt_images,omitempty"`
	// Maximum image size in bytes
	MaxPromptImageSize *int64 `json:"max_prompt_image_size,omitempty"`
	// MIME types the model accepts
	SupportedMediaTypes []string `json:"supported_media_types,omitempty"`
}

type ModelCapabilitiesOverrideSupports struct {
	ReasoningEffort *bool `json:"reasoningEffort,omitempty"`
	Vision          *bool `json:"vision,omitempty"`
}

type ModelCapabilitiesSupports struct {
	// Whether this model supports reasoning effort configuration
	ReasoningEffort *bool `json:"reasoningEffort,omitempty"`
	// Whether this model supports vision/image input
	Vision *bool `json:"vision,omitempty"`
}

type ModelList struct {
	// List of available models with full metadata
	Models []Model `json:"models"`
}

type ModelPickerCategory string

type ModelPickerPriceCategory string

type ModelPolicy struct {
	// Current policy state for this model
	State string `json:"state"`
	// Usage terms or conditions for this model
	Terms *string `json:"terms,omitempty"`
}

type ModelSwitchToRequest struct {
	// Override individual model capabilities resolved by the runtime
	ModelCapabilities *ModelCapabilitiesOverride `json:"modelCapabilities,omitempty"`
	// Model identifier to switch to
	ModelID string `json:"modelId"`
	// Reasoning effort level to use for the model
	ReasoningEffort *string `json:"reasoningEffort,omitempty"`
}

type ModelSwitchToResult struct {
	// Currently active model identifier after the switch
	ModelID *string `json:"modelId,omitempty"`
}

type ModelsListRequest struct {
	// GitHub token for per-user model listing. When provided, resolves this token to determine
	// the user's Copilot plan and available models instead of using the global auth.
	GitHubToken *string `json:"gitHubToken,omitempty"`
}

type NameApi sessionApi

type NameGetResult struct {
	// The session name (user-set or auto-generated), or null if not yet set
	Name *string `json:"name"`
}

type NameSetRequest struct {
	// New session name (1–100 characters, trimmed of leading/trailing whitespace)
	Name string `json:"name"`
}

type NameSetResult struct {
}

type PermissionDecision interface {
	Kind() PermissionDecisionKind
	// contains filtered or unexported methods
}

type PermissionDecisionApproveForLocation struct {
	// The approval to persist for this location
	Approval PermissionDecisionApproveForLocationApproval `json:"approval"`
	// The location key (git root or cwd) to persist the approval to
	LocationKey string `json:"locationKey"`
}

type PermissionDecisionApproveForLocationApproval interface {
	Kind() PermissionDecisionApproveForLocationApprovalKind
	// contains filtered or unexported methods
}

type PermissionDecisionApproveForLocationApprovalCommands struct {
	CommandIdentifiers []string `json:"commandIdentifiers"`
}

type PermissionDecisionApproveForLocationApprovalCustomTool struct {
	ToolName string `json:"toolName"`
}

type PermissionDecisionApproveForLocationApprovalExtensionManagement struct {
	Operation *string `json:"operation,omitempty"`
}

type PermissionDecisionApproveForLocationApprovalExtensionPermissionAccess struct {
	ExtensionName string `json:"extensionName"`
}

type PermissionDecisionApproveForLocationApprovalKind string

type PermissionDecisionApproveForLocationApprovalMcp struct {
	ServerName string  `json:"serverName"`
	ToolName   *string `json:"toolName"`
}

type PermissionDecisionApproveForLocationApprovalMcpSampling struct {
	ServerName string `json:"serverName"`
}

type PermissionDecisionApproveForLocationApprovalMemory struct {
}

type PermissionDecisionApproveForLocationApprovalRead struct {
}

type PermissionDecisionApproveForLocationApprovalWrite struct {
}

type PermissionDecisionApproveForSession struct {
	// The approval to add as a session-scoped rule
	Approval PermissionDecisionApproveForSessionApproval `json:"approval,omitempty"`
	// The URL domain to approve for this session
	Domain *string `json:"domain,omitempty"`
}

type PermissionDecisionApproveForSessionApproval interface {
	Kind() PermissionDecisionApproveForSessionApprovalKind
	// contains filtered or unexported methods
}

type PermissionDecisionApproveForSessionApprovalCommands struct {
	CommandIdentifiers []string `json:"commandIdentifiers"`
}

type PermissionDecisionApproveForSessionApprovalCustomTool struct {
	ToolName string `json:"toolName"`
}

type PermissionDecisionApproveForSessionApprovalExtensionManagement struct {
	Operation *string `json:"operation,omitempty"`
}

type PermissionDecisionApproveForSessionApprovalExtensionPermissionAccess struct {
	ExtensionName string `json:"extensionName"`
}

type PermissionDecisionApproveForSessionApprovalKind string

type PermissionDecisionApproveForSessionApprovalMcp struct {
	ServerName string  `json:"serverName"`
	ToolName   *string `json:"toolName"`
}

type PermissionDecisionApproveForSessionApprovalMcpSampling struct {
	ServerName string `json:"serverName"`
}

type PermissionDecisionApproveForSessionApprovalMemory struct {
}

type PermissionDecisionApproveForSessionApprovalRead struct {
}

type PermissionDecisionApproveForSessionApprovalWrite struct {
}

type PermissionDecisionApproveOnce struct {
}

type PermissionDecisionApprovePermanently struct {
	// The URL domain to approve permanently
	Domain string `json:"domain"`
}

type PermissionDecisionKind string

type PermissionDecisionReject struct {
	// Optional feedback from the user explaining the denial
	Feedback *string `json:"feedback,omitempty"`
}

type PermissionDecisionRequest struct {
	// Request ID of the pending permission request
	RequestID string             `json:"requestId"`
	Result    PermissionDecision `json:"result"`
}

type PermissionDecisionUserNotAvailable struct {
}

type PermissionRequestResult struct {
	// Whether the permission request was handled successfully
	Success bool `json:"success"`
}

type PermissionsApi sessionApi

type PermissionsResetSessionApprovalsRequest struct {
}

type PermissionsResetSessionApprovalsResult struct {
	// Whether the operation succeeded
	Success bool `json:"success"`
}

type PermissionsSetApproveAllRequest struct {
	// Whether to auto-approve all tool permission requests
	Enabled bool `json:"enabled"`
}

type PermissionsSetApproveAllResult struct {
	// Whether the operation succeeded
	Success bool `json:"success"`
}

type PingRequest struct {
	// Optional message to echo back
	Message *string `json:"message,omitempty"`
}

type PingResult struct {
	// Echoed message (or default greeting)
	Message string `json:"message"`
	// Server protocol version number
	ProtocolVersion int64 `json:"protocolVersion"`
	// Server timestamp in milliseconds
	Timestamp int64 `json:"timestamp"`
}

type PlanApi sessionApi

type PlanDeleteResult struct {
}

type PlanReadResult struct {
	// The content of the plan file, or null if it does not exist
	Content *string `json:"content"`
	// Whether the plan file exists in the workspace
	Exists bool `json:"exists"`
	// Absolute file path of the plan file, or null if workspace is not enabled
	Path *string `json:"path"`
}

type PlanUpdateRequest struct {
	// The new content for the plan file
	Content string `json:"content"`
}

type PlanUpdateResult struct {
}

type Plugin struct {
	// Whether the plugin is currently enabled
	Enabled bool `json:"enabled"`
	// Marketplace the plugin came from
	Marketplace string `json:"marketplace"`
	// Plugin name
	Name string `json:"name"`
	// Installed version
	Version *string `json:"version,omitempty"`
}

type PluginList struct {
	// Installed plugins
	Plugins []Plugin `json:"plugins"`
}

type PluginsApi sessionApi

type QueuedCommandHandled struct {
	// The command was handled
	Handled bool `json:"handled"`
	// If true, stop processing remaining queued items
	StopProcessingQueue *bool `json:"stopProcessingQueue,omitempty"`
}

type QueuedCommandNotHandled struct {
	// The command was not handled
	Handled bool `json:"handled"`
}

type QueuedCommandResult struct {
	// The command was handled
	Handled any `json:"handled"`
	// If true, stop processing remaining queued items
	StopProcessingQueue *bool `json:"stopProcessingQueue,omitempty"`
}

type RawExternalToolTextResultForLlmContentData struct {
	Discriminator ExternalToolTextResultForLlmContentType
	Raw           json.RawMessage
}

type RawExternalToolTextResultForLlmContentResourceDetailsData struct {
	Raw json.RawMessage
}

type RawMcpServerConfigData struct {
	Raw json.RawMessage
}

type RawPermissionDecisionApproveForLocationApprovalData struct {
	Discriminator PermissionDecisionApproveForLocationApprovalKind
	Raw           json.RawMessage
}

type RawPermissionDecisionApproveForSessionApprovalData struct {
	Discriminator PermissionDecisionApproveForSessionApprovalKind
	Raw           json.RawMessage
}

type RawPermissionDecisionData struct {
	Discriminator PermissionDecisionKind
	Raw           json.RawMessage
}

type RawTaskInfoData struct {
	Discriminator TaskInfoType
	Raw           json.RawMessage
}

type RawUIElicitationSchemaPropertyData struct {
	Discriminator UIElicitationSchemaPropertyType
	Raw           json.RawMessage
}

type RemoteApi sessionApi

type RemoteDisableResult struct {
}

type RemoteEnableResult struct {
	// Whether remote steering is enabled
	RemoteSteerable bool `json:"remoteSteerable"`
	// Mission Control frontend URL for this session
	URL *string `json:"url,omitempty"`
}

type ServerAccountApi serverApi

type ServerMcpApi serverApi

type ServerMcpConfigApi serverApi

type ServerModelsApi serverApi

type ServerRpc struct {
	Account   *ServerAccountApi
	Mcp       *ServerMcpApi
	Models    *ServerModelsApi
	SessionFs *ServerSessionFsApi
	Sessions  *ServerSessionsApi
	Skills    *ServerSkillsApi
	Tools     *ServerToolsApi
	// contains filtered or unexported fields
}

type ServerSessionFsApi serverApi

type ServerSessionsApi serverApi

type ServerSkill struct {
	// Description of what the skill does
	Description string `json:"description"`
	// Whether the skill is currently enabled (based on global config)
	Enabled bool `json:"enabled"`
	// Unique identifier for the skill
	Name string `json:"name"`
	// Absolute path to the skill file
	Path *string `json:"path,omitempty"`
	// The project path this skill belongs to (only for project/inherited skills)
	ProjectPath *string `json:"projectPath,omitempty"`
	// Source location type (e.g., project, personal-copilot, plugin, builtin)
	Source string `json:"source"`
	// Whether the skill can be invoked by the user as a slash command
	UserInvocable bool `json:"userInvocable"`
}

type ServerSkillList struct {
	// All discovered skills across all sources
	Skills []ServerSkill `json:"skills"`
}

type ServerSkillsApi serverApi

type ServerSkillsConfigApi serverApi

type ServerToolsApi serverApi

type SessionAuthStatus struct {
	// Authentication type
	AuthType *AuthInfoType `json:"authType,omitempty"`
	// Copilot plan tier (e.g., individual_pro, business)
	CopilotPlan *string `json:"copilotPlan,omitempty"`
	// Authentication host URL
	Host *string `json:"host,omitempty"`
	// Whether the session has resolved authentication
	IsAuthenticated bool `json:"isAuthenticated"`
	// Authenticated login/username, if available
	Login *string `json:"login,omitempty"`
	// Human-readable authentication status description
	StatusMessage *string `json:"statusMessage,omitempty"`
}

type SessionFsAppendFileRequest struct {
	// Content to append
	Content string `json:"content"`
	// Optional POSIX-style mode for newly created files
	Mode *int64 `json:"mode,omitempty"`
	// Path using SessionFs conventions
	Path string `json:"path"`
	// Target session identifier
	SessionID string `json:"sessionId"`
}

type SessionFsError struct {
	// Error classification
	Code SessionFsErrorCode `json:"code"`
	// Free-form detail about the error, for logging/diagnostics
	Message *string `json:"message,omitempty"`
}

type SessionFsErrorCode string

type SessionFsExistsRequest struct {
	// Path using SessionFs conventions
	Path string `json:"path"`
	// Target session identifier
	SessionID string `json:"sessionId"`
}

type SessionFsExistsResult struct {
	// Whether the path exists
	Exists bool `json:"exists"`
}

type SessionFsHandler interface {
	AppendFile(request *SessionFsAppendFileRequest) (*SessionFsError, error)
	Exists(request *SessionFsExistsRequest) (*SessionFsExistsResult, error)
	Mkdir(request *SessionFsMkdirRequest) (*SessionFsError, error)
	Readdir(request *SessionFsReaddirRequest) (*SessionFsReaddirResult, error)
	ReaddirWithTypes(request *SessionFsReaddirWithTypesRequest) (*SessionFsReaddirWithTypesResult, error)
	ReadFile(request *SessionFsReadFileRequest) (*SessionFsReadFileResult, error)
	Rename(request *SessionFsRenameRequest) (*SessionFsError, error)
	Rm(request *SessionFsRmRequest) (*SessionFsError, error)
	Stat(request *SessionFsStatRequest) (*SessionFsStatResult, error)
	WriteFile(request *SessionFsWriteFileRequest) (*SessionFsError, error)
}

type SessionFsMkdirRequest struct {
	// Optional POSIX-style mode for newly created directories
	Mode *int64 `json:"mode,omitempty"`
	// Path using SessionFs conventions
	Path string `json:"path"`
	// Create parent directories as needed
	Recursive *bool `json:"recursive,omitempty"`
	// Target session identifier
	SessionID string `json:"sessionId"`
}

type SessionFsReadFileRequest struct {
	// Path using SessionFs conventions
	Path string `json:"path"`
	// Target session identifier
	SessionID string `json:"sessionId"`
}

type SessionFsReadFileResult struct {
	// File content as UTF-8 string
	Content string `json:"content"`
	// Describes a filesystem error.
	Error *SessionFsError `json:"error,omitempty"`
}

type SessionFsReaddirRequest struct {
	// Path using SessionFs conventions
	Path string `json:"path"`
	// Target session identifier
	SessionID string `json:"sessionId"`
}

type SessionFsReaddirResult struct {
	// Entry names in the directory
	Entries []string `json:"entries"`
	// Describes a filesystem error.
	Error *SessionFsError `json:"error,omitempty"`
}

type SessionFsReaddirWithTypesEntry struct {
	// Entry name
	Name string `json:"name"`
	// Entry type
	Type SessionFsReaddirWithTypesEntryType `json:"type"`
}

type SessionFsReaddirWithTypesEntryType string

type SessionFsReaddirWithTypesRequest struct {
	// Path using SessionFs conventions
	Path string `json:"path"`
	// Target session identifier
	SessionID string `json:"sessionId"`
}

type SessionFsReaddirWithTypesResult struct {
	// Directory entries with type information
	Entries []SessionFsReaddirWithTypesEntry `json:"entries"`
	// Describes a filesystem error.
	Error *SessionFsError `json:"error,omitempty"`
}

type SessionFsRenameRequest struct {
	// Destination path using SessionFs conventions
	Dest string `json:"dest"`
	// Target session identifier
	SessionID string `json:"sessionId"`
	// Source path using SessionFs conventions
	Src string `json:"src"`
}

type SessionFsRmRequest struct {
	// Ignore errors if the path does not exist
	Force *bool `json:"force,omitempty"`
	// Path using SessionFs conventions
	Path string `json:"path"`
	// Remove directories and their contents recursively
	Recursive *bool `json:"recursive,omitempty"`
	// Target session identifier
	SessionID string `json:"sessionId"`
}

type SessionFsSetProviderConventions string

type SessionFsSetProviderRequest struct {
	// Path conventions used by this filesystem
	Conventions SessionFsSetProviderConventions `json:"conventions"`
	// Initial working directory for sessions
	InitialCwd string `json:"initialCwd"`
	// Path within each session's SessionFs where the runtime stores files for that session
	SessionStatePath string `json:"sessionStatePath"`
}

type SessionFsSetProviderResult struct {
	// Whether the provider was set successfully
	Success bool `json:"success"`
}

type SessionFsStatRequest struct {
	// Path using SessionFs conventions
	Path string `json:"path"`
	// Target session identifier
	SessionID string `json:"sessionId"`
}

type SessionFsStatResult struct {
	// ISO 8601 timestamp of creation
	Birthtime time.Time `json:"birthtime"`
	// Describes a filesystem error.
	Error *SessionFsError `json:"error,omitempty"`
	// Whether the path is a directory
	IsDirectory bool `json:"isDirectory"`
	// Whether the path is a file
	IsFile bool `json:"isFile"`
	// ISO 8601 timestamp of last modification
	Mtime time.Time `json:"mtime"`
	// File size in bytes
	Size int64 `json:"size"`
}

type SessionFsWriteFileRequest struct {
	// Content to write
	Content string `json:"content"`
	// Optional POSIX-style mode for newly created files
	Mode *int64 `json:"mode,omitempty"`
	// Path using SessionFs conventions
	Path string `json:"path"`
	// Target session identifier
	SessionID string `json:"sessionId"`
}

type SessionLogLevel string

type SessionMode string

type SessionRpc struct {
	Agent        *AgentApi
	Auth         *AuthApi
	Commands     *CommandsApi
	Extensions   *ExtensionsApi
	Fleet        *FleetApi
	History      *HistoryApi
	Instructions *InstructionsApi
	Mcp          *McpApi
	Mode         *ModeApi
	Model        *ModelApi
	Name         *NameApi
	Permissions  *PermissionsApi
	Plan         *PlanApi
	Plugins      *PluginsApi
	Remote       *RemoteApi
	Shell        *ShellApi
	Skills       *SkillsApi
	Tasks        *TasksApi
	Tools        *ToolsApi
	UI           *UIApi
	Usage        *UsageApi
	Workspaces   *WorkspacesApi
	// contains filtered or unexported fields
}

type SessionsForkRequest struct {
	// Source session ID to fork from
	SessionID string `json:"sessionId"`
	// Optional event ID boundary. When provided, the fork includes only events before this ID
	// (exclusive). When omitted, all events are included.
	ToEventID *string `json:"toEventId,omitempty"`
}

type SessionsForkResult struct {
	// The new forked session's ID
	SessionID string `json:"sessionId"`
}

type ShellApi sessionApi

type ShellExecRequest struct {
	// Shell command to execute
	Command string `json:"command"`
	// Working directory (defaults to session working directory)
	Cwd *string `json:"cwd,omitempty"`
	// Timeout in milliseconds (default: 30000)
	Timeout *int64 `json:"timeout,omitempty"`
}

type ShellExecResult struct {
	// Unique identifier for tracking streamed output
	ProcessID string `json:"processId"`
}

type ShellKillRequest struct {
	// Process identifier returned by shell.exec
	ProcessID string `json:"processId"`
	// Signal to send (default: SIGTERM)
	Signal *ShellKillSignal `json:"signal,omitempty"`
}

type ShellKillResult struct {
	// Whether the signal was sent successfully
	Killed bool `json:"killed"`
}

type ShellKillSignal string

type Skill struct {
	// Description of what the skill does
	Description string `json:"description"`
	// Whether the skill is currently enabled
	Enabled bool `json:"enabled"`
	// Unique identifier for the skill
	Name string `json:"name"`
	// Absolute path to the skill file
	Path *string `json:"path,omitempty"`
	// Source location type (e.g., project, personal, plugin)
	Source string `json:"source"`
	// Whether the skill can be invoked by the user as a slash command
	UserInvocable bool `json:"userInvocable"`
}

type SkillList struct {
	// Available skills
	Skills []Skill `json:"skills"`
}

type SkillsApi sessionApi

type SkillsConfigSetDisabledSkillsRequest struct {
	// List of skill names to disable
	DisabledSkills []string `json:"disabledSkills"`
}

type SkillsConfigSetDisabledSkillsResult struct {
}

type SkillsDisableRequest struct {
	// Name of the skill to disable
	Name string `json:"name"`
}

type SkillsDisableResult struct {
}

type SkillsDiscoverRequest struct {
	// Optional list of project directory paths to scan for project-scoped skills
	ProjectPaths []string `json:"projectPaths,omitempty"`
	// Optional list of additional skill directory paths to include
	SkillDirectories []string `json:"skillDirectories,omitempty"`
}

type SkillsEnableRequest struct {
	// Name of the skill to enable
	Name string `json:"name"`
}

type SkillsEnableResult struct {
}

type SkillsReloadResult struct {
}

type SuspendResult struct {
}

type TaskAgentInfo struct {
	// ISO 8601 timestamp when the current active period began
	ActiveStartedAt *time.Time `json:"activeStartedAt,omitempty"`
	// Accumulated active execution time in milliseconds
	ActiveTimeMs *int64 `json:"activeTimeMs,omitempty"`
	// Type of agent running this task
	AgentType string `json:"agentType"`
	// Whether the task is currently in the original sync wait and can be moved to background
	// mode. False once it is already backgrounded, idle, finished, or no longer has a
	// promotable sync waiter.
	CanPromoteToBackground *bool `json:"canPromoteToBackground,omitempty"`
	// ISO 8601 timestamp when the task finished
	CompletedAt *time.Time `json:"completedAt,omitempty"`
	// Short description of the task
	Description string `json:"description"`
	// Error message when the task failed
	Error *string `json:"error,omitempty"`
	// How the agent is currently being managed by the runtime
	ExecutionMode *TaskAgentInfoExecutionMode `json:"executionMode,omitempty"`
	// Unique task identifier
	ID string `json:"id"`
	// ISO 8601 timestamp when the agent entered idle state
	IdleSince *time.Time `json:"idleSince,omitempty"`
	// Most recent response text from the agent
	LatestResponse *string `json:"latestResponse,omitempty"`
	// Model used for the task when specified
	Model *string `json:"model,omitempty"`
	// Prompt passed to the agent
	Prompt string `json:"prompt"`
	// Result text from the task when available
	Result *string `json:"result,omitempty"`
	// ISO 8601 timestamp when the task was started
	StartedAt time.Time `json:"startedAt"`
	// Current lifecycle status of the task
	Status TaskAgentInfoStatus `json:"status"`
	// Tool call ID associated with this agent task
	ToolCallID string `json:"toolCallId"`
}

type TaskAgentInfoExecutionMode string

type TaskAgentInfoStatus string

type TaskInfo interface {
	Type() TaskInfoType
	// contains filtered or unexported methods
}

type TaskInfoType string

type TaskList struct {
	// Currently tracked tasks
	Tasks []TaskInfo `json:"tasks"`
}

type TaskShellInfo struct {
	// Whether the shell runs inside a managed PTY session or as an independent background
	// process
	AttachmentMode TaskShellInfoAttachmentMode `json:"attachmentMode"`
	// Whether this shell task can be promoted to background mode
	CanPromoteToBackground *bool `json:"canPromoteToBackground,omitempty"`
	// Command being executed
	Command string `json:"command"`
	// ISO 8601 timestamp when the task finished
	CompletedAt *time.Time `json:"completedAt,omitempty"`
	// Short description of the task
	Description string `json:"description"`
	// Whether the shell command is currently sync-waited or background-managed
	ExecutionMode *TaskShellInfoExecutionMode `json:"executionMode,omitempty"`
	// Unique task identifier
	ID string `json:"id"`
	// Path to the detached shell log, when available
	LogPath *string `json:"logPath,omitempty"`
	// Process ID when available
	Pid *int64 `json:"pid,omitempty"`
	// ISO 8601 timestamp when the task was started
	StartedAt time.Time `json:"startedAt"`
	// Current lifecycle status of the task
	Status TaskShellInfoStatus `json:"status"`
}

type TaskShellInfoAttachmentMode string

type TaskShellInfoExecutionMode string

type TaskShellInfoStatus string

type TasksApi sessionApi

type TasksCancelRequest struct {
	// Task identifier
	ID string `json:"id"`
}

type TasksCancelResult struct {
	// Whether the task was successfully cancelled
	Cancelled bool `json:"cancelled"`
}

type TasksPromoteToBackgroundRequest struct {
	// Task identifier
	ID string `json:"id"`
}

type TasksPromoteToBackgroundResult struct {
	// Whether the task was successfully promoted to background mode
	Promoted bool `json:"promoted"`
}

type TasksRemoveRequest struct {
	// Task identifier
	ID string `json:"id"`
}

type TasksRemoveResult struct {
	// Whether the task was removed. Returns false if the task does not exist or is still
	// running/idle (cancel it first).
	Removed bool `json:"removed"`
}

type TasksSendMessageRequest struct {
	// Agent ID of the sender, if sent on behalf of another agent
	FromAgentID *string `json:"fromAgentId,omitempty"`
	// Agent task identifier
	ID string `json:"id"`
	// Message content to send to the agent
	Message string `json:"message"`
}

type TasksSendMessageResult struct {
	// Error message if delivery failed
	Error *string `json:"error,omitempty"`
	// Whether the message was successfully delivered or steered
	Sent bool `json:"sent"`
}

type TasksStartAgentRequest struct {
	// Type of agent to start (e.g., 'explore', 'task', 'general-purpose')
	AgentType string `json:"agentType"`
	// Short description of the task
	Description *string `json:"description,omitempty"`
	// Optional model override
	Model *string `json:"model,omitempty"`
	// Short name for the agent, used to generate a human-readable ID
	Name string `json:"name"`
	// Task prompt for the agent
	Prompt string `json:"prompt"`
}

type TasksStartAgentResult struct {
	// Generated agent ID for the background task
	AgentID string `json:"agentId"`
}

type Tool struct {
	// Description of what the tool does
	Description string `json:"description"`
	// Optional instructions for how to use this tool effectively
	Instructions *string `json:"instructions,omitempty"`
	// Tool identifier (e.g., "bash", "grep", "str_replace_editor")
	Name string `json:"name"`
	// Optional namespaced name for declarative filtering (e.g., "playwright/navigate" for MCP
	// tools)
	NamespacedName *string `json:"namespacedName,omitempty"`
	// JSON Schema for the tool's input parameters
	Parameters map[string]any `json:"parameters,omitempty"`
}

type ToolList struct {
	// List of available built-in tools with metadata
	Tools []Tool `json:"tools"`
}

type ToolsApi sessionApi

type ToolsListRequest struct {
	// Optional model ID — when provided, the returned tool list reflects model-specific
	// overrides
	Model *string `json:"model,omitempty"`
}

type UIApi sessionApi

type UIElicitationArrayAnyOfField struct {
	Default     []string                          `json:"default,omitempty"`
	Description *string                           `json:"description,omitempty"`
	Items       UIElicitationArrayAnyOfFieldItems `json:"items"`
	MaxItems    *float64                          `json:"maxItems,omitempty"`
	MinItems    *float64                          `json:"minItems,omitempty"`
	Title       *string                           `json:"title,omitempty"`
}

type UIElicitationArrayAnyOfFieldItems struct {
	AnyOf []UIElicitationArrayAnyOfFieldItemsAnyOf `json:"anyOf"`
}

type UIElicitationArrayAnyOfFieldItemsAnyOf struct {
	Const string `json:"const"`
	Title string `json:"title"`
}