@github/copilot-sdk 1.0.7-preview.0 → 1.0.7-preview.1

package/dist/cjs/types.js

@@ -59,6 +59,18 @@ const RuntimeConnection = {
    */
   forUri(url, opts = {}) {
     return { kind: "uri", url, connectionToken: opts.connectionToken };
+  },
+  /**
+   * Host the runtime in-process over the native runtime library's C ABI (FFI).
+   *
+   * @experimental Per-client options lowered to environment variables (`env`,
+   * `telemetry`, `gitHubToken`, `baseDirectory`) are **not** honored in-process;
+   * the worker inherits the host process's ambient environment. Set the
+   * corresponding environment variables on the host process instead. See
+   * https://github.com/github/copilot-sdk/issues/1934.
+   */
+  forInProcess() {
+    return { kind: "inprocess" };
   }
 };
 function convertMcpCallToolResult(callResult) {

package/dist/client.d.ts

@@ -4,6 +4,7 @@ import type { CopilotClientOptions, GetAuthStatusResponse, GetStatusResponse, Mo
 export declare class CopilotClient {
     private cliStartTimeout;
     private cliProcess;
+    private ffiHost;
     private connection;
     private messageWriter;
     private socket;
@@ -45,6 +46,18 @@ export declare class CopilotClient {
     get rpc(): ReturnType<typeof createServerRpc>;
     private logDebugTiming;
     private logDebug;
+    /**
+     * Environment variable that overrides the transport when the caller does not set
+     * {@link CopilotClientOptions.connection}. Accepts `"inprocess"` or `"stdio"`
+     * (case-insensitive); unset preserves the default stdio transport. Any other value
+     * is an error.
+     */
+    private static readonly DEFAULT_CONNECTION_ENV_VAR;
+    /**
+     * Resolves the default {@link RuntimeConnection} for the no-connection case,
+     * honoring {@link CopilotClient.DEFAULT_CONNECTION_ENV_VAR}.
+     */
+    private static resolveDefaultConnection;
     /**
      * Creates a new CopilotClient instance.
      *
@@ -406,6 +419,14 @@ export declare class CopilotClient {
      * ```
      */
     onLifecycle(handler: SessionLifecycleHandler): () => void;
+    /**
+     * Builds the environment for the spawned runtime child process (stdio/TCP): applies
+     * the auth token, connection token, `COPILOT_HOME`, keychain setting, and telemetry
+     * variables on top of the effective env. Not used by the in-process (FFI) transport,
+     * whose worker inherits the host process's ambient environment
+     * (see {@link CopilotClient.startInProcessFfi}).
+     */
+    private buildRuntimeEnv;
     /**
      * Start the CLI server process
      */
@@ -414,6 +435,34 @@ export declare class CopilotClient {
      * Connect to the CLI server (via socket or stdio)
      */
     private connectToServer;
+    /**
+     * Start the in-process FFI runtime host: resolve the CLI entrypoint and native
+     * runtime library, then let the native host spawn the CLI worker.
+     *
+     * The worker inherits this host process's ambient environment; per-client options
+     * that lower to environment variables (`env`, `telemetry`, `gitHubToken`,
+     * `baseDirectory`) are intentionally not applied here, because the native runtime
+     * loads into the shared host process and a single env block cannot carry per-client
+     * values. Configure the in-process runtime via the host process environment instead.
+     * See https://github.com/github/copilot-sdk/issues/1934.
+     */
+    private startInProcessFfi;
+    /**
+     * Connect to the in-process FFI runtime host over its receive/send streams,
+     * reusing the same `vscode-jsonrpc` framing as the stdio transport.
+     */
+    private connectViaFfi;
+    /**
+     * Resolves the CLI entrypoint used for in-process FFI hosting: `COPILOT_CLI_PATH`
+     * when set, otherwise the bundled platform-package entrypoint.
+     */
+    private resolveCliPathForFfi;
+    /**
+     * Returns the napi prebuilds folder name for the current host — the
+     * `<node-platform>-<arch>` convention (e.g. `win32-x64`, `darwin-arm64`,
+     * `linux-x64`) under which the runtime ships `prebuilds/<folder>/runtime.node`.
+     */
+    private static getNapiPrebuildsFolder;
     /**
      * Connect to child via stdio pipes
      */

package/dist/client.js

@@ -233,6 +233,7 @@ class TeardownResilientStreamMessageWriter extends StreamMessageWriter {
 class CopilotClient {
   cliStartTimeout = null;
   cliProcess = null;
+  ffiHost = null;
   connection = null;
   messageWriter = null;
   socket = null;
@@ -309,6 +310,29 @@ class CopilotClient {
 `);
     }
   }
+  /**
+   * Environment variable that overrides the transport when the caller does not set
+   * {@link CopilotClientOptions.connection}. Accepts `"inprocess"` or `"stdio"`
+   * (case-insensitive); unset preserves the default stdio transport. Any other value
+   * is an error.
+   */
+  static DEFAULT_CONNECTION_ENV_VAR = "COPILOT_SDK_DEFAULT_CONNECTION";
+  /**
+   * Resolves the default {@link RuntimeConnection} for the no-connection case,
+   * honoring {@link CopilotClient.DEFAULT_CONNECTION_ENV_VAR}.
+   */
+  static resolveDefaultConnection() {
+    const value = process.env[CopilotClient.DEFAULT_CONNECTION_ENV_VAR];
+    if (!value || value.toLowerCase() === "stdio") {
+      return { kind: "stdio" };
+    }
+    if (value.toLowerCase() === "inprocess") {
+      return { kind: "inprocess" };
+    }
+    throw new Error(
+      `Invalid ${CopilotClient.DEFAULT_CONNECTION_ENV_VAR} value '${value}'. Expected 'inprocess', 'stdio', or unset.`
+    );
+  }
   /**
    * Creates a new CopilotClient instance.
    *
@@ -337,12 +361,17 @@ class CopilotClient {
    * ```
    */
   constructor(options = {}) {
-    const conn = options._internalConnection ?? options.connection ?? { kind: "stdio" };
+    const conn = options._internalConnection ?? options.connection ?? CopilotClient.resolveDefaultConnection();
     if (conn.kind === "uri" && (options.gitHubToken !== void 0 || options.useLoggedInUser !== void 0)) {
       throw new Error(
         "gitHubToken and useLoggedInUser cannot be used with RuntimeConnection.forUri (external server manages its own auth)"
       );
     }
+    if (conn.kind === "inprocess" && options.workingDirectory !== void 0) {
+      throw new Error(
+        "workingDirectory is not supported with RuntimeConnection.forInProcess(): the in-process transport hosts the runtime in this process, so honoring it would require mutating the shared process-global cwd. Change the host process's working directory before constructing the client instead."
+      );
+    }
     if (conn.kind === "tcp" && conn.connectionToken !== void 0) {
       if (typeof conn.connectionToken !== "string" || conn.connectionToken.length === 0) {
         throw new Error("connectionToken must be a non-empty string");
@@ -498,7 +527,9 @@ class CopilotClient {
     }
     this.state = "connecting";
     try {
-      if (!this.isExternalServer) {
+      if (this.connectionConfig.kind === "inprocess") {
+        await this.startInProcessFfi();
+      } else if (!this.isExternalServer) {
         await this.startCLIServer();
       }
       await this.connectToServer();
@@ -547,6 +578,9 @@ class CopilotClient {
   async stop() {
     const errors = [];
     const activeSessions = [...this.sessions.values()];
+    if (this.connectionConfig.kind === "inprocess") {
+      await Promise.allSettled(activeSessions.map((session) => session.abort()));
+    }
     for (const session of activeSessions) {
       const sessionId = session.sessionId;
       let lastError = null;
@@ -575,7 +609,7 @@ class CopilotClient {
       session._markDisconnected();
     }
     this.sessions.clear();
-    if (this.connection && this.cliProcess && !this.isExternalServer) {
+    if (this.connection && (this.cliProcess || this.ffiHost) && !this.isExternalServer) {
       const runtimeShutdownStart = Date.now();
       const shutdownPromise = this.rpc.runtime.shutdown();
       void shutdownPromise.catch(() => void 0);
@@ -660,6 +694,19 @@ class CopilotClient {
         );
       }
     }
+    if (this.ffiHost) {
+      const host = this.ffiHost;
+      this.ffiHost = null;
+      try {
+        host.dispose();
+      } catch (error) {
+        errors.push(
+          new Error(
+            `Failed to dispose in-process runtime host: ${error instanceof Error ? error.message : String(error)}`
+          )
+        );
+      }
+    }
     if (this.cliStartTimeout) {
       clearTimeout(this.cliStartTimeout);
       this.cliStartTimeout = null;
@@ -744,6 +791,13 @@ class CopilotClient {
       }
       this.cliProcess = null;
     }
+    if (this.ffiHost) {
+      try {
+        this.ffiHost.dispose();
+      } catch {
+      }
+      this.ffiHost = null;
+    }
     if (this.cliStartTimeout) {
       clearTimeout(this.cliStartTimeout);
       this.cliStartTimeout = null;
@@ -988,6 +1042,7 @@ class CopilotClient {
         requestExtensions: config.requestExtensions,
         extensionSdkPath: config.extensionSdkPath,
         extensionInfo: config.extensionInfo,
+        canvasProvider: config.canvasProvider,
         commands: config.commands?.map((cmd) => ({
           name: cmd.name,
           description: cmd.description
@@ -1185,6 +1240,7 @@ class CopilotClient {
         requestExtensions: config.requestExtensions,
         extensionSdkPath: config.extensionSdkPath,
         extensionInfo: config.extensionInfo,
+        canvasProvider: config.canvasProvider,
         commands: config.commands?.map((cmd) => ({
           name: cmd.name,
           description: cmd.description
@@ -1583,6 +1639,41 @@ class CopilotClient {
       this.sessionLifecycleHandlers.delete(wildcardHandler);
     };
   }
+  /**
+   * Builds the environment for the spawned runtime child process (stdio/TCP): applies
+   * the auth token, connection token, `COPILOT_HOME`, keychain setting, and telemetry
+   * variables on top of the effective env. Not used by the in-process (FFI) transport,
+   * whose worker inherits the host process's ambient environment
+   * (see {@link CopilotClient.startInProcessFfi}).
+   */
+  buildRuntimeEnv() {
+    const env = { ...this.resolvedEnv };
+    delete env.NODE_DEBUG;
+    if (this.options.gitHubToken) {
+      env.COPILOT_SDK_AUTH_TOKEN = this.options.gitHubToken;
+    }
+    if (this.effectiveConnectionToken) {
+      env.COPILOT_CONNECTION_TOKEN = this.effectiveConnectionToken;
+    }
+    if (this.options.baseDirectory) {
+      env.COPILOT_HOME = this.options.baseDirectory;
+    }
+    if (this.options.mode === "empty") {
+      env.COPILOT_DISABLE_KEYTAR = "1";
+    }
+    if (this.options.telemetry) {
+      const t = this.options.telemetry;
+      env.COPILOT_OTEL_ENABLED = "true";
+      if (t.otlpEndpoint !== void 0) env.OTEL_EXPORTER_OTLP_ENDPOINT = t.otlpEndpoint;
+      if (t.otlpProtocol !== void 0) env.OTEL_EXPORTER_OTLP_PROTOCOL = t.otlpProtocol;
+      if (t.filePath !== void 0) env.COPILOT_OTEL_FILE_EXPORTER_PATH = t.filePath;
+      if (t.exporterType !== void 0) env.COPILOT_OTEL_EXPORTER_TYPE = t.exporterType;
+      if (t.sourceName !== void 0) env.COPILOT_OTEL_SOURCE_NAME = t.sourceName;
+      if (t.captureContent !== void 0)
+        env.OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT = String(t.captureContent);
+    }
+    return env;
+  }
   /**
    * Start the CLI server process
    */
@@ -1616,43 +1707,12 @@ class CopilotClient {
       if (this.options.enableRemoteSessions) {
         args.push("--remote");
       }
-      const envWithoutNodeDebug = { ...this.resolvedEnv };
-      delete envWithoutNodeDebug.NODE_DEBUG;
-      if (this.options.gitHubToken) {
-        envWithoutNodeDebug.COPILOT_SDK_AUTH_TOKEN = this.options.gitHubToken;
-      }
-      if (this.effectiveConnectionToken) {
-        envWithoutNodeDebug.COPILOT_CONNECTION_TOKEN = this.effectiveConnectionToken;
-      }
-      if (this.options.baseDirectory) {
-        envWithoutNodeDebug.COPILOT_HOME = this.options.baseDirectory;
-      }
-      if (this.options.mode === "empty") {
-        envWithoutNodeDebug.COPILOT_DISABLE_KEYTAR = "1";
-      }
+      const envWithoutNodeDebug = this.buildRuntimeEnv();
       if (!this.resolvedCliPath) {
         throw new Error(
           "Path to Copilot CLI is required. Please supply it via `RuntimeConnection.forStdio({ path })` or `RuntimeConnection.forTcp({ path })`, set the COPILOT_CLI_PATH environment variable, or use `RuntimeConnection.forUri(...)` to connect to an already-running runtime."
         );
       }
-      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.otlpProtocol !== void 0)
-          envWithoutNodeDebug.OTEL_EXPORTER_OTLP_PROTOCOL = t.otlpProtocol;
-        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.resolvedCliPath)) {
         throw new Error(
           `Copilot CLI not found at ${this.resolvedCliPath}. Ensure @github/copilot is installed.`
@@ -1771,11 +1831,66 @@ stderr: ${stderrOutput}`
         return this.connectToParentProcessViaStdio();
       case "stdio":
         return this.connectToChildProcessViaStdio();
+      case "inprocess":
+        return this.connectViaFfi();
       case "tcp":
       case "uri":
         return this.connectViaTcp();
     }
   }
+  /**
+   * Start the in-process FFI runtime host: resolve the CLI entrypoint and native
+   * runtime library, then let the native host spawn the CLI worker.
+   *
+   * The worker inherits this host process's ambient environment; per-client options
+   * that lower to environment variables (`env`, `telemetry`, `gitHubToken`,
+   * `baseDirectory`) are intentionally not applied here, because the native runtime
+   * loads into the shared host process and a single env block cannot carry per-client
+   * values. Configure the in-process runtime via the host process environment instead.
+   * See https://github.com/github/copilot-sdk/issues/1934.
+   */
+  async startInProcessFfi() {
+    const entrypoint = this.resolveCliPathForFfi();
+    const { FfiRuntimeHost } = await import("./ffiRuntimeHost.js");
+    const host = FfiRuntimeHost.create(entrypoint, CopilotClient.getNapiPrebuildsFolder());
+    this.ffiHost = host;
+    await host.start();
+  }
+  /**
+   * Connect to the in-process FFI runtime host over its receive/send streams,
+   * reusing the same `vscode-jsonrpc` framing as the stdio transport.
+   */
+  async connectViaFfi() {
+    if (!this.ffiHost) {
+      throw new Error("In-process FFI runtime host not started");
+    }
+    this.messageWriter = new TeardownResilientStreamMessageWriter(this.ffiHost.sendStream);
+    this.connection = createMessageConnection(
+      new StreamMessageReader(this.ffiHost.receiveStream),
+      this.messageWriter
+    );
+    this.attachConnectionHandlers();
+    this.connection.listen();
+  }
+  /**
+   * Resolves the CLI entrypoint used for in-process FFI hosting: `COPILOT_CLI_PATH`
+   * when set, otherwise the bundled platform-package entrypoint.
+   */
+  resolveCliPathForFfi() {
+    return this.resolvedEnv.COPILOT_CLI_PATH ?? getBundledCliPath();
+  }
+  /**
+   * Returns the napi prebuilds folder name for the current host — the
+   * `<node-platform>-<arch>` convention (e.g. `win32-x64`, `darwin-arm64`,
+   * `linux-x64`) under which the runtime ships `prebuilds/<folder>/runtime.node`.
+   */
+  static getNapiPrebuildsFolder() {
+    const arch = process.arch;
+    if (arch !== "x64" && arch !== "arm64") {
+      throw new Error(`Unsupported architecture '${arch}' for in-process FFI hosting.`);
+    }
+    return `${process.platform}-${arch}`;
+  }
   /**
    * Connect to child via stdio pipes
    */
@@ -1897,8 +2012,9 @@ stderr: ${stderrOutput}`
       return;
     }
     const session = this.sessions.get(notification.sessionId);
+    const event = notification.event;
     if (session) {
-      session._dispatchEvent(notification.event);
+      session._dispatchEvent(event);
     }
   }
   handleSessionLifecycleNotification(notification) {

package/dist/copilotRequestHandler.d.ts

@@ -8,6 +8,9 @@ declare const kSuppressCloseOnDispose: unique symbol;
 export interface CopilotRequestContext {
     readonly requestId: string;
     readonly sessionId?: string;
+    readonly agentId?: string;
+    readonly parentAgentId?: string;
+    readonly interactionType?: string;
     readonly transport: "http" | "websocket";
     url: string;
     headers: LlmInferenceHeaders;

package/dist/copilotRequestHandler.js

@@ -153,6 +153,9 @@ class CopilotRequestHandler {
     const ctx = {
       requestId: exchange.requestId,
       sessionId: exchange.sessionId,
+      agentId: exchange.agentId,
+      parentAgentId: exchange.parentAgentId,
+      interactionType: exchange.interactionType,
       transport: exchange.transport,
       url: exchange.url,
       headers: exchange.headers,
@@ -278,6 +281,9 @@ function routeChunk(exchange, params) {
 class CopilotRequestExchange {
   requestId;
   sessionId;
+  agentId;
+  parentAgentId;
+  interactionType;
   method = "GET";
   url = "";
   headers = {};
@@ -297,6 +303,9 @@ class CopilotRequestExchange {
   /** Fill in the request context once the matching start frame arrives. */
   setContext(params) {
     this.sessionId = params.sessionId;
+    this.agentId = params.agentId;
+    this.parentAgentId = params.parentAgentId;
+    this.interactionType = params.interactionType;
     this.method = params.method;
     this.url = params.url;
     this.headers = params.headers;

package/dist/ffiRuntimeHost.d.ts

@@ -0,0 +1,40 @@
+import { PassThrough, Writable } from "node:stream";
+export declare class FfiRuntimeHost {
+    private readonly libraryPath;
+    private readonly cliEntrypoint;
+    private readonly environment?;
+    private readonly lib;
+    private serverId;
+    private connectionId;
+    private disposed;
+    private outboundCallback;
+    private keepAliveTimer;
+    /** The stream JSON-RPC reads server→client frames from. */
+    readonly receiveStream: PassThrough;
+    /** The stream JSON-RPC writes client→server frames to. */
+    readonly sendStream: Writable;
+    private constructor();
+    /**
+     * Resolves the cdylib next to the given CLI entrypoint and prepares the FFI host.
+     * The cdylib is resolved as `prebuilds/<prebuildsFolder>/runtime.node` relative to
+     * the entrypoint directory (the napi-rs `<node-platform>-<arch>` layout, e.g.
+     * `linux-x64`). Throws if it cannot be found.
+     */
+    static create(cliEntrypoint: string, prebuildsFolder: string, environment?: Record<string, string | undefined>): FfiRuntimeHost;
+    /**
+     * Starts the in-process runtime: spawns the CLI worker via the native host,
+     * waits for readiness, and opens the FFI JSON-RPC connection.
+     */
+    start(): Promise<void>;
+    private writeFrame;
+    /**
+     * Native outbound (server→client) callback. koffi delivers it on the JS event loop
+     * via a threadsafe function, so the frame is decoded and written straight to
+     * {@link receiveStream}. The native pointer is only valid for this call, so the
+     * bytes are copied out before returning.
+     */
+    private feedInbound;
+    private unregisterCallback;
+    /** Closes the FFI connection, shuts down the native host, and releases resources. */
+    dispose(): void;
+}