@github/copilot-sdk 0.1.31-unstable.0 → 0.1.32

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

@@ -19,6 +19,7 @@ export declare class CopilotClient {
     private typedLifecycleHandlers;
     private _rpc;
     private processExitPromise;
+    private negotiatedProtocolVersion;
     /**
      * Typed server-scoped RPC methods.
      * @throws Error if the client is not connected
@@ -74,10 +75,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.
      *
@@ -220,7 +225,8 @@ export declare class CopilotClient {
      */
     listModels(): Promise<ModelInfo[]>;
     /**
-     * Verify that the server's protocol version matches the SDK's expected version
+     * Verify that the server's protocol version is within the supported range
+     * and store the negotiated version.
      */
     private verifyProtocolVersion;
     /**
@@ -242,10 +248,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
@@ -377,6 +385,18 @@ export declare class CopilotClient {
     private handleSessionLifecycleNotification;
     private handleUserInputRequest;
     private handleHooksInvoke;
+    /**
+     * Handles a v2-style tool.call RPC request from the server.
+     * Looks up the session and tool handler, executes it, and returns the result
+     * in the v2 response format.
+     */
+    private handleToolCallRequestV2;
+    /**
+     * Handles a v2-style permission.request RPC request from the server.
+     */
+    private handlePermissionRequestV2;
+    private normalizeToolResultV2;
+    private isToolResultObject;
     /**
      * Attempt to reconnect to the server
      */

package/dist/client.js

@@ -11,6 +11,7 @@ import {
 import { createServerRpc } from "./generated/rpc.js";
 import { getSdkProtocolVersion } from "./sdkProtocolVersion.js";
 import { CopilotSession } from "./session.js";
+const MIN_PROTOCOL_VERSION = 2;
 function isZodSchema(value) {
   return value != null && typeof value === "object" && "toJSONSchema" in value && typeof value.toJSONSchema === "function";
 }
@@ -52,6 +53,7 @@ class CopilotClient {
   _rpc = null;
   processExitPromise = null;
   // Rejects when CLI process exits
+  negotiatedProtocolVersion = null;
   /**
    * Typed server-scoped RPC methods.
    * @throws Error if the client is not connected
@@ -188,10 +190,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.
    *
@@ -210,7 +216,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) {
@@ -224,7 +230,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}`
           )
         );
       }
@@ -578,10 +584,11 @@ class CopilotClient {
     }
   }
   /**
-   * Verify that the server's protocol version matches the SDK's expected version
+   * Verify that the server's protocol version is within the supported range
+   * and store the negotiated version.
    */
   async verifyProtocolVersion() {
-    const expectedVersion = getSdkProtocolVersion();
+    const maxVersion = getSdkProtocolVersion();
     let pingResult;
     if (this.processExitPromise) {
       pingResult = await Promise.race([this.ping(), this.processExitPromise]);
@@ -591,14 +598,15 @@ class CopilotClient {
     const serverVersion = pingResult.protocolVersion;
     if (serverVersion === void 0) {
       throw new Error(
-        `SDK protocol version mismatch: SDK expects version ${expectedVersion}, but server does not report a protocol version. Please update your server to ensure compatibility.`
+        `SDK protocol version mismatch: SDK supports versions ${MIN_PROTOCOL_VERSION}-${maxVersion}, but server does not report a protocol version. Please update your server to ensure compatibility.`
       );
     }
-    if (serverVersion !== expectedVersion) {
+    if (serverVersion < MIN_PROTOCOL_VERSION || serverVersion > maxVersion) {
       throw new Error(
-        `SDK protocol version mismatch: SDK expects version ${expectedVersion}, but server reports version ${serverVersion}. Please update your SDK or server to ensure compatibility.`
+        `SDK protocol version mismatch: SDK supports versions ${MIN_PROTOCOL_VERSION}-${maxVersion}, but server reports version ${serverVersion}. Please update your SDK or server to ensure compatibility.`
       );
     }
+    this.negotiatedProtocolVersion = serverVersion;
   }
   /**
    * Gets the ID of the most recently updated session.
@@ -625,10 +633,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
@@ -969,6 +979,14 @@ stderr: ${stderrOutput}`
     this.connection.onNotification("session.lifecycle", (notification) => {
       this.handleSessionLifecycleNotification(notification);
     });
+    this.connection.onRequest(
+      "tool.call",
+      async (params) => await this.handleToolCallRequestV2(params)
+    );
+    this.connection.onRequest(
+      "permission.request",
+      async (params) => await this.handlePermissionRequestV2(params)
+    );
     this.connection.onRequest(
       "userInput.request",
       async (params) => await this.handleUserInputRequest(params)
@@ -1041,6 +1059,98 @@ stderr: ${stderrOutput}`
     const output = await session._handleHooksInvoke(params.hookType, params.input);
     return { output };
   }
+  // ========================================================================
+  // Protocol v2 backward-compatibility adapters
+  // ========================================================================
+  /**
+   * Handles a v2-style tool.call RPC request from the server.
+   * Looks up the session and tool handler, executes it, and returns the result
+   * in the v2 response format.
+   */
+  async handleToolCallRequestV2(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: {
+          textResultForLlm: `Tool '${params.toolName}' is not supported by this client instance.`,
+          resultType: "failure",
+          error: `tool '${params.toolName}' not supported`,
+          toolTelemetry: {}
+        }
+      };
+    }
+    try {
+      const invocation = {
+        sessionId: params.sessionId,
+        toolCallId: params.toolCallId,
+        toolName: params.toolName,
+        arguments: params.arguments
+      };
+      const result = await handler(params.arguments, invocation);
+      return { result: this.normalizeToolResultV2(result) };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        result: {
+          textResultForLlm: "Invoking this tool produced an error. Detailed information is not available.",
+          resultType: "failure",
+          error: message,
+          toolTelemetry: {}
+        }
+      };
+    }
+  }
+  /**
+   * Handles a v2-style permission.request RPC request from the server.
+   */
+  async handlePermissionRequestV2(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._handlePermissionRequestV2(params.permissionRequest);
+      return { result };
+    } catch (_error) {
+      return {
+        result: {
+          kind: "denied-no-approval-rule-and-could-not-request-from-user"
+        }
+      };
+    }
+  }
+  normalizeToolResultV2(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;
+  }
   /**
    * Attempt to reconnect to the server
    */

package/dist/generated/rpc.d.ts

@@ -407,7 +407,14 @@ export interface SessionToolsHandlePendingToolCallParams {
      */
     sessionId: string;
     requestId: string;
-    result?: string;
+    result?: string | {
+        textResultForLlm: string;
+        resultType?: string;
+        error?: string;
+        toolTelemetry?: {
+            [k: string]: unknown;
+        };
+    };
     error?: string;
 }
 export interface SessionPermissionsHandlePendingPermissionRequestResult {
@@ -420,8 +427,19 @@ export interface SessionPermissionsHandlePendingPermissionRequestParams {
     sessionId: string;
     requestId: string;
     result: {
-        kind: "approved" | "denied-by-rules" | "denied-no-approval-rule-and-could-not-request-from-user" | "denied-interactively-by-user";
-        rules?: unknown[];
+        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). */

package/dist/session.d.ts

@@ -4,7 +4,7 @@
  */
 import type { MessageConnection } from "vscode-jsonrpc/node";
 import { createSessionRpc } from "./generated/rpc.js";
-import type { MessageOptions, PermissionHandler, SessionEvent, SessionEventHandler, SessionEventType, SessionHooks, Tool, ToolHandler, TypedSessionEventHandler, UserInputHandler, UserInputResponse } from "./types.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, {
     type: "assistant.message";
@@ -31,7 +31,7 @@ export type AssistantMessageEvent = Extract<SessionEvent, {
  * await session.sendAndWait({ prompt: "Hello, world!" });
  *
  * // Clean up
- * await session.destroy();
+ * await session.disconnect();
  * ```
  */
 export declare class CopilotSession {
@@ -72,7 +72,7 @@ export declare class CopilotSession {
      *
      * @param options - The message options including the prompt and optional attachments
      * @returns A promise that resolves with the message ID of the response
-     * @throws Error if the session has been destroyed or the connection fails
+     * @throws Error if the session has been disconnected or the connection fails
      *
      * @example
      * ```typescript
@@ -97,7 +97,7 @@ export declare class CopilotSession {
      * @returns A promise that resolves with the final assistant message when the session becomes idle,
      *          or undefined if no assistant message was received
      * @throws Error if the timeout is reached before the session becomes idle
-     * @throws Error if the session has been destroyed or the connection fails
+     * @throws Error if the session has been disconnected or the connection fails
      *
      * @example
      * ```typescript
@@ -226,6 +226,15 @@ export declare class CopilotSession {
      * @internal This method is typically called internally when creating a session.
      */
     registerHooks(hooks?: SessionHooks): void;
+    /**
+     * Handles a permission request in the v2 protocol format (synchronous RPC).
+     * Used as a back-compat adapter when connected to a v2 server.
+     *
+     * @param request - The permission request data from the CLI
+     * @returns A promise that resolves with the permission decision
+     * @internal This method is for internal use by the SDK.
+     */
+    _handlePermissionRequestV2(request: unknown): Promise<PermissionRequestResult>;
     /**
      * Handles a user input request from the Copilot CLI.
      *
@@ -250,7 +259,7 @@ export declare class CopilotSession {
      * assistant responses, tool executions, and other session events.
      *
      * @returns A promise that resolves with an array of all session events
-     * @throws Error if the session has been destroyed or the connection fails
+     * @throws Error if the session has been disconnected or the connection fails
      *
      * @example
      * ```typescript
@@ -264,22 +273,39 @@ export declare class CopilotSession {
      */
     getMessages(): Promise<SessionEvent[]>;
     /**
-     * Destroys this session and releases all associated resources.
+     * Disconnects this session and releases all in-memory resources (event handlers,
+     * tool handlers, permission handlers).
+     *
+     * Session state on disk (conversation history, planning state, artifacts) is
+     * preserved, so the conversation can be resumed later by calling
+     * {@link CopilotClient.resumeSession} with the session ID. To permanently
+     * remove all session data including files on disk, use
+     * {@link CopilotClient.deleteSession} instead.
      *
-     * After calling this method, the session can no longer be used. All event
-     * handlers and tool handlers are cleared. To continue the conversation,
-     * use {@link CopilotClient.resumeSession} with the session ID.
+     * After calling this method, the session object can no longer be used.
      *
-     * @returns A promise that resolves when the session is destroyed
+     * @returns A promise that resolves when the session is disconnected
      * @throws Error if the connection fails
      *
      * @example
      * ```typescript
-     * // Clean up when done
-     * await session.destroy();
+     * // Clean up when done — session can still be resumed later
+     * await session.disconnect();
      * ```
      */
+    disconnect(): Promise<void>;
+    /**
+     * @deprecated Use {@link disconnect} instead. This method will be removed in a future release.
+     *
+     * Disconnects this session and releases all in-memory resources.
+     * Session data on disk is preserved for later resumption.
+     *
+     * @returns A promise that resolves when the session is disconnected
+     * @throws Error if the connection fails
+     */
     destroy(): Promise<void>;
+    /** Enables `await using session = ...` syntax for automatic cleanup. */
+    [Symbol.asyncDispose](): Promise<void>;
     /**
      * Aborts the currently processing message in this session.
      *
@@ -287,7 +313,7 @@ export declare class CopilotSession {
      * and can continue to be used for new messages.
      *
      * @returns A promise that resolves when the abort request is acknowledged
-     * @throws Error if the session has been destroyed or the connection fails
+     * @throws Error if the session has been disconnected or the connection fails
      *
      * @example
      * ```typescript

package/dist/session.js

@@ -1,3 +1,4 @@
+import { ConnectionError, ResponseError } from "vscode-jsonrpc/node";
 import { createSessionRpc } from "./generated/rpc.js";
 class CopilotSession {
   /**
@@ -45,7 +46,7 @@ class CopilotSession {
    *
    * @param options - The message options including the prompt and optional attachments
    * @returns A promise that resolves with the message ID of the response
-   * @throws Error if the session has been destroyed or the connection fails
+   * @throws Error if the session has been disconnected or the connection fails
    *
    * @example
    * ```typescript
@@ -78,7 +79,7 @@ class CopilotSession {
    * @returns A promise that resolves with the final assistant message when the session becomes idle,
    *          or undefined if no assistant message was received
    * @throws Error if the timeout is reached before the session becomes idle
-   * @throws Error if the session has been destroyed or the connection fails
+   * @throws Error if the session has been disconnected or the connection fails
    *
    * @example
    * ```typescript
@@ -220,7 +221,13 @@ class CopilotSession {
       await this.rpc.tools.handlePendingToolCall({ requestId, result });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      await this.rpc.tools.handlePendingToolCall({ requestId, error: message });
+      try {
+        await this.rpc.tools.handlePendingToolCall({ requestId, error: message });
+      } catch (rpcError) {
+        if (!(rpcError instanceof ConnectionError || rpcError instanceof ResponseError)) {
+          throw rpcError;
+        }
+      }
     }
   }
   /**
@@ -234,12 +241,18 @@ class CopilotSession {
       });
       await this.rpc.permissions.handlePendingPermissionRequest({ requestId, result });
     } catch (_error) {
-      await this.rpc.permissions.handlePendingPermissionRequest({
-        requestId,
-        result: {
-          kind: "denied-no-approval-rule-and-could-not-request-from-user"
+      try {
+        await this.rpc.permissions.handlePendingPermissionRequest({
+          requestId,
+          result: {
+            kind: "denied-no-approval-rule-and-could-not-request-from-user"
+          }
+        });
+      } catch (rpcError) {
+        if (!(rpcError instanceof ConnectionError || rpcError instanceof ResponseError)) {
+          throw rpcError;
         }
-      });
+      }
     }
   }
   /**
@@ -306,6 +319,27 @@ class CopilotSession {
   registerHooks(hooks) {
     this.hooks = hooks;
   }
+  /**
+   * Handles a permission request in the v2 protocol format (synchronous RPC).
+   * Used as a back-compat adapter when connected to a v2 server.
+   *
+   * @param request - The permission request data from the CLI
+   * @returns A promise that resolves with the permission decision
+   * @internal This method is for internal use by the SDK.
+   */
+  async _handlePermissionRequestV2(request) {
+    if (!this.permissionHandler) {
+      return { kind: "denied-no-approval-rule-and-could-not-request-from-user" };
+    }
+    try {
+      const result = await this.permissionHandler(request, {
+        sessionId: this.sessionId
+      });
+      return result;
+    } catch (_error) {
+      return { kind: "denied-no-approval-rule-and-could-not-request-from-user" };
+    }
+  }
   /**
    * Handles a user input request from the Copilot CLI.
    *
@@ -364,7 +398,7 @@ class CopilotSession {
    * assistant responses, tool executions, and other session events.
    *
    * @returns A promise that resolves with an array of all session events
-   * @throws Error if the session has been destroyed or the connection fails
+   * @throws Error if the session has been disconnected or the connection fails
    *
    * @example
    * ```typescript
@@ -383,22 +417,27 @@ class CopilotSession {
     return response.events;
   }
   /**
-   * Destroys this session and releases all associated resources.
+   * Disconnects this session and releases all in-memory resources (event handlers,
+   * tool handlers, permission handlers).
    *
-   * After calling this method, the session can no longer be used. All event
-   * handlers and tool handlers are cleared. To continue the conversation,
-   * use {@link CopilotClient.resumeSession} with the session ID.
+   * Session state on disk (conversation history, planning state, artifacts) is
+   * preserved, so the conversation can be resumed later by calling
+   * {@link CopilotClient.resumeSession} with the session ID. To permanently
+   * remove all session data including files on disk, use
+   * {@link CopilotClient.deleteSession} instead.
    *
-   * @returns A promise that resolves when the session is destroyed
+   * After calling this method, the session object can no longer be used.
+   *
+   * @returns A promise that resolves when the session is disconnected
    * @throws Error if the connection fails
    *
    * @example
    * ```typescript
-   * // Clean up when done
-   * await session.destroy();
+   * // Clean up when done — session can still be resumed later
+   * await session.disconnect();
    * ```
    */
-  async destroy() {
+  async disconnect() {
     await this.connection.sendRequest("session.destroy", {
       sessionId: this.sessionId
     });
@@ -407,6 +446,22 @@ class CopilotSession {
     this.toolHandlers.clear();
     this.permissionHandler = void 0;
   }
+  /**
+   * @deprecated Use {@link disconnect} instead. This method will be removed in a future release.
+   *
+   * Disconnects this session and releases all in-memory resources.
+   * Session data on disk is preserved for later resumption.
+   *
+   * @returns A promise that resolves when the session is disconnected
+   * @throws Error if the connection fails
+   */
+  async destroy() {
+    return this.disconnect();
+  }
+  /** Enables `await using session = ...` syntax for automatic cleanup. */
+  async [Symbol.asyncDispose]() {
+    return this.disconnect();
+  }
   /**
    * Aborts the currently processing message in this session.
    *
@@ -414,7 +469,7 @@ class CopilotSession {
    * and can continue to be used for new messages.
    *
    * @returns A promise that resolves when the abort request is acknowledged
-   * @throws Error if the session has been destroyed or the connection fails
+   * @throws Error if the session has been disconnected or the connection fails
    *
    * @example
    * ```typescript

package/dist/types.d.ts

@@ -185,10 +185,8 @@ export interface PermissionRequest {
     toolCallId?: string;
     [key: string]: unknown;
 }
-export interface PermissionRequestResult {
-    kind: "approved" | "denied-by-rules" | "denied-no-approval-rule-and-could-not-request-from-user" | "denied-interactively-by-user";
-    rules?: unknown[];
-}
+import type { SessionPermissionsHandlePendingPermissionRequestParams } from "./generated/rpc.js";
+export type PermissionRequestResult = SessionPermissionsHandlePendingPermissionRequestParams["result"];
 export type PermissionHandler = (request: PermissionRequest, invocation: {
     sessionId: string;
 }) => Promise<PermissionRequestResult> | PermissionRequestResult;

package/package.json

@@ -4,7 +4,7 @@
     "type": "git",
     "url": "https://github.com/github/copilot-sdk.git"
   },
-  "version": "0.1.31-unstable.0",
+  "version": "0.1.32",
   "description": "TypeScript SDK for programmatic control of GitHub Copilot CLI via JSON-RPC",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -44,7 +44,7 @@
   "author": "GitHub",
   "license": "MIT",
   "dependencies": {
-    "@github/copilot": "^0.0.421",
+    "@github/copilot": "^1.0.2",
     "vscode-jsonrpc": "^8.2.1",
     "zod": "^4.3.6"
   },