@github/copilot-language-server 1.551.2 → 1.551.3

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

@@ -40,17 +40,69 @@ var import_node = require("vscode-jsonrpc/node.js");
 var import_rpc = require("./generated/rpc.js");
 var import_sdkProtocolVersion = require("./sdkProtocolVersion.js");
 var import_session = require("./session.js");
+var import_host = require("./host.js");
 var import_runtimeArtifacts = require("./runtimeArtifacts.js");
 var import_cliVersion = require("./cliVersion.js");
 var import_sessionFsProvider = require("./sessionFsProvider.js");
 var import_copilotRequestHandler = require("./copilotRequestHandler.js");
+var import_installationConfirmation = require("./installationConfirmation.js");
 var import_telemetry = require("./telemetry.js");
+var import_schema = require("./schema.js");
 var import_toolSet = require("./toolSet.js");
 var import_types = require("./types.js");
 const MIN_PROTOCOL_VERSION = 3;
 const RUNTIME_SHUTDOWN_TIMEOUT_MS = 1e4;
-function isZodSchema(value) {
-  return value != null && typeof value === "object" && "toJSONSchema" in value && typeof value.toJSONSchema === "function";
+const CLOUD_SESSION_CLEANUP_TIMEOUT_MS = 1e4;
+function createMessageConnection(reader, writer) {
+  let dispatch;
+  let finishDrain;
+  let drained;
+  let disposed = false;
+  const barrier = { jsonrpc: "2.0", method: "$/sdkDrain" };
+  const connection = (0, import_node.createMessageConnection)(
+    {
+      onError: reader.onError,
+      onClose: reader.onClose,
+      onPartialMessage: reader.onPartialMessage,
+      listen: (callback) => {
+        dispatch = callback;
+        return reader.listen(callback);
+      },
+      dispose: () => reader.dispose()
+    },
+    writer,
+    void 0,
+    {
+      messageStrategy: {
+        handleMessage: (message, next) => {
+          if (message === barrier) {
+            finishDrain?.();
+          } else {
+            next(message);
+          }
+        }
+      }
+    }
+  );
+  connection.onDispose(() => {
+    disposed = true;
+    finishDrain?.();
+  });
+  return Object.assign(connection, {
+    drain: () => {
+      if (!drained) {
+        drained = new Promise((resolve2) => {
+          finishDrain = resolve2;
+          if (disposed || !dispatch) {
+            resolve2();
+          } else {
+            dispatch(barrier);
+          }
+        });
+      }
+      return drained;
+    }
+  });
 }
 async function withTimeout(promise, timeoutMs, message) {
   let timeout;
@@ -96,13 +148,6 @@ async function waitForChildExit(child, timeoutMs) {
     }
   });
 }
