feat: replace sessionDataStore with SessionFs virtual filesystem

Migrate the TypeScript SDK from the event-level sessionDataStore
abstraction to the general-purpose SessionFs virtual filesystem,
matching the runtime's new design (copilot-agent-runtime#5432).

Key changes:
- Regenerate RPC types from runtime schema with sessionFs.* methods
- Replace SessionDataStoreConfig with SessionFsConfig (initialCwd,
  sessionStatePath, conventions + 9 filesystem handler callbacks)
- Client calls sessionFs.setProvider on connect (was setDataStore)
- Client registers sessionFs.* RPC handlers (readFile, writeFile,
  appendFile, exists, stat, mkdir, readdir, rm, rename)
- New E2E tests with InMemorySessionFs (filesystem-level, not events)
- Remove old session_store tests and snapshots

Author: SteveSandersonMS

nodejs/src/client.ts

@@ -46,7 +46,7 @@ import type {
     SessionListFilter,
     SessionMetadata,
     SystemMessageCustomizeConfig,
-    SessionDataStoreConfig,
+    SessionFsConfig,
     TelemetryConfig,
     Tool,
     ToolCallRequestPayload,
@@ -217,7 +217,7 @@ export class CopilotClient {
             | "onListModels"
             | "telemetry"
             | "onGetTraceContext"
-            | "sessionDataStore"
+            | "sessionFs"
         >
     > & {
         cliPath?: string;
@@ -240,8 +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;
+    /** Connection-level session filesystem config, set via constructor option. */
+    private sessionFsConfig: SessionFsConfig | null = null;
 
     /**
      * Typed server-scoped RPC methods.
@@ -311,7 +311,7 @@ export class CopilotClient {
 
         this.onListModels = options.onListModels;
         this.onGetTraceContext = options.onGetTraceContext;
-        this.sessionDataStoreConfig = options.sessionDataStore ?? null;
+        this.sessionFsConfig = options.sessionFs ?? null;
 
         const effectiveEnv = options.env ?? process.env;
         this.options = {
@@ -404,10 +404,12 @@ 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,
+            // If a session filesystem provider was configured, register it
+            if (this.sessionFsConfig) {
+                await this.connection!.sendRequest("sessionFs.setProvider", {
+                    initialCwd: this.sessionFsConfig.initialCwd,
+                    sessionStatePath: this.sessionFsConfig.sessionStatePath,
+                    conventions: this.sessionFsConfig.conventions,
                 });
             }
 
@@ -1576,10 +1578,10 @@ export class CopilotClient {
                 await this.handleSystemMessageTransform(params)
         );
 
-        // Register session data store RPC handlers if configured.
-        if (this.sessionDataStoreConfig) {
+        // Register session filesystem RPC handlers if configured.
+        if (this.sessionFsConfig) {
             registerClientApiHandlers(this.connection, {
-                sessionDataStore: this.sessionDataStoreConfig,
+                sessionFs: this.sessionFsConfig,
             });
         }
 

nodejs/src/generated/rpc.ts

@@ -179,18 +179,26 @@ export interface AccountGetQuotaResult {
   };
 }
 
-export interface SessionDataStoreSetDataStoreResult {
+export interface SessionFsSetProviderResult {
   /**
-   * Whether the data store was set successfully
+   * Whether the provider was set successfully
    */
   success: boolean;
 }
 
-export interface SessionDataStoreSetDataStoreParams {
+export interface SessionFsSetProviderParams {
   /**
-   * Opaque descriptor identifying the storage backend (e.g., 'redis://localhost/sessions')
+   * Initial working directory for sessions
    */
-  descriptor: string;
+  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" | "linux";
 }
 
 export interface SessionModelGetCurrentResult {
@@ -1064,76 +1072,143 @@ export interface SessionShellKillParams {
   signal?: "SIGTERM" | "SIGKILL" | "SIGINT";
 }
 
-export interface SessionDataStoreLoadResult {
+export interface SessionFsReadFileResult {
   /**
-   * All persisted events for the session, in order
+   * File content as UTF-8 string
    */
-  events: {
-    [k: string]: unknown;
-  }[];
+  content: string;
 }
 
-export interface SessionDataStoreLoadParams {
+export interface SessionFsReadFileParams {
   /**
-   * The session to load events for
+   * Target session identifier
    */
   sessionId: string;
+  /**
+   * Path using SessionFs conventions
+   */
+  path: string;
 }
 
-export interface SessionDataStoreAppendParams {
+export interface SessionFsWriteFileParams {
   /**
-   * The session to append events to
+   * Target session identifier
    */
   sessionId: string;
   /**
-   * Events to append, in order
+   * Path using SessionFs conventions
    */
-  events: {
-    [k: string]: unknown;
-  }[];
+  path: string;
+  /**
+   * Content to write
+   */
+  content: string;
+  /**
+   * Optional POSIX-style mode for newly created files
+   */
+  mode?: number;
 }
 
-export interface SessionDataStoreTruncateResult {
+export interface SessionFsAppendFileParams {
+  /**
+   * Target session identifier
+   */
+  sessionId: string;
+  /**
+   * Path using SessionFs conventions
+   */
+  path: string;
   /**
-   * Number of events removed
+   * Content to append
    */
-  eventsRemoved: number;
+  content: string;
   /**
-   * Number of events kept
+   * Optional POSIX-style mode for newly created files
    */
-  eventsKept: number;
+  mode?: number;
+}
+
+export interface SessionFsExistsResult {
+  exists: boolean;
 }
 
-export interface SessionDataStoreTruncateParams {
+export interface SessionFsExistsParams {
   /**
-   * The session to truncate
+   * Target session identifier
    */
   sessionId: string;
   /**
-   * Event ID marking the truncation boundary (excluded)
+   * Path using SessionFs conventions
    */
-  upToEventId: string;
+  path: string;
 }
 
-export interface SessionDataStoreListResult {
-  sessions: {
-    sessionId: string;
-    /**
-     * ISO 8601 timestamp of last modification
-     */
-    mtime: string;
-    /**
-     * ISO 8601 timestamp of creation
-     */
-    birthtime: string;
-  }[];
+export interface SessionFsStatResult {
+  isFile: boolean;
+  isDirectory: boolean;
+  size: number;
+  /**
+   * ISO 8601 timestamp of last modification
+   */
+  mtime: string;
+  /**
+   * ISO 8601 timestamp of creation
+   */
+  birthtime: string;
 }
 
-export interface SessionDataStoreDeleteParams {
+export interface SessionFsStatParams {
+  /**
+   * Target session identifier
+   */
+  sessionId: string;
   /**
-   * The session to delete
+   * Path using SessionFs conventions
+   */
+  path: string;
+}
+
+export interface SessionFsMkdirParams {
+  /**
+   * Target session identifier
+   */
+  sessionId: string;
+  path: string;
+  recursive?: boolean;
+}
+
+export interface SessionFsReaddirResult {
+  /**
+   * Entry names in the directory
+   */
+  entries: string[];
+}
+
+export interface SessionFsReaddirParams {
+  /**
+   * Target session identifier
+   */
+  sessionId: string;
+  path: string;
+}
+
+export interface SessionFsRmParams {
+  /**
+   * Target session identifier
+   */
+  sessionId: string;
+  path: string;
+  recursive?: boolean;
+  force?: boolean;
+}
+
+export interface SessionFsRenameParams {
+  /**
+   * Target session identifier
    */
   sessionId: string;
+  src: string;
+  dest: string;
 }
 
 /** Create typed server-scoped RPC methods (no session required). */
@@ -1153,9 +1228,9 @@ 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),
+        sessionFs: {
+            setProvider: async (params: SessionFsSetProviderParams): Promise<SessionFsSetProviderResult> =>
+                connection.sendRequest("sessionFs.setProvider", params),
         },
     };
 }
@@ -1280,20 +1355,24 @@ export function createSessionRpc(connection: MessageConnection, sessionId: strin
 }
 
 /**
- * Handler interface for the `sessionDataStore` client API group.
- * Implement this to provide a custom sessionDataStore backend.
+ * Handler interface for the `sessionFs` client API group.
+ * Implement this to provide a custom sessionFs 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>;
+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>;
+    rm(params: SessionFsRmParams): Promise<void>;
+    rename(params: SessionFsRenameParams): Promise<void>;
 }
 
 /** All client API handler groups. Each group is optional. */
 export interface ClientApiHandlers {
-    sessionDataStore?: SessionDataStoreHandler;
+    sessionFs?: SessionFsHandler;
 }
 
 /**
@@ -1306,12 +1385,16 @@ 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));
+    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.rm", (params: SessionFsRmParams) => h.rm(params));
+        connection.onRequest("sessionFs.rename", (params: SessionFsRenameParams) => h.rename(params));
     }
 }

nodejs/src/generated/session-events.ts

@@ -91,6 +91,10 @@ 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

@@ -56,8 +56,8 @@ export type {
     SessionListFilter,
     SessionMetadata,
     SessionUiApi,
-    SessionDataStoreConfig,
-    SessionDataStoreHandler,
+    SessionFsConfig,
+    SessionFsHandler,
     ClientApiHandlers,
     SystemMessageAppendConfig,
     SystemMessageConfig,