@github/copilot-sdk 0.1.30 → 0.1.31

package/README.md

@@ -52,10 +52,17 @@ await session.send({ prompt: "What is 2+2?" });
 await done;
 
 // Clean up
-await session.destroy();
+await session.disconnect();
 await client.stop();
 ```
 
+Sessions also support `Symbol.asyncDispose` for use with [`await using`](https://github.com/tc39/proposal-explicit-resource-management) (TypeScript 5.2+/Node.js 18.0+):
+
+```typescript
+await using session = await client.createSession({ model: "gpt-5" });
+// session is automatically disconnected when leaving scope
+```
+
 ## API Reference
 
 ### CopilotClient
@@ -265,9 +272,13 @@ Abort the currently processing message in this session.
 
 Get all events/messages from this session.
 
-##### `destroy(): Promise<void>`
+##### `disconnect(): Promise<void>`
+
+Disconnect the session and free resources. Session data on disk is preserved for later resumption.
+
+##### `destroy(): Promise<void>` *(deprecated)*
 
-Destroy the session and free resources.
+Deprecated — use `disconnect()` instead.
 
 ---
 

package/dist/client.d.ts

@@ -74,10 +74,14 @@ export declare class CopilotClient {
      * Stops the CLI server and closes all active sessions.
      *
      * This method performs graceful cleanup:
-     * 1. Destroys all active sessions with retry logic
+     * 1. Closes all active sessions (releases in-memory resources)
      * 2. Closes the JSON-RPC connection
      * 3. Terminates the CLI server process (if spawned by this client)
      *
+     * Note: session data on disk is preserved, so sessions can be resumed later.
+     * To permanently remove session data before stopping, call
+     * {@link deleteSession} for each session first.
+     *
      * @returns A promise that resolves with an array of errors encountered during cleanup.
      *          An empty array indicates all cleanup succeeded.
      *
@@ -242,10 +246,12 @@ export declare class CopilotClient {
      */
     getLastSessionId(): Promise<string | undefined>;
     /**
-     * Deletes a session and its data from disk.
+     * Permanently deletes a session and all its data from disk, including
+     * conversation history, planning state, and artifacts.
      *
-     * This permanently removes the session and all its conversation history.
-     * The session cannot be resumed after deletion.
+     * Unlike {@link CopilotSession.disconnect}, which only releases in-memory
+     * resources and preserves session data for later resumption, this method
+     * is irreversible. The session cannot be resumed after deletion.
      *
      * @param sessionId - The ID of the session to delete
      * @returns A promise that resolves when the session is deleted
@@ -361,9 +367,13 @@ export declare class CopilotClient {
      */
     private connectToServer;
     /**
-     * Connect via stdio pipes
+     * Connect to child via stdio pipes
+     */
+    private connectToChildProcessViaStdio;
+    /**
+     * Connect to parent via stdio pipes
      */
-    private connectViaStdio;
+    private connectToParentProcessViaStdio;
     /**
      * Connect to the CLI server via TCP socket
      */
@@ -371,14 +381,8 @@ export declare class CopilotClient {
     private attachConnectionHandlers;
     private handleSessionEventNotification;
     private handleSessionLifecycleNotification;
-    private handleToolCallRequest;
-    private executeToolCall;
-    private handlePermissionRequest;
     private handleUserInputRequest;
     private handleHooksInvoke;
-    private normalizeToolResult;
-    private isToolResultObject;
-    private buildUnsupportedToolResult;
     /**
      * Attempt to reconnect to the server
      */

package/dist/client.js

@@ -90,6 +90,11 @@ class CopilotClient {
     if (options.cliUrl && (options.useStdio === true || options.cliPath)) {
       throw new Error("cliUrl is mutually exclusive with useStdio and cliPath");
     }
+    if (options.isChildProcess && (options.cliUrl || options.useStdio === false)) {
+      throw new Error(
+        "isChildProcess must be used in conjunction with useStdio and not with cliUrl"
+      );
+    }
     if (options.cliUrl && (options.githubToken || options.useLoggedInUser !== void 0)) {
       throw new Error(
         "githubToken and useLoggedInUser cannot be used with cliUrl (external server manages its own auth)"
@@ -101,6 +106,9 @@ class CopilotClient {
       this.actualPort = port;
       this.isExternalServer = true;
     }
+    if (options.isChildProcess) {
+      this.isExternalServer = true;
+    }
     this.options = {
       cliPath: options.cliPath || getBundledCliPath(),
       cliArgs: options.cliArgs ?? [],
@@ -108,6 +116,7 @@ class CopilotClient {
       port: options.port || 0,
       useStdio: options.cliUrl ? false : options.useStdio ?? true,
       // Default to stdio unless cliUrl is provided
+      isChildProcess: options.isChildProcess ?? false,
       cliUrl: options.cliUrl,
       logLevel: options.logLevel || "debug",
       autoStart: options.autoStart ?? true,
@@ -179,10 +188,14 @@ class CopilotClient {
    * Stops the CLI server and closes all active sessions.
    *
    * This method performs graceful cleanup:
-   * 1. Destroys all active sessions with retry logic
+   * 1. Closes all active sessions (releases in-memory resources)
    * 2. Closes the JSON-RPC connection
    * 3. Terminates the CLI server process (if spawned by this client)
    *
+   * Note: session data on disk is preserved, so sessions can be resumed later.
+   * To permanently remove session data before stopping, call
+   * {@link deleteSession} for each session first.
+   *
    * @returns A promise that resolves with an array of errors encountered during cleanup.
    *          An empty array indicates all cleanup succeeded.
    *
@@ -201,7 +214,7 @@ class CopilotClient {
       let lastError = null;
       for (let attempt = 1; attempt <= 3; attempt++) {
         try {
-          await session.destroy();
+          await session.disconnect();
           lastError = null;
           break;
         } catch (error) {
@@ -215,7 +228,7 @@ class CopilotClient {
       if (lastError) {
         errors.push(
           new Error(
-            `Failed to destroy session ${sessionId} after 3 attempts: ${lastError.message}`
+            `Failed to disconnect session ${sessionId} after 3 attempts: ${lastError.message}`
           )
         );
       }
@@ -616,10 +629,12 @@ class CopilotClient {
     return response.sessionId;
   }
   /**
-   * Deletes a session and its data from disk.
+   * Permanently deletes a session and all its data from disk, including
+   * conversation history, planning state, and artifacts.
    *
-   * This permanently removes the session and all its conversation history.
-   * The session cannot be resumed after deletion.
+   * Unlike {@link CopilotSession.disconnect}, which only releases in-memory
+   * resources and preserves session data for later resumption, this method
+   * is irreversible. The session cannot be resumed after deletion.
    *
    * @param sessionId - The ID of the session to delete
    * @returns A promise that resolves when the session is deleted
@@ -886,16 +901,18 @@ stderr: ${stderrOutput}`
    * Connect to the CLI server (via socket or stdio)
    */
   async connectToServer() {
-    if (this.options.useStdio) {
-      return this.connectViaStdio();
+    if (this.options.isChildProcess) {
+      return this.connectToParentProcessViaStdio();
+    } else if (this.options.useStdio) {
+      return this.connectToChildProcessViaStdio();
     } else {
       return this.connectViaTcp();
     }
   }
   /**
-   * Connect via stdio pipes
+   * Connect to child via stdio pipes
    */
-  async connectViaStdio() {
+  async connectToChildProcessViaStdio() {
     if (!this.cliProcess) {
       throw new Error("CLI process not started");
     }
@@ -911,6 +928,20 @@ stderr: ${stderrOutput}`
     this.attachConnectionHandlers();
     this.connection.listen();
   }
+  /**
+   * Connect to parent via stdio pipes
+   */
+  async connectToParentProcessViaStdio() {
+    if (this.cliProcess) {
+      throw new Error("CLI child process was unexpectedly started in parent process mode");
+    }
+    this.connection = createMessageConnection(
+      new StreamMessageReader(process.stdin),
+      new StreamMessageWriter(process.stdout)
+    );
+    this.attachConnectionHandlers();
+    this.connection.listen();
+  }
   /**
    * Connect to the CLI server via TCP socket
    */
@@ -944,14 +975,6 @@ stderr: ${stderrOutput}`
     this.connection.onNotification("session.lifecycle", (notification) => {
       this.handleSessionLifecycleNotification(notification);
     });
-    this.connection.onRequest(
-      "tool.call",
-      async (params) => await this.handleToolCallRequest(params)
-    );
-    this.connection.onRequest(
-      "permission.request",
-      async (params) => await this.handlePermissionRequest(params)
-    );
     this.connection.onRequest(
       "userInput.request",
       async (params) => await this.handleUserInputRequest(params)
@@ -998,62 +1021,6 @@ stderr: ${stderrOutput}`
       }
     }
   }
-  async handleToolCallRequest(params) {
-    if (!params || typeof params.sessionId !== "string" || typeof params.toolCallId !== "string" || typeof params.toolName !== "string") {
-      throw new Error("Invalid tool call payload");
-    }
-    const session = this.sessions.get(params.sessionId);
-    if (!session) {
-      throw new Error(`Unknown session ${params.sessionId}`);
-    }
-    const handler = session.getToolHandler(params.toolName);
-    if (!handler) {
-      return { result: this.buildUnsupportedToolResult(params.toolName) };
-    }
-    return await this.executeToolCall(handler, params);
-  }
-  async executeToolCall(handler, request) {
-    try {
-      const invocation = {
-        sessionId: request.sessionId,
-        toolCallId: request.toolCallId,
-        toolName: request.toolName,
-        arguments: request.arguments
-      };
-      const result = await handler(request.arguments, invocation);
-      return { result: this.normalizeToolResult(result) };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      return {
-        result: {
-          // Don't expose detailed error information to the LLM for security reasons
-          textResultForLlm: "Invoking this tool produced an error. Detailed information is not available.",
-          resultType: "failure",
-          error: message,
-          toolTelemetry: {}
-        }
-      };
-    }
-  }
-  async handlePermissionRequest(params) {
-    if (!params || typeof params.sessionId !== "string" || !params.permissionRequest) {
-      throw new Error("Invalid permission request payload");
-    }
-    const session = this.sessions.get(params.sessionId);
-    if (!session) {
-      throw new Error(`Session not found: ${params.sessionId}`);
-    }
-    try {
-      const result = await session._handlePermissionRequest(params.permissionRequest);
-      return { result };
-    } catch (_error) {
-      return {
-        result: {
-          kind: "denied-no-approval-rule-and-could-not-request-from-user"
-        }
-      };
-    }
-  }
   async handleUserInputRequest(params) {
     if (!params || typeof params.sessionId !== "string" || typeof params.question !== "string") {
       throw new Error("Invalid user input request payload");
@@ -1080,36 +1047,6 @@ stderr: ${stderrOutput}`
     const output = await session._handleHooksInvoke(params.hookType, params.input);
     return { output };
   }
-  normalizeToolResult(result) {
-    if (result === void 0 || result === null) {
-      return {
-        textResultForLlm: "Tool returned no result",
-        resultType: "failure",
-        error: "tool returned no result",
-        toolTelemetry: {}
-      };
-    }
-    if (this.isToolResultObject(result)) {
-      return result;
-    }
-    const textResult = typeof result === "string" ? result : JSON.stringify(result);
-    return {
-      textResultForLlm: textResult,
-      resultType: "success",
-      toolTelemetry: {}
-    };
-  }
-  isToolResultObject(value) {
-    return typeof value === "object" && value !== null && "textResultForLlm" in value && typeof value.textResultForLlm === "string" && "resultType" in value;
-  }
-  buildUnsupportedToolResult(toolName) {
-    return {
-      textResultForLlm: `Tool '${toolName}' is not supported by this client instance.`,
-      resultType: "failure",
-      error: `tool '${toolName}' not supported`,
-      toolTelemetry: {}
-    };
-  }
   /**
    * Attempt to reconnect to the server
    */

package/dist/extension.d.ts

@@ -0,0 +1,2 @@
+import { CopilotClient } from "./client.js";
+export declare const extension: CopilotClient;

package/dist/extension.js

@@ -0,0 +1,5 @@
+import { CopilotClient } from "./client.js";
+const extension = new CopilotClient({ isChildProcess: true });
+export {
+  extension
+};

package/dist/generated/rpc.d.ts

@@ -193,13 +193,17 @@ export interface SessionModeSetParams {
 }
 export interface SessionPlanReadResult {
     /**
-     * Whether plan.md exists in the workspace
+     * Whether the plan file exists in the workspace
      */
     exists: boolean;
     /**
-     * The content of plan.md, or null if it does not exist
+     * The content of the plan file, or null if it does not exist
      */
     content: string | null;
+    /**
+     * Absolute file path of the plan file, or null if workspace is not enabled
+     */
+    path: string | null;
 }
 export interface SessionPlanReadParams {
     /**
@@ -215,7 +219,7 @@ export interface SessionPlanUpdateParams {
      */
     sessionId: string;
     /**
-     * The new content for plan.md
+     * The new content for the plan file
      */
     content: string;
 }
@@ -394,6 +398,50 @@ export interface SessionCompactionCompactParams {
      */
     sessionId: string;
 }
+export interface SessionToolsHandlePendingToolCallResult {
+    success: boolean;
+}
+export interface SessionToolsHandlePendingToolCallParams {
+    /**
+     * Target session identifier
+     */
+    sessionId: string;
+    requestId: string;
+    result?: string | {
+        textResultForLlm: string;
+        resultType?: string;
+        error?: string;
+        toolTelemetry?: {
+            [k: string]: unknown;
+        };
+    };
+    error?: string;
+}
+export interface SessionPermissionsHandlePendingPermissionRequestResult {
+    success: boolean;
+}
+export interface SessionPermissionsHandlePendingPermissionRequestParams {
+    /**
+     * Target session identifier
+     */
+    sessionId: string;
+    requestId: string;
+    result: {
+        kind: "approved";
+    } | {
+        kind: "denied-by-rules";
+        rules: unknown[];
+    } | {
+        kind: "denied-no-approval-rule-and-could-not-request-from-user";
+    } | {
+        kind: "denied-interactively-by-user";
+        feedback?: string;
+    } | {
+        kind: "denied-by-content-exclusion-policy";
+        path: string;
+        message: string;
+    };
+}
 /** Create typed server-scoped RPC methods (no session required). */
 export declare function createServerRpc(connection: MessageConnection): {
     ping: (params: PingParams) => Promise<PingResult>;
@@ -439,4 +487,10 @@ export declare function createSessionRpc(connection: MessageConnection, sessionI
     compaction: {
         compact: () => Promise<SessionCompactionCompactResult>;
     };
+    tools: {
+        handlePendingToolCall: (params: Omit<SessionToolsHandlePendingToolCallParams, "sessionId">) => Promise<SessionToolsHandlePendingToolCallResult>;
+    };
+    permissions: {
+        handlePendingPermissionRequest: (params: Omit<SessionPermissionsHandlePendingPermissionRequestParams, "sessionId">) => Promise<SessionPermissionsHandlePendingPermissionRequestResult>;
+    };
 };

package/dist/generated/rpc.js

@@ -43,6 +43,12 @@ function createSessionRpc(connection, sessionId) {
     },
     compaction: {
       compact: async () => connection.sendRequest("session.compaction.compact", { sessionId })
+    },
+    tools: {
+      handlePendingToolCall: async (params) => connection.sendRequest("session.tools.handlePendingToolCall", { sessionId, ...params })
+    },
+    permissions: {
+      handlePendingPermissionRequest: async (params) => connection.sendRequest("session.permissions.handlePendingPermissionRequest", { sessionId, ...params })
     }
   };
 }