@github/copilot-sdk 0.1.33-unstable.1 → 0.2.0

package/dist/client.d.ts

@@ -47,6 +47,7 @@ export declare class CopilotClient {
     private isExternalServer;
     private forceStopping;
     private onListModels?;
+    private onGetTraceContext?;
     private modelsCache;
     private modelsCacheLock;
     private sessionLifecycleHandlers;
@@ -422,6 +423,7 @@ export declare class CopilotClient {
     private handleSessionLifecycleNotification;
     private handleUserInputRequest;
     private handleHooksInvoke;
+    private handleSystemMessageTransform;
     /**
      * Handles a v2-style tool.call RPC request from the server.
      * Looks up the session and tool handler, executes it, and returns the result
@@ -434,8 +436,4 @@ export declare class CopilotClient {
     private handlePermissionRequestV2;
     private normalizeToolResultV2;
     private isToolResultObject;
-    /**
-     * Attempt to reconnect to the server
-     */
-    private reconnect;
 }

package/dist/client.js

@@ -1,5 +1,7 @@
 import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
 import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
 import { Socket } from "node:net";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -10,7 +12,8 @@ import {
 } from "vscode-jsonrpc/node.js";
 import { createServerRpc } from "./generated/rpc.js";
 import { getSdkProtocolVersion } from "./sdkProtocolVersion.js";
-import { CopilotSession } from "./session.js";
+import { CopilotSession, NO_RESULT_PERMISSION_V2_ERROR } from "./session.js";
+import { getTraceContext } from "./telemetry.js";
 const MIN_PROTOCOL_VERSION = 2;
 function isZodSchema(value) {
   return value != null && typeof value === "object" && "toJSONSchema" in value && typeof value.toJSONSchema === "function";
@@ -22,6 +25,30 @@ function toJsonSchema(parameters) {
   }
   return parameters;
 }
+function extractTransformCallbacks(systemMessage) {
+  if (!systemMessage || systemMessage.mode !== "customize" || !systemMessage.sections) {
+    return { wirePayload: systemMessage, transformCallbacks: void 0 };
+  }
+  const transformCallbacks = /* @__PURE__ */ new Map();
+  const wireSections = {};
+  for (const [sectionId, override] of Object.entries(systemMessage.sections)) {
+    if (!override) continue;
+    if (typeof override.action === "function") {
+      transformCallbacks.set(sectionId, override.action);
+      wireSections[sectionId] = { action: "transform" };
+    } else {
+      wireSections[sectionId] = { action: override.action, content: override.content };
+    }
+  }
+  if (transformCallbacks.size === 0) {
+    return { wirePayload: systemMessage, transformCallbacks: void 0 };
+  }
+  const wirePayload = {
+    ...systemMessage,
+    sections: wireSections
+  };
+  return { wirePayload, transformCallbacks };
+}
 function getNodeExecPath() {
   if (process.versions.bun) {
     return "node";
@@ -29,9 +56,22 @@ function getNodeExecPath() {
   return process.execPath;
 }
 function getBundledCliPath() {
-  const sdkUrl = import.meta.resolve("@github/copilot/sdk");
-  const sdkPath = fileURLToPath(sdkUrl);
-  return join(dirname(dirname(sdkPath)), "index.js");
+  if (typeof import.meta.resolve === "function") {
+    const sdkUrl = import.meta.resolve("@github/copilot/sdk");
+    const sdkPath = fileURLToPath(sdkUrl);
+    return join(dirname(dirname(sdkPath)), "index.js");
+  }
+  const req = createRequire(__filename);
+  const searchPaths = req.resolve.paths("@github/copilot") ?? [];
+  for (const base of searchPaths) {
+    const candidate = join(base, "@github", "copilot", "index.js");
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error(
+    `Could not find @github/copilot package. Searched ${searchPaths.length} paths. Ensure it is installed, or pass cliPath/cliUrl to CopilotClient.`
+  );
 }
 class CopilotClient {
   cliProcess = null;
@@ -47,6 +87,7 @@ class CopilotClient {
   isExternalServer = false;
   forceStopping = false;
   onListModels;
+  onGetTraceContext;
   modelsCache = null;
   modelsCacheLock = Promise.resolve();
   sessionLifecycleHandlers = /* @__PURE__ */ new Set();
@@ -113,8 +154,9 @@ class CopilotClient {
       this.isExternalServer = true;
     }
     this.onListModels = options.onListModels;
+    this.onGetTraceContext = options.onGetTraceContext;
     this.options = {
-      cliPath: options.cliPath || getBundledCliPath(),
+      cliPath: options.cliUrl ? void 0 : options.cliPath || getBundledCliPath(),
       cliArgs: options.cliArgs ?? [],
       cwd: options.cwd ?? process.cwd(),
       port: options.port || 0,
@@ -124,11 +166,12 @@ class CopilotClient {
       cliUrl: options.cliUrl,
       logLevel: options.logLevel || "debug",
       autoStart: options.autoStart ?? true,
-      autoRestart: options.autoRestart ?? true,
+      autoRestart: false,
       env: options.env ?? process.env,
       githubToken: options.githubToken,
       // Default useLoggedInUser to false when githubToken is provided, otherwise true
-      useLoggedInUser: options.useLoggedInUser ?? (options.githubToken ? false : true)
+      useLoggedInUser: options.useLoggedInUser ?? (options.githubToken ? false : true),
+      telemetry: options.telemetry
     };
   }
   /**
@@ -380,37 +423,13 @@ class CopilotClient {
         throw new Error("Client not connected. Call start() first.");
       }
     }
-    const response = await this.connection.sendRequest("session.create", {
-      model: config.model,
-      sessionId: config.sessionId,
-      clientName: config.clientName,
-      reasoningEffort: config.reasoningEffort,
-      tools: config.tools?.map((tool) => ({
-        name: tool.name,
-        description: tool.description,
-        parameters: toJsonSchema(tool.parameters),
-        overridesBuiltInTool: tool.overridesBuiltInTool
-      })),
-      systemMessage: config.systemMessage,
-      availableTools: config.availableTools,
-      excludedTools: config.excludedTools,
-      provider: config.provider,
-      requestPermission: true,
-      requestUserInput: !!config.onUserInputRequest,
-      hooks: !!(config.hooks && Object.values(config.hooks).some(Boolean)),
-      workingDirectory: config.workingDirectory,
-      streaming: config.streaming,
-      mcpServers: config.mcpServers,
-      envValueMode: "direct",
-      customAgents: config.customAgents,
-      agent: config.agent,
-      configDir: config.configDir,
-      skillDirectories: config.skillDirectories,
-      disabledSkills: config.disabledSkills,
-      infiniteSessions: config.infiniteSessions
-    });
-    const { sessionId, workspacePath } = response;
-    const session = new CopilotSession(sessionId, this.connection, workspacePath);
+    const sessionId = config.sessionId ?? randomUUID();
+    const session = new CopilotSession(
+      sessionId,
+      this.connection,
+      void 0,
+      this.onGetTraceContext
+    );
     session.registerTools(config.tools);
     session.registerPermissionHandler(config.onPermissionRequest);
     if (config.onUserInputRequest) {
@@ -419,7 +438,54 @@ class CopilotClient {
     if (config.hooks) {
       session.registerHooks(config.hooks);
     }
+    const { wirePayload: wireSystemMessage, transformCallbacks } = extractTransformCallbacks(
+      config.systemMessage
+    );
+    if (transformCallbacks) {
+      session.registerTransformCallbacks(transformCallbacks);
+    }
+    if (config.onEvent) {
+      session.on(config.onEvent);
+    }
     this.sessions.set(sessionId, session);
+    try {
+      const response = await this.connection.sendRequest("session.create", {
+        ...await getTraceContext(this.onGetTraceContext),
+        model: config.model,
+        sessionId,
+        clientName: config.clientName,
+        reasoningEffort: config.reasoningEffort,
+        tools: config.tools?.map((tool) => ({
+          name: tool.name,
+          description: tool.description,
+          parameters: toJsonSchema(tool.parameters),
+          overridesBuiltInTool: tool.overridesBuiltInTool,
+          skipPermission: tool.skipPermission
+        })),
+        systemMessage: wireSystemMessage,
+        availableTools: config.availableTools,
+        excludedTools: config.excludedTools,
+        provider: config.provider,
+        requestPermission: true,
+        requestUserInput: !!config.onUserInputRequest,
+        hooks: !!(config.hooks && Object.values(config.hooks).some(Boolean)),
+        workingDirectory: config.workingDirectory,
+        streaming: config.streaming,
+        mcpServers: config.mcpServers,
+        envValueMode: "direct",
+        customAgents: config.customAgents,
+        agent: config.agent,
+        configDir: config.configDir,
+        skillDirectories: config.skillDirectories,
+        disabledSkills: config.disabledSkills,
+        infiniteSessions: config.infiniteSessions
+      });
+      const { workspacePath } = response;
+      session["_workspacePath"] = workspacePath;
+    } catch (e) {
+      this.sessions.delete(sessionId);
+      throw e;
+    }
     return session;
   }
   /**
@@ -459,38 +525,12 @@ class CopilotClient {
         throw new Error("Client not connected. Call start() first.");
       }
     }
-    const response = await this.connection.sendRequest("session.resume", {
+    const session = new CopilotSession(
       sessionId,
-      clientName: config.clientName,
-      model: config.model,
-      reasoningEffort: config.reasoningEffort,
-      systemMessage: config.systemMessage,
-      availableTools: config.availableTools,
-      excludedTools: config.excludedTools,
-      tools: config.tools?.map((tool) => ({
-        name: tool.name,
-        description: tool.description,
-        parameters: toJsonSchema(tool.parameters),
-        overridesBuiltInTool: tool.overridesBuiltInTool
-      })),
-      provider: config.provider,
-      requestPermission: true,
-      requestUserInput: !!config.onUserInputRequest,
-      hooks: !!(config.hooks && Object.values(config.hooks).some(Boolean)),
-      workingDirectory: config.workingDirectory,
-      configDir: config.configDir,
-      streaming: config.streaming,
-      mcpServers: config.mcpServers,
-      envValueMode: "direct",
-      customAgents: config.customAgents,
-      agent: config.agent,
-      skillDirectories: config.skillDirectories,
-      disabledSkills: config.disabledSkills,
-      infiniteSessions: config.infiniteSessions,
-      disableResume: config.disableResume
-    });
-    const { sessionId: resumedSessionId, workspacePath } = response;
-    const session = new CopilotSession(resumedSessionId, this.connection, workspacePath);
+      this.connection,
+      void 0,
+      this.onGetTraceContext
+    );
     session.registerTools(config.tools);
     session.registerPermissionHandler(config.onPermissionRequest);
     if (config.onUserInputRequest) {
@@ -499,7 +539,55 @@ class CopilotClient {
     if (config.hooks) {
       session.registerHooks(config.hooks);
     }
-    this.sessions.set(resumedSessionId, session);
+    const { wirePayload: wireSystemMessage, transformCallbacks } = extractTransformCallbacks(
+      config.systemMessage
+    );
+    if (transformCallbacks) {
+      session.registerTransformCallbacks(transformCallbacks);
+    }
+    if (config.onEvent) {
+      session.on(config.onEvent);
+    }
+    this.sessions.set(sessionId, session);
+    try {
+      const response = await this.connection.sendRequest("session.resume", {
+        ...await getTraceContext(this.onGetTraceContext),
+        sessionId,
+        clientName: config.clientName,
+        model: config.model,
+        reasoningEffort: config.reasoningEffort,
+        systemMessage: wireSystemMessage,
+        availableTools: config.availableTools,
+        excludedTools: config.excludedTools,
+        tools: config.tools?.map((tool) => ({
+          name: tool.name,
+          description: tool.description,
+          parameters: toJsonSchema(tool.parameters),
+          overridesBuiltInTool: tool.overridesBuiltInTool,
+          skipPermission: tool.skipPermission
+        })),
+        provider: config.provider,
+        requestPermission: true,
+        requestUserInput: !!config.onUserInputRequest,
+        hooks: !!(config.hooks && Object.values(config.hooks).some(Boolean)),
+        workingDirectory: config.workingDirectory,
+        configDir: config.configDir,
+        streaming: config.streaming,
+        mcpServers: config.mcpServers,
+        envValueMode: "direct",
+        customAgents: config.customAgents,
+        agent: config.agent,
+        skillDirectories: config.skillDirectories,
+        disabledSkills: config.disabledSkills,
+        infiniteSessions: config.infiniteSessions,
+        disableResume: config.disableResume
+      });
+      const { workspacePath } = response;
+      session["_workspacePath"] = workspacePath;
+    } catch (e) {
+      this.sessions.delete(sessionId);
+      throw e;
+    }
     return session;
   }
   /**
@@ -802,6 +890,27 @@ class CopilotClient {
       if (this.options.githubToken) {
         envWithoutNodeDebug.COPILOT_SDK_AUTH_TOKEN = this.options.githubToken;
       }
+      if (!this.options.cliPath) {
+        throw new Error(
+          "Path to Copilot CLI is required. Please provide it via the cliPath option, or use cliUrl to rely on a remote CLI."
+        );
+      }
+      if (this.options.telemetry) {
+        const t = this.options.telemetry;
+        envWithoutNodeDebug.COPILOT_OTEL_ENABLED = "true";
+        if (t.otlpEndpoint !== void 0)
+          envWithoutNodeDebug.OTEL_EXPORTER_OTLP_ENDPOINT = t.otlpEndpoint;
+        if (t.filePath !== void 0)
+          envWithoutNodeDebug.COPILOT_OTEL_FILE_EXPORTER_PATH = t.filePath;
+        if (t.exporterType !== void 0)
+          envWithoutNodeDebug.COPILOT_OTEL_EXPORTER_TYPE = t.exporterType;
+        if (t.sourceName !== void 0)
+          envWithoutNodeDebug.COPILOT_OTEL_SOURCE_NAME = t.sourceName;
+        if (t.captureContent !== void 0)
+          envWithoutNodeDebug.OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT = String(
+            t.captureContent
+          );
+      }
       if (!existsSync(this.options.cliPath)) {
         throw new Error(
           `Copilot CLI not found at ${this.options.cliPath}. Ensure @github/copilot is installed.`
@@ -901,8 +1010,6 @@ stderr: ${stderrOutput}`
           } else {
             reject(new Error(`CLI server exited with code ${code}`));
           }
-        } else if (this.options.autoRestart && this.state === "connected") {
-          void this.reconnect();
         }
       });
       setTimeout(() => {
@@ -1007,12 +1114,15 @@ stderr: ${stderrOutput}`
       "hooks.invoke",
       async (params) => await this.handleHooksInvoke(params)
     );
+    this.connection.onRequest(
+      "systemMessage.transform",
+      async (params) => await this.handleSystemMessageTransform(params)
+    );
     this.connection.onClose(() => {
-      if (this.state === "connected" && this.options.autoRestart) {
-        void this.reconnect();
-      }
+      this.state = "disconnected";
     });
     this.connection.onError((_error) => {
+      this.state = "disconnected";
     });
   }
   handleSessionEventNotification(notification) {
@@ -1071,6 +1181,16 @@ stderr: ${stderrOutput}`
     const output = await session._handleHooksInvoke(params.hookType, params.input);
     return { output };
   }
+  async handleSystemMessageTransform(params) {
+    if (!params || typeof params.sessionId !== "string" || !params.sections || typeof params.sections !== "object") {
+      throw new Error("Invalid systemMessage.transform payload");
+    }
+    const session = this.sessions.get(params.sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${params.sessionId}`);
+    }
+    return await session._handleSystemMessageTransform(params.sections);
+  }
   // ========================================================================
   // Protocol v2 backward-compatibility adapters
   // ========================================================================
@@ -1099,11 +1219,15 @@ stderr: ${stderrOutput}`
       };
     }
     try {
+      const traceparent = params.traceparent;
+      const tracestate = params.tracestate;
       const invocation = {
         sessionId: params.sessionId,
         toolCallId: params.toolCallId,
         toolName: params.toolName,
-        arguments: params.arguments
+        arguments: params.arguments,
+        traceparent,
+        tracestate
       };
       const result = await handler(params.arguments, invocation);
       return { result: this.normalizeToolResultV2(result) };
@@ -1133,7 +1257,10 @@ stderr: ${stderrOutput}`
     try {
       const result = await session._handlePermissionRequestV2(params.permissionRequest);
       return { result };
-    } catch (_error) {
+    } catch (error) {
+      if (error instanceof Error && error.message === NO_RESULT_PERMISSION_V2_ERROR) {
+        throw error;
+      }
       return {
         result: {
           kind: "denied-no-approval-rule-and-could-not-request-from-user"
@@ -1163,17 +1290,6 @@ stderr: ${stderrOutput}`
   isToolResultObject(value) {
     return typeof value === "object" && value !== null && "textResultForLlm" in value && typeof value.textResultForLlm === "string" && "resultType" in value;
   }
-  /**
-   * Attempt to reconnect to the server
-   */
-  async reconnect() {
-    this.state = "disconnected";
-    try {
-      await this.stop();
-      await this.start();
-    } catch (_error) {
-    }
-  }
 }
 export {
   CopilotClient

package/dist/extension.d.ts

@@ -1,5 +1,8 @@
 import type { CopilotSession } from "./session.js";
-import type { ResumeSessionConfig } from "./types.js";
+import type { PermissionHandler, ResumeSessionConfig } from "./types.js";
+export type JoinSessionConfig = Omit<ResumeSessionConfig, "onPermissionRequest"> & {
+    onPermissionRequest?: PermissionHandler;
+};
 /**
  * Joins the current foreground session.
  *
@@ -8,13 +11,9 @@ import type { ResumeSessionConfig } from "./types.js";
  *
  * @example
  * ```typescript
- * import { approveAll } from "@github/copilot-sdk";
  * import { joinSession } from "@github/copilot-sdk/extension";
  *
- * const session = await joinSession({
- *   onPermissionRequest: approveAll,
- *   tools: [myTool],
- * });
+ * const session = await joinSession({ tools: [myTool] });
  * ```
  */
-export declare function joinSession(config: ResumeSessionConfig): Promise<CopilotSession>;
+export declare function joinSession(config?: JoinSessionConfig): Promise<CopilotSession>;

package/dist/extension.js

@@ -1,5 +1,8 @@
 import { CopilotClient } from "./client.js";
-async function joinSession(config) {
+const defaultJoinSessionPermissionHandler = () => ({
+  kind: "no-result"
+});
+async function joinSession(config = {}) {
   const sessionId = process.env.SESSION_ID;
   if (!sessionId) {
     throw new Error(
@@ -9,6 +12,7 @@ async function joinSession(config) {
   const client = new CopilotClient({ isChildProcess: true });
   return client.resumeSession(sessionId, {
     ...config,
+    onPermissionRequest: config.onPermissionRequest ?? defaultJoinSessionPermissionHandler,
     disableResume: config.disableResume ?? true
   });
 }