@github/copilot-sdk 0.1.33-unstable.0 → 0.2.0

package/dist/generated/rpc.d.ts

@@ -40,16 +40,34 @@ export interface ModelsListResult {
          * Model capabilities and limits
          */
         capabilities: {
+            /**
+             * Feature flags indicating what the model supports
+             */
             supports: {
+                /**
+                 * Whether this model supports vision/image input
+                 */
                 vision?: boolean;
                 /**
                  * Whether this model supports reasoning effort configuration
                  */
                 reasoningEffort?: boolean;
             };
+            /**
+             * Token limits for prompts, outputs, and context window
+             */
             limits: {
+                /**
+                 * Maximum number of prompt/input tokens
+                 */
                 max_prompt_tokens?: number;
+                /**
+                 * Maximum number of output/completion tokens
+                 */
                 max_output_tokens?: number;
+                /**
+                 * Maximum total context window size in tokens
+                 */
                 max_context_window_tokens: number;
             };
         };
@@ -57,13 +75,22 @@ export interface ModelsListResult {
          * Policy state (if applicable)
          */
         policy?: {
+            /**
+             * Current policy state for this model
+             */
             state: string;
+            /**
+             * Usage terms or conditions for this model
+             */
             terms: string;
         };
         /**
          * Billing information
          */
         billing?: {
+            /**
+             * Billing cost multiplier relative to the base rate
+             */
             multiplier: number;
         };
         /**
@@ -145,6 +172,9 @@ export interface AccountGetQuotaResult {
     };
 }
 export interface SessionModelGetCurrentResult {
+    /**
+     * Currently active model identifier
+     */
     modelId?: string;
 }
 export interface SessionModelGetCurrentParams {
@@ -154,6 +184,9 @@ export interface SessionModelGetCurrentParams {
     sessionId: string;
 }
 export interface SessionModelSwitchToResult {
+    /**
+     * Currently active model identifier after the switch
+     */
     modelId?: string;
 }
 export interface SessionModelSwitchToParams {
@@ -161,8 +194,14 @@ export interface SessionModelSwitchToParams {
      * Target session identifier
      */
     sessionId: string;
+    /**
+     * Model identifier to switch to
+     */
     modelId: string;
-    reasoningEffort?: "low" | "medium" | "high" | "xhigh";
+    /**
+     * Reasoning effort level to use for the model
+     */
+    reasoningEffort?: string;
 }
 export interface SessionModeGetResult {
     /**
@@ -276,12 +315,14 @@ export interface SessionWorkspaceCreateFileParams {
      */
     content: string;
 }
+/** @experimental */
 export interface SessionFleetStartResult {
     /**
      * Whether fleet mode was successfully activated
      */
     started: boolean;
 }
+/** @experimental */
 export interface SessionFleetStartParams {
     /**
      * Target session identifier
@@ -292,6 +333,7 @@ export interface SessionFleetStartParams {
      */
     prompt?: string;
 }
+/** @experimental */
 export interface SessionAgentListResult {
     /**
      * Available custom agents
@@ -311,12 +353,14 @@ export interface SessionAgentListResult {
         description: string;
     }[];
 }
+/** @experimental */
 export interface SessionAgentListParams {
     /**
      * Target session identifier
      */
     sessionId: string;
 }
+/** @experimental */
 export interface SessionAgentGetCurrentResult {
     /**
      * Currently selected custom agent, or null if using the default agent
@@ -336,12 +380,14 @@ export interface SessionAgentGetCurrentResult {
         description: string;
     } | null;
 }
+/** @experimental */
 export interface SessionAgentGetCurrentParams {
     /**
      * Target session identifier
      */
     sessionId: string;
 }
+/** @experimental */
 export interface SessionAgentSelectResult {
     /**
      * The newly selected custom agent
@@ -361,6 +407,7 @@ export interface SessionAgentSelectResult {
         description: string;
     };
 }
+/** @experimental */
 export interface SessionAgentSelectParams {
     /**
      * Target session identifier
@@ -371,14 +418,294 @@ export interface SessionAgentSelectParams {
      */
     name: string;
 }
+/** @experimental */
 export interface SessionAgentDeselectResult {
 }
+/** @experimental */
 export interface SessionAgentDeselectParams {
     /**
      * Target session identifier
      */
     sessionId: string;
 }
+/** @experimental */
+export interface SessionAgentReloadResult {
+    /**
+     * Reloaded custom agents
+     */
+    agents: {
+        /**
+         * Unique identifier of the custom agent
+         */
+        name: string;
+        /**
+         * Human-readable display name
+         */
+        displayName: string;
+        /**
+         * Description of the agent's purpose
+         */
+        description: string;
+    }[];
+}
+/** @experimental */
+export interface SessionAgentReloadParams {
+    /**
+     * Target session identifier
+     */
+    sessionId: string;
+}
+/** @experimental */
+export interface SessionSkillsListResult {
+    /**
+     * Available skills
+     */
+    skills: {
+        /**
+         * Unique identifier for the skill
+         */
+        name: string;
+        /**
+         * Description of what the skill does
+         */
+        description: string;
+        /**
+         * Source location type (e.g., project, personal, plugin)
+         */
+        source: string;
+        /**
+         * Whether the skill can be invoked by the user as a slash command
+         */
+        userInvocable: boolean;
+        /**
+         * Whether the skill is currently enabled
+         */
+        enabled: boolean;
+        /**
+         * Absolute path to the skill file
+         */
+        path?: string;
+    }[];
+}
+/** @experimental */
+export interface SessionSkillsListParams {
+    /**
+     * Target session identifier
+     */
+    sessionId: string;
+}
+/** @experimental */
+export interface SessionSkillsEnableResult {
+}
+/** @experimental */
+export interface SessionSkillsEnableParams {
+    /**
+     * Target session identifier
+     */
+    sessionId: string;
+    /**
+     * Name of the skill to enable
+     */
+    name: string;
+}
+/** @experimental */
+export interface SessionSkillsDisableResult {
+}
+/** @experimental */
+export interface SessionSkillsDisableParams {
+    /**
+     * Target session identifier
+     */
+    sessionId: string;
+    /**
+     * Name of the skill to disable
+     */
+    name: string;
+}
+/** @experimental */
+export interface SessionSkillsReloadResult {
+}
+/** @experimental */
+export interface SessionSkillsReloadParams {
+    /**
+     * Target session identifier
+     */
+    sessionId: string;
+}
+/** @experimental */
+export interface SessionMcpListResult {
+    /**
+     * Configured MCP servers
+     */
+    servers: {
+        /**
+         * Server name (config key)
+         */
+        name: string;
+        /**
+         * Connection status: connected, failed, pending, disabled, or not_configured
+         */
+        status: "connected" | "failed" | "pending" | "disabled" | "not_configured";
+        /**
+         * Configuration source: user, workspace, plugin, or builtin
+         */
+        source?: string;
+        /**
+         * Error message if the server failed to connect
+         */
+        error?: string;
+    }[];
+}
+/** @experimental */
+export interface SessionMcpListParams {
+    /**
+     * Target session identifier
+     */
+    sessionId: string;
+}
+/** @experimental */
+export interface SessionMcpEnableResult {
+}
+/** @experimental */
+export interface SessionMcpEnableParams {
+    /**
+     * Target session identifier
+     */
+    sessionId: string;
+    /**
+     * Name of the MCP server to enable
+     */
+    serverName: string;
+}
+/** @experimental */
+export interface SessionMcpDisableResult {
+}
+/** @experimental */
+export interface SessionMcpDisableParams {
+    /**
+     * Target session identifier
+     */
+    sessionId: string;
+    /**
+     * Name of the MCP server to disable
+     */
+    serverName: string;
+}
+/** @experimental */
+export interface SessionMcpReloadResult {
+}
+/** @experimental */
+export interface SessionMcpReloadParams {
+    /**
+     * Target session identifier
+     */
+    sessionId: string;
+}
+/** @experimental */
+export interface SessionPluginsListResult {
+    /**
+     * Installed plugins
+     */
+    plugins: {
+        /**
+         * Plugin name
+         */
+        name: string;
+        /**
+         * Marketplace the plugin came from
+         */
+        marketplace: string;
+        /**
+         * Installed version
+         */
+        version?: string;
+        /**
+         * Whether the plugin is currently enabled
+         */
+        enabled: boolean;
+    }[];
+}
+/** @experimental */
+export interface SessionPluginsListParams {
+    /**
+     * Target session identifier
+     */
+    sessionId: string;
+}
+/** @experimental */
+export interface SessionExtensionsListResult {
+    /**
+     * Discovered extensions and their current status
+     */
+    extensions: {
+        /**
+         * Source-qualified ID (e.g., 'project:my-ext', 'user:auth-helper')
+         */
+        id: string;
+        /**
+         * Extension name (directory name)
+         */
+        name: string;
+        /**
+         * Discovery source: project (.github/extensions/) or user (~/.copilot/extensions/)
+         */
+        source: "project" | "user";
+        /**
+         * Current status: running, disabled, failed, or starting
+         */
+        status: "running" | "disabled" | "failed" | "starting";
+        /**
+         * Process ID if the extension is running
+         */
+        pid?: number;
+    }[];
+}
+/** @experimental */
+export interface SessionExtensionsListParams {
+    /**
+     * Target session identifier
+     */
+    sessionId: string;
+}
+/** @experimental */
+export interface SessionExtensionsEnableResult {
+}
+/** @experimental */
+export interface SessionExtensionsEnableParams {
+    /**
+     * Target session identifier
+     */
+    sessionId: string;
+    /**
+     * Source-qualified extension ID to enable
+     */
+    id: string;
+}
+/** @experimental */
+export interface SessionExtensionsDisableResult {
+}
+/** @experimental */
+export interface SessionExtensionsDisableParams {
+    /**
+     * Target session identifier
+     */
+    sessionId: string;
+    /**
+     * Source-qualified extension ID to disable
+     */
+    id: string;
+}
+/** @experimental */
+export interface SessionExtensionsReloadResult {
+}
+/** @experimental */
+export interface SessionExtensionsReloadParams {
+    /**
+     * Target session identifier
+     */
+    sessionId: string;
+}
+/** @experimental */
 export interface SessionCompactionCompactResult {
     /**
      * Whether compaction completed successfully
@@ -393,6 +720,7 @@ export interface SessionCompactionCompactResult {
      */
     messagesRemoved: number;
 }
+/** @experimental */
 export interface SessionCompactionCompactParams {
     /**
      * Target session identifier
@@ -400,6 +728,9 @@ export interface SessionCompactionCompactParams {
     sessionId: string;
 }
 export interface SessionToolsHandlePendingToolCallResult {
+    /**
+     * Whether the tool call result was handled successfully
+     */
     success: boolean;
 }
 export interface SessionToolsHandlePendingToolCallParams {
@@ -418,7 +749,128 @@ export interface SessionToolsHandlePendingToolCallParams {
     };
     error?: string;
 }
+export interface SessionCommandsHandlePendingCommandResult {
+    success: boolean;
+}
+export interface SessionCommandsHandlePendingCommandParams {
+    /**
+     * Target session identifier
+     */
+    sessionId: string;
+    /**
+     * Request ID from the command invocation event
+     */
+    requestId: string;
+    /**
+     * Error message if the command handler failed
+     */
+    error?: string;
+}
+export interface SessionUiElicitationResult {
+    /**
+     * The user's response: accept (submitted), decline (rejected), or cancel (dismissed)
+     */
+    action: "accept" | "decline" | "cancel";
+    /**
+     * The form values submitted by the user (present when action is 'accept')
+     */
+    content?: {
+        [k: string]: string | number | boolean | string[];
+    };
+}
+export interface SessionUiElicitationParams {
+    /**
+     * Target session identifier
+     */
+    sessionId: string;
+    /**
+     * Message describing what information is needed from the user
+     */
+    message: string;
+    /**
+     * JSON Schema describing the form fields to present to the user
+     */
+    requestedSchema: {
+        /**
+         * Schema type indicator (always 'object')
+         */
+        type: "object";
+        /**
+         * Form field definitions, keyed by field name
+         */
+        properties: {
+            [k: string]: {
+                type: "string";
+                title?: string;
+                description?: string;
+                enum: string[];
+                enumNames?: string[];
+                default?: string;
+            } | {
+                type: "string";
+                title?: string;
+                description?: string;
+                oneOf: {
+                    const: string;
+                    title: string;
+                }[];
+                default?: string;
+            } | {
+                type: "array";
+                title?: string;
+                description?: string;
+                minItems?: number;
+                maxItems?: number;
+                items: {
+                    type: "string";
+                    enum: string[];
+                };
+                default?: string[];
+            } | {
+                type: "array";
+                title?: string;
+                description?: string;
+                minItems?: number;
+                maxItems?: number;
+                items: {
+                    anyOf: {
+                        const: string;
+                        title: string;
+                    }[];
+                };
+                default?: string[];
+            } | {
+                type: "boolean";
+                title?: string;
+                description?: string;
+                default?: boolean;
+            } | {
+                type: "string";
+                title?: string;
+                description?: string;
+                minLength?: number;
+                maxLength?: number;
+                format?: "email" | "uri" | "date" | "date-time";
+                default?: string;
+            } | {
+                type: "number" | "integer";
+                title?: string;
+                description?: string;
+                minimum?: number;
+                maximum?: number;
+                default?: number;
+            };
+        };
+        /**
+         * List of required field names
+         */
+        required?: string[];
+    };
+}
 export interface SessionPermissionsHandlePendingPermissionRequestResult {
+    /**
+     * Whether the permission request was handled successfully
+     */
     success: boolean;
 }
 export interface SessionPermissionsHandlePendingPermissionRequestParams {
@@ -466,6 +918,54 @@ export interface SessionLogParams {
      * When true, the message is transient and not persisted to the session event log on disk
      */
     ephemeral?: boolean;
+    /**
+     * Optional URL the user can open in their browser for more details
+     */
+    url?: string;
+}
+export interface SessionShellExecResult {
+    /**
+     * Unique identifier for tracking streamed output
+     */
+    processId: string;
+}
+export interface SessionShellExecParams {
+    /**
+     * Target session identifier
+     */
+    sessionId: string;
+    /**
+     * Shell command to execute
+     */
+    command: string;
+    /**
+     * Working directory (defaults to session working directory)
+     */
+    cwd?: string;
+    /**
+     * Timeout in milliseconds (default: 30000)
+     */
+    timeout?: number;
+}
+export interface SessionShellKillResult {
+    /**
+     * Whether the signal was sent successfully
+     */
+    killed: boolean;
+}
+export interface SessionShellKillParams {
+    /**
+     * Target session identifier
+     */
+    sessionId: string;
+    /**
+     * Process identifier returned by shell.exec
+     */
+    processId: string;
+    /**
+     * Signal to send (default: SIGTERM)
+     */
+    signal?: "SIGTERM" | "SIGKILL" | "SIGINT";
 }
 /** Create typed server-scoped RPC methods (no session required). */
 export declare function createServerRpc(connection: MessageConnection): {
@@ -500,23 +1000,62 @@ export declare function createSessionRpc(connection: MessageConnection, sessionI
         readFile: (params: Omit<SessionWorkspaceReadFileParams, "sessionId">) => Promise<SessionWorkspaceReadFileResult>;
         createFile: (params: Omit<SessionWorkspaceCreateFileParams, "sessionId">) => Promise<SessionWorkspaceCreateFileResult>;
     };
+    /** @experimental */
     fleet: {
         start: (params: Omit<SessionFleetStartParams, "sessionId">) => Promise<SessionFleetStartResult>;
     };
+    /** @experimental */
     agent: {
         list: () => Promise<SessionAgentListResult>;
         getCurrent: () => Promise<SessionAgentGetCurrentResult>;
         select: (params: Omit<SessionAgentSelectParams, "sessionId">) => Promise<SessionAgentSelectResult>;
         deselect: () => Promise<SessionAgentDeselectResult>;
+        reload: () => Promise<SessionAgentReloadResult>;
+    };
+    /** @experimental */
+    skills: {
+        list: () => Promise<SessionSkillsListResult>;
+        enable: (params: Omit<SessionSkillsEnableParams, "sessionId">) => Promise<SessionSkillsEnableResult>;
+        disable: (params: Omit<SessionSkillsDisableParams, "sessionId">) => Promise<SessionSkillsDisableResult>;
+        reload: () => Promise<SessionSkillsReloadResult>;
+    };
+    /** @experimental */
+    mcp: {
+        list: () => Promise<SessionMcpListResult>;
+        enable: (params: Omit<SessionMcpEnableParams, "sessionId">) => Promise<SessionMcpEnableResult>;
+        disable: (params: Omit<SessionMcpDisableParams, "sessionId">) => Promise<SessionMcpDisableResult>;
+        reload: () => Promise<SessionMcpReloadResult>;
+    };
+    /** @experimental */
+    plugins: {
+        list: () => Promise<SessionPluginsListResult>;
     };
+    /** @experimental */
+    extensions: {
+        list: () => Promise<SessionExtensionsListResult>;
+        enable: (params: Omit<SessionExtensionsEnableParams, "sessionId">) => Promise<SessionExtensionsEnableResult>;
+        disable: (params: Omit<SessionExtensionsDisableParams, "sessionId">) => Promise<SessionExtensionsDisableResult>;
+        reload: () => Promise<SessionExtensionsReloadResult>;
+    };
+    /** @experimental */
     compaction: {
         compact: () => Promise<SessionCompactionCompactResult>;
     };
     tools: {
         handlePendingToolCall: (params: Omit<SessionToolsHandlePendingToolCallParams, "sessionId">) => Promise<SessionToolsHandlePendingToolCallResult>;
     };
+    commands: {
+        handlePendingCommand: (params: Omit<SessionCommandsHandlePendingCommandParams, "sessionId">) => Promise<SessionCommandsHandlePendingCommandResult>;
+    };
+    ui: {
+        elicitation: (params: Omit<SessionUiElicitationParams, "sessionId">) => Promise<SessionUiElicitationResult>;
+    };
     permissions: {
         handlePendingPermissionRequest: (params: Omit<SessionPermissionsHandlePendingPermissionRequestParams, "sessionId">) => Promise<SessionPermissionsHandlePendingPermissionRequestResult>;
     };
     log: (params: Omit<SessionLogParams, "sessionId">) => Promise<SessionLogResult>;
+    shell: {
+        exec: (params: Omit<SessionShellExecParams, "sessionId">) => Promise<SessionShellExecResult>;
+        kill: (params: Omit<SessionShellKillParams, "sessionId">) => Promise<SessionShellKillResult>;
+    };
 };