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

package/dist/cjs/generated/rpc.js

@@ -321,6 +321,15 @@ function createServerRpc(connection) {
       getDiscoveryPaths: async (params) => connection.sendRequest("instructions.getDiscoveryPaths", params)
     },
     /** @experimental */
+    commands: {
+      /**
+       * Lists the well-known built-in slash commands that work as the first message in a new session (e.g. /plan, /env), without requiring an active session. Commands that depend on session state, authentication, or a synced session are omitted.
+       *
+       * @returns Slash commands available in the session, after applying any include/exclude filters.
+       */
+      list: async () => connection.sendRequest("commands.list", {})
+    },
+    /** @experimental */
     user: {
       /** @experimental */
       settings: {
@@ -656,6 +665,16 @@ function createSessionRpc(connection, sessionId) {
      * @experimental
      */
     send: async (params) => connection.sendRequest("session.send", { sessionId, ...params }),
+    /**
+     * Sends zero or more user messages to the session in a single turn and returns their message IDs. All provided messages are appended to the conversation in order, then exactly one agent turn runs over the resulting history. When the list is empty, one turn runs over the existing history with no new user message. Remote-backed (Mission Control) sessions do not support this method and will return an error.
+     *
+     * @param params Parameters for sending zero or more user messages to the session in a single turn. Remote-backed (Mission Control) sessions do not support this method and will return an error.
+     *
+     * @returns Result of sending zero or more user messages
+     *
+     * @experimental
+     */
+    sendMessages: async (params) => connection.sendRequest("session.sendMessages", { sessionId, ...params }),
     /**
      * Aborts the current agent turn.
      *
@@ -1153,6 +1172,18 @@ function createSessionRpc(connection, sessionId) {
        * @returns Indicates whether the auto-managed `github` MCP server was removed (false when nothing to remove).
        */
       removeGitHub: async () => connection.sendRequest("session.mcp.removeGitHub", { sessionId }),
+      /**
+       * Starts an individual MCP server on the live session from a caller-supplied config. Session-scoped and ephemeral: the server is added to this session's running set only and is reaped when the session ends. Does NOT modify persistent user configuration (`mcp.config.*`), so it does not affect future sessions. The server surfaces through `session.mcp.list` and the `session.mcp_servers_loaded` / `session.mcp_server_status_changed` events like any other server.
+       *
+       * @param params Server name and configuration for an individual MCP server start.
+       */
+      startServer: async (params) => connection.sendRequest("session.mcp.startServer", { sessionId, ...params }),
+      /**
+       * Restarts an individual MCP server on the live session (stops then starts). Omit `config` for a config-free restart-by-name of an already-configured server; supply `config` to restart with a replacement configuration. Session-scoped and ephemeral: does NOT modify persistent user configuration (`mcp.config.*`).
+       *
+       * @param params Server name and optional replacement configuration for an individual MCP server restart. Omit `config` for a config-free restart-by-name of an already-configured server.
+       */
+      restartServer: async (params) => connection.sendRequest("session.mcp.restartServer", { sessionId, ...params }),
       /**
        * Stops an individual MCP server on the session's host.
        *
@@ -1200,11 +1231,13 @@ function createSessionRpc(connection, sessionId) {
       /** @experimental */
       apps: {
         /**
-         * Fetch an MCP resource (typically a `ui://` MCP App bundle, per SEP-1865) from a connected server. Requires the `mcp-apps` session capability.
+         * Deprecated/obsolete alias for `session.mcp.resources.read`; retained for backwards compatibility with earlier MCP Apps host integrations.
          *
-         * @param params MCP server and resource URI to fetch.
+         * @param params Deprecated/obsolete MCP Apps alias for `McpResourcesReadRequest`; use `session.mcp.resources.read` instead.
          *
-         * @returns Resource contents returned by the MCP server.
+         * @returns Deprecated/obsolete MCP Apps alias for `McpResourcesReadResult`; use `session.mcp.resources.read` instead.
+         *
+         * @deprecated
          */
         readResource: async (params) => connection.sendRequest("session.mcp.apps.readResource", { sessionId, ...params }),
         /**
@@ -1243,6 +1276,33 @@ function createSessionRpc(connection, sessionId) {
          * @returns Diagnostic snapshot of MCP Apps wiring for the named server.
          */
         diagnose: async (params) => connection.sendRequest("session.mcp.apps.diagnose", { sessionId, ...params })
+      },
+      /** @experimental */
+      resources: {
+        /**
+         * Fetch an MCP resource from a connected server by URI (proxies MCP `resources/read`).
+         *
+         * @param params MCP server and resource URI to fetch.
+         *
+         * @returns Resource contents returned by the MCP server.
+         */
+        read: async (params) => connection.sendRequest("session.mcp.resources.read", { sessionId, ...params }),
+        /**
+         * Enumerate one page of resources a connected MCP server exposes (proxies MCP `resources/list`). Pass `cursor` to continue from a prior result's `nextCursor`.
+         *
+         * @param params MCP server whose resources to enumerate.
+         *
+         * @returns One page of resources advertised by the named MCP server.
+         */
+        list: async (params) => connection.sendRequest("session.mcp.resources.list", { sessionId, ...params }),
+        /**
+         * Enumerate one page of resource templates a connected MCP server exposes (proxies MCP `resources/templates/list`). Pass `cursor` to continue from a prior result's `nextCursor`.
+         *
+         * @param params MCP server whose resource templates to enumerate.
+         *
+         * @returns One page of resource templates advertised by the named MCP server.
+         */
+        listTemplates: async (params) => connection.sendRequest("session.mcp.resources.listTemplates", { sessionId, ...params })
       }
     },
     /** @experimental */
@@ -1972,18 +2032,6 @@ function createInternalSessionRpc(connection, sessionId) {
        * @returns Result of configuring GitHub MCP.
        */
       configureGitHub: async (params) => connection.sendRequest("session.mcp.configureGitHub", { sessionId, ...params }),
-      /**
-       * Starts an individual MCP server on the session's host.
-       *
-       * @param params Server name and opaque configuration for an individual MCP server start.
-       */
-      startServer: async (params) => connection.sendRequest("session.mcp.startServer", { sessionId, ...params }),
-      /**
-       * Restarts an individual MCP server on the session's host (stops then starts).
-       *
-       * @param params Server name and opaque configuration for an individual MCP server restart.
-       */
-      restartServer: async (params) => connection.sendRequest("session.mcp.restartServer", { sessionId, ...params }),
       /**
        * Registers a pre-connected external MCP client (e.g. IDE) on the session's host. The caller retains lifecycle ownership of the client and transport. Marked internal because the `client` and `transport` arguments are in-process MCP SDK instances that cannot be serialized across the JSON-RPC boundary; once the CLI moves on top of the SDK, external clients will be expressed as transport configs the runtime can construct itself.
        *

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
@@ -1042,7 +1097,8 @@ class CopilotClient {
         gitHubToken: config.gitHubToken,
         remoteSession: config.remoteSession,
         cloud: config.cloud,
-        expAssignments: config.expAssignments
+        expAssignments: config.expAssignments,
+        enableManagedSettings: config.enableManagedSettings
       });
       const {
         sessionId: returnedSessionId,
@@ -1184,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
@@ -1232,7 +1289,8 @@ class CopilotClient {
         gitHubToken: config.gitHubToken,
         remoteSession: config.remoteSession,
         openCanvases: config.openCanvases,
-        expAssignments: config.expAssignments
+        expAssignments: config.expAssignments,
+        enableManagedSettings: config.enableManagedSettings
       });
       const { workspacePath, capabilities, openCanvases } = response;
       session["_workspacePath"] = workspacePath;
@@ -1581,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
    */
@@ -1614,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.`
@@ -1769,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
    */
@@ -1895,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;
+}