@github/copilot-sdk 0.1.24-preview.0 → 0.1.25-preview.0

package/README.md

@@ -10,6 +10,19 @@ TypeScript SDK for programmatic control of GitHub Copilot CLI via JSON-RPC.
 npm install @github/copilot-sdk
 ```
 
+## Run the Sample
+
+Try the interactive chat sample (from the repo root):
+
+```bash
+cd nodejs
+npm ci
+npm run build
+cd samples
+npm install
+npm start
+```
+
 ## Quick Start
 
 ```typescript
@@ -108,9 +121,25 @@ Ping the server to check connectivity.
 
 Get current connection state.
 
-##### `listSessions(): Promise<SessionMetadata[]>`
+##### `listSessions(filter?: SessionListFilter): Promise<SessionMetadata[]>`
+
+List all available sessions. Optionally filter by working directory context.
+
+**SessionMetadata:**
+
+- `sessionId: string` - Unique session identifier
+- `startTime: Date` - When the session was created
+- `modifiedTime: Date` - When the session was last modified
+- `summary?: string` - Optional session summary
+- `isRemote: boolean` - Whether the session is remote
+- `context?: SessionContext` - Working directory context from session creation
+
+**SessionContext:**
 
-List all available sessions.
+- `cwd: string` - Working directory where the session was created
+- `gitRoot?: string` - Git repository root (if in a git repo)
+- `repository?: string` - GitHub repository in "owner/repo" format
+- `branch?: string` - Current git branch
 
 ##### `deleteSession(sessionId: string): Promise<void>`
 

package/dist/client.d.ts

@@ -1,5 +1,6 @@
+import { createServerRpc } from "./generated/rpc.js";
 import { CopilotSession } from "./session.js";
