@github/copilot-sdk 0.2.1-preview.1 → 0.2.1-unstable.0

package/dist/generated/rpc.d.ts

@@ -171,6 +171,165 @@ export interface AccountGetQuotaResult {
         };
     };
 }
+export interface McpConfigListResult {
+    /**
+     * All MCP servers from user config, keyed by name
+     */
+    servers: {
+        /**
+         * MCP server configuration (local/stdio or remote/http)
+         */
+        [k: string]: {
+            /**
+             * Tools to include. Defaults to all tools if not specified.
+             */
+            tools?: string[];
+            type?: "local" | "stdio";
+            isDefaultServer?: boolean;
+            filterMapping?: {
+                [k: string]: "none" | "markdown" | "hidden_characters";
+            } | ("none" | "markdown" | "hidden_characters");
+            timeout?: number;
+            command: string;
+            args: string[];
+            cwd?: string;
+            env?: {
+                [k: string]: string;
+            };
+        } | {
+            /**
+             * Tools to include. Defaults to all tools if not specified.
+             */
+            tools?: string[];
+            type: "http" | "sse";
+            isDefaultServer?: boolean;
+            filterMapping?: {
+                [k: string]: "none" | "markdown" | "hidden_characters";
+            } | ("none" | "markdown" | "hidden_characters");
+            timeout?: number;
+            url: string;
+            headers?: {
+                [k: string]: string;
+            };
+            oauthClientId?: string;
+            oauthPublicClient?: boolean;
+        };
+    };
+}
+export interface McpConfigAddParams {
+    /**
+     * Unique name for the MCP server
+     */
+    name: string;
+    /**
+     * MCP server configuration (local/stdio or remote/http)
+     */
+    config: {
+        /**
+         * Tools to include. Defaults to all tools if not specified.
+         */
+        tools?: string[];
+        type?: "local" | "stdio";
+        isDefaultServer?: boolean;
+        filterMapping?: {
+            [k: string]: "none" | "markdown" | "hidden_characters";
+        } | ("none" | "markdown" | "hidden_characters");
+        timeout?: number;
+        command: string;
+        args: string[];
+        cwd?: string;
+        env?: {
+            [k: string]: string;
+        };
+    } | {
+        /**
+         * Tools to include. Defaults to all tools if not specified.
+         */
+        tools?: string[];
+        type: "http" | "sse";
+        isDefaultServer?: boolean;
+        filterMapping?: {
+            [k: string]: "none" | "markdown" | "hidden_characters";
+        } | ("none" | "markdown" | "hidden_characters");
+        timeout?: number;
+        url: string;
+        headers?: {
+            [k: string]: string;
+        };
+        oauthClientId?: string;
+        oauthPublicClient?: boolean;
+    };
+}
+export interface McpConfigUpdateParams {
+    /**
+     * Name of the MCP server to update
+     */
+    name: string;
+    /**
+     * MCP server configuration (local/stdio or remote/http)
+     */
+    config: {
+        /**
+         * Tools to include. Defaults to all tools if not specified.
+         */
+        tools?: string[];
+        type?: "local" | "stdio";
+        isDefaultServer?: boolean;
+        filterMapping?: {
+            [k: string]: "none" | "markdown" | "hidden_characters";
+        } | ("none" | "markdown" | "hidden_characters");
+        timeout?: number;
+        command: string;
+        args: string[];
+        cwd?: string;
+        env?: {
+            [k: string]: string;
+        };
+    } | {
+        /**
+         * Tools to include. Defaults to all tools if not specified.
+         */
+        tools?: string[];
+        type: "http" | "sse";
+        isDefaultServer?: boolean;
+        filterMapping?: {
+            [k: string]: "none" | "markdown" | "hidden_characters";
+        } | ("none" | "markdown" | "hidden_characters");
+        timeout?: number;
+        url: string;
+        headers?: {
+            [k: string]: string;
+        };
+        oauthClientId?: string;
+        oauthPublicClient?: boolean;
+    };
+}
+export interface McpConfigRemoveParams {
+    /**
+     * Name of the MCP server to remove
+     */
+    name: string;
+}
+export interface SessionFsSetProviderResult {
+    /**
+     * Whether the provider was set successfully
+     */
+    success: boolean;
+}
+export interface SessionFsSetProviderParams {
+    /**
+     * Initial working directory for sessions
+     */
+    initialCwd: string;
+    /**
+     * Path within each session's SessionFs where the runtime stores files for that session
+     */
+    sessionStatePath: string;
+    /**
+     * Path conventions used by this filesystem
+     */
+    conventions: "windows" | "posix";
+}
 export interface SessionModelGetCurrentResult {
     /**
      * Currently active model identifier
@@ -543,9 +702,9 @@ export interface SessionMcpListResult {
          */
         name: string;
         /**
-         * Connection status: connected, failed, pending, disabled, or not_configured
+         * Connection status: connected, failed, needs-auth, pending, disabled, or not_configured
          */
-        status: "connected" | "failed" | "pending" | "disabled" | "not_configured";
+        status: "connected" | "failed" | "needs-auth" | "pending" | "disabled" | "not_configured";
         /**
          * Configuration source: user, workspace, plugin, or builtin
          */
@@ -867,6 +1026,37 @@ export interface SessionUiElicitationParams {
         required?: string[];
     };
 }
