@github/copilot-sdk 1.0.7-preview.2 → 1.0.7

package/README.md

@@ -84,9 +84,11 @@ new CopilotClient(options?: CopilotClientOptions)
 **Options:**
 
 - `connection?: RuntimeConnection` - How to connect to the Copilot runtime. Construct via the factory functions on `RuntimeConnection`:
-    - `RuntimeConnection.forStdio({ path?, args? })` (default) — spawn the runtime and communicate over its stdin/stdout.
-    - `RuntimeConnection.forTcp({ port?, connectionToken?, path?, args? })` — spawn the runtime as a TCP server.
+    - `RuntimeConnection.forStdio({ path?, args?, env? })` (default) — spawn the runtime and communicate over its stdin/stdout.
+    - `RuntimeConnection.forTcp({ port?, connectionToken?, path?, args?, env? })` — spawn the runtime as a TCP server.
     - `RuntimeConnection.forUri(url, { connectionToken? })` — connect to an already-running runtime (mutually exclusive with `gitHubToken`/`useLoggedInUser`). There is no top-level `cliUrl` shortcut; use this factory for URL-based connections.
+    - `RuntimeConnection.forInProcess()` — host the runtime in-process over its native C ABI (FFI). **Experimental.** Because the runtime shares this process, `env`, `telemetry`, and `workingDirectory` are rejected with this transport; set them on the host process instead.
+    - The child-process transports (`forStdio`/`forTcp`) also accept a per-connection `env`. Set it there or via the top-level `env` option — not both (setting both throws).
 - `mode?: "empty" | "copilot-cli"` - Defaulting strategy. Use `"empty"` for multi-user server mode; defaults to `"copilot-cli"`.
 - `workingDirectory?: string` - Working directory for the runtime process (default: current process cwd).
 - `baseDirectory?: string` - Base directory for Copilot data (session state, config, etc.). Sets `COPILOT_HOME` on the spawned runtime. When not set, the runtime defaults to `~/.copilot`. Ignored when connecting via `RuntimeConnection.forUri`.

package/dist/cjs/client.js

@@ -395,6 +395,21 @@ class CopilotClient {
         "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 === "inprocess" && options.env !== void 0) {
+      throw new Error(
+        "env is not supported with RuntimeConnection.forInProcess(): the in-process transport loads the native runtime into the shared host process, whose single environment block cannot carry per-client values. Set the variables on the host process environment instead."
+      );
+    }
+    if (conn.kind === "inprocess" && options.telemetry !== void 0) {
+      throw new Error(
+        "telemetry is not supported with RuntimeConnection.forInProcess(): telemetry configuration is lowered to environment variables read by native runtime code running in the shared host process, so per-client telemetry cannot be honored in-process. Configure telemetry via the host process environment, or use a child-process transport."
+      );
+    }
+    if ((conn.kind === "stdio" || conn.kind === "tcp") && conn.env !== void 0 && options.env !== void 0) {
+      throw new Error(
+        "Set environment variables via either the client-level env option or the connection's env (RuntimeConnection.forStdio/forTcp), not both. Prefer the connection-level env for child-process transports."
+      );
+    }
     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");
