@github/copilot-sdk 0.1.33-preview.2 → 0.1.33-preview.4

package/dist/generated/rpc.d.ts

@@ -315,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
@@ -331,6 +333,7 @@ export interface SessionFleetStartParams {
      */
     prompt?: string;
 }
+/** @experimental */
 export interface SessionAgentListResult {
     /**
      * Available custom agents
@@ -350,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
@@ -375,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
@@ -400,6 +407,7 @@ export interface SessionAgentSelectResult {
         description: string;
     };
 }
+/** @experimental */
 export interface SessionAgentSelectParams {
     /**
      * Target session identifier
@@ -410,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
@@ -432,6 +720,7 @@ export interface SessionCompactionCompactResult {
      */
     messagesRemoved: number;
 }
+/** @experimental */
 export interface SessionCompactionCompactParams {
     /**
      * Target session identifier
@@ -460,6 +749,124 @@ 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
@@ -511,6 +918,10 @@ 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 {
     /**
@@ -589,21 +1000,56 @@ 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>;
     };

package/dist/generated/rpc.js

@@ -32,21 +32,56 @@ function createSessionRpc(connection, sessionId) {
       readFile: async (params) => connection.sendRequest("session.workspace.readFile", { sessionId, ...params }),
       createFile: async (params) => connection.sendRequest("session.workspace.createFile", { sessionId, ...params })
     },
+    /** @experimental */
     fleet: {
       start: async (params) => connection.sendRequest("session.fleet.start", { sessionId, ...params })
     },
+    /** @experimental */
     agent: {
       list: async () => connection.sendRequest("session.agent.list", { sessionId }),
       getCurrent: async () => connection.sendRequest("session.agent.getCurrent", { sessionId }),
       select: async (params) => connection.sendRequest("session.agent.select", { sessionId, ...params }),
-      deselect: async () => connection.sendRequest("session.agent.deselect", { sessionId })
+      deselect: async () => connection.sendRequest("session.agent.deselect", { sessionId }),
+      reload: async () => connection.sendRequest("session.agent.reload", { sessionId })
     },
+    /** @experimental */
+    skills: {
+      list: async () => connection.sendRequest("session.skills.list", { sessionId }),
+      enable: async (params) => connection.sendRequest("session.skills.enable", { sessionId, ...params }),
+      disable: async (params) => connection.sendRequest("session.skills.disable", { sessionId, ...params }),
+      reload: async () => connection.sendRequest("session.skills.reload", { sessionId })
+    },
+    /** @experimental */
+    mcp: {
+      list: async () => connection.sendRequest("session.mcp.list", { sessionId }),
+      enable: async (params) => connection.sendRequest("session.mcp.enable", { sessionId, ...params }),
+      disable: async (params) => connection.sendRequest("session.mcp.disable", { sessionId, ...params }),
+      reload: async () => connection.sendRequest("session.mcp.reload", { sessionId })
+    },
+    /** @experimental */
+    plugins: {
+      list: async () => connection.sendRequest("session.plugins.list", { sessionId })
+    },
+    /** @experimental */
+    extensions: {
+      list: async () => connection.sendRequest("session.extensions.list", { sessionId }),
+      enable: async (params) => connection.sendRequest("session.extensions.enable", { sessionId, ...params }),
+      disable: async (params) => connection.sendRequest("session.extensions.disable", { sessionId, ...params }),
+      reload: async () => connection.sendRequest("session.extensions.reload", { sessionId })
+    },
+    /** @experimental */
     compaction: {
       compact: async () => connection.sendRequest("session.compaction.compact", { sessionId })
     },
     tools: {
       handlePendingToolCall: async (params) => connection.sendRequest("session.tools.handlePendingToolCall", { sessionId, ...params })
     },
+    commands: {
+      handlePendingCommand: async (params) => connection.sendRequest("session.commands.handlePendingCommand", { sessionId, ...params })
+    },
+    ui: {
+      elicitation: async (params) => connection.sendRequest("session.ui.elicitation", { sessionId, ...params })
+    },
     permissions: {
       handlePendingPermissionRequest: async (params) => connection.sendRequest("session.permissions.handlePendingPermissionRequest", { sessionId, ...params })
     },