-import type { ConnectionState, CopilotClientOptions, GetAuthStatusResponse, GetStatusResponse, ModelInfo, ResumeSessionConfig, SessionConfig, SessionLifecycleEventType, SessionLifecycleHandler, SessionMetadata, TypedSessionLifecycleHandler } from "./types.js";
+import type { ConnectionState, CopilotClientOptions, GetAuthStatusResponse, GetStatusResponse, ModelInfo, ResumeSessionConfig, SessionConfig, SessionLifecycleEventType, SessionLifecycleHandler, SessionListFilter, SessionMetadata, TypedSessionLifecycleHandler } from "./types.js";
 export declare class CopilotClient {
     private cliProcess;
     private connection;
@@ -8,6 +9,7 @@ export declare class CopilotClient {
     private actualHost;
     private state;
     private sessions;
+    private stderrBuffer;
     private options;
     private isExternalServer;
     private forceStopping;
@@ -15,6 +17,13 @@ export declare class CopilotClient {
     private modelsCacheLock;
     private sessionLifecycleHandlers;
     private typedLifecycleHandlers;
+    private _rpc;
+    private processExitPromise;
+    /**
+     * Typed server-scoped RPC methods.
+     * @throws Error if the client is not connected
+     */
+    get rpc(): ReturnType<typeof createServerRpc>;
     /**
      * Creates a new CopilotClient instance.
      *
@@ -247,22 +256,19 @@ export declare class CopilotClient {
      */
     deleteSession(sessionId: string): Promise<void>;
     /**
-     * Lists all available sessions known to the server.
+     * List all available sessions.
      *
-     * Returns metadata about each session including ID, timestamps, and summary.
-     *
-     * @returns A promise that resolves with an array of session metadata
-     * @throws Error if the client is not connected
+     * @param filter - Optional filter to limit returned sessions by context fields
      *
      * @example
-     * ```typescript
+     * // List all sessions
      * const sessions = await client.listSessions();
-     * for (const session of sessions) {
-     *   console.log(`${session.sessionId}: ${session.summary}`);
-     * }
-     * ```
+     *
+     * @example
+     * // List sessions for a specific repository
+     * const sessions = await client.listSessions({ repository: "owner/repo" });
      */
-    listSessions(): Promise<SessionMetadata[]>;
+    listSessions(filter?: SessionListFilter): Promise<SessionMetadata[]>;
     /**
      * Gets the foreground session ID in TUI+server mode.
      *

package/dist/client.js

@@ -8,6 +8,7 @@ import {
   StreamMessageReader,
   StreamMessageWriter
 } from "vscode-jsonrpc/node.js";
+import { createServerRpc } from "./generated/rpc.js";
 import { getSdkProtocolVersion } from "./sdkProtocolVersion.js";
 import { CopilotSession } from "./session.js";
 function isZodSchema(value) {
@@ -33,6 +34,8 @@ class CopilotClient {
   actualHost = "localhost";
   state = "disconnected";
   sessions = /* @__PURE__ */ new Map();
+  stderrBuffer = "";
+  // Captures CLI stderr for error messages
   options;
   isExternalServer = false;
   forceStopping = false;
@@ -40,6 +43,22 @@ class CopilotClient {
   modelsCacheLock = Promise.resolve();
   sessionLifecycleHandlers = /* @__PURE__ */ new Set();
   typedLifecycleHandlers = /* @__PURE__ */ new Map();
+  _rpc = null;
+  processExitPromise = null;
+  // Rejects when CLI process exits
+  /**
+   * Typed server-scoped RPC methods.
+   * @throws Error if the client is not connected
+   */
+  get rpc() {
+    if (!this.connection) {
+      throw new Error("Client is not connected. Call start() first.");
+    }
+    if (!this._rpc) {
+      this._rpc = createServerRpc(this.connection);
+    }
+    return this._rpc;
+  }
   /**
    * Creates a new CopilotClient instance.
    *
@@ -207,6 +226,7 @@ class CopilotClient {
         );
       }
       this.connection = null;
+      this._rpc = null;
     }
     this.modelsCache = null;
     if (this.socket) {
@@ -235,6 +255,8 @@ class CopilotClient {
     }
     this.state = "disconnected";
     this.actualPort = null;
+    this.stderrBuffer = "";
+    this.processExitPromise = null;
     return errors;
   }
   /**
@@ -271,6 +293,7 @@ class CopilotClient {
       } catch {
       }
       this.connection = null;
+      this._rpc = null;
     }
     this.modelsCache = null;
     if (this.socket) {
@@ -289,6 +312,8 @@ class CopilotClient {
     }
     this.state = "disconnected";
     this.actualPort = null;
+    this.stderrBuffer = "";
+    this.processExitPromise = null;
   }
   /**
    * Creates a new conversation session with the Copilot CLI.
@@ -345,6 +370,7 @@ class CopilotClient {
       workingDirectory: config.workingDirectory,
       streaming: config.streaming,
       mcpServers: config.mcpServers,
+      envValueMode: "direct",
       customAgents: config.customAgents,
       configDir: config.configDir,
       skillDirectories: config.skillDirectories,
@@ -417,6 +443,7 @@ class CopilotClient {
       configDir: config.configDir,
       streaming: config.streaming,
       mcpServers: config.mcpServers,
+      envValueMode: "direct",
       customAgents: config.customAgents,
       skillDirectories: config.skillDirectories,
       disabledSkills: config.disabledSkills,
@@ -528,7 +555,12 @@ class CopilotClient {
    */
   async verifyProtocolVersion() {
     const expectedVersion = getSdkProtocolVersion();
-    const pingResult = await this.ping();
+    let pingResult;
+    if (this.processExitPromise) {
+      pingResult = await Promise.race([this.ping(), this.processExitPromise]);
+    } else {
+      pingResult = await this.ping();
+    }
     const serverVersion = pingResult.protocolVersion;
     if (serverVersion === void 0) {
       throw new Error(
@@ -594,33 +626,31 @@ class CopilotClient {
     this.sessions.delete(sessionId);
   }
   /**
-   * Lists all available sessions known to the server.
+   * List all available sessions.
    *
-   * Returns metadata about each session including ID, timestamps, and summary.
-   *
-   * @returns A promise that resolves with an array of session metadata
-   * @throws Error if the client is not connected
+   * @param filter - Optional filter to limit returned sessions by context fields
    *
    * @example
-   * ```typescript
+   * // List all sessions
    * const sessions = await client.listSessions();
-   * for (const session of sessions) {
-   *   console.log(`${session.sessionId}: ${session.summary}`);
-   * }
-   * ```
+   *
+   * @example
+   * // List sessions for a specific repository
+   * const sessions = await client.listSessions({ repository: "owner/repo" });
    */
-  async listSessions() {
+  async listSessions(filter) {
     if (!this.connection) {
       throw new Error("Client not connected");
     }
-    const response = await this.connection.sendRequest("session.list", {});
+    const response = await this.connection.sendRequest("session.list", { filter });
     const { sessions } = response;
     return sessions.map((s) => ({
       sessionId: s.sessionId,
       startTime: new Date(s.startTime),
       modifiedTime: new Date(s.modifiedTime),
       summary: s.summary,
-      isRemote: s.isRemote
+      isRemote: s.isRemote,
+      context: s.context
     }));
   }
   /**
@@ -699,6 +729,7 @@ class CopilotClient {
    */
   async startCLIServer() {
     return new Promise((resolve, reject) => {
+      this.stderrBuffer = "";
       const args = [
         ...this.options.cliArgs,
         "--headless",
@@ -733,13 +764,15 @@ class CopilotClient {
         this.cliProcess = spawn(process.execPath, [this.options.cliPath, ...args], {
           stdio: stdioConfig,
           cwd: this.options.cwd,
-          env: envWithoutNodeDebug
+          env: envWithoutNodeDebug,
+          windowsHide: true
         });
       } else {
         this.cliProcess = spawn(this.options.cliPath, args, {
           stdio: stdioConfig,
           cwd: this.options.cwd,
-          env: envWithoutNodeDebug
+          env: envWithoutNodeDebug,
+          windowsHide: true
         });
       }
       let stdout = "";
@@ -759,6 +792,7 @@ class CopilotClient {
         });
       }
       this.cliProcess.stderr?.on("data", (data) => {
+        this.stderrBuffer += data.toString();
         const lines = data.toString().split("\n");
         for (const line of lines) {
           if (line.trim()) {
@@ -770,13 +804,54 @@ class CopilotClient {
       this.cliProcess.on("error", (error) => {
         if (!resolved) {
           resolved = true;
-          reject(new Error(`Failed to start CLI server: ${error.message}`));
+          const stderrOutput = this.stderrBuffer.trim();
+          if (stderrOutput) {
+            reject(
+              new Error(
+                `Failed to start CLI server: ${error.message}
+stderr: ${stderrOutput}`
+              )
+            );
+          } else {
+            reject(new Error(`Failed to start CLI server: ${error.message}`));
+          }
         }
       });
+      this.processExitPromise = new Promise((_, rejectProcessExit) => {
+        this.cliProcess.on("exit", (code) => {
+          setTimeout(() => {
+            const stderrOutput = this.stderrBuffer.trim();
+            if (stderrOutput) {
+              rejectProcessExit(
+                new Error(
+                  `CLI server exited with code ${code}
+stderr: ${stderrOutput}`
+                )
+              );
+            } else {
+              rejectProcessExit(
+                new Error(`CLI server exited unexpectedly with code ${code}`)
+              );
+            }
+          }, 50);
+        });
+      });
+      this.processExitPromise.catch(() => {
+      });
       this.cliProcess.on("exit", (code) => {
         if (!resolved) {
           resolved = true;
-          reject(new Error(`CLI server exited with code ${code}`));
+          const stderrOutput = this.stderrBuffer.trim();
+          if (stderrOutput) {
+            reject(
+              new Error(
+                `CLI server exited with code ${code}
+stderr: ${stderrOutput}`
+              )
+            );
+          } else {
+            reject(new Error(`CLI server exited with code ${code}`));
+          }
         } else if (this.options.autoRestart && this.state === "connected") {
           void this.reconnect();
         }

package/dist/generated/rpc.d.ts

@@ -0,0 +1,326 @@
+/**
+ * AUTO-GENERATED FILE - DO NOT EDIT
+ * Generated from: api.schema.json
+ */
+import type { MessageConnection } from "vscode-jsonrpc/node.js";
+export interface PingResult {
+    /**
+     * Echoed message (or default greeting)
+     */
+    message: string;
+    /**
+     * Server timestamp in milliseconds
+     */
+    timestamp: number;
+    /**
+     * Server protocol version number
+     */
+    protocolVersion: number;
+}
+export interface PingParams {
+    /**
+     * Optional message to echo back
+     */
+    message?: string;
+}
+export interface ModelsListResult {
+    /**
+     * List of available models with full metadata
+     */
+    models: {
+        /**
+         * Model identifier (e.g., "claude-sonnet-4.5")
+         */
+        id: string;
+        /**
+         * Display name
+         */
+        name: string;
+        /**
+         * Model capabilities and limits
+         */
+        capabilities: {
+            supports: {
+                vision: boolean;
+                /**
+                 * Whether this model supports reasoning effort configuration
+                 */
+                reasoningEffort: boolean;
+            };
+            limits: {
+                max_prompt_tokens?: number;
+                max_output_tokens?: number;
+                max_context_window_tokens: number;
+            };
+        };
+        /**
+         * Policy state (if applicable)
+         */
+        policy?: {
+            state: string;
+            terms: string;
+        };
+        /**
+         * Billing information
+         */
+        billing?: {
+            multiplier: number;
+        };
+        /**
+         * Supported reasoning effort levels (only present if model supports reasoning effort)
+         */
+        supportedReasoningEfforts?: string[];
+        /**
+         * Default reasoning effort level (only present if model supports reasoning effort)
+         */
+        defaultReasoningEffort?: string;
+    }[];
+}
+export interface ToolsListResult {
+    /**
+     * List of available built-in tools with metadata
+     */
+    tools: {
+        /**
+         * Tool identifier (e.g., "bash", "grep", "str_replace_editor")
+         */
+        name: string;
+        /**
+         * Optional namespaced name for declarative filtering (e.g., "playwright/navigate" for MCP tools)
+         */
+        namespacedName?: string;
+        /**
+         * Description of what the tool does
+         */
+        description: string;
+        /**
+         * JSON Schema for the tool's input parameters
+         */
+        parameters?: {
+            [k: string]: unknown;
+        };
+        /**
+         * Optional instructions for how to use this tool effectively
+         */
+        instructions?: string;
+    }[];
+}
+export interface ToolsListParams {
+    /**
+     * Optional model ID — when provided, the returned tool list reflects model-specific overrides
+     */
+    model?: string;
+}
+export interface AccountGetQuotaResult {
+    /**
+     * Quota snapshots keyed by type (e.g., chat, completions, premium_interactions)
+     */
+    quotaSnapshots: {
+        [k: string]: {
+            /**
+             * Number of requests included in the entitlement
+             */
+            entitlementRequests: number;
+            /**
+             * Number of requests used so far this period
+             */
+            usedRequests: number;
+            /**
+             * Percentage of entitlement remaining
+             */
+            remainingPercentage: number;
+            /**
+             * Number of overage requests made this period
+             */
+            overage: number;
+            /**
+             * Whether pay-per-request usage is allowed when quota is exhausted
+             */
+            overageAllowedWithExhaustedQuota: boolean;
+            /**
+             * Date when the quota resets (ISO 8601)
+             */
+            resetDate?: string;
+        };
+    };
+}
+export interface SessionModelGetCurrentResult {
+    modelId?: string;
+}
+export interface SessionModelGetCurrentParams {
+    /**
+     * Target session identifier
+     */
+    sessionId: string;
+}
+export interface SessionModelSwitchToResult {
+    modelId?: string;
+}
+export interface SessionModelSwitchToParams {
+    /**
+     * Target session identifier
+     */
+    sessionId: string;
+    modelId: string;
+}
+export interface SessionModeGetResult {
+    /**
+     * The current agent mode.
+     */
+    mode: "interactive" | "plan" | "autopilot";
+}
+export interface SessionModeGetParams {
+    /**
+     * Target session identifier
+     */
+    sessionId: string;
+}
+export interface SessionModeSetResult {
+    /**
+     * The agent mode after switching.
+     */
+    mode: "interactive" | "plan" | "autopilot";
+}
+export interface SessionModeSetParams {
+    /**
+     * Target session identifier
+     */
+    sessionId: string;
+    /**
+     * The mode to switch to. Valid values: "interactive", "plan", "autopilot".
+     */
+    mode: "interactive" | "plan" | "autopilot";
+}
+export interface SessionPlanReadResult {
+    /**
+     * Whether plan.md exists in the workspace
+     */
+    exists: boolean;
+    /**
+     * The content of plan.md, or null if it does not exist
+     */
+    content: string | null;
+}
+export interface SessionPlanReadParams {
+    /**
+     * Target session identifier
+     */
+    sessionId: string;
+}
+export interface SessionPlanUpdateResult {
+}
+export interface SessionPlanUpdateParams {
+    /**
+     * Target session identifier
+     */
+    sessionId: string;
+    /**
+     * The new content for plan.md
+     */
+    content: string;
+}
+export interface SessionPlanDeleteResult {
+}
+export interface SessionPlanDeleteParams {
+    /**
+     * Target session identifier
+     */
+    sessionId: string;
+}
+export interface SessionWorkspaceListFilesResult {
+    /**
+     * Relative file paths in the workspace files directory
+     */
+    files: string[];
+}
+export interface SessionWorkspaceListFilesParams {
+    /**
+     * Target session identifier
+     */
+    sessionId: string;
+}
+export interface SessionWorkspaceReadFileResult {
+    /**
+     * File content as a UTF-8 string
+     */
+    content: string;
+}
+export interface SessionWorkspaceReadFileParams {
+    /**
+     * Target session identifier
+     */
+    sessionId: string;
+    /**
+     * Relative path within the workspace files directory
+     */
+    path: string;
+}
+export interface SessionWorkspaceCreateFileResult {
+}
+export interface SessionWorkspaceCreateFileParams {
+    /**
+     * Target session identifier
+     */
+    sessionId: string;
+    /**
+     * Relative path within the workspace files directory
+     */
+    path: string;
+    /**
+     * File content to write as a UTF-8 string
+     */
+    content: string;
+}
+export interface SessionFleetStartResult {
+    /**
+     * Whether fleet mode was successfully activated
+     */
+    started: boolean;
+}
+export interface SessionFleetStartParams {
+    /**
+     * Target session identifier
+     */
+    sessionId: string;
+    /**
+     * Optional user prompt to combine with fleet instructions
+     */
+    prompt?: string;
+}
+/** Create typed server-scoped RPC methods (no session required). */
+export declare function createServerRpc(connection: MessageConnection): {
+    ping: (params: PingParams) => Promise<PingResult>;
+    models: {
+        list: () => Promise<ModelsListResult>;
+    };
+    tools: {
+        list: (params: ToolsListParams) => Promise<ToolsListResult>;
+    };
+    account: {
+        getQuota: () => Promise<AccountGetQuotaResult>;
+    };
+};
+/** Create typed session-scoped RPC methods. */
+export declare function createSessionRpc(connection: MessageConnection, sessionId: string): {
+    model: {
+        getCurrent: () => Promise<SessionModelGetCurrentResult>;
+        switchTo: (params: Omit<SessionModelSwitchToParams, "sessionId">) => Promise<SessionModelSwitchToResult>;
+    };
+    mode: {
+        get: () => Promise<SessionModeGetResult>;
+        set: (params: Omit<SessionModeSetParams, "sessionId">) => Promise<SessionModeSetResult>;
+    };
+    plan: {
+        read: () => Promise<SessionPlanReadResult>;
+        update: (params: Omit<SessionPlanUpdateParams, "sessionId">) => Promise<SessionPlanUpdateResult>;
+        delete: () => Promise<SessionPlanDeleteResult>;
+    };
+    workspace: {
+        listFiles: () => Promise<SessionWorkspaceListFilesResult>;
+        readFile: (params: Omit<SessionWorkspaceReadFileParams, "sessionId">) => Promise<SessionWorkspaceReadFileResult>;
+        createFile: (params: Omit<SessionWorkspaceCreateFileParams, "sessionId">) => Promise<SessionWorkspaceCreateFileResult>;
+    };
+    fleet: {
+        start: (params: Omit<SessionFleetStartParams, "sessionId">) => Promise<SessionFleetStartResult>;
+    };
+};

package/dist/generated/rpc.js

@@ -0,0 +1,43 @@
+function createServerRpc(connection) {
+  return {
+    ping: async (params) => connection.sendRequest("ping", params),
+    models: {
+      list: async () => connection.sendRequest("models.list", {})
+    },
+    tools: {
+      list: async (params) => connection.sendRequest("tools.list", params)
+    },
+    account: {
+      getQuota: async () => connection.sendRequest("account.getQuota", {})
+    }
+  };
+}
+function createSessionRpc(connection, sessionId) {
+  return {
+    model: {
+      getCurrent: async () => connection.sendRequest("session.model.getCurrent", { sessionId }),
+      switchTo: async (params) => connection.sendRequest("session.model.switchTo", { sessionId, ...params })
+    },
+    mode: {
+      get: async () => connection.sendRequest("session.mode.get", { sessionId }),
+      set: async (params) => connection.sendRequest("session.mode.set", { sessionId, ...params })
+    },
+    plan: {
+      read: async () => connection.sendRequest("session.plan.read", { sessionId }),
+      update: async (params) => connection.sendRequest("session.plan.update", { sessionId, ...params }),
+      delete: async () => connection.sendRequest("session.plan.delete", { sessionId })
+    },
+    workspace: {
+      listFiles: async () => connection.sendRequest("session.workspace.listFiles", { sessionId }),
+      readFile: async (params) => connection.sendRequest("session.workspace.readFile", { sessionId, ...params }),
+      createFile: async (params) => connection.sendRequest("session.workspace.createFile", { sessionId, ...params })
+    },
+    fleet: {
+      start: async (params) => connection.sendRequest("session.fleet.start", { sessionId, ...params })
+    }
+  };
+}
+export {
+  createServerRpc,
+  createSessionRpc
+};

package/dist/generated/session-events.d.ts

@@ -1,13 +1,6 @@
 /**
  * AUTO-GENERATED FILE - DO NOT EDIT
- *
- * Generated from: @github/copilot/session-events.schema.json
- * Generated by: scripts/generate-session-types.ts
- * Generated at: 2026-02-06T20:38:23.139Z
- *
- * To update these types:
- * 1. Update the schema in copilot-agent-runtime
- * 2. Run: npm run generate:session-types
+ * Generated from: session-events.schema.json
  */
 export type SessionEvent = {
     id: string;
@@ -65,6 +58,15 @@ export type SessionEvent = {
     ephemeral: true;
     type: "session.idle";
     data: {};
+} | {
+    id: string;
+    timestamp: string;
+    parentId: string | null;
+    ephemeral: true;
+    type: "session.title_changed";
+    data: {
+        title: string;
+    };
 } | {
     id: string;
     timestamp: string;
@@ -75,6 +77,16 @@ export type SessionEvent = {
         infoType: string;
         message: string;
     };
+} | {
+    id: string;
+    timestamp: string;
+    parentId: string | null;
+    ephemeral?: boolean;
+    type: "session.warning";
+    data: {
+        warningType: string;
+        message: string;
+    };
 } | {
     id: string;
     timestamp: string;
@@ -85,6 +97,38 @@ export type SessionEvent = {
         previousModel?: string;
         newModel: string;
     };
+} | {
+    id: string;
+    timestamp: string;
+    parentId: string | null;
+    ephemeral?: boolean;
+    type: "session.mode_changed";
+    data: {
+        previousMode: string;
+        newMode: string;
+    };
+} | {
+    id: string;
+    timestamp: string;
+    parentId: string | null;
+    ephemeral?: boolean;
+    type: "session.plan_changed";
+    data: {
+        operation: "create" | "update" | "delete";
+    };
+} | {
+    id: string;
+    timestamp: string;
+    parentId: string | null;
+    ephemeral?: boolean;
+    type: "session.workspace_file_changed";
+    data: {
+        /**
+         * Relative path within the workspace files directory
+         */
+        path: string;
+        operation: "create" | "update";
+    };
 } | {
     id: string;
     timestamp: string;
@@ -162,6 +206,18 @@ export type SessionEvent = {
         };
         currentModel?: string;
     };
+} | {
+    id: string;
+    timestamp: string;
+    parentId: string | null;
+    ephemeral?: boolean;
+    type: "session.context_changed";
+    data: {
+        cwd: string;
+        gitRoot?: string;
+        repository?: string;
+        branch?: string;
+    };
 } | {
     id: string;
     timestamp: string;
@@ -217,10 +273,18 @@ export type SessionEvent = {
             type: "file";
             path: string;
             displayName: string;
+            lineRange?: {
+                start: number;
+                end: number;
+            };
         } | {
             type: "directory";
             path: string;
             displayName: string;
+            lineRange?: {
+                start: number;
+                end: number;
+            };
         } | {
             type: "selection";
             filePath: string;
@@ -238,6 +302,7 @@ export type SessionEvent = {
             };
         })[];
         source?: string;
+        agentMode?: "interactive" | "plan" | "autopilot" | "shell";
     };
 } | {
     id: string;
@@ -302,6 +367,7 @@ export type SessionEvent = {
         reasoningOpaque?: string;
         reasoningText?: string;
         encryptedContent?: string;
+        phase?: string;
         parentToolCallId?: string;
     };
 } | {
@@ -423,6 +489,48 @@ export type SessionEvent = {
         result?: {
             content: string;
             detailedContent?: string;
+            contents?: ({
+                type: "text";
+                text: string;
+            } | {
+                type: "terminal";
+                text: string;
+                exitCode?: number;
+                cwd?: string;
+            } | {
+                type: "image";
+                data: string;
+                mimeType: string;
+            } | {
+                type: "audio";
+                data: string;
+                mimeType: string;
+            } | {
+                icons?: {
+                    src: string;
+                    mimeType?: string;
+                    sizes?: string[];
+                    theme?: "light" | "dark";
+                }[];
+                name: string;
+                title?: string;
+                uri: string;
+                description?: string;
+                mimeType?: string;
+                size?: number;
+                type: "resource_link";
+            } | {
+                type: "resource";
+                resource: {
+                    uri: string;
+                    mimeType?: string;
+                    text: string;
+                } | {
+                    uri: string;
+                    mimeType?: string;
+                    blob: string;
+                };
+            })[];
         };
         error?: {
             message: string;
@@ -466,6 +574,7 @@ export type SessionEvent = {
     data: {
         toolCallId: string;
         agentName: string;
+        agentDisplayName: string;
     };
 } | {
     id: string;
@@ -476,6 +585,7 @@ export type SessionEvent = {
     data: {
         toolCallId: string;
         agentName: string;
+        agentDisplayName: string;
         error: string;
     };
 } | {

package/dist/index.d.ts

@@ -6,4 +6,4 @@
 export { CopilotClient } from "./client.js";
 export { CopilotSession, type AssistantMessageEvent } from "./session.js";
 export { defineTool } from "./types.js";
-export type { ConnectionState, CopilotClientOptions, CustomAgentConfig, ForegroundSessionInfo, GetAuthStatusResponse, GetStatusResponse, InfiniteSessionConfig, MCPLocalServerConfig, MCPRemoteServerConfig, MCPServerConfig, MessageOptions, ModelBilling, ModelCapabilities, ModelInfo, ModelPolicy, PermissionHandler, PermissionRequest, PermissionRequestResult, ResumeSessionConfig, SessionConfig, SessionEvent, SessionEventHandler, SessionEventPayload, SessionEventType, SessionLifecycleEvent, SessionLifecycleEventType, SessionLifecycleHandler, SessionMetadata, SystemMessageAppendConfig, SystemMessageConfig, SystemMessageReplaceConfig, Tool, ToolHandler, ToolInvocation, ToolResultObject, TypedSessionEventHandler, TypedSessionLifecycleHandler, ZodSchema, } from "./types.js";
+export type { ConnectionState, CopilotClientOptions, CustomAgentConfig, ForegroundSessionInfo, GetAuthStatusResponse, GetStatusResponse, InfiniteSessionConfig, MCPLocalServerConfig, MCPRemoteServerConfig, MCPServerConfig, MessageOptions, ModelBilling, ModelCapabilities, ModelInfo, ModelPolicy, PermissionHandler, PermissionRequest, PermissionRequestResult, ResumeSessionConfig, SessionConfig, SessionEvent, SessionEventHandler, SessionEventPayload, SessionEventType, SessionLifecycleEvent, SessionLifecycleEventType, SessionLifecycleHandler, SessionContext, SessionListFilter, SessionMetadata, SystemMessageAppendConfig, SystemMessageConfig, SystemMessageReplaceConfig, Tool, ToolHandler, ToolInvocation, ToolResultObject, TypedSessionEventHandler, TypedSessionLifecycleHandler, ZodSchema, } from "./types.js";

package/dist/session.d.ts

@@ -3,6 +3,7 @@
  * @module session
  */
 import type { MessageConnection } from "vscode-jsonrpc/node";
+import { createSessionRpc } from "./generated/rpc.js";
 import type { MessageOptions, PermissionHandler, PermissionRequestResult, SessionEvent, SessionEventHandler, SessionEventType, SessionHooks, Tool, ToolHandler, TypedSessionEventHandler, UserInputHandler, UserInputResponse } from "./types.js";
 /** Assistant message event - the final response from the assistant. */
 export type AssistantMessageEvent = Extract<SessionEvent, {
@@ -43,6 +44,7 @@ export declare class CopilotSession {
     private permissionHandler?;
     private userInputHandler?;
     private hooks?;
+    private _rpc;
     /**
      * Creates a new CopilotSession instance.
      *
@@ -52,6 +54,10 @@ export declare class CopilotSession {
      * @internal This constructor is internal. Use {@link CopilotClient.createSession} to create sessions.
      */
     constructor(sessionId: string, connection: MessageConnection, _workspacePath?: string | undefined);
+    /**
+     * Typed session-scoped RPC methods.
+     */
+    get rpc(): ReturnType<typeof createSessionRpc>;
     /**
      * Path to the session workspace directory when infinite sessions are enabled.
      * Contains checkpoints/, plan.md, and files/ subdirectories.

package/dist/session.js

@@ -1,3 +1,4 @@
+import { createSessionRpc } from "./generated/rpc.js";
 class CopilotSession {
   /**
    * Creates a new CopilotSession instance.
@@ -18,6 +19,16 @@ class CopilotSession {
   permissionHandler;
   userInputHandler;
   hooks;
+  _rpc = null;
+  /**
+   * Typed session-scoped RPC methods.
+   */
+  get rpc() {
+    if (!this._rpc) {
+      this._rpc = createSessionRpc(this.connection, this.sessionId);
+    }
+    return this._rpc;
+  }
   /**
    * Path to the session workspace directory when infinite sessions are enabled.
    * Contains checkpoints/, plan.md, and files/ subdirectories.

package/dist/types.d.ts

@@ -695,6 +695,32 @@ export type SessionEventHandler = (event: SessionEvent) => void;
  * Connection state
  */
 export type ConnectionState = "disconnected" | "connecting" | "connected" | "error";
+/**
+ * Working directory context for a session
+ */
+export interface SessionContext {
+    /** Working directory where the session was created */
+    cwd: string;
+    /** Git repository root (if in a git repo) */
+    gitRoot?: string;
+    /** GitHub repository in "owner/repo" format */
+    repository?: string;
+    /** Current git branch */
+    branch?: string;
+}
+/**
+ * Filter options for listing sessions
+ */
+export interface SessionListFilter {
+    /** Filter by exact cwd match */
+    cwd?: string;
+    /** Filter by git root */
+    gitRoot?: string;
+    /** Filter by repository (owner/repo format) */
+    repository?: string;
+    /** Filter by branch */
+    branch?: string;
+}
 /**
  * Metadata about a session
  */
@@ -704,6 +730,8 @@ export interface SessionMetadata {
     modifiedTime: Date;
     summary?: string;
     isRemote: boolean;
+    /** Working directory context (cwd, git info) from session creation */
+    context?: SessionContext;
 }
 /**
  * Response from status.get

package/package.json

@@ -4,7 +4,7 @@
     "type": "git",
     "url": "https://github.com/github/copilot-sdk.git"
   },
-  "version": "0.1.24-preview.0",
+  "version": "0.1.25-preview.0",
   "description": "TypeScript SDK for programmatic control of GitHub Copilot CLI via JSON-RPC",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -25,7 +25,7 @@
     "lint": "eslint \"src/**/*.ts\" \"test/**/*.ts\"",
     "lint:fix": "eslint --fix \"src/**/*.ts\" \"test/**/*.ts\"",
     "typecheck": "tsc --noEmit",
-    "generate:session-types": "tsx scripts/generate-session-types.ts",
+    "generate": "cd ../scripts/codegen && npm run generate",
     "update:protocol-version": "tsx scripts/update-protocol-version.ts",
     "prepublishOnly": "npm run build",
     "package": "npm run clean && npm run build && node scripts/set-version.js && npm pack && npm version 0.1.0 --no-git-tag-version --allow-same-version"
@@ -40,7 +40,7 @@
   "author": "GitHub",
   "license": "MIT",
   "dependencies": {
-    "@github/copilot": "^0.0.405",
+    "@github/copilot": "^0.0.411-1",
     "vscode-jsonrpc": "^8.2.1",
     "zod": "^4.3.6"
   },
@@ -62,7 +62,7 @@
     "vitest": "^4.0.18"
   },
   "engines": {
-    "node": ">=24.0.0"
+    "node": ">=20.0.0"
   },
   "files": [
     "dist/**/*",