+export interface SessionUiHandlePendingElicitationResult {
+    /**
+     * Whether the response was accepted. False if the request was already resolved by another client.
+     */
+    success: boolean;
+}
+export interface SessionUiHandlePendingElicitationParams {
+    /**
+     * Target session identifier
+     */
+    sessionId: string;
+    /**
+     * The unique request ID from the elicitation.requested event
+     */
+    requestId: string;
+    /**
+     * The elicitation response (accept with form values, decline, or cancel)
+     */
+    result: {
+        /**
+         * 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 SessionPermissionsHandlePendingPermissionRequestResult {
     /**
      * Whether the permission request was handled successfully
@@ -967,6 +1157,197 @@ export interface SessionShellKillParams {
      */
     signal?: "SIGTERM" | "SIGKILL" | "SIGINT";
 }
+export interface SessionFsReadFileResult {
+    /**
+     * File content as UTF-8 string
+     */
+    content: string;
+}
+export interface SessionFsReadFileParams {
+    /**
+     * Target session identifier
+     */
+    sessionId: string;
+    /**
+     * Path using SessionFs conventions
+     */
+    path: string;
+}
+export interface SessionFsWriteFileParams {
+    /**
+     * Target session identifier
+     */
+    sessionId: string;
+    /**
+     * Path using SessionFs conventions
+     */
+    path: string;
+    /**
+     * Content to write
+     */
+    content: string;
+    /**
+     * Optional POSIX-style mode for newly created files
+     */
+    mode?: number;
+}
+export interface SessionFsAppendFileParams {
+    /**
+     * Target session identifier
+     */
+    sessionId: string;
+    /**
+     * Path using SessionFs conventions
+     */
+    path: string;
+    /**
+     * Content to append
+     */
+    content: string;
+    /**
+     * Optional POSIX-style mode for newly created files
+     */
+    mode?: number;
+}
+export interface SessionFsExistsResult {
+    /**
+     * Whether the path exists
+     */
+    exists: boolean;
+}
+export interface SessionFsExistsParams {
+    /**
+     * Target session identifier
+     */
+    sessionId: string;
+    /**
+     * Path using SessionFs conventions
+     */
+    path: string;
+}
+export interface SessionFsStatResult {
+    /**
+     * Whether the path is a file
+     */
+    isFile: boolean;
+    /**
+     * Whether the path is a directory
+     */
+    isDirectory: boolean;
+    /**
+     * File size in bytes
+     */
+    size: number;
+    /**
+     * ISO 8601 timestamp of last modification
+     */
+    mtime: string;
+    /**
+     * ISO 8601 timestamp of creation
+     */
+    birthtime: string;
+}
+export interface SessionFsStatParams {
+    /**
+     * Target session identifier
+     */
+    sessionId: string;
+    /**
+     * Path using SessionFs conventions
+     */
+    path: string;
+}
+export interface SessionFsMkdirParams {
+    /**
+     * Target session identifier
+     */
+    sessionId: string;
+    /**
+     * Path using SessionFs conventions
+     */
+    path: string;
+    /**
+     * Create parent directories as needed
+     */
+    recursive?: boolean;
+    /**
+     * Optional POSIX-style mode for newly created directories
+     */
+    mode?: number;
+}
+export interface SessionFsReaddirResult {
+    /**
+     * Entry names in the directory
+     */
+    entries: string[];
+}
+export interface SessionFsReaddirParams {
+    /**
+     * Target session identifier
+     */
+    sessionId: string;
+    /**
+     * Path using SessionFs conventions
+     */
+    path: string;
+}
+export interface SessionFsReaddirWithTypesResult {
+    /**
+     * Directory entries with type information
+     */
+    entries: {
+        /**
+         * Entry name
+         */
+        name: string;
+        /**
+         * Entry type
+         */
+        type: "file" | "directory";
+    }[];
+}
+export interface SessionFsReaddirWithTypesParams {
+    /**
+     * Target session identifier
+     */
+    sessionId: string;
+    /**
+     * Path using SessionFs conventions
+     */
+    path: string;
+}
+export interface SessionFsRmParams {
+    /**
+     * Target session identifier
+     */
+    sessionId: string;
+    /**
+     * Path using SessionFs conventions
+     */
+    path: string;
+    /**
+     * Remove directories and their contents recursively
+     */
+    recursive?: boolean;
+    /**
+     * Ignore errors if the path does not exist
+     */
+    force?: boolean;
+}
+export interface SessionFsRenameParams {
+    /**
+     * Target session identifier
+     */
+    sessionId: string;
+    /**
+     * Source path using SessionFs conventions
+     */
+    src: string;
+    /**
+     * Destination path using SessionFs conventions
+     */
+    dest: string;
+}
 /** Create typed server-scoped RPC methods (no session required). */
 export declare function createServerRpc(connection: MessageConnection): {
     ping: (params: PingParams) => Promise<PingResult>;
@@ -979,6 +1360,17 @@ export declare function createServerRpc(connection: MessageConnection): {
     account: {
         getQuota: () => Promise<AccountGetQuotaResult>;
     };
+    mcp: {
+        config: {
+            list: () => Promise<McpConfigListResult>;
+            add: (params: McpConfigAddParams) => Promise<void>;
+            update: (params: McpConfigUpdateParams) => Promise<void>;
+            remove: (params: McpConfigRemoveParams) => Promise<void>;
+        };
+    };
+    sessionFs: {
+        setProvider: (params: SessionFsSetProviderParams) => Promise<SessionFsSetProviderResult>;
+    };
 };
 /** Create typed session-scoped RPC methods. */
 export declare function createSessionRpc(connection: MessageConnection, sessionId: string): {
@@ -1049,6 +1441,7 @@ export declare function createSessionRpc(connection: MessageConnection, sessionI
     };
     ui: {
         elicitation: (params: Omit<SessionUiElicitationParams, "sessionId">) => Promise<SessionUiElicitationResult>;
+        handlePendingElicitation: (params: Omit<SessionUiHandlePendingElicitationParams, "sessionId">) => Promise<SessionUiHandlePendingElicitationResult>;
     };
     permissions: {
         handlePendingPermissionRequest: (params: Omit<SessionPermissionsHandlePendingPermissionRequestParams, "sessionId">) => Promise<SessionPermissionsHandlePendingPermissionRequestResult>;
@@ -1059,3 +1452,27 @@ export declare function createSessionRpc(connection: MessageConnection, sessionI
         kill: (params: Omit<SessionShellKillParams, "sessionId">) => Promise<SessionShellKillResult>;
     };
 };
+/** Handler for `sessionFs` client session API methods. */
+export interface SessionFsHandler {
+    readFile(params: SessionFsReadFileParams): Promise<SessionFsReadFileResult>;
+    writeFile(params: SessionFsWriteFileParams): Promise<void>;
+    appendFile(params: SessionFsAppendFileParams): Promise<void>;
+    exists(params: SessionFsExistsParams): Promise<SessionFsExistsResult>;
+    stat(params: SessionFsStatParams): Promise<SessionFsStatResult>;
+    mkdir(params: SessionFsMkdirParams): Promise<void>;
+    readdir(params: SessionFsReaddirParams): Promise<SessionFsReaddirResult>;
+    readdirWithTypes(params: SessionFsReaddirWithTypesParams): Promise<SessionFsReaddirWithTypesResult>;
+    rm(params: SessionFsRmParams): Promise<void>;
+    rename(params: SessionFsRenameParams): Promise<void>;
+}
+/** All client session API handler groups. */
+export interface ClientSessionApiHandlers {
+    sessionFs?: SessionFsHandler;
+}
+/**
+ * Register client session API handlers on a JSON-RPC connection.
+ * The server calls these methods to delegate work to the client.
+ * Each incoming call includes a `sessionId` in the params; the registration
+ * function uses `getHandlers` to resolve the session's handlers.
+ */
+export declare function registerClientSessionApiHandlers(connection: MessageConnection, getHandlers: (sessionId: string) => ClientSessionApiHandlers): void;

package/dist/generated/rpc.js

@@ -9,6 +9,17 @@ function createServerRpc(connection) {
     },
     account: {
       getQuota: async () => connection.sendRequest("account.getQuota", {})
+    },
+    mcp: {
+      config: {
+        list: async () => connection.sendRequest("mcp.config.list", {}),
+        add: async (params) => connection.sendRequest("mcp.config.add", params),
+        update: async (params) => connection.sendRequest("mcp.config.update", params),
+        remove: async (params) => connection.sendRequest("mcp.config.remove", params)
+      }
+    },
+    sessionFs: {
+      setProvider: async (params) => connection.sendRequest("sessionFs.setProvider", params)
     }
   };
 }
@@ -80,7 +91,8 @@ function createSessionRpc(connection, sessionId) {
       handlePendingCommand: async (params) => connection.sendRequest("session.commands.handlePendingCommand", { sessionId, ...params })
     },
     ui: {
-      elicitation: async (params) => connection.sendRequest("session.ui.elicitation", { sessionId, ...params })
+      elicitation: async (params) => connection.sendRequest("session.ui.elicitation", { sessionId, ...params }),
+      handlePendingElicitation: async (params) => connection.sendRequest("session.ui.handlePendingElicitation", { sessionId, ...params })
     },
     permissions: {
       handlePendingPermissionRequest: async (params) => connection.sendRequest("session.permissions.handlePendingPermissionRequest", { sessionId, ...params })
@@ -92,7 +104,60 @@ function createSessionRpc(connection, sessionId) {
     }
   };
 }