-function toJsonSchema(parameters) {
-  if (!parameters) return void 0;
-  if (isZodSchema(parameters)) {
-    return parameters.toJSONSchema();
-  }
-  return parameters;
-}
 const DEFAULT_PROVIDER_NAME = "default";
 function extractBearerTokenProviders(provider, providers) {
   const callbacks = /* @__PURE__ */ new Map();
@@ -235,8 +280,10 @@ class CopilotClient {
   cliProcess = null;
   ffiHost = null;
   connection = null;
+  requestAdapter = null;
   messageWriter = null;
   connectionClosed = false;
+  connectionEpoch = 0;
   socket = null;
   runtimePort = null;
   actualHost = "localhost";
@@ -244,6 +291,9 @@ class CopilotClient {
   /** Shared in-flight start; concurrent callers await it instead of spawning another CLI. */
   startPromise = null;
   sessions = /* @__PURE__ */ new Map();
+  hostExitCallbacks = /* @__PURE__ */ new Map();
+  hostSessionFactories = /* @__PURE__ */ new Map();
+  hostHandoffs = /* @__PURE__ */ new Map();
   stderrBuffer = "";
   // Captures CLI stderr for error messages
   /** Resolved connection mode chosen in the constructor. */
@@ -272,6 +322,8 @@ class CopilotClient {
   /** Connection-level session filesystem config, set via constructor option. */
   sessionFsConfig = null;
   requestHandler = null;
+  extensionLaunchProvider;
+  installationConfirmationHandler;
   builtinPluginDirectories = [];
   onGitHubTelemetry;
   clientGlobalHandlers = {};
@@ -429,6 +481,8 @@ class CopilotClient {
     this.onGetTraceContext = options.onGetTraceContext;
     this.sessionFsConfig = options.sessionFs ?? null;
     this.requestHandler = options.requestHandler ?? null;
+    this.extensionLaunchProvider = options.extensionLaunchProvider;
+    this.installationConfirmationHandler = options.installationConfirmationHandler;
     this.onGitHubTelemetry = options.onGitHubTelemetry;
     this.setupClientGlobalHandlers();
     const connEnv = conn.kind === "stdio" || conn.kind === "tcp" ? conn.env : void 0;
@@ -527,18 +581,30 @@ class CopilotClient {
         "SessionFsConfig declares capabilities.sqlite but the provider does not implement sqlite."
       );
     }
+    if (this.sessionFsConfig.capabilities?.binary && (!provider.readFileBytes || !provider.writeFileBytes)) {
+      throw new Error(
+        "SessionFsConfig declares capabilities.binary but the provider does not implement readFileBytes and writeFileBytes."
+      );
+    }
     session.clientSessionApis.sessionFs = (0, import_sessionFsProvider.createSessionFsAdapter)(provider);
   }
   setupClientGlobalHandlers() {
     const handlers = {};
+    handlers.host = {
+      exited: async (exit) => {
+        this.handleHostExit(exit);
+      }
+    };
+    handlers.extensionLaunchProvider = this.extensionLaunchProvider;
     if (this.requestHandler) {
-      handlers.llmInference = (0, import_copilotRequestHandler.createCopilotRequestAdapter)(this.requestHandler, () => {
+      this.requestAdapter = (0, import_copilotRequestHandler.createCopilotRequestAdapter)(this.requestHandler, () => {
         if (!this.connection) {
           return void 0;
         }
         this._rpc ??= (0, import_rpc.createServerRpc)(this.connection);
         return this._rpc;
       });
+      handlers.llmInference = this.requestAdapter;
     }
     if (this.onGitHubTelemetry) {
       const onGitHubTelemetry = this.onGitHubTelemetry;
@@ -632,6 +698,7 @@ class CopilotClient {
   }
   async doStart() {
     this.forceStopping = false;
+    this.connectionEpoch++;
     this.connectionClosed = false;
     this.processTransportError = null;
     this.state = "connecting";
@@ -643,6 +710,9 @@ class CopilotClient {
       }
       await this.connectToServer();
       await this.verifyProtocolVersion();
+      if (this.extensionLaunchProvider) {
+        await this.rpc.registerExtensionLaunchProvider();
+      }
       if (this.builtinPluginDirectories.length > 0) {
         try {
           await this.connection.sendRequest("plugins.builtin.set", {
@@ -664,6 +734,9 @@ class CopilotClient {
       if (this.requestHandler) {
         await this.connection.sendRequest("llmInference.setProvider", {});
       }
+      if (this.connectionClosed) {
+        throw new Error("CLI server connection closed during startup");
+      }
       this.state = "connected";
     } catch (error) {
       const startupError = this.processTransportError ?? error;
@@ -679,7 +752,8 @@ class CopilotClient {
    * 1. Closes all active sessions (releases in-memory resources)
    * 2. Requests runtime shutdown for SDK-owned CLI processes
    * 3. Closes the JSON-RPC connection
-   * 4. Terminates the CLI server process (if spawned by this client)
+   * 4. Signals EOF to an owned stdio process and waits for host cleanup, then
+   *    terminates the process if it does not exit within the shutdown timeout
    *
    * Note: session data on disk is preserved, so sessions can be resumed later.
    * To permanently remove session data before stopping, call
@@ -731,6 +805,7 @@ class CopilotClient {
     }
     this.sessions.clear();
     this.githubTokenProviders.clear();
+    this.requestAdapter?.cancelPending();
     if (this.connection && !this.connectionClosed && (this.cliProcess || this.ffiHost) && !this.isExternalServer) {
       const runtimeShutdownStart = Date.now();
       const shutdownPromise = this.rpc.runtime.shutdown();
@@ -781,10 +856,23 @@ class CopilotClient {
       this.socket = null;
       try {
         if (!socket.destroyed) {
-          await new Promise((resolve2) => {
-            socket.once("close", () => resolve2());
-            socket.end();
-          });
+          let timeout;
+          try {
+            await new Promise((resolve2) => {
+              socket.once("close", () => resolve2());
+              if (this.connectionClosed) {
+                socket.destroy();
+              } else {
+                timeout = setTimeout(
+                  () => socket.destroy(),
+                  RUNTIME_SHUTDOWN_TIMEOUT_MS
+                );
+                socket.end();
+              }
+            });
+          } finally {
+            if (timeout !== void 0) clearTimeout(timeout);
+          }
         }
       } catch (error) {
         errors.push(
@@ -796,7 +884,23 @@ class CopilotClient {
     }
     if (this.cliProcess && !this.isExternalServer) {
       const child = this.cliProcess;
-      this.cliProcess = null;
+      if (this.connectionConfig.kind === "stdio" && child.stdin && child.exitCode == null && child.signalCode == null) {
+        const gracefulExitStart = Date.now();
+        try {
+          child.stdin.end();
+          const exited = await waitForChildExit(child, RUNTIME_SHUTDOWN_TIMEOUT_MS);
+          this.logDebugTiming(
+            exited ? "CopilotClient.stop graceful stdio exit complete" : "CopilotClient.stop graceful stdio exit timed out; terminating child",
+            gracefulExitStart
+          );
+        } catch (error) {
+          errors.push(
+            new Error(
+              `Failed to close CLI stdin: ${error instanceof Error ? error.message : String(error)}`
+            )
+          );
+        }
+      }
       try {
         if (child.exitCode == null && child.signalCode == null) {
           child.kill();
@@ -814,6 +918,10 @@ class CopilotClient {
             `Failed to kill CLI process: ${error instanceof Error ? error.message : String(error)}`
           )
         );
+      } finally {
+        if (this.cliProcess === child) {
+          this.cliProcess = null;
+        }
       }
     }
     if (this.ffiHost) {
@@ -837,6 +945,7 @@ class CopilotClient {
     this.runtimePort = null;
     this.stderrBuffer = "";
     this.processExitPromise = null;
+    this.disconnectHosts();
     return errors;
   }
   /**
@@ -881,11 +990,13 @@ class CopilotClient {
    */
   async forceStop() {
     this.forceStopping = true;
+    this.disconnectHosts();
     for (const session of this.sessions.values()) {
       session._markDisconnected();
     }
     this.sessions.clear();
     this.githubTokenProviders.clear();
+    this.requestAdapter?.cancelPending();
     if (this.messageWriter) {
       this.messageWriter.suppressWriteErrors = true;
     }
@@ -1093,6 +1204,9 @@ class CopilotClient {
     if (config.gitHubToken !== void 0 && config.gitHubTokenProvider !== void 0) {
       throw new Error("gitHubToken and gitHubTokenProvider are mutually exclusive");
     }
+    if (config.cloud != null && config.skillProvider) {
+      throw new Error("Skill providers are not supported for cloud sessions.");
+    }
     if (!this.connection) {
       await this.start();
     }
@@ -1152,18 +1266,22 @@ class CopilotClient {
       if (config.hooks) {
         s.registerHooks(config.hooks);
       }
+      if (config.skillProvider) {
+        s.registerSkillProvider(config.skillProvider);
+      }
       if (transformCallbacks) {
         s.registerTransformCallbacks(transformCallbacks);
       }
       if (config.onEvent) {
         s.on(config.onEvent);
       }
-      this.sessions.set(sessionId, s);
       this.setupSessionFs(s, config);
+      this.sessions.set(sessionId, s);
       return s;
     };
     let session;
     let registeredId;
+    let uninitializedCloudSessionId;
     if (localSessionId !== void 0) {
       try {
         session = initializeSession(localSessionId);
@@ -1179,6 +1297,7 @@ class CopilotClient {
       const response = await this.connection.sendRequest("session.create", {
         ...await (0, import_telemetry.getTraceContext)(this.onGetTraceContext),
         model: config.model,
+        allowedModels: config.allowedModels,
         sessionId: localSessionId,
         clientName: config.clientName,
         reasoningEffort: config.reasoningEffort,
@@ -1188,7 +1307,7 @@ class CopilotClient {
         tools: config.tools?.map((tool) => ({
           name: tool.name,
           description: tool.description,
-          parameters: toJsonSchema(tool.parameters),
+          parameters: (0, import_schema.toJsonSchema)(tool.parameters),
           overridesBuiltInTool: tool.overridesBuiltInTool,
           skipPermission: tool.skipPermission,
           defer: tool.defer,
@@ -1236,6 +1355,7 @@ class CopilotClient {
         includeSubAgentStreamingEvents: config.includeSubAgentStreamingEvents ?? true,
         ...this.onGitHubTelemetry != null ? { enableGitHubTelemetryForwarding: true } : {},
         mcpServers: toWireMcpServers(config.mcpServers),
+        ...config.diagnostics !== void 0 ? { diagnostics: config.diagnostics } : {},
         mcpOAuthTokenStorage: config.mcpOAuthTokenStorage,
         authClientIdMetadataUrl: config.authClientIdMetadataUrl,
         envValueMode: "direct",
@@ -1245,6 +1365,7 @@ class CopilotClient {
         agent: config.agent,
         configDir: config.configDirectory,
         enableConfigDiscovery: config.enableConfigDiscovery,
+        refreshCustomInstructions: config.refreshCustomInstructions,
         skipEmbeddingRetrieval: config.skipEmbeddingRetrieval,
         embeddingCacheStorage: config.embeddingCacheStorage,
         organizationCustomInstructions: config.organizationCustomInstructions,
@@ -1254,6 +1375,7 @@ class CopilotClient {
         enableSessionStore: config.enableSessionStore,
         enableSkills: config.enableSkills,
         skillDirectories: config.skillDirectories,
+        ...config.skillProvider ? { hasSkillProvider: true } : {},
         pluginDirectories: config.pluginDirectories,
         instructionDirectories: config.instructionDirectories,
         disabledSkills: config.disabledSkills,
@@ -1267,6 +1389,7 @@ class CopilotClient {
         featureFlags: config.featureFlags,
         expAssignments: config.expAssignments,
         enableManagedSettings: config.enableManagedSettings,
+        enforceManagedModelDefaults: config.enforceManagedModelDefaults,
         managedSettings: config.managedSettings
       });
       const {
@@ -1283,7 +1406,9 @@ class CopilotClient {
         );
       }
       if (session === void 0) {
+        uninitializedCloudSessionId = returnedSessionId;
         session = initializeSession(returnedSessionId);
+        uninitializedCloudSessionId = void 0;
         registeredId = returnedSessionId;
       }
       this.assignGitHubTokenProvider(gitHubTokenProviderRegistrationId, returnedSessionId);
@@ -1305,8 +1430,27 @@ class CopilotClient {
       if (gitHubTokenProviderRegistrationId !== void 0) {
         this.githubTokenProviders.delete(gitHubTokenProviderRegistrationId);
       }
+      if (uninitializedCloudSessionId !== void 0) {
+        try {
+          await withTimeout(
+            this.deleteSession(uninitializedCloudSessionId),
+            CLOUD_SESSION_CLEANUP_TIMEOUT_MS,
+            `session.delete timed out after ${CLOUD_SESSION_CLEANUP_TIMEOUT_MS}ms`
+          );
+        } catch (cleanupError) {
+          throw new AggregateError(
+            [e, cleanupError],
+            "Failed to initialize and delete cloud session"
+          );
+        }
+      }
       throw e;
     }
+    for (const entry of this.hostHandoffs.values()) {
+      if (entry.requestedSessionId === session.sessionId) {
+        entry.configs.set(session, config);
+      }
+    }
     return session;
   }
   /**
@@ -1337,10 +1481,11 @@ class CopilotClient {
     return this.resumeSessionInternal(sessionId, config);
   }
   /** @internal */
-  async resumeSessionForExtension(sessionId, config, factories, extensionOptions) {
-    return this.resumeSessionInternal(sessionId, config, factories, extensionOptions);
+  async resumeSessionForExtension(sessionId, config, contributions = {}, extensionOptions) {
+    return this.resumeSessionInternal(sessionId, config, contributions, extensionOptions);
   }
-  async resumeSessionInternal(sessionId, config, factories, extensionOptions) {
+  async resumeSessionInternal(sessionId, config, contributions = {}, extensionOptions) {
+    const { workflows } = contributions;
     if (config.gitHubToken !== void 0 && config.gitHubTokenProvider !== void 0) {
       throw new Error("gitHubToken and gitHubTokenProvider are mutually exclusive");
     }
@@ -1360,7 +1505,7 @@ class CopilotClient {
     session.registerTools(config.tools);
     session.registerCanvases(config.canvases);
     session.registerCommands(config.commands);
-    session.registerFactories(factories);
+    session.registerWorkflows(workflows);
     const {
       wireProvider: bearerWireProvider,
       wireProviders: bearerWireProviders,
@@ -1385,6 +1530,9 @@ class CopilotClient {
     if (config.hooks) {
       session.registerHooks(config.hooks);
     }
+    if (config.skillProvider) {
+      session.registerSkillProvider(config.skillProvider);
+    }
     const modeDefaults = this.configDefaultsForMode();
     config = { ...modeDefaults, ...config };
     config.customAgentsLocalOnly ??= modeDefaults.customAgentsLocalOnly;
@@ -1398,9 +1546,10 @@ class CopilotClient {
     if (config.onEvent) {
       session.on(config.onEvent);
     }
-    this.sessions.set(sessionId, session);
-    this.setupSessionFs(session, config);
     const toolFilterOptions = this.resolveToolFilterOptions(config);
+    this.setupSessionFs(session, config);
+    const replacedSession = this.sessions.get(sessionId);
+    this.sessions.set(sessionId, session);
     const gitHubTokenProviderRegistrationId = this.registerGitHubTokenProvider(
       config.gitHubTokenProvider,
       sessionId
@@ -1412,8 +1561,10 @@ class CopilotClient {
     }
     try {
       const response = await this.connection.sendRequest("session.resume", {
+        allowedModels: config.allowedModels,
         ...await (0, import_telemetry.getTraceContext)(this.onGetTraceContext),
         sessionId,
+        allowTranscriptRecovery: config.allowTranscriptRecovery,
         clientName: config.clientName,
         model: config.model,
         reasoningEffort: config.reasoningEffort,
@@ -1432,7 +1583,7 @@ class CopilotClient {
         tools: config.tools?.map((tool) => ({
           name: tool.name,
           description: tool.description,
-          parameters: toJsonSchema(tool.parameters),
+          parameters: (0, import_schema.toJsonSchema)(tool.parameters),
           overridesBuiltInTool: tool.overridesBuiltInTool,
           skipPermission: tool.skipPermission,
           defer: tool.defer,
@@ -1441,7 +1592,7 @@ class CopilotClient {
         })),
         toolSearch: config.toolSearch,
         canvases: config.canvases?.map((canvas) => canvas.declaration),
-        factories: factories?.map((factory) => factory.meta),
+        workflows: workflows?.map((workflow) => workflow.meta),
         requestCanvasRenderer: config.requestCanvasRenderer,
         requestExtensions: config.requestExtensions,
         extensionSdkPath: config.extensionSdkPath,
@@ -1482,6 +1633,7 @@ class CopilotClient {
         includeSubAgentStreamingEvents: config.includeSubAgentStreamingEvents ?? true,
         ...this.onGitHubTelemetry != null ? { enableGitHubTelemetryForwarding: true } : {},
         mcpServers: toWireMcpServers(config.mcpServers),
+        ...config.diagnostics !== void 0 ? { diagnostics: config.diagnostics } : {},
         mcpOAuthTokenStorage: config.mcpOAuthTokenStorage,
         authClientIdMetadataUrl: config.authClientIdMetadataUrl,
         envValueMode: "direct",
@@ -1490,6 +1642,7 @@ class CopilotClient {
         defaultAgent: config.defaultAgent,
         agent: config.agent,
         skillDirectories: config.skillDirectories,
+        ...config.skillProvider ? { hasSkillProvider: true } : {},
         pluginDirectories: config.pluginDirectories,
         instructionDirectories: config.instructionDirectories,
         disabledSkills: config.disabledSkills,
@@ -1505,6 +1658,7 @@ class CopilotClient {
         featureFlags: config.featureFlags,
         expAssignments: config.expAssignments,
         enableManagedSettings: config.enableManagedSettings,
+        enforceManagedModelDefaults: config.enforceManagedModelDefaults,
         managedSettings: config.managedSettings,
         ...extensionOptions?.requestedEnvironmentVariables ? {
           requestedEnvironmentVariables: extensionOptions.requestedEnvironmentVariables
@@ -1519,10 +1673,11 @@ class CopilotClient {
           }
         }
       }
-      const { workspacePath, capabilities, openCanvases } = response;
+      const { workspacePath, capabilities, openCanvases, transcriptRecovery } = response;
       session["_workspacePath"] = workspacePath;
       session.setCapabilities(capabilities);
       session.setOpenCanvases(openCanvases ?? []);
+      session.setTranscriptRecovery(transcriptRecovery);
       if (config.onMcpAuthRequest) {
         await this.connection.sendRequest("session.eventLog.registerInterest", {
           sessionId,
@@ -1533,14 +1688,220 @@ class CopilotClient {
       this.commitGitHubTokenProvider(sessionId, gitHubTokenProviderRegistrationId);
     } catch (e) {
       session._markDisconnected();
-      this.sessions.delete(sessionId);
+      if (this.sessions.get(sessionId) === session) {
+        if (replacedSession) {
+          this.sessions.set(sessionId, replacedSession);
+        } else {
+          this.sessions.delete(sessionId);
+        }
+      }
       if (gitHubTokenProviderRegistrationId !== void 0) {
         this.githubTokenProviders.delete(gitHubTokenProviderRegistrationId);
       }
       throw e;
     }
+    for (const entry of this.hostHandoffs.values()) {
+      if (entry.requestedSessionId === session.sessionId) {
+        entry.configs.set(session, { ...config, sessionId });
+      }
+    }
     return session;
   }
+  /**
+   * Start a complete AHP listener hosted in-process by this runtime.
+   *
+   * This connection owns the host. Disposing it or disconnecting the client
+   * stops the listener without deleting sessions. The host uses a separate
+   * SDK connection to the same runtime, not another runtime process.
+   * Only one AHP host may own a compute-scoped catalog in an effective Copilot home
+   * at a time. Other SDK clients and sessions remain usable in that home.
+   * Select localServer, githubEnvironment, or both. An empty localServer
+   * selects 127.0.0.1 on an available port. `onExit` runs at most once; owner disconnection cannot
+   * acknowledge listener cleanup over the disconnected transport.
+   *
+   * @experimental
+   */
+  async startAhpHost(options) {
+    if (!options?.localServer && !options?.githubEnvironment) {
+      throw new Error("At least one of localServer or githubEnvironment is required");
+    }
+    if (this.state !== "connected") {
+      await this.start();
+    }
+    const rpc = this.rpc;
+    const hostId = (0, import_node_crypto.randomUUID)();
+    const {
+      computeId,
+      localServer,
+      githubEnvironment,
+      onExit,
+      createSession,
+      resumeSession,
+      onSessionReleased
+    } = options;
+    if (createSession || resumeSession) {
+      this.hostSessionFactories.set(hostId, {
+        createSession,
+        resumeSession,
+        onSessionReleased
+      });
+    }
+    if (onExit) {
+      this.hostExitCallbacks.set(hostId, onExit);
+    }
+    try {
+      const info = await rpc.host.start({
+        hostId,
+        computeId,
+        localServer,
+        githubEnvironment,
+        sessionFactory: createSession ? true : void 0,
+        resumeFactory: resumeSession ? true : void 0
+      });
+      return new import_host.AhpHost(
+        info,
+        async () => {
+          await rpc.host.dispose({ hostId });
+        },
+        (sessionId) => rpc.host.publishSession({ hostId, sessionId }),
+        () => rpc.host.listSessions({ hostId })
+      );
+    } catch (error) {
+      this.hostExitCallbacks.delete(hostId);
+      this.releaseHostSessions(hostId);
+      throw error;
+    }
+  }
+  handleHostExit(exit) {
+    this.releaseHostSessions(exit.hostId);
+    const onExit = this.hostExitCallbacks.get(exit.hostId);
+    if (onExit) {
+      this.hostExitCallbacks.delete(exit.hostId);
+      const reportError = (error) => {
+        console.error("AHP host exit callback failed", { hostId: exit.hostId, error });
+      };
+      try {
+        void Promise.resolve(onExit(exit)).catch(reportError);
+      } catch (error) {
+        reportError(error);
+      }
+    }
+  }
+  disconnectHosts() {
+    for (const hostId of /* @__PURE__ */ new Set([
+      ...this.hostExitCallbacks.keys(),
+      ...this.hostSessionFactories.keys()
+    ])) {
+      this.handleHostExit({
+        hostId,
+        reason: "ownerDisconnected",
+        error: "Owner connection closed; runtime cleanup cannot be acknowledged on this connection."
+      });
+    }
+  }
+  releaseHostSessions(hostId) {
+    this.hostSessionFactories.delete(hostId);
+    for (const [handoffId, entry] of this.hostHandoffs) {
+      if (entry.hostId === hostId) this.releaseHostSession(handoffId);
+    }
+  }
+  releaseHostSession(handoffId) {
+    const entry = this.hostHandoffs.get(handoffId);
+    if (!entry) return;
+    this.hostHandoffs.delete(handoffId);
+    entry.released = true;
+    entry.configs.clear();
+    entry.controller.abort();
+    if (entry.session) this.notifyHostSessionReleased(entry);
+  }
+  notifyHostSessionReleased(entry) {
+    const { session, onReleased } = entry;
+    entry.session = void 0;
+    if (session && onReleased) {
+      try {
+        void Promise.resolve(onReleased(session)).catch(() => {
+          console.error("AHP session release callback failed");
+        });
+      } catch {
+        console.error("AHP session release callback failed");
+      }
+    }
+  }
+  async createHostSession(params) {
+    const options = this.hostSessionFactories.get(params.hostId);
+    if (!(params.resume ? options?.resumeSession : options?.createSession) || this.hostHandoffs.has(params.handoffId)) {
+      throw new Error("AHP session factory is unavailable or handoff already exists");
+    }
+    const entry = {
+      hostId: params.hostId,
+      requestedSessionId: params.config.sessionId,
+      controller: new AbortController(),
+      configs: /* @__PURE__ */ new Map(),
+      released: false,
+      onReleased: options.onSessionReleased
+    };
+    this.hostHandoffs.set(params.handoffId, entry);
+    const { configDir, ...config } = params.config;
+    if (configDir !== void 0) config.configDirectory = configDir;
+    const expected = structuredClone(config);
+    const cancelled = new Promise((_resolve, reject) => {
+      entry.controller.signal.addEventListener(
+        "abort",
+        () => {
+          reject(new Error("AHP session handoff ended"));
+        },
+        { once: true }
+      );
+    });
+    const materialized = Promise.resolve().then(() => {
+      if (params.resume) {
+        const { sessionId, ...resumeConfig } = config;
+        if (!sessionId) throw new Error("AHP resume requires sessionId");
+        return options.resumeSession({
+          sessionId,
+          config: resumeConfig,
+          signal: entry.controller.signal
+        });
+      }
+      return options.createSession({
+        config,
+        signal: entry.controller.signal
+      });
+    }).then((session) => {
+      entry.session = session;
+      const actual = entry.configs.get(session);
+      entry.configs.clear();
+      if (entry.released) {
+        this.notifyHostSessionReleased(entry);
+        throw new Error("AHP session handoff ended");
+      }
+      if (this.sessions.get(session.sessionId) !== session || session.sessionId !== expected.sessionId) {
+        throw new Error(
+          "AHP callback must return the requested session from this client"
+        );
+      }
+      const contains = (value, required) => {
+        if (required && typeof required === "object" && !Array.isArray(required)) {
+          return !!value && typeof value === "object" && Object.entries(required).every(
+            ([key, child]) => contains(value[key], child)
+          );
+        }
+        return JSON.stringify(value) === JSON.stringify(required);
+      };
+      if ((!params.resume || actual !== void 0) && !contains(actual, expected)) {
+        throw new Error(
+          "AHP callback must preserve the supplied session configuration"
+        );
+      }
+      return { sessionId: session.sessionId };
+    });
+    try {
+      return await Promise.race([materialized, cancelled]);
+    } catch (error) {
+      this.releaseHostSession(params.handoffId);
+      throw error;
+    }
+  }
   /**
    * Sends a ping request to the server to verify connectivity.
    *
@@ -1902,6 +2263,9 @@ class CopilotClient {
     if (this.options.mode === "empty") {
       env.COPILOT_DISABLE_KEYTAR = "1";
     }
+    if (this.options.mode !== "empty") {
+      env.COPILOT_RUNTIME_PROCESS_FILE_LOGGING = "1";
+    }
     if (this.options.telemetry) {
       const t = this.options.telemetry;
       env.COPILOT_OTEL_ENABLED = "true";
@@ -2077,8 +2441,13 @@ stderr: ${stderrOutput}`
       case "inprocess":
         return this.connectViaFfi();
       case "tcp":
-      case "uri":
         return this.connectViaTcp();
+      case "uri": {
+        const { host, port } = this.parseCliUrl(this.connectionConfig.url);
+        this.actualHost = host;
+        this.runtimePort = port;
+        return this.connectViaTcp();
+      }
     }
   }
   /** Starts the in-process FFI runtime with SDK-managed typed options. */
@@ -2137,7 +2506,7 @@ stderr: ${stderrOutput}`
       throw new Error("In-process FFI runtime host not started");
     }
     this.messageWriter = new TeardownResilientStreamMessageWriter(this.ffiHost.sendStream);
-    this.connection = (0, import_node.createMessageConnection)(
+    this.connection = createMessageConnection(
       new import_node.StreamMessageReader(this.ffiHost.receiveStream),
       this.messageWriter
     );
@@ -2191,7 +2560,7 @@ stderr: ${stderrOutput}` : ""}`
       }
     });
     this.messageWriter = new TeardownResilientStreamMessageWriter(this.cliProcess.stdin);
-    this.connection = (0, import_node.createMessageConnection)(
+    this.connection = createMessageConnection(
       new import_node.StreamMessageReader(this.cliProcess.stdout),
       this.messageWriter
     );
@@ -2206,7 +2575,7 @@ stderr: ${stderrOutput}` : ""}`
       throw new Error("CLI child process was unexpectedly started in parent process mode");
     }
     this.messageWriter = new TeardownResilientStreamMessageWriter(process.stdout);
-    this.connection = (0, import_node.createMessageConnection)(
+    this.connection = createMessageConnection(
       new import_node.StreamMessageReader(process.stdin),
       this.messageWriter
     );
@@ -2229,7 +2598,7 @@ stderr: ${stderrOutput}` : ""}`
       this.socket.connect(this.runtimePort, this.actualHost, () => {
         clearTimeout(connectionTimeout);
         this.messageWriter = new TeardownResilientStreamMessageWriter(this.socket);
-        this.connection = (0, import_node.createMessageConnection)(
+        this.connection = createMessageConnection(
           new import_node.StreamMessageReader(this.socket),
           this.messageWriter
         );
@@ -2276,28 +2645,112 @@ stderr: ${stderrOutput}` : ""}`
       return session.clientSessionApis;
     });
     (0, import_rpc.registerClientGlobalApiHandlers)(this.connection, this.clientGlobalHandlers);
+    if (this.installationConfirmationHandler) {
+      const confirmation = (0, import_installationConfirmation.createInstallationConfirmationAdapter)(
+        this.connection,
+        this.installationConfirmationHandler
+      );
+      this.connection.onRequest(
+        "installations.confirm",
+        (params, token) => confirmation.confirm(params, token)
+      );
+    }
+    this.connection.onRequest(
+      "host.materializeSession",
+      (params) => this.createHostSession(params)
+    );
+    this.connection.onNotification(
+      "host.sessionReleased",
+      (params) => {
+        if (this.hostHandoffs.get(params.handoffId)?.hostId === params.hostId) {
+          this.releaseHostSession(params.handoffId);
+        }
+      }
+    );
     this.connection.onRequest(
       "hooks.invoke",
       async (params) => {
         return await this.handleHooksInvoke(params);
       }
     );
+    this.connection.onRequest(
+      "skillProvider.list",
+      async (params, token) => await this.resolveSkillProviderSession(params)._handleSkillProviderList(token)
+    );
+    this.connection.onRequest(
+      "skillProvider.read",
+      async (params, token) => {
+        const session = this.resolveSkillProviderSession(params);
+        if (typeof params.name !== "string") {
+          throw new Error("Invalid skillProvider.read payload");
+        }
+        return await session._handleSkillProviderRead(params.name, token);
+      }
+    );
     const connection = this.connection;
+    const messageWriter = this.messageWriter;
+    const cliProcess = this.isExternalServer ? null : this.cliProcess;
+    const connectionEpoch = this.connectionEpoch;
+    const isCurrentConnection = () => connectionEpoch === this.connectionEpoch && this.connection === connection && (cliProcess === null || this.cliProcess === cliProcess);
+    let disconnecting = false;
+    let exitFallback;
     const markDisconnected = () => {
-      if (this.connection !== connection) {
+      if (!isCurrentConnection()) {
+        connection.dispose();
         return;
       }
       this.connectionClosed = true;
       this.state = "disconnected";
+      this.disconnectHosts();
       for (const session of this.sessions.values()) {
         session._markDisconnected();
       }
       this.sessions.clear();
       this.githubTokenProviders.clear();
+      this.requestAdapter?.cancelPending();
+      connection.dispose();
+      this.socket?.destroy();
+      this.connection = null;
+      this.messageWriter = null;
+      this._rpc = null;
+      this._internalRpc = null;
+      this.modelsCache = null;
     };
-    this.connection.onClose(markDisconnected);
+    const disconnectAfterDrain = () => {
+      if (exitFallback !== void 0) {
+        clearTimeout(exitFallback);
+        exitFallback = void 0;
+      }
+      if (!isCurrentConnection()) {
+        connection.dispose();
+        return;
+      }
+      if (disconnecting) return;
+      disconnecting = true;
+      this.connectionClosed = true;
+      if (messageWriter) messageWriter.suppressWriteErrors = true;
+      void connection.drain().then(markDisconnected);
+    };
+    this.connection.onClose(disconnectAfterDrain);
+    if (cliProcess) {
+      cliProcess.once("exit", () => {
+        if (!isCurrentConnection()) {
+          connection.dispose();
+          return;
+        }
+        if (disconnecting) return;
+        if (this.socket) {
+          disconnectAfterDrain();
+          return;
+        }
+        this.connectionClosed = true;
+        if (messageWriter) messageWriter.suppressWriteErrors = true;
+        exitFallback = setTimeout(disconnectAfterDrain, RUNTIME_SHUTDOWN_TIMEOUT_MS);
+        exitFallback.unref();
+      });
+    }
     this.connection.onError(() => {
-      if (this.connection === connection) {
+      if (connectionEpoch === this.connectionEpoch && this.connection === connection) {
         this.state = "disconnected";
       }
     });
@@ -2390,6 +2843,16 @@ stderr: ${stderrOutput}` : ""}`
     });
     return { response };
   }
+  resolveSkillProviderSession(params) {
+    if (!params || typeof params.sessionId !== "string") {
+      throw new Error("Invalid skillProvider payload");
+    }
+    const session = this.sessions.get(params.sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${params.sessionId}`);
+    }
+    return session;
+  }
   async handleHooksInvoke(params) {
     if (!params || typeof params.sessionId !== "string" || typeof params.hookType !== "string") {
       throw new Error("Invalid hooks invoke payload");