Use RPC from json schema

Author: SteveSandersonMS

nodejs/src/client.ts

@@ -24,7 +24,7 @@ import {
     StreamMessageWriter,
 } from "vscode-jsonrpc/node.js";
 import { createServerRpc, registerClientApiHandlers } from "./generated/rpc.js";
-import type { SessionStoreHandler } from "./generated/rpc.js";
+import type { SessionDataStoreHandler } from "./generated/rpc.js";
 import { getSdkProtocolVersion } from "./sdkProtocolVersion.js";
 import { CopilotSession, NO_RESULT_PERMISSION_V2_ERROR } from "./session.js";
 import { getTraceContext } from "./telemetry.js";
@@ -45,7 +45,7 @@ import type {
     SessionLifecycleHandler,
     SessionListFilter,
     SessionMetadata,
-    SessionStoreConfig,
+    SessionDataStoreConfig,
     TelemetryConfig,
     Tool,
     ToolCallRequestPayload,
@@ -156,6 +156,7 @@ export class CopilotClient {
             | "onListModels"
             | "telemetry"
             | "onGetTraceContext"
+            | "sessionDataStore"
         >
     > & {
         cliPath?: string;
@@ -178,8 +179,8 @@ export class CopilotClient {
     private _rpc: ReturnType<typeof createServerRpc> | null = null;
     private processExitPromise: Promise<never> | null = null; // Rejects when CLI process exits
     private negotiatedProtocolVersion: number | null = null;
-    /** Connection-level storage provider config set via setStorageProvider(). */
-    private storageProviderConfig: SessionStoreConfig | null = null;
+    /** Connection-level session data store config, set via constructor option. */
+    private sessionDataStoreConfig: SessionDataStoreConfig | null = null;
 
     /**
      * Typed server-scoped RPC methods.
@@ -249,6 +250,7 @@ export class CopilotClient {
 
         this.onListModels = options.onListModels;
         this.onGetTraceContext = options.onGetTraceContext;
+        this.sessionDataStoreConfig = options.sessionDataStore ?? null;
 
         this.options = {
             cliPath: options.cliUrl ? undefined : options.cliPath || getBundledCliPath(),
@@ -338,47 +340,20 @@ export class CopilotClient {
             // Verify protocol version compatibility
             await this.verifyProtocolVersion();
 
+            // If a session data store was configured, register as the storage provider
+            if (this.sessionDataStoreConfig) {
+                await this.connection!.sendRequest("sessionDataStore.setDataStore", {
+                    descriptor: this.sessionDataStoreConfig.descriptor,
+                });
+            }
+
             this.state = "connected";
         } catch (error) {
             this.state = "error";
             throw error;
         }
     }
 
-    /**
-     * Declare this client as the session data storage provider.
-     * Must be called before creating any sessions. Only one client can be the
-     * storage provider at a time.
-     *
-     * @param config - The storage provider configuration with callbacks for persistence
-     * @throws Error if the client is not connected and autoStart is disabled
-     *
-     * @example
-     * ```typescript
-     * await client.setStorageProvider({
-     *   descriptor: "redis://localhost/sessions",
-     *   onLoad: async (sessionId) => loadEventsFromRedis(sessionId),
-     *   onAppend: async (events, sessionId) => appendEventsToRedis(events, sessionId),
-     *   onTruncate: async (upToEventId, sessionId) => truncateEventsInRedis(upToEventId, sessionId),
-     *   onListSessions: async () => listSessionsFromRedis(),
-     *   onDelete: async (sessionId) => deleteSessionFromRedis(sessionId),
-     * });
-     * ```
-     */
-    async setStorageProvider(config: SessionStoreConfig): Promise<void> {
-        if (!this.connection) {
-            if (this.options.autoStart) {
-                await this.start();
-            } else {
-                throw new Error("Client not connected. Call start() first.");
-            }
-        }
-        await this.connection!.sendRequest("session.setStorageProvider", {
-            descriptor: config.descriptor,
-        });
-        this.storageProviderConfig = config;
-    }
-
     /**
      * Stops the CLI server and closes all active sessions.
      *
@@ -436,7 +411,6 @@ export class CopilotClient {
             }
         }
         this.sessions.clear();
-        this.storageProviderConfig = null;
 
         // Close connection
         if (this.connection) {
@@ -521,7 +495,6 @@ export class CopilotClient {
 
         // Clear sessions immediately without trying to destroy them
         this.sessions.clear();
-        this.storageProviderConfig = null;
 
         // Force close connection
         if (this.connection) {
@@ -1506,10 +1479,9 @@ export class CopilotClient {
             }): Promise<{ output?: unknown }> => await this.handleHooksInvoke(params)
         );
 
-        // Register session store RPC handlers via generated registration function.
-        // The handler routes each call to the appropriate SessionStoreConfig based on sessionId.
+        // Register session data store RPC handlers via generated registration function.
         registerClientApiHandlers(this.connection, {
-            sessionStore: this.createSessionStoreHandler(),
+            sessionDataStore: this.createSessionDataStoreHandler(),
         });
 
         this.connection.onClose(() => {
@@ -1522,15 +1494,15 @@ export class CopilotClient {
     }
 
     /**
-     * Create a {@link SessionStoreHandler} that routes each RPC call to the
-     * connection-level storage provider set via {@link setStorageProvider}.
+     * Create a {@link SessionDataStoreHandler} that routes each RPC call to the
+     * connection-level session data store set via constructor option.
      */
-    private createSessionStoreHandler(): SessionStoreHandler {
-        const getStore = (): SessionStoreConfig => {
-            if (!this.storageProviderConfig) {
-                throw new Error("No storage provider configured. Call setStorageProvider() first.");
+    private createSessionDataStoreHandler(): SessionDataStoreHandler {
+        const getStore = (): SessionDataStoreConfig => {
+            if (!this.sessionDataStoreConfig) {
+                throw new Error("No session data store configured.");
             }
-            return this.storageProviderConfig;
+            return this.sessionDataStoreConfig;
         };
 
         return {

nodejs/src/generated/rpc.ts

@@ -179,6 +179,20 @@ export interface AccountGetQuotaResult {
   };
 }
 
+export interface SessionDataStoreSetDataStoreResult {
+  /**
+   * Whether the data store was set successfully
+   */
+  success: boolean;
+}
+
+export interface SessionDataStoreSetDataStoreParams {
+  /**
+   * Opaque descriptor identifying the storage backend (e.g., 'redis://localhost/sessions')
+   */
+  descriptor: string;
+}
+
 export interface SessionModelGetCurrentResult {
   /**
    * Currently active model identifier
@@ -1010,7 +1024,7 @@ export interface SessionShellKillParams {
   signal?: "SIGTERM" | "SIGKILL" | "SIGINT";
 }
 
-export interface SessionStoreLoadResult {
+export interface SessionDataStoreLoadResult {
   /**
    * All persisted events for the session, in order
    */
@@ -1019,14 +1033,14 @@ export interface SessionStoreLoadResult {
   }[];
 }
 
-export interface SessionStoreLoadParams {
+export interface SessionDataStoreLoadParams {
   /**
    * The session to load events for
    */
   sessionId: string;
 }
 
-export interface SessionStoreAppendParams {
+export interface SessionDataStoreAppendParams {
   /**
    * The session to append events to
    */
@@ -1039,7 +1053,7 @@ export interface SessionStoreAppendParams {
   }[];
 }
 
-export interface SessionStoreTruncateResult {
+export interface SessionDataStoreTruncateResult {
   /**
    * Number of events removed
    */
@@ -1050,7 +1064,7 @@ export interface SessionStoreTruncateResult {
   eventsKept: number;
 }
 
-export interface SessionStoreTruncateParams {
+export interface SessionDataStoreTruncateParams {
   /**
    * The session to truncate
    */
@@ -1061,7 +1075,7 @@ export interface SessionStoreTruncateParams {
   upToEventId: string;
 }
 
-export interface SessionStoreListResult {
+export interface SessionDataStoreListResult {
   sessions: {
     sessionId: string;
     /**
@@ -1075,7 +1089,7 @@ export interface SessionStoreListResult {
   }[];
 }
 
-export interface SessionStoreDeleteParams {
+export interface SessionDataStoreDeleteParams {
   /**
    * The session to delete
    */
@@ -1099,6 +1113,10 @@ export function createServerRpc(connection: MessageConnection) {
             getQuota: async (): Promise<AccountGetQuotaResult> =>
                 connection.sendRequest("account.getQuota", {}),
         },
+        sessionDataStore: {
+            setDataStore: async (params: SessionDataStoreSetDataStoreParams): Promise<SessionDataStoreSetDataStoreResult> =>
+                connection.sendRequest("sessionDataStore.setDataStore", params),
+        },
     };
 }
 
@@ -1215,20 +1233,20 @@ export function createSessionRpc(connection: MessageConnection, sessionId: strin
 }
 
 /**
- * Handler interface for the `sessionStore` client API group.
- * Implement this to provide a custom sessionStore backend.
+ * Handler interface for the `sessionDataStore` client API group.
+ * Implement this to provide a custom sessionDataStore backend.
  */
-export interface SessionStoreHandler {
-    load(params: SessionStoreLoadParams): Promise<SessionStoreLoadResult>;
-    append(params: SessionStoreAppendParams): Promise<void>;
-    truncate(params: SessionStoreTruncateParams): Promise<SessionStoreTruncateResult>;
-    list(): Promise<SessionStoreListResult>;
-    delete(params: SessionStoreDeleteParams): Promise<void>;
+export interface SessionDataStoreHandler {
+    load(params: SessionDataStoreLoadParams): Promise<SessionDataStoreLoadResult>;
+    append(params: SessionDataStoreAppendParams): Promise<void>;
+    truncate(params: SessionDataStoreTruncateParams): Promise<SessionDataStoreTruncateResult>;
+    list(): Promise<SessionDataStoreListResult>;
+    delete(params: SessionDataStoreDeleteParams): Promise<void>;
 }
 
 /** All client API handler groups. Each group is optional. */
 export interface ClientApiHandlers {
-    sessionStore?: SessionStoreHandler;
+    sessionDataStore?: SessionDataStoreHandler;
 }
 
 /**
@@ -1241,12 +1259,12 @@ export function registerClientApiHandlers(
     connection: MessageConnection,
     handlers: ClientApiHandlers,
 ): void {
-    if (handlers.sessionStore) {
-        const h = handlers.sessionStore!;
-        connection.onRequest("sessionStore.load", (params: SessionStoreLoadParams) => h.load(params));
-        connection.onRequest("sessionStore.append", (params: SessionStoreAppendParams) => h.append(params));
-        connection.onRequest("sessionStore.truncate", (params: SessionStoreTruncateParams) => h.truncate(params));
-        connection.onRequest("sessionStore.list", () => h.list());
-        connection.onRequest("sessionStore.delete", (params: SessionStoreDeleteParams) => h.delete(params));
+    if (handlers.sessionDataStore) {
+        const h = handlers.sessionDataStore!;
+        connection.onRequest("sessionDataStore.load", (params: SessionDataStoreLoadParams) => h.load(params));
+        connection.onRequest("sessionDataStore.append", (params: SessionDataStoreAppendParams) => h.append(params));
+        connection.onRequest("sessionDataStore.truncate", (params: SessionDataStoreTruncateParams) => h.truncate(params));
+        connection.onRequest("sessionDataStore.list", () => h.list());
+        connection.onRequest("sessionDataStore.delete", (params: SessionDataStoreDeleteParams) => h.delete(params));
     }
 }

nodejs/src/index.ts

@@ -43,9 +43,8 @@ export type {
     SessionContext,
     SessionListFilter,
     SessionMetadata,
-    SessionStoreConfig,
-    SessionStoreHandler,
-    StorageProviderConfig,
+    SessionDataStoreConfig,
+    SessionDataStoreHandler,
     ClientApiHandlers,
     SystemMessageAppendConfig,
     SystemMessageConfig,

nodejs/src/types.ts

@@ -12,14 +12,14 @@ export type SessionEvent = GeneratedSessionEvent;
 
 // Re-export generated client API types
 export type {
-    SessionStoreHandler,
-    SessionStoreLoadParams,
-    SessionStoreLoadResult,
-    SessionStoreAppendParams,
-    SessionStoreTruncateParams,
-    SessionStoreTruncateResult,
-    SessionStoreListResult,
-    SessionStoreDeleteParams,
+    SessionDataStoreHandler,
+    SessionDataStoreLoadParams,
+    SessionDataStoreLoadResult,
+    SessionDataStoreAppendParams,
+    SessionDataStoreTruncateParams,
+    SessionDataStoreTruncateResult,
+    SessionDataStoreListResult,
+    SessionDataStoreDeleteParams,
     ClientApiHandlers,
 } from "./generated/rpc.js";
 
@@ -184,6 +184,14 @@ export interface CopilotClientOptions {
      * ```
      */
     onGetTraceContext?: TraceContextProvider;
+
+    /**
+     * Custom session data storage backend.
+     * When provided, the client registers as the session data storage provider
+     * on connection, routing all event persistence through these callbacks
+     * instead of the server's default file-based storage.
+     */
+    sessionDataStore?: SessionDataStoreConfig;
 }
 
 /**
@@ -1021,19 +1029,14 @@ export interface SessionContext {
 }
 
 /**
- * Callbacks for a session event store. When provided to {@link SessionConfig.sessionStore},
- * the server routes all event persistence through these callbacks over RPC instead
- * of using its default file-based storage.
- */
-/**
- * Configuration for a custom session store backend.
+ * Configuration for a custom session data store backend.
  *
  * The `descriptor` identifies the storage backend. The callback methods
- * correspond to the generated {@link SessionStoreHandler} interface but
+ * correspond to the generated {@link SessionDataStoreHandler} interface but
  * use a consumer-friendly signature where `sessionId` is a plain argument
  * rather than embedded in a params object.
  */
-export interface SessionStoreConfig {
+export interface SessionDataStoreConfig {
     /**
      * Opaque descriptor identifying this storage backend.
      * Used for UI display (e.g., `"redis://localhost/sessions"`).
@@ -1069,13 +1072,6 @@ export interface ListSessionsOptions {
     filter?: SessionListFilter;
 }
 
-/**
- * Configuration for becoming the session data storage provider.
- * Same shape as SessionStoreConfig — call client.setStorageProvider(config)
- * to claim storage before creating sessions.
- */
-export type StorageProviderConfig = SessionStoreConfig;
-
 /**
  * Filter options for listing sessions
  */