+function registerClientSessionApiHandlers(connection, getHandlers) {
+  connection.onRequest("sessionFs.readFile", async (params) => {
+    const handler = getHandlers(params.sessionId).sessionFs;
+    if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);
+    return handler.readFile(params);
+  });
+  connection.onRequest("sessionFs.writeFile", async (params) => {
+    const handler = getHandlers(params.sessionId).sessionFs;
+    if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);
+    return handler.writeFile(params);
+  });
+  connection.onRequest("sessionFs.appendFile", async (params) => {
+    const handler = getHandlers(params.sessionId).sessionFs;
+    if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);
+    return handler.appendFile(params);
+  });
+  connection.onRequest("sessionFs.exists", async (params) => {
+    const handler = getHandlers(params.sessionId).sessionFs;
+    if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);
+    return handler.exists(params);
+  });
+  connection.onRequest("sessionFs.stat", async (params) => {
+    const handler = getHandlers(params.sessionId).sessionFs;
+    if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);
+    return handler.stat(params);
+  });
+  connection.onRequest("sessionFs.mkdir", async (params) => {
+    const handler = getHandlers(params.sessionId).sessionFs;
+    if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);
+    return handler.mkdir(params);
+  });
+  connection.onRequest("sessionFs.readdir", async (params) => {
+    const handler = getHandlers(params.sessionId).sessionFs;
+    if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);
+    return handler.readdir(params);
+  });
+  connection.onRequest("sessionFs.readdirWithTypes", async (params) => {
+    const handler = getHandlers(params.sessionId).sessionFs;
+    if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);
+    return handler.readdirWithTypes(params);
+  });
+  connection.onRequest("sessionFs.rm", async (params) => {
+    const handler = getHandlers(params.sessionId).sessionFs;
+    if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);
+    return handler.rm(params);
+  });
+  connection.onRequest("sessionFs.rename", async (params) => {
+    const handler = getHandlers(params.sessionId).sessionFs;
+    if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);
+    return handler.rename(params);
+  });
+}
 export {
   createServerRpc,
-  createSessionRpc
+  createSessionRpc,
+  registerClientSessionApiHandlers
 };