@@ -423,7 +438,8 @@ class CopilotClient {
     this.requestHandler = options.requestHandler ?? null;
     this.onGitHubTelemetry = options.onGitHubTelemetry;
     this.setupClientGlobalHandlers();
-    const effectiveEnv = options.env ?? process.env;
+    const connEnv = conn.kind === "stdio" || conn.kind === "tcp" ? conn.env : void 0;
+    const effectiveEnv = connEnv ?? options.env ?? process.env;
     this.resolvedEnv = effectiveEnv;
     this.resolvedCliPath = conn.kind === "stdio" || conn.kind === "tcp" ? conn.path ?? effectiveEnv.COPILOT_CLI_PATH ?? getBundledCliPath() : void 0;
     const connArgs = conn.kind === "stdio" || conn.kind === "tcp" ? conn.args ?? [] : [];
@@ -504,6 +520,9 @@ class CopilotClient {
   }
   setupClientGlobalHandlers() {
     const handlers = {};
+    handlers.hooks = {
+      invoke: async (params) => await this.handleHooksInvoke(params)
+    };
     if (this.requestHandler) {
       handlers.llmInference = (0, import_copilotRequestHandler.createCopilotRequestAdapter)(this.requestHandler, () => {
         if (!this.connection) {
@@ -1058,8 +1077,10 @@ class CopilotClient {
           parameters: toJsonSchema(tool.parameters),
           overridesBuiltInTool: tool.overridesBuiltInTool,
           skipPermission: tool.skipPermission,
-          defer: tool.defer
+          defer: tool.defer,
+          metadata: tool.metadata
         })),
+        toolSearch: config.toolSearch,
         canvases: config.canvases?.map((canvas) => canvas.declaration),
         requestCanvasRenderer: config.requestCanvasRenderer,
         requestExtensions: config.requestExtensions,
@@ -1256,8 +1277,10 @@ class CopilotClient {
           parameters: toJsonSchema(tool.parameters),
           overridesBuiltInTool: tool.overridesBuiltInTool,
           skipPermission: tool.skipPermission,
-          defer: tool.defer
+          defer: tool.defer,
+          metadata: tool.metadata
         })),
+        toolSearch: config.toolSearch,
         canvases: config.canvases?.map((canvas) => canvas.declaration),
         requestCanvasRenderer: config.requestCanvasRenderer,
         requestExtensions: config.requestExtensions,
@@ -1861,21 +1884,42 @@ stderr: ${stderrOutput}`
         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.
-   */
+  /** Starts the in-process FFI runtime with SDK-managed typed options. */
   async startInProcessFfi() {
     const entrypoint = this.resolveCliPathForFfi();
     const { FfiRuntimeHost } = await import("./ffiRuntimeHost.js");
-    const host = FfiRuntimeHost.create(entrypoint, CopilotClient.getNapiPrebuildsFolder());
+    const environment = {};
+    if (this.options.gitHubToken) {
+      environment.COPILOT_SDK_AUTH_TOKEN = this.options.gitHubToken;
+    }
+    if (this.options.baseDirectory) {
+      environment.COPILOT_HOME = this.options.baseDirectory;
+    }
+    if (this.options.mode === "empty") {
+      environment.COPILOT_DISABLE_KEYTAR = "1";
+    }
+    const args = [];
+    if (this.options.logLevel) {
+      args.push("--log-level", this.options.logLevel);
+    }
+    if (this.options.gitHubToken) {
+      args.push("--auth-token-env", "COPILOT_SDK_AUTH_TOKEN");
+    }
+    if (!this.options.useLoggedInUser) {
+      args.push("--no-auto-login");
+    }
+    if (this.options.sessionIdleTimeoutSeconds > 0) {
+      args.push("--session-idle-timeout", this.options.sessionIdleTimeoutSeconds.toString());
+    }
+    if (this.options.enableRemoteSessions) {
+      args.push("--remote");
+    }
+    const host = FfiRuntimeHost.create(
+      entrypoint,
+      CopilotClient.getNapiPrebuildsFolder(entrypoint),
+      environment,
+      args
+    );
     this.ffiHost = host;
     await host.start();
   }
@@ -1905,14 +1949,30 @@ stderr: ${stderrOutput}`
   /**
    * 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`.
+   * `linux-x64`, `linuxmusl-x64`) under which the runtime ships
+   * `prebuilds/<folder>/runtime.node`.
    */
-  static getNapiPrebuildsFolder() {
+  static getNapiPrebuildsFolder(entrypoint) {
     const arch = process.arch;
     if (arch !== "x64" && arch !== "arm64") {
       throw new Error(`Unsupported architecture '${arch}' for in-process FFI hosting.`);
     }
-    return `${process.platform}-${arch}`;
+    let platform = process.platform;
+    if (platform === "linux" && CopilotClient.isMusl(entrypoint)) {
+      platform = "linuxmusl";
+    }
+    return `${platform}-${arch}`;
+  }
+  static isMusl(entrypoint) {
+    if (entrypoint.includes(`copilot-linuxmusl-${process.arch}`)) {
+      return true;
+    }
+    if (entrypoint.includes(`copilot-linux-${process.arch}`)) {
+      return false;
+    }
+    const report = process.report?.getReport();
+    const header = report && "header" in report ? report.header : void 0;
+    return header !== void 0 && header.glibcVersionRuntime === void 0;
   }
   /**
    * Connect to child via stdio pipes
@@ -2008,10 +2068,6 @@ stderr: ${stderrOutput}`
       "autoModeSwitch.request",
       async (params) => await this.handleAutoModeSwitchRequest(params)
     );
-    this.connection.onRequest(
-      "hooks.invoke",
-      async (params) => await this.handleHooksInvoke(params)
-    );
     this.connection.onRequest(
       "systemMessage.transform",
       async (params) => await this.handleSystemMessageTransform(params)

package/dist/cjs/ffiRuntimeHost.js

@@ -84,8 +84,9 @@ function loadLibrary(libraryPath) {
   loadedLibraryPath = libraryPath;
   return loadedLibrary;
 }
-function buildArgvJson(cliEntrypoint) {
+function buildArgvJson(cliEntrypoint, args) {
   const argv = cliEntrypoint.toLowerCase().endsWith(".js") ? ["node", cliEntrypoint, "--embedded-host", "--no-auto-update"] : [cliEntrypoint, "--embedded-host", "--no-auto-update"];
+  argv.push(...args);
   return Buffer.from(JSON.stringify(argv), "utf8");
 }
 function buildEnvJson(environment) {
@@ -104,10 +105,11 @@ function buildEnvJson(environment) {
   return Buffer.from(JSON.stringify(obj), "utf8");
 }
 class FfiRuntimeHost {
-  constructor(libraryPath, cliEntrypoint, environment) {
+  constructor(libraryPath, cliEntrypoint, environment, args) {
     this.libraryPath = libraryPath;
     this.cliEntrypoint = cliEntrypoint;
     this.environment = environment;
+    this.args = args;
     this.lib = loadLibrary(libraryPath);
     this.receiveStream = new import_node_stream.PassThrough();
     this.sendStream = new import_node_stream.Writable({
@@ -126,6 +128,7 @@ class FfiRuntimeHost {
   libraryPath;
   cliEntrypoint;
   environment;
+  args;
   lib;
   serverId = 0;
   connectionId = 0;
@@ -142,21 +145,21 @@ class FfiRuntimeHost {
    * the entrypoint directory (the napi-rs `<node-platform>-<arch>` layout, e.g.
    * `linux-x64`). Throws if it cannot be found.
    */
-  static create(cliEntrypoint, prebuildsFolder, environment) {
+  static create(cliEntrypoint, prebuildsFolder, environment, args) {
     const fullEntrypoint = (0, import_node_path.resolve)(cliEntrypoint);
     const distDir = (0, import_node_path.dirname)(fullEntrypoint);
     const libraryPath = (0, import_node_path.join)(distDir, "prebuilds", prebuildsFolder, "runtime.node");
     if (!(0, import_node_fs.existsSync)(libraryPath)) {
       throw new Error(`FFI runtime library not found. Looked for '${libraryPath}'.`);
     }
-    return new FfiRuntimeHost(libraryPath, fullEntrypoint, environment);
+    return new FfiRuntimeHost(libraryPath, fullEntrypoint, environment, args);
   }
   /**
    * Starts the in-process runtime: spawns the CLI worker via the native host,
    * waits for readiness, and opens the FFI JSON-RPC connection.
    */
   async start() {
-    const argvJson = buildArgvJson(this.cliEntrypoint);
+    const argvJson = buildArgvJson(this.cliEntrypoint, this.args);
     const envJson = buildEnvJson(this.environment);
     this.serverId = await new Promise((resolvePromise, rejectPromise) => {
       this.lib.hostStart.async(

package/dist/cjs/generated/rpc.js

@@ -223,7 +223,7 @@ function createServerRpc(connection) {
         /**
          * Registers a new marketplace from a source (owner/repo, URL, or local path).
          *
-         * @param params Marketplace source to register.
+         * @param params Marketplace source and optional working directory for relative-path resolution.
          *
          * @returns Result of registering a new marketplace.
          */
@@ -1119,7 +1119,7 @@ function createSessionRpc(connection, sessionId) {
        */
       list: async () => connection.sendRequest("session.mcp.list", { sessionId }),
       /**
-       * Lists the tools exposed by a connected MCP server on this session's host.
+       * Lists the tools exposed by a connected MCP server on this session's host. This performs a live `tools/list` request. Tool UI metadata is returned independently of whether MCP Apps rendering is enabled for the session.
        *
        * @param params Server name whose tool list should be returned.
        *
@@ -1231,13 +1231,11 @@ function createSessionRpc(connection, sessionId) {
       /** @experimental */
       apps: {
         /**
-         * Deprecated/obsolete alias for `session.mcp.resources.read`; retained for backwards compatibility with earlier MCP Apps host integrations.
+         * Fetch an MCP resource (typically a `ui://` MCP App bundle, per SEP-1865) from a connected server. Requires the `mcp-apps` session capability.
          *
-         * @param params Deprecated/obsolete MCP Apps alias for `McpResourcesReadRequest`; use `session.mcp.resources.read` instead.
-         *
-         * @returns Deprecated/obsolete MCP Apps alias for `McpResourcesReadResult`; use `session.mcp.resources.read` instead.
+         * @param params MCP server and resource URI to fetch.
          *
-         * @deprecated
+         * @returns Resource contents returned by the MCP server.
          */
         readResource: async (params) => connection.sendRequest("session.mcp.apps.readResource", { sessionId, ...params }),
         /**
@@ -1804,11 +1802,11 @@ function createSessionRpc(connection, sessionId) {
        */
       recordContextChange: async (params) => connection.sendRequest("session.metadata.recordContextChange", { sessionId, ...params }),
       /**
-       * Updates the session's recorded working directory.
+       * Updates the session's working directory. For local sessions the target is validated first (an absolute path that exists on disk) and the permission primary directory is re-based; a rejected validation fails the call before any session state changes.
        *
-       * @param params Absolute path to set as the session's new working directory.
+       * @param params Absolute path to set as the session's new working directory. For local sessions the path must be absolute and exist on disk: it is validated before any session state changes, and a failing validation rejects the call with nothing mutated, persisted, or emitted. Remote sessions record the path as-is.
        *
-       * @returns Update the session's working directory. Used by the host when the user explicitly changes cwd (e.g., the `/cd` slash command). The host is responsible for `process.chdir` and any related side-effects (file index, etc.); this method only updates the session's own recorded path.
+       * @returns Update the session's working directory. Used by the host when the user explicitly changes cwd (e.g., the `/cd` slash command). The host is responsible for any related side-effects (file index, etc.); it does NOT change the process working directory (a session's cwd is per-session, not process-global). For local sessions the runtime validates the target first (an absolute path that exists on disk) and re-bases the permission primary directory; a rejected validation fails the call before anything is mutated, persisted, or emitted. Location-scoped permission rules are then re-keyed to the new directory (best-effort). Remote sessions only record the path.
        */
       setWorkingDirectory: async (params) => connection.sendRequest("session.metadata.setWorkingDirectory", { sessionId, ...params }),
       /**
@@ -2147,6 +2145,11 @@ function registerClientSessionApiHandlers(connection, getHandlers) {
   });
 }
 function registerClientGlobalApiHandlers(connection, handlers) {
+  connection.onRequest("hooks.invoke", async (params) => {
+    const handler = handlers.hooks;
+    if (!handler) throw new Error("No hooks client-global handler registered");
+    return handler.invoke(params);
+  });
   connection.onRequest("llmInference.httpRequestStart", async (params) => {
     const handler = handlers.llmInference;
     if (!handler) throw new Error("No llmInference client-global handler registered");

package/dist/cjs/session.js

@@ -40,6 +40,7 @@ function isOpenCanvasInstance(value) {
   const instance = value;
   return typeof instance.instanceId === "string" && instance.instanceId.length > 0 && typeof instance.extensionId === "string" && instance.extensionId.length > 0 && typeof instance.canvasId === "string" && instance.canvasId.length > 0;
 }
+const TOOL_SEARCH_TOOL_NAME = "tool_search_tool";
 class CopilotSession {
   /**
    * Creates a new CopilotSession instance.
@@ -352,11 +353,21 @@ class CopilotSession {
    */
   async _executeToolAndRespond(requestId, toolName, toolCallId, args, handler, traceparent, tracestate) {
     try {
+      let availableTools;
+      if (toolName === TOOL_SEARCH_TOOL_NAME) {
+        try {
+          const metadata = await this.rpc.tools.getCurrentMetadata();
+          availableTools = metadata.tools ?? void 0;
+        } catch {
+          availableTools = void 0;
+        }
+      }
       const rawResult = await handler(args, {
         sessionId: this.sessionId,
         toolCallId,
         toolName,
         arguments: args,
+        availableTools,
         traceparent,
         tracestate
       });
@@ -1009,7 +1020,7 @@ class CopilotSession {
    *
    * @example
    * ```typescript
-   * await session.setModel("gpt-4.1");
+   * await session.setModel("gpt-5.4");
    * await session.setModel("claude-sonnet-4.6", { reasoningEffort: "high" });
    * ```
    */

package/dist/cjs/types.js

@@ -39,7 +39,7 @@ const RuntimeConnection = {
    * This is the default if no {@link CopilotClientOptions.connection} is set.
    */
   forStdio(opts = {}) {
-    return { kind: "stdio", path: opts.path, args: opts.args };
+    return { kind: "stdio", path: opts.path, args: opts.args, env: opts.env };
   },
   /**
    * Spawn a runtime child process that listens on a TCP socket and connect to it.
@@ -50,7 +50,8 @@ const RuntimeConnection = {
       port: opts.port,
       connectionToken: opts.connectionToken,
       path: opts.path,
-      args: opts.args
+      args: opts.args,
+      env: opts.env
     };
   },
   /**

package/dist/client.d.ts

@@ -435,17 +435,7 @@ 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.
-     */
+    /** Starts the in-process FFI runtime with SDK-managed typed options. */
     private startInProcessFfi;
     /**
      * Connect to the in-process FFI runtime host over its receive/send streams,
@@ -460,9 +450,11 @@ export declare class CopilotClient {
     /**
      * 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`.
+     * `linux-x64`, `linuxmusl-x64`) under which the runtime ships
+     * `prebuilds/<folder>/runtime.node`.
      */
     private static getNapiPrebuildsFolder;
+    private static isMusl;
     /**
      * Connect to child via stdio pipes
      */

package/dist/client.js

@@ -372,6 +372,21 @@ class CopilotClient {
         "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 === "inprocess" && options.env !== void 0) {
+      throw new Error(
+        "env is not supported with RuntimeConnection.forInProcess(): the in-process transport loads the native runtime into the shared host process, whose single environment block cannot carry per-client values. Set the variables on the host process environment instead."
+      );
+    }
+    if (conn.kind === "inprocess" && options.telemetry !== void 0) {
+      throw new Error(
+        "telemetry is not supported with RuntimeConnection.forInProcess(): telemetry configuration is lowered to environment variables read by native runtime code running in the shared host process, so per-client telemetry cannot be honored in-process. Configure telemetry via the host process environment, or use a child-process transport."
+      );
+    }
+    if ((conn.kind === "stdio" || conn.kind === "tcp") && conn.env !== void 0 && options.env !== void 0) {
+      throw new Error(
+        "Set environment variables via either the client-level env option or the connection's env (RuntimeConnection.forStdio/forTcp), not both. Prefer the connection-level env for child-process transports."
+      );
+    }
     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");
@@ -400,7 +415,8 @@ class CopilotClient {
     this.requestHandler = options.requestHandler ?? null;
     this.onGitHubTelemetry = options.onGitHubTelemetry;
     this.setupClientGlobalHandlers();
-    const effectiveEnv = options.env ?? process.env;
+    const connEnv = conn.kind === "stdio" || conn.kind === "tcp" ? conn.env : void 0;
+    const effectiveEnv = connEnv ?? options.env ?? process.env;
     this.resolvedEnv = effectiveEnv;
     this.resolvedCliPath = conn.kind === "stdio" || conn.kind === "tcp" ? conn.path ?? effectiveEnv.COPILOT_CLI_PATH ?? getBundledCliPath() : void 0;
     const connArgs = conn.kind === "stdio" || conn.kind === "tcp" ? conn.args ?? [] : [];
@@ -481,6 +497,9 @@ class CopilotClient {
   }
   setupClientGlobalHandlers() {
     const handlers = {};
+    handlers.hooks = {
+      invoke: async (params) => await this.handleHooksInvoke(params)
+    };
     if (this.requestHandler) {
       handlers.llmInference = createCopilotRequestAdapter(this.requestHandler, () => {
         if (!this.connection) {
@@ -1035,8 +1054,10 @@ class CopilotClient {
           parameters: toJsonSchema(tool.parameters),
           overridesBuiltInTool: tool.overridesBuiltInTool,
           skipPermission: tool.skipPermission,
-          defer: tool.defer
+          defer: tool.defer,
+          metadata: tool.metadata
         })),
+        toolSearch: config.toolSearch,
         canvases: config.canvases?.map((canvas) => canvas.declaration),
         requestCanvasRenderer: config.requestCanvasRenderer,
         requestExtensions: config.requestExtensions,
@@ -1233,8 +1254,10 @@ class CopilotClient {
           parameters: toJsonSchema(tool.parameters),
           overridesBuiltInTool: tool.overridesBuiltInTool,
           skipPermission: tool.skipPermission,
-          defer: tool.defer
+          defer: tool.defer,
+          metadata: tool.metadata
         })),
+        toolSearch: config.toolSearch,
         canvases: config.canvases?.map((canvas) => canvas.declaration),
         requestCanvasRenderer: config.requestCanvasRenderer,
         requestExtensions: config.requestExtensions,
@@ -1838,21 +1861,42 @@ stderr: ${stderrOutput}`
         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.
-   */
+  /** Starts the in-process FFI runtime with SDK-managed typed options. */
   async startInProcessFfi() {
     const entrypoint = this.resolveCliPathForFfi();
     const { FfiRuntimeHost } = await import("./ffiRuntimeHost.js");
-    const host = FfiRuntimeHost.create(entrypoint, CopilotClient.getNapiPrebuildsFolder());
+    const environment = {};
+    if (this.options.gitHubToken) {
+      environment.COPILOT_SDK_AUTH_TOKEN = this.options.gitHubToken;
+    }
+    if (this.options.baseDirectory) {
+      environment.COPILOT_HOME = this.options.baseDirectory;
+    }
+    if (this.options.mode === "empty") {
+      environment.COPILOT_DISABLE_KEYTAR = "1";
+    }
+    const args = [];
+    if (this.options.logLevel) {
+      args.push("--log-level", this.options.logLevel);
+    }
+    if (this.options.gitHubToken) {
+      args.push("--auth-token-env", "COPILOT_SDK_AUTH_TOKEN");
+    }
+    if (!this.options.useLoggedInUser) {
+      args.push("--no-auto-login");
+    }
+    if (this.options.sessionIdleTimeoutSeconds > 0) {
+      args.push("--session-idle-timeout", this.options.sessionIdleTimeoutSeconds.toString());
+    }
+    if (this.options.enableRemoteSessions) {
+      args.push("--remote");
+    }
+    const host = FfiRuntimeHost.create(
+      entrypoint,
+      CopilotClient.getNapiPrebuildsFolder(entrypoint),
+      environment,
+      args
+    );
     this.ffiHost = host;
     await host.start();
   }
@@ -1882,14 +1926,30 @@ stderr: ${stderrOutput}`
   /**
    * 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`.
+   * `linux-x64`, `linuxmusl-x64`) under which the runtime ships
+   * `prebuilds/<folder>/runtime.node`.
    */
-  static getNapiPrebuildsFolder() {
+  static getNapiPrebuildsFolder(entrypoint) {
     const arch = process.arch;
     if (arch !== "x64" && arch !== "arm64") {
       throw new Error(`Unsupported architecture '${arch}' for in-process FFI hosting.`);
     }
-    return `${process.platform}-${arch}`;
+    let platform = process.platform;
+    if (platform === "linux" && CopilotClient.isMusl(entrypoint)) {
+      platform = "linuxmusl";
+    }
+    return `${platform}-${arch}`;
+  }
+  static isMusl(entrypoint) {
+    if (entrypoint.includes(`copilot-linuxmusl-${process.arch}`)) {
+      return true;
+    }
+    if (entrypoint.includes(`copilot-linux-${process.arch}`)) {
+      return false;
+    }
+    const report = process.report?.getReport();
+    const header = report && "header" in report ? report.header : void 0;
+    return header !== void 0 && header.glibcVersionRuntime === void 0;
   }
   /**
    * Connect to child via stdio pipes
@@ -1985,10 +2045,6 @@ stderr: ${stderrOutput}`
       "autoModeSwitch.request",
       async (params) => await this.handleAutoModeSwitchRequest(params)
     );
-    this.connection.onRequest(
-      "hooks.invoke",
-      async (params) => await this.handleHooksInvoke(params)
-    );
     this.connection.onRequest(
       "systemMessage.transform",
       async (params) => await this.handleSystemMessageTransform(params)

package/dist/ffiRuntimeHost.d.ts

@@ -2,7 +2,8 @@ import { PassThrough, Writable } from "node:stream";
 export declare class FfiRuntimeHost {
     private readonly libraryPath;
     private readonly cliEntrypoint;
-    private readonly environment?;
+    private readonly environment;
+    private readonly args;
     private readonly lib;
     private serverId;
     private connectionId;
@@ -20,7 +21,7 @@ export declare class FfiRuntimeHost {
      * 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;
+    static create(cliEntrypoint: string, prebuildsFolder: string, environment: Record<string, string | undefined> | undefined, args: readonly string[]): FfiRuntimeHost;
     /**
      * Starts the in-process runtime: spawns the CLI worker via the native host,
      * waits for readiness, and opens the FFI JSON-RPC connection.

package/dist/ffiRuntimeHost.js

@@ -51,8 +51,9 @@ function loadLibrary(libraryPath) {
   loadedLibraryPath = libraryPath;
   return loadedLibrary;
 }
-function buildArgvJson(cliEntrypoint) {
+function buildArgvJson(cliEntrypoint, args) {
   const argv = cliEntrypoint.toLowerCase().endsWith(".js") ? ["node", cliEntrypoint, "--embedded-host", "--no-auto-update"] : [cliEntrypoint, "--embedded-host", "--no-auto-update"];
+  argv.push(...args);
   return Buffer.from(JSON.stringify(argv), "utf8");
 }
 function buildEnvJson(environment) {
@@ -71,10 +72,11 @@ function buildEnvJson(environment) {
   return Buffer.from(JSON.stringify(obj), "utf8");
 }
 class FfiRuntimeHost {
-  constructor(libraryPath, cliEntrypoint, environment) {
+  constructor(libraryPath, cliEntrypoint, environment, args) {
     this.libraryPath = libraryPath;
     this.cliEntrypoint = cliEntrypoint;
     this.environment = environment;
+    this.args = args;
     this.lib = loadLibrary(libraryPath);
     this.receiveStream = new PassThrough();
     this.sendStream = new Writable({
@@ -93,6 +95,7 @@ class FfiRuntimeHost {
   libraryPath;
   cliEntrypoint;
   environment;
+  args;
   lib;
   serverId = 0;
   connectionId = 0;
@@ -109,21 +112,21 @@ class FfiRuntimeHost {
    * the entrypoint directory (the napi-rs `<node-platform>-<arch>` layout, e.g.
    * `linux-x64`). Throws if it cannot be found.
    */
-  static create(cliEntrypoint, prebuildsFolder, environment) {
+  static create(cliEntrypoint, prebuildsFolder, environment, args) {
     const fullEntrypoint = resolve(cliEntrypoint);
     const distDir = dirname(fullEntrypoint);
     const libraryPath = join(distDir, "prebuilds", prebuildsFolder, "runtime.node");
     if (!existsSync(libraryPath)) {
       throw new Error(`FFI runtime library not found. Looked for '${libraryPath}'.`);
     }
-    return new FfiRuntimeHost(libraryPath, fullEntrypoint, environment);
+    return new FfiRuntimeHost(libraryPath, fullEntrypoint, environment, args);
   }
   /**
    * Starts the in-process runtime: spawns the CLI worker via the native host,
    * waits for readiness, and opens the FFI JSON-RPC connection.
    */
   async start() {
-    const argvJson = buildArgvJson(this.cliEntrypoint);
+    const argvJson = buildArgvJson(this.cliEntrypoint, this.args);
     const envJson = buildEnvJson(this.environment);
     this.serverId = await new Promise((resolvePromise, rejectPromise) => {
       this.lib.hostStart.async(