@github/copilot-language-server 1.528.0 → 1.529.0

package/dist/node_modules/@github/copilot-sdk/dist/cjs/client.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var client_exports = {};
 __export(client_exports, {
@@ -246,6 +256,7 @@ class TeardownResilientStreamMessageWriter extends import_node.StreamMessageWrit
 class CopilotClient {
   cliStartTimeout = null;
   cliProcess = null;
+  ffiHost = null;
   connection = null;
   messageWriter = null;
   socket = null;
@@ -322,6 +333,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.
    *
@@ -350,12 +384,32 @@ 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 === "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");
@@ -384,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 ?? [] : [];
@@ -511,7 +566,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();
@@ -560,6 +617,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;
@@ -588,7 +648,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);
@@ -673,6 +733,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;
@@ -757,6 +830,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;
@@ -834,11 +914,16 @@ class CopilotClient {
         enableHostGitOperations: false,
         enableSessionStore: false,
         enableSkills: false,
-        memory: { enabled: false }
+        memory: { enabled: false },
+        customAgentsLocalOnly: true
       };
     }
     return {};
   }
+  /** Mode-specific default for enableExperimentalMode. */
+  experimentalModeForMode(supplied) {
+    return this.options.mode === "empty" ? supplied ?? false : supplied;
+  }
   /**
    * Returns the systemMessage config to use, adjusted for the current mode.
    * In empty mode we ensure the environment_context section is removed
@@ -919,7 +1004,9 @@ class CopilotClient {
     if (!this.connection) {
       await this.start();
     }
-    config = { ...this.configDefaultsForMode(), ...config };
+    const modeDefaults = this.configDefaultsForMode();
+    config = { ...modeDefaults, ...config };
+    config.customAgentsLocalOnly ??= modeDefaults.customAgentsLocalOnly;
     config.systemMessage = this.getSystemMessageConfigForMode(config.systemMessage);
     const callerSessionId = config.sessionId;
     const useServerGeneratedId = config.cloud != null && callerSessionId == null;
@@ -938,7 +1025,10 @@ class CopilotClient {
         this.connection,
         void 0,
         this.onGetTraceContext,
-        { mcpAuthHandler: config.onMcpAuthRequest }
+        {
+          mcpAuthHandler: config.onMcpAuthRequest,
+          managedSettingsEnabled: config.enableManagedSettings
+        }
       );
       s.registerTools(config.tools);
       s.registerCanvases(config.canvases);
@@ -987,6 +1077,7 @@ class CopilotClient {
         clientName: config.clientName,
         reasoningEffort: config.reasoningEffort,
         reasoningSummary: config.reasoningSummary,
+        isExperimentalMode: this.experimentalModeForMode(config.enableExperimentalMode),
         contextTier: config.contextTier,
         tools: config.tools?.map((tool) => ({
           name: tool.name,
@@ -994,13 +1085,16 @@ 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,
         extensionSdkPath: config.extensionSdkPath,
         extensionInfo: config.extensionInfo,
+        canvasProvider: config.canvasProvider,
         commands: config.commands?.map((cmd) => ({
           name: cmd.name,
           description: cmd.description
@@ -1023,10 +1117,12 @@ class CopilotClient {
         requestUserInput: !!config.onUserInputRequest,
         requestElicitation: !!config.onElicitationRequest,
         ...config.enableMcpApps ? { requestMcpApps: true } : {},
+        ...config.githubMcpToolConfig != null ? { githubMcpToolConfig: config.githubMcpToolConfig } : {},
         requestExitPlanMode: !!config.onExitPlanModeRequest,
         requestAutoModeSwitch: !!config.onAutoModeSwitchRequest,
         hooks: !!(config.hooks && Object.values(config.hooks).some(Boolean)),
         workingDirectory: config.workingDirectory,
+        additionalDirectories: config.additionalDirectories,
         streaming: config.streaming,
         includeSubAgentStreamingEvents: config.includeSubAgentStreamingEvents ?? true,
         ...this.onGitHubTelemetry != null ? { enableGitHubTelemetryForwarding: true } : {},
@@ -1034,6 +1130,7 @@ class CopilotClient {
         mcpOAuthTokenStorage: config.mcpOAuthTokenStorage,
         envValueMode: "direct",
         customAgents: toWireCustomAgents(config.customAgents),
+        customAgentsLocalOnly: config.customAgentsLocalOnly,
         defaultAgent: config.defaultAgent,
         agent: config.agent,
         configDir: config.configDirectory,
@@ -1050,12 +1147,14 @@ class CopilotClient {
         pluginDirectories: config.pluginDirectories,
         instructionDirectories: config.instructionDirectories,
         disabledSkills: config.disabledSkills,
+        disabledMcpServers: config.disabledMcpServers,
         infiniteSessions: config.infiniteSessions,
         memory: config.memory,
         gitHubToken: config.gitHubToken,
         remoteSession: config.remoteSession,
         cloud: config.cloud,
-        expAssignments: config.expAssignments
+        expAssignments: config.expAssignments,
+        enableManagedSettings: config.enableManagedSettings
       });
       const {
         sessionId: returnedSessionId,
@@ -1116,6 +1215,13 @@ class CopilotClient {
    * ```
    */
   async resumeSession(sessionId, config) {
+    return this.resumeSessionInternal(sessionId, config);
+  }
+  /** @internal */
+  async resumeSessionForExtension(sessionId, config, factories) {
+    return this.resumeSessionInternal(sessionId, config, factories);
+  }
+  async resumeSessionInternal(sessionId, config, factories) {
     if (!this.connection) {
       await this.start();
     }
@@ -1124,11 +1230,15 @@ class CopilotClient {
       this.connection,
       void 0,
       this.onGetTraceContext,
-      { mcpAuthHandler: config.onMcpAuthRequest }
+      {
+        mcpAuthHandler: config.onMcpAuthRequest,
+        managedSettingsEnabled: config.enableManagedSettings
+      }
     );
     session.registerTools(config.tools);
     session.registerCanvases(config.canvases);
     session.registerCommands(config.commands);
+    session.registerFactories(factories);
     const {
       wireProvider: bearerWireProvider,
       wireProviders: bearerWireProviders,
@@ -1153,7 +1263,9 @@ class CopilotClient {
     if (config.hooks) {
       session.registerHooks(config.hooks);
     }
-    config = { ...this.configDefaultsForMode(), ...config };
+    const modeDefaults = this.configDefaultsForMode();
+    config = { ...modeDefaults, ...config };
+    config.customAgentsLocalOnly ??= modeDefaults.customAgentsLocalOnly;
     config.systemMessage = this.getSystemMessageConfigForMode(config.systemMessage);
     const { wirePayload: wireSystemMessage, transformCallbacks } = extractTransformCallbacks(
       config.systemMessage
@@ -1175,6 +1287,7 @@ class CopilotClient {
         model: config.model,
         reasoningEffort: config.reasoningEffort,
         reasoningSummary: config.reasoningSummary,
+        isExperimentalMode: this.experimentalModeForMode(config.enableExperimentalMode),
         contextTier: config.contextTier,
         systemMessage: wireSystemMessage,
         availableTools: toolFilterOptions.availableTools,
@@ -1190,13 +1303,17 @@ 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),
+        factories: factories?.map((factory) => factory.meta),
         requestCanvasRenderer: config.requestCanvasRenderer,
         requestExtensions: config.requestExtensions,
         extensionSdkPath: config.extensionSdkPath,
         extensionInfo: config.extensionInfo,
+        canvasProvider: config.canvasProvider,
         commands: config.commands?.map((cmd) => ({
           name: cmd.name,
           description: cmd.description
@@ -1211,10 +1328,12 @@ class CopilotClient {
         requestUserInput: !!config.onUserInputRequest,
         requestElicitation: !!config.onElicitationRequest,
         ...config.enableMcpApps ? { requestMcpApps: true } : {},
+        ...config.githubMcpToolConfig != null ? { githubMcpToolConfig: config.githubMcpToolConfig } : {},
         requestExitPlanMode: !!config.onExitPlanModeRequest,
         requestAutoModeSwitch: !!config.onAutoModeSwitchRequest,
         hooks: !!(config.hooks && Object.values(config.hooks).some(Boolean)),
         workingDirectory: config.workingDirectory,
+        additionalDirectories: config.additionalDirectories,
         configDir: config.configDirectory,
         enableConfigDiscovery: config.enableConfigDiscovery,
         skipEmbeddingRetrieval: config.skipEmbeddingRetrieval,
@@ -1232,12 +1351,14 @@ class CopilotClient {
         mcpOAuthTokenStorage: config.mcpOAuthTokenStorage,
         envValueMode: "direct",
         customAgents: toWireCustomAgents(config.customAgents),
+        customAgentsLocalOnly: config.customAgentsLocalOnly,
         defaultAgent: config.defaultAgent,
         agent: config.agent,
         skillDirectories: config.skillDirectories,
         pluginDirectories: config.pluginDirectories,
         instructionDirectories: config.instructionDirectories,
         disabledSkills: config.disabledSkills,
+        disabledMcpServers: config.disabledMcpServers,
         infiniteSessions: config.infiniteSessions,
         memory: config.memory,
         disableResume: config.suppressResumeEvent,
@@ -1245,7 +1366,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;
@@ -1371,9 +1493,11 @@ class CopilotClient {
     const raceAgainstExit = (p) => this.processExitPromise ? Promise.race([p, this.processExitPromise]) : p;
     let serverVersion;
     try {
-      const result = await raceAgainstExit(
-        this.internalRpc.connect({ token: this.effectiveConnectionToken })
-      );
+      const connectParams = { token: this.effectiveConnectionToken };
+      if (this.onGitHubTelemetry != null) {
+        connectParams.enableGitHubTelemetryForwarding = true;
+      }
+      const result = await raceAgainstExit(this.internalRpc.connect(connectParams));
       serverVersion = result.protocolVersion;
     } catch (err) {
       if (err instanceof import_node.ResponseError && (err.code === import_node.ErrorCodes.MethodNotFound || err.message === "Unhandled method connect")) {
@@ -1592,6 +1716,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
    */
@@ -1625,43 +1784,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 (!(0, import_node_fs.existsSync)(this.resolvedCliPath)) {
         throw new Error(
           `Copilot CLI not found at ${this.resolvedCliPath}. Ensure @github/copilot is installed.`
@@ -1780,11 +1908,103 @@ stderr: ${stderrOutput}`
         return this.connectToParentProcessViaStdio();
       case "stdio":
         return this.connectToChildProcessViaStdio();
+      case "inprocess":
+        return this.connectViaFfi();
       case "tcp":
       case "uri":
         return this.connectViaTcp();
     }
   }
+  /** Starts the in-process FFI runtime with SDK-managed typed options. */
+  async startInProcessFfi() {
+    const entrypoint = this.resolveCliPathForFfi();
+    const { FfiRuntimeHost } = await import("./ffiRuntimeHost.js");
+    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();
+  }
+  /**
+   * 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 = (0, import_node.createMessageConnection)(
+      new import_node.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`, `linuxmusl-x64`) under which the runtime ships
+   * `prebuilds/<folder>/runtime.node`.
+   */
+  static getNapiPrebuildsFolder(entrypoint) {
+    const arch = process.arch;
+    if (arch !== "x64" && arch !== "arm64") {
+      throw new Error(`Unsupported architecture '${arch}' for in-process FFI hosting.`);
+    }
+    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
    */
@@ -1879,10 +2099,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)
@@ -1894,6 +2110,12 @@ stderr: ${stderrOutput}`
       return session.clientSessionApis;
     });
     (0, import_rpc.registerClientGlobalApiHandlers)(this.connection, this.clientGlobalHandlers);
+    this.connection.onRequest(
+      "hooks.invoke",
+      async (params) => {
+        return await this.handleHooksInvoke(params);
+      }
+    );
     this.connection.onClose(() => {
       this.state = "disconnected";
     });
@@ -1906,8 +2128,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/node_modules/@github/copilot-sdk/dist/cjs/copilotRequestHandler.js

@@ -180,6 +180,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,
@@ -305,6 +308,9 @@ function routeChunk(exchange, params) {
 class CopilotRequestExchange {
   requestId;
   sessionId;
+  agentId;
+  parentAgentId;
+  interactionType;
   method = "GET";
   url = "";
   headers = {};
@@ -324,6 +330,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;