feat: add session data store support to TypeScript SDK

- Add sessionDataStore option to CopilotClientOptions
- Extend codegen to generate client API handler types (SessionDataStoreHandler)
- Register as session data storage provider on connection via sessionDataStore.setDataStore RPC
- Add E2E tests for persist, resume, list, delete, and reject scenarios

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: SteveSandersonMS

nodejs/src/client.ts

@@ -24,7 +24,7 @@ import {
     StreamMessageReader,
     StreamMessageWriter,
 } from "vscode-jsonrpc/node.js";
-import { createServerRpc } from "./generated/rpc.js";
+import { createServerRpc, registerClientApiHandlers } from "./generated/rpc.js";
 import { getSdkProtocolVersion } from "./sdkProtocolVersion.js";
 import { CopilotSession, NO_RESULT_PERMISSION_V2_ERROR } from "./session.js";
 import { getTraceContext } from "./telemetry.js";
@@ -46,6 +46,7 @@ import type {
     SessionListFilter,
     SessionMetadata,
     SystemMessageCustomizeConfig,
+    SessionDataStoreConfig,
     TelemetryConfig,
     Tool,
     ToolCallRequestPayload,
@@ -216,6 +217,7 @@ export class CopilotClient {
             | "onListModels"
             | "telemetry"
             | "onGetTraceContext"
+            | "sessionDataStore"
         >
     > & {
         cliPath?: string;
@@ -238,6 +240,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 session data store config, set via constructor option. */
+    private sessionDataStoreConfig: SessionDataStoreConfig | null = null;
 
     /**
      * Typed server-scoped RPC methods.
@@ -307,6 +311,7 @@ export class CopilotClient {
 
         this.onListModels = options.onListModels;
         this.onGetTraceContext = options.onGetTraceContext;
+        this.sessionDataStoreConfig = options.sessionDataStore ?? null;
 
         const effectiveEnv = options.env ?? process.env;
         this.options = {
@@ -399,6 +404,13 @@ 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";
@@ -1069,7 +1081,9 @@ export class CopilotClient {
             throw new Error("Client not connected");
         }
 
-        const response = await this.connection.sendRequest("session.list", { filter });
+        const response = await this.connection.sendRequest("session.list", {
+            filter,
+        });
         const { sessions } = response as {
             sessions: Array<{
                 sessionId: string;
@@ -1562,6 +1576,13 @@ export class CopilotClient {
                 await this.handleSystemMessageTransform(params)
         );
 
+        // Register session data store RPC handlers if configured.
+        if (this.sessionDataStoreConfig) {
+            registerClientApiHandlers(this.connection, {
+                sessionDataStore: this.sessionDataStoreConfig,
+            });
+        }
+
         this.connection.onClose(() => {
             this.state = "disconnected";
         });

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
@@ -1050,6 +1064,78 @@ export interface SessionShellKillParams {
   signal?: "SIGTERM" | "SIGKILL" | "SIGINT";
 }
 
+export interface SessionDataStoreLoadResult {
+  /**
+   * All persisted events for the session, in order
+   */
+  events: {
+    [k: string]: unknown;
+  }[];
+}
+
+export interface SessionDataStoreLoadParams {
+  /**
+   * The session to load events for
+   */
+  sessionId: string;
+}
+
+export interface SessionDataStoreAppendParams {
+  /**
+   * The session to append events to
+   */
+  sessionId: string;
+  /**
+   * Events to append, in order
+   */
+  events: {
+    [k: string]: unknown;
+  }[];
+}
+
+export interface SessionDataStoreTruncateResult {
+  /**
+   * Number of events removed
+   */
+  eventsRemoved: number;
+  /**
+   * Number of events kept
+   */
+  eventsKept: number;
+}
+
+export interface SessionDataStoreTruncateParams {
+  /**
+   * The session to truncate
+   */
+  sessionId: string;
+  /**
+   * Event ID marking the truncation boundary (excluded)
+   */
+  upToEventId: string;
+}
+
+export interface SessionDataStoreListResult {
+  sessions: {
+    sessionId: string;
+    /**
+     * ISO 8601 timestamp of last modification
+     */
+    mtime: string;
+    /**
+     * ISO 8601 timestamp of creation
+     */
+    birthtime: string;
+  }[];
+}
+
+export interface SessionDataStoreDeleteParams {
+  /**
+   * The session to delete
+   */
+  sessionId: string;
+}
+
 /** Create typed server-scoped RPC methods (no session required). */
 export function createServerRpc(connection: MessageConnection) {
     return {
@@ -1067,6 +1153,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),
+        },
     };
 }
 
@@ -1188,3 +1278,40 @@ export function createSessionRpc(connection: MessageConnection, sessionId: strin
         },
     };
 }
+
+/**
+ * Handler interface for the `sessionDataStore` client API group.
+ * Implement this to provide a custom sessionDataStore backend.
+ */
+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 {
+    sessionDataStore?: SessionDataStoreHandler;
+}
+
+/**
+ * Register client 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.
+ */
+export function registerClientApiHandlers(
+    connection: MessageConnection,
+    handlers: ClientApiHandlers,
+): void {
+    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

@@ -56,6 +56,9 @@ export type {
     SessionListFilter,
     SessionMetadata,
     SessionUiApi,
+    SessionDataStoreConfig,
+    SessionDataStoreHandler,
+    ClientApiHandlers,
     SystemMessageAppendConfig,
     SystemMessageConfig,
     SystemMessageCustomizeConfig,

nodejs/src/types.ts

@@ -10,6 +10,21 @@
 import type { SessionEvent as GeneratedSessionEvent } from "./generated/session-events.js";
 export type SessionEvent = GeneratedSessionEvent;
 
+// Re-export generated client API types
+export type {
+    SessionDataStoreHandler,
+    SessionDataStoreLoadParams,
+    SessionDataStoreLoadResult,
+    SessionDataStoreAppendParams,
+    SessionDataStoreTruncateParams,
+    SessionDataStoreTruncateResult,
+    SessionDataStoreListResult,
+    SessionDataStoreDeleteParams,
+    ClientApiHandlers,
+} from "./generated/rpc.js";
+
+import type { SessionDataStoreHandler } from "./generated/rpc.js";
+
 /**
  * Options for creating a CopilotClient
  */
@@ -171,6 +186,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;
 }
 
 /**
@@ -1318,6 +1341,20 @@ export interface SessionContext {
     branch?: string;
 }
 
+/**
+ * Configuration for a custom session data store backend.
+ *
+ * Extends the generated {@link SessionDataStoreHandler} with a `descriptor`
+ * that identifies the storage backend for display purposes.
+ */
+export interface SessionDataStoreConfig extends SessionDataStoreHandler {
+    /**
+     * Opaque descriptor identifying this storage backend.
+     * Used for UI display (e.g., `"redis://localhost/sessions"`).
+     */
+    descriptor: string;
+}
+
 /**
  * Filter options for listing sessions
  */