Move to per-session client APIs

Author: SteveSandersonMS

nodejs/src/client.ts

@@ -24,7 +24,7 @@ import {
     StreamMessageReader,
     StreamMessageWriter,
 } from "vscode-jsonrpc/node.js";
-import { createServerRpc, registerClientApiHandlers } from "./generated/rpc.js";
+import { createServerRpc, registerClientSessionApiHandlers } from "./generated/rpc.js";
 import { getSdkProtocolVersion } from "./sdkProtocolVersion.js";
 import { CopilotSession, NO_RESULT_PERMISSION_V2_ERROR } from "./session.js";
 import { getTraceContext } from "./telemetry.js";
@@ -40,13 +40,13 @@ import type {
     SessionConfig,
     SessionContext,
     SessionEvent,
+    SessionFsConfig,
     SessionLifecycleEvent,
     SessionLifecycleEventType,
     SessionLifecycleHandler,
     SessionListFilter,
     SessionMetadata,
     SystemMessageCustomizeConfig,
-    SessionFsConfig,
     TelemetryConfig,
     Tool,
     ToolCallRequestPayload,
@@ -677,6 +677,9 @@ export class CopilotClient {
             session.on(config.onEvent);
         }
         this.sessions.set(sessionId, session);
+        if (this.sessionFsConfig) {
+            session.clientSessionApis.sessionFs = this.sessionFsConfig.createHandler(session);
+        }
 
         try {
             const response = await this.connection!.sendRequest("session.create", {
@@ -799,6 +802,9 @@ export class CopilotClient {
             session.on(config.onEvent);
         }
         this.sessions.set(sessionId, session);
+        if (this.sessionFsConfig) {
+            session.clientSessionApis.sessionFs = this.sessionFsConfig.createHandler(session);
+        }
 
         try {
             const response = await this.connection!.sendRequest("session.resume", {
@@ -1578,12 +1584,11 @@ export class CopilotClient {
                 await this.handleSystemMessageTransform(params)
         );
 
-        // Register session filesystem RPC handlers if configured.
-        if (this.sessionFsConfig) {
-            registerClientApiHandlers(this.connection, {
-                sessionFs: this.sessionFsConfig,
-            });
-        }
+        // Register client session API handlers.
+        const sessions = this.sessions;
+        registerClientSessionApiHandlers(this.connection, (sessionId) =>
+            sessions.get(sessionId)?.clientSessionApis,
+        );
 
         this.connection.onClose(() => {
             this.state = "disconnected";

nodejs/src/generated/rpc.ts

@@ -1196,16 +1196,14 @@ export interface SessionFsReaddirParams {
   path: string;
 }
 
-export interface SessionFsDirEntry {
-  name: string;
-  type: "file" | "directory";
-}
-
 export interface SessionFsReaddirWithTypesResult {
   /**
    * Directory entries with type information
    */
-  entries: SessionFsDirEntry[];
+  entries: {
+    name: string;
+    type: "file" | "directory";
+  }[];
 }
 
 export interface SessionFsReaddirWithTypesParams {
@@ -1378,10 +1376,7 @@ export function createSessionRpc(connection: MessageConnection, sessionId: strin
     };
 }
 
-/**
- * Handler interface for the `sessionFs` client API group.
- * Implement this to provide a custom sessionFs backend.
- */
+/** Handler for `sessionFs` client session API methods. */
 export interface SessionFsHandler {
     readFile(params: SessionFsReadFileParams): Promise<SessionFsReadFileResult>;
     writeFile(params: SessionFsWriteFileParams): Promise<void>;
@@ -1395,32 +1390,89 @@ export interface SessionFsHandler {
     rename(params: SessionFsRenameParams): Promise<void>;
 }
 
-/** All client API handler groups. Each group is optional. */
-export interface ClientApiHandlers {
+/** All client session API handler groups. */
+export interface ClientSessionApiHandlers {
     sessionFs?: SessionFsHandler;
 }
 
 /**
- * Register client API handlers on a JSON-RPC connection.
+ * Register client session API handlers on a JSON-RPC connection.
  * The server calls these methods to delegate work to the client.
- * Methods for unregistered groups will respond with a standard JSON-RPC
- * method-not-found error.
+ * Each incoming call includes a `sessionId` in the params; the registration
+ * function uses `getHandlers` to resolve the session's handlers.
  */
-export function registerClientApiHandlers(
+export function registerClientSessionApiHandlers(
     connection: MessageConnection,
-    handlers: ClientApiHandlers,
+    getHandlers: (sessionId: string) => ClientSessionApiHandlers | undefined,
 ): void {
-    if (handlers.sessionFs) {
-        const h = handlers.sessionFs!;
-        connection.onRequest("sessionFs.readFile", (params: SessionFsReadFileParams) => h.readFile(params));
-        connection.onRequest("sessionFs.writeFile", (params: SessionFsWriteFileParams) => h.writeFile(params));
-        connection.onRequest("sessionFs.appendFile", (params: SessionFsAppendFileParams) => h.appendFile(params));
-        connection.onRequest("sessionFs.exists", (params: SessionFsExistsParams) => h.exists(params));
-        connection.onRequest("sessionFs.stat", (params: SessionFsStatParams) => h.stat(params));
-        connection.onRequest("sessionFs.mkdir", (params: SessionFsMkdirParams) => h.mkdir(params));
-        connection.onRequest("sessionFs.readdir", (params: SessionFsReaddirParams) => h.readdir(params));
-        connection.onRequest("sessionFs.readdirWithTypes", (params: SessionFsReaddirWithTypesParams) => h.readdirWithTypes(params));
-        connection.onRequest("sessionFs.rm", (params: SessionFsRmParams) => h.rm(params));
-        connection.onRequest("sessionFs.rename", (params: SessionFsRenameParams) => h.rename(params));
-    }
+    connection.onRequest("sessionFs.readFile", async (params: SessionFsReadFileParams) => {
+        const handlers = getHandlers(params.sessionId);
+        if (!handlers) throw new Error(`No session found for sessionId: ${params.sessionId}`);
+        const handler = handlers.sessionFs;
+        if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);
+        return handler.readFile(params);
+    });
+    connection.onRequest("sessionFs.writeFile", async (params: SessionFsWriteFileParams) => {
+        const handlers = getHandlers(params.sessionId);
+        if (!handlers) throw new Error(`No session found for sessionId: ${params.sessionId}`);
+        const handler = handlers.sessionFs;
+        if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);
+        return handler.writeFile(params);
+    });
+    connection.onRequest("sessionFs.appendFile", async (params: SessionFsAppendFileParams) => {
+        const handlers = getHandlers(params.sessionId);
+        if (!handlers) throw new Error(`No session found for sessionId: ${params.sessionId}`);
+        const handler = handlers.sessionFs;
+        if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);
+        return handler.appendFile(params);
+    });
+    connection.onRequest("sessionFs.exists", async (params: SessionFsExistsParams) => {
+        const handlers = getHandlers(params.sessionId);
+        if (!handlers) throw new Error(`No session found for sessionId: ${params.sessionId}`);
+        const handler = handlers.sessionFs;
+        if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);
+        return handler.exists(params);
+    });
+    connection.onRequest("sessionFs.stat", async (params: SessionFsStatParams) => {
+        const handlers = getHandlers(params.sessionId);
+        if (!handlers) throw new Error(`No session found for sessionId: ${params.sessionId}`);
+        const handler = handlers.sessionFs;
+        if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);
+        return handler.stat(params);
+    });
+    connection.onRequest("sessionFs.mkdir", async (params: SessionFsMkdirParams) => {
+        const handlers = getHandlers(params.sessionId);
+        if (!handlers) throw new Error(`No session found for sessionId: ${params.sessionId}`);
+        const handler = handlers.sessionFs;
+        if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);
+        return handler.mkdir(params);
+    });
+    connection.onRequest("sessionFs.readdir", async (params: SessionFsReaddirParams) => {
+        const handlers = getHandlers(params.sessionId);
+        if (!handlers) throw new Error(`No session found for sessionId: ${params.sessionId}`);
+        const handler = handlers.sessionFs;
+        if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);
+        return handler.readdir(params);
+    });
+    connection.onRequest("sessionFs.readdirWithTypes", async (params: SessionFsReaddirWithTypesParams) => {
+        const handlers = getHandlers(params.sessionId);
+        if (!handlers) throw new Error(`No session found for sessionId: ${params.sessionId}`);
+        const handler = handlers.sessionFs;
+        if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);
+        return handler.readdirWithTypes(params);
+    });
+    connection.onRequest("sessionFs.rm", async (params: SessionFsRmParams) => {
+        const handlers = getHandlers(params.sessionId);
+        if (!handlers) throw new Error(`No session found for sessionId: ${params.sessionId}`);
+        const handler = handlers.sessionFs;
+        if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);
+        return handler.rm(params);
+    });
+    connection.onRequest("sessionFs.rename", async (params: SessionFsRenameParams) => {
+        const handlers = getHandlers(params.sessionId);
+        if (!handlers) throw new Error(`No session found for sessionId: ${params.sessionId}`);
+        const handler = handlers.sessionFs;
+        if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);
+        return handler.rename(params);
+    });
 }

nodejs/src/generated/session-events.ts

@@ -91,10 +91,6 @@ export type SessionEvent =
          * Whether the session was already in use by another client at start time
          */
         alreadyInUse?: boolean;
-        /**
-         * Whether this session supports remote steering via Mission Control
-         */
-        steerable?: boolean;
       };
     }
   | {

nodejs/src/index.ts

@@ -58,7 +58,6 @@ export type {
     SessionUiApi,
     SessionFsConfig,
     SessionFsHandler,
-    ClientApiHandlers,
     SystemMessageAppendConfig,
     SystemMessageConfig,
     SystemMessageCustomizeConfig,

nodejs/src/session.ts

@@ -10,6 +10,7 @@
 import type { MessageConnection } from "vscode-jsonrpc/node.js";
 import { ConnectionError, ResponseError } from "vscode-jsonrpc/node.js";
 import { createSessionRpc } from "./generated/rpc.js";
+import type { ClientSessionApiHandlers } from "./generated/rpc.js";
 import { getTraceContext } from "./telemetry.js";
 import type {
     CommandHandler,
@@ -83,6 +84,9 @@ export class CopilotSession {
     private traceContextProvider?: TraceContextProvider;
     private _capabilities: SessionCapabilities = {};
 
+    /** @internal Client session API handlers, populated by CopilotClient during create/resume. */
+    clientSessionApis: ClientSessionApiHandlers = {};
+
     /**
      * Creates a new CopilotSession instance.
      *

nodejs/src/types.ts

@@ -10,29 +10,8 @@
 import type { SessionEvent as GeneratedSessionEvent } from "./generated/session-events.js";
 export type SessionEvent = GeneratedSessionEvent;
 
-// Re-export generated client API types
-export type {
-    SessionFsHandler,
-    SessionFsReadFileParams,
-    SessionFsReadFileResult,
-    SessionFsWriteFileParams,
-    SessionFsAppendFileParams,
-    SessionFsExistsParams,
-    SessionFsExistsResult,
-    SessionFsStatParams,
-    SessionFsStatResult,
-    SessionFsMkdirParams,
-    SessionFsReaddirParams,
-    SessionFsReaddirResult,
-    SessionFsDirEntry,
-    SessionFsReaddirWithTypesParams,
-    SessionFsReaddirWithTypesResult,
-    SessionFsRmParams,
-    SessionFsRenameParams,
-    ClientApiHandlers,
-} from "./generated/rpc.js";
-
 import type { SessionFsHandler } from "./generated/rpc.js";
+export type { SessionFsHandler } from "./generated/rpc.js";
 
 /**
  * Options for creating a CopilotClient
@@ -644,6 +623,7 @@ export interface PermissionRequest {
 }
 
 import type { SessionPermissionsHandlePendingPermissionRequestParams } from "./generated/rpc.js";
+import { CopilotSession } from "./session.js";
 
 export type PermissionRequestResult =
     | SessionPermissionsHandlePendingPermissionRequestParams["result"]
@@ -1352,11 +1332,8 @@ export interface SessionContext {
 
 /**
  * Configuration for a custom session filesystem provider.
- *
- * Extends the generated {@link SessionFsHandler} with registration
- * parameters sent to the server's `sessionFs.setProvider` call.
  */
-export interface SessionFsConfig extends SessionFsHandler {
+export interface SessionFsConfig {
     /**
      * Initial working directory for sessions (user's project directory).
      */
@@ -1372,6 +1349,11 @@ export interface SessionFsConfig extends SessionFsHandler {
      * Path conventions used by this filesystem provider.
      */
     conventions: "windows" | "linux";
+
+    /**
+     * Supplies a handler for session filesystem operations.
+     */
+    createHandler: (session: CopilotSession) => SessionFsHandler;
 }
 
 /**