@github/copilot-sdk 1.0.14 → 1.0.15-preview.0

package/dist/cjs/generated/rpc.js

@@ -225,7 +225,15 @@ function createServerRpc(connection) {
        *
        * @returns Outcome of a catalog.search call: either bounded inert candidates, or one typed refusal. Never a partial success.
        */
-      search: async (params) => connection.sendRequest("catalog.search", params)
+      search: async (params) => connection.sendRequest("catalog.search", params),
+      /**
+       * Terminates one retained catalog selection group. A selected outcome returns the native host a fresh single-use candidate handle plus the original searchId for a later explicit mcp.planInstall call; non-selected outcomes release the group without producing a planning input. Candidate state, cards, URLs, credentials and private identifiers remain inside the runtime. The model-facing catalog_select tool projects the result separately and never exposes the candidate handle or searchId.
+       *
+       * @param params Terminates one retained catalog selection group through an opaque reference previously returned by the model-safe search projection.
+       *
+       * @returns Typed outcome of catalog.select. Only the selected host result carries a fresh candidate handle; the model-facing projection removes both that handle and searchId.
+       */
+      select: async (params) => connection.sendRequest("catalog.select", params)
     },
     /** @experimental */
     plugins: {
@@ -456,7 +464,7 @@ function createServerRpc(connection) {
       /**
        * Registers an SDK client as the session filesystem provider.
        *
-       * @param params Initial working directory, session-state path layout, and path conventions used to register the calling SDK client as the session filesystem provider.
+       * @param params Initial working directory, session-state path layout, and path conventions used to register the calling SDK client as the session filesystem provider. A registered provider is authoritative for path interpretation and filesystem facts used by workspace permission validation. Paths are interpreted lexically; home-relative paths (`~` and `~/...`) and Windows drive-relative paths such as `C:foo` are unsupported. Until provider-side canonicalization is supported, providers must not expose symlinks inside allowed roots that escape those roots.
        *
        * @returns Indicates whether the calling client was registered as the session filesystem provider.
        */
@@ -1020,6 +1028,108 @@ function createSessionRpc(connection, sessionId) {
       }
     },
     /** @experimental */
+    workflow: {
+      /**
+       * Runs a registered dynamic workflow by name at the top level.
+       *
+       * @param params Parameters for invoking a registered workflow.
+       *
+       * @returns Complete current or terminal workflow run envelope.
+       */
+      run: async (params) => connection.sendRequest("session.workflow.run", { sessionId, ...params }),
+      /**
+       * Resumes a dynamic workflow run using its persisted name, arguments, journal, and accounting.
+       *
+       * @param params Parameters for resuming a workflow run from its persisted identity.
+       *
+       * @returns Resolved persisted workflow identity and resumed run envelope.
+       */
+      resume: async (params) => connection.sendRequest("session.workflow.resume", { sessionId, ...params }),
+      /**
+       * Gets the current or settled envelope for a dynamic workflow run.
+       *
+       * @param params Parameters for retrieving a workflow run.
+       *
+       * @returns Complete current or terminal workflow run envelope.
+       */
+      getRun: async (params) => connection.sendRequest("session.workflow.getRun", { sessionId, ...params }),
+      /**
+       * Lists durable dynamic workflow runs for this session in creation order.
+       *
+       * @param params Parameters for paging workflow runs.
+       *
+       * @returns A page of workflow runs in durable creation order.
+       */
+      listRuns: async (params) => connection.sendRequest("session.workflow.listRuns", { sessionId, ...params }),
+      /**
+       * Gets durable and live observability detail for one dynamic workflow run.
+       *
+       * @param params Parameters for retrieving a workflow run.
+       *
+       * @returns Full workflow run observability detail.
+       */
+      getRunDetail: async (params) => connection.sendRequest("session.workflow.getRunDetail", { sessionId, ...params }),
+      /**
+       * Pages durable progress for one dynamic workflow run.
+       *
+       * @param params Parameters for paging workflow progress.
+       *
+       * @returns A bidirectional page of workflow progress.
+       */
+      getRunProgress: async (params) => connection.sendRequest("session.workflow.getRunProgress", { sessionId, ...params }),
+      /**
+       * Requests cancellation of a dynamic workflow run and returns its run envelope.
+       *
+       * @param params Parameters for cancelling a workflow run.
+       *
+       * @returns Complete current or terminal workflow run envelope.
+       */
+      cancel: async (params) => connection.sendRequest("session.workflow.cancel", { sessionId, ...params }),
+      /**
+       * Pauses a running dynamic workflow and returns its settled run envelope.
+       *
+       * @param params Parameters for pausing a running workflow.
+       *
+       * @returns Complete current or terminal workflow run envelope.
+       */
+      pause: async (params) => connection.sendRequest("session.workflow.pause", { sessionId, ...params }),
+      /**
+       * Records a batch of ordered dynamic workflow progress lines.
+       *
+       * @param params Parameters for recording workflow progress.
+       *
+       * @returns Acknowledgement that a workflow request was accepted.
+       */
+      log: async (params) => connection.sendRequest("session.workflow.log", { sessionId, ...params }),
+      /**
+       * Runs one dynamic-workflow-scoped subagent and returns its result.
+       *
+       * @param params Parameters for one workflow-scoped subagent call.
+       *
+       * @returns Result of one workflow-scoped subagent call.
+       */
+      agent: async (params) => connection.sendRequest("session.workflow.agent", { sessionId, ...params }),
+      /** @experimental */
+      journal: {
+        /**
+         * Reads a memoized dynamic workflow journal entry.
+         *
+         * @param params Parameters for reading a workflow journal entry.
+         *
+         * @returns Result of reading a workflow journal entry.
+         */
+        get: async (params) => connection.sendRequest("session.workflow.journal.get", { sessionId, ...params }),
+        /**
+         * Stores a memoized dynamic workflow journal entry.
+         *
+         * @param params Parameters for storing a workflow journal entry.
+         *
+         * @returns Acknowledgement that a workflow request was accepted.
+         */
+        put: async (params) => connection.sendRequest("session.workflow.journal.put", { sessionId, ...params })
+      }
+    },
+    /** @experimental */
     model: {
       /**
        * Gets the session's authoritative model snapshot, including the committed Auto preference and any newer unclaimed Auto preference waiting for a future user turn.
@@ -1725,13 +1835,97 @@ function createSessionRpc(connection, sessionId) {
       }
     },
     /** @experimental */
+    managedSettings: {
+      /**
+       * Waits for the live session's in-flight managed-settings application, then returns the retained effective snapshot used by runtime enforcement and by `session.managed_settings_resolved`. It does not perform another account, device, or server resolution, and rejects when resolution has not produced a snapshot.
+       *
+       * @returns Enterprise managed-settings resolution: the effective managed settings the session applied and which channels contributed, so SDK clients can show users what is enterprise-managed. Fires whenever managed policy is (re)applied — at session start, on resume, and on account switch. This is an ephemeral live snapshot (delivered to subscribers but not persisted to the session event log), because at session start it resolves before `session.start` is emitted. Device values take precedence over server values, then the policy helper, per ordinary key, while permissions compose restrictively across device, server, policy-helper, and SDK-client layers. The account-scoped `getManagedSettings()` API does not include session-local client injection. Marked experimental while the managed-settings surface stabilizes.
+       */
+      get: async () => connection.sendRequest("session.managedSettings.get", { sessionId })
+    },
+    /** @experimental */
     plugins: {
       /**
-       * Lists plugins installed for the session.
+       * Lists globally installed, live, built-in, and enterprise-managed desired plugins using the live session's authoritative account, working directory, and retained managed policy.
        *
        * @returns Plugins installed for the session, with their enabled state and version metadata.
        */
       list: async () => connection.sendRequest("session.plugins.list", { sessionId }),
+      /**
+       * Installs a plugin using the live session's authoritative account, working directory, and retained managed policy.
+       *
+       * @param params Plugin source resolved relative to the session's authoritative working directory.
+       *
+       * @returns Result of installing a plugin.
+       */
+      install: async (params) => connection.sendRequest("session.plugins.install", { sessionId, ...params }),
+      /**
+       * Uninstalls a plugin when permitted by the live session's retained managed policy.
+       *
+       * @param params Name (or spec) of the plugin to uninstall.
+       */
+      uninstall: async (params) => connection.sendRequest("session.plugins.uninstall", { sessionId, ...params }),
+      /**
+       * Updates an installed plugin using the live session's authoritative account, working directory, and retained managed policy.
+       *
+       * @param params Name (or spec) of the plugin to update.
+       *
+       * @returns Result of updating a single plugin.
+       */
+      update: async (params) => connection.sendRequest("session.plugins.update", { sessionId, ...params }),
+      /**
+       * Enables installed plugins when permitted by the live session's retained managed policy.
+       *
+       * @param params Plugin names (or specs) to enable in the session's authoritative working directory.
+       */
+      enable: async (params) => connection.sendRequest("session.plugins.enable", { sessionId, ...params }),
+      /**
+       * Disables installed plugins when permitted by the live session's retained managed policy.
+       *
+       * @param params Plugin names (or specs) to disable in the session's authoritative working directory.
+       */
+      disable: async (params) => connection.sendRequest("session.plugins.disable", { sessionId, ...params }),
+      /** @experimental */
+      marketplaces: {
+        /**
+         * Lists registered and enterprise-managed desired marketplaces using the live session's retained policy.
+         *
+         * @returns All registered marketplaces, including built-in defaults.
+         */
+        list: async () => connection.sendRequest("session.plugins.marketplaces.list", { sessionId }),
+        /**
+         * Adds a marketplace when permitted by the live session's retained managed policy.
+         *
+         * @param params Marketplace source and optional working directory for relative-path resolution.
+         *
+         * @returns Result of registering a new marketplace.
+         */
+        add: async (params) => connection.sendRequest("session.plugins.marketplaces.add", { sessionId, ...params }),
+        /**
+         * Removes a marketplace when permitted by the live session's retained managed policy.
+         *
+         * @param params Name of the marketplace to remove and an optional force flag.
+         *
+         * @returns Outcome of the remove attempt, including dependent-plugin info when applicable.
+         */
+        remove: async (params) => connection.sendRequest("session.plugins.marketplaces.remove", { sessionId, ...params }),
+        /**
+         * Browses a marketplace resolved through the live session's working directory and retained managed policy.
+         *
+         * @param params Name of the marketplace whose plugin catalog to fetch.
+         *
+         * @returns Plugins advertised by the marketplace.
+         */
+        browse: async (params) => connection.sendRequest("session.plugins.marketplaces.browse", { sessionId, ...params }),
+        /**
+         * Refreshes marketplaces resolved through the live session's working directory and retained managed policy.
+         *
+         * @param params Optional marketplace name; omit to refresh all.
+         *
+         * @returns Result of refreshing one or more marketplace catalogs.
+         */
+        refresh: async (params) => connection.sendRequest("session.plugins.marketplaces.refresh", { sessionId, ...params })
+      },
       /**
        * Reloads the session's plugin set, refreshing MCP servers, custom agents, hooks, and skills cache so SDK-driven changes via `server.plugins.*` take effect immediately.
        *
@@ -2440,6 +2634,22 @@ function createSessionRpc(connection, sessionId) {
        * @returns Result of editing a queued message.
        */
       updateText: async (params) => connection.sendRequest("session.queue.updateText", { sessionId, ...params }),
+      /**
+       * Atomically withdraws an unchanged, unconsumed user message from the local queued or steering lane. A client retaining the original draft may restore it only when removed is true. Does not interrupt the running turn.
+       *
+       * @param params Conditional withdrawal of a single user message, before the runtime claims it for delivery.
+       *
+       * @returns Result of removing a queued item.
+       */
+      withdrawMessage: async (params) => connection.sendRequest("session.queue.withdrawMessage", { sessionId, ...params }),
+      /**
+       * Atomically appends text and attachments to an unchanged, unconsumed local steering message. Returns updated=false if delivery or withdrawal already claimed the message.
+       *
+       * @param params Append to one pending steering message without changing its identity or delivery position.
+       *
+       * @returns Result of editing a queued message.
+       */
+      appendSteering: async (params) => connection.sendRequest("session.queue.appendSteering", { sessionId, ...params }),
       /**
        * Duplicates an addressable queued item immediately after its source.
        *
@@ -2694,6 +2904,31 @@ function createInternalSessionRpc(connection, sessionId) {
       pauseAtCheckpoint: async (params) => connection.sendRequest("session.factory.pauseAtCheckpoint", { sessionId, ...params })
     },
     /** @experimental */
+    workflow: {
+      /**
+       * Internal tool-originated dynamic workflow invocation.
+       *
+       * @param params Internal parameters for invoking a registered workflow from a tool.
+       *
+       * @returns Complete current or terminal workflow run envelope.
+       */
+      runFromTool: async (params) => connection.sendRequest("session.workflow.runFromTool", { sessionId, ...params }),
+      /**
+       * Internal tool-originated dynamic workflow resume.
+       *
+       * @param params Internal parameters for resuming a workflow run from a tool.
+       *
+       * @returns Resolved persisted workflow identity and resumed run envelope.
+       */
+      resumeFromTool: async (params) => connection.sendRequest("session.workflow.resumeFromTool", { sessionId, ...params }),
+      /**
+       * Atomically pauses an owned dynamic workflow attempt at a durable checkpoint.
+       *
+       * @param params Parameters for an owned durable pause checkpoint.
+       */
+      pauseAtCheckpoint: async (params) => connection.sendRequest("session.workflow.pauseAtCheckpoint", { sessionId, ...params })
+    },
+    /** @experimental */
     model: {
       /**
        * Resolves and applies organization-managed and repository model overlays.
@@ -2889,6 +3124,16 @@ function registerClientSessionApiHandlers(connection, getHandlers) {
     if (!handler) throw new Error(`No factory handler registered for session: ${params.sessionId}`);
     return handler.abort(params);
   });
+  connection.onRequest("workflow.execute", async (params) => {
+    const handler = getHandlers(params.sessionId).workflow;
+    if (!handler) throw new Error(`No workflow handler registered for session: ${params.sessionId}`);
+    return handler.execute(params);
+  });
+  connection.onRequest("workflow.abort", async (params) => {
+    const handler = getHandlers(params.sessionId).workflow;
+    if (!handler) throw new Error(`No workflow handler registered for session: ${params.sessionId}`);
+    return handler.abort(params);
+  });
   connection.onRequest("tasks.cancel", async (params) => {
     const handler = getHandlers(params.sessionId).tasks;
     if (!handler) throw new Error(`No tasks handler registered for session: ${params.sessionId}`);

package/dist/cjs/schema.js

@@ -0,0 +1,40 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var schema_exports = {};
+__export(schema_exports, {
+  isResponseSchema: () => isResponseSchema,
+  isZodSchema: () => isZodSchema,
+  toJsonSchema: () => toJsonSchema
+});
+module.exports = __toCommonJS(schema_exports);
+function isZodSchema(value) {
+  return typeof value === "object" && value !== null && "toJSONSchema" in value && typeof value.toJSONSchema === "function";
+}
+function toJsonSchema(schema) {
+  return isZodSchema(schema) ? schema.toJSONSchema() : schema;
+}
+function isResponseSchema(value) {
+  return isZodSchema(value) && "parse" in value && typeof value.parse === "function";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isResponseSchema,
+  isZodSchema,
+  toJsonSchema
+});

package/dist/cjs/session.js

@@ -26,6 +26,7 @@ var import_node = require("vscode-jsonrpc/node.js");
 var import_rpc = require("./generated/rpc.js");
 var import_canvas = require("./canvas.js");
 var import_telemetry = require("./telemetry.js");
+var import_schema = require("./schema.js");
 var import_types = require("./types.js");
 var import_factory = require("./factory.js");
 function isFactoryResumeErrorCode(value) {
@@ -277,6 +278,7 @@ class CopilotSession {
   _capabilities = {};
   openCanvasInstances = [];
   disconnected = false;
+  pendingStructuredWaits = /* @__PURE__ */ new Set();
   disconnecting = false;
   onDisconnected;
   /** @internal Client session API handlers, populated by CopilotClient during create/resume. */
@@ -493,13 +495,54 @@ class CopilotSession {
       attachments: options.attachments,
       mode: options.mode,
       agentMode: options.agentMode,
-      requestHeaders: options.requestHeaders
+      requestHeaders: options.requestHeaders,
+      ...options.responseSchema ? {
+        responseFormat: {
+          type: "json_schema",
+          jsonSchema: {
+            name: "response",
+            strict: true,
+            schema: (0, import_schema.toJsonSchema)(options.responseSchema)
+          }
+        }
+      } : {}
     });
     return response.messageId;
   }
-  async sendAndWait(optionsOrPrompt, timeout) {
+  async sendAndWait(optionsOrPrompt, schemaOrTimeout, timeout) {
     const options = typeof optionsOrPrompt === "string" ? { prompt: optionsOrPrompt } : optionsOrPrompt;
-    const effectiveTimeout = timeout ?? 6e4;
+    const typedSchema = (0, import_schema.isResponseSchema)(schemaOrTimeout) ? schemaOrTimeout : void 0;
+    if (schemaOrTimeout !== void 0 && typeof schemaOrTimeout !== "number" && !typedSchema) {
+      throw new TypeError(
+        "The second argument must be a timeout or a schema with toJSONSchema() and parse(). Pass raw JSON Schema in options.responseSchema instead."
+      );
+    }
+    const effectiveTimeout = (typeof schemaOrTimeout === "number" ? schemaOrTimeout : timeout) ?? 6e4;
+    if (typedSchema && options.responseSchema) {
+      throw new Error(
+        "Do not specify responseSchema in options when requesting a typed response."
+      );
+    }
+    if (typedSchema && options.mode === "immediate") {
+      throw new Error(
+        "Structured output cannot be requested on an immediate steering message."
+      );
+    }
+    if (typedSchema || options.responseSchema) {
+      const message = await this.sendAndWaitForStructuredMessage(
+        typedSchema ? { ...options, responseSchema: typedSchema } : options,
+        effectiveTimeout
+      );
+      if (typedSchema) {
+        if (!message) {
+          throw new Error(
+            "The requested run completed without a structured assistant response."
+          );
+        }
+        return typedSchema.parse(JSON.parse(message.data.content));
+      }
+      return message;
+    }
     let resolveOutcome;
     const outcomePromise = new Promise((resolve) => {
       resolveOutcome = resolve;
@@ -541,12 +584,95 @@ class CopilotSession {
       unsubscribe();
     }
   }
+  async sendAndWaitForStructuredMessage(options, timeout) {
+    if (this.disconnected) {
+      throw new Error("Session is disconnected");
+    }
+    let resolveOutcome;
+    const outcomePromise = new Promise((resolve) => {
+      resolveOutcome = resolve;
+    });
+    const fail = (error) => resolveOutcome({ kind: "error", error });
+    let messageId;
+    let consumed = false;
+    let lastMessage;
+    const buffered = [];
+    const observe = (event) => {
+      if (event.agentId) return;
+      if (event.type === "user.message" && event.data.messageId === messageId) {
+        consumed = true;
+      } else if (event.type === "assistant.message" && event.data.originatingMessageId === messageId) {
+        consumed = true;
+        lastMessage = event.data.toolRequests?.length ? void 0 : event;
+      } else if (consumed && event.type === "session.idle" && event.data.mode !== "autopilot") {
+        if (event.data.aborted) {
+          fail(
+            new Error(
+              "The requested run was aborted before a structured result was completed."
+            )
+          );
+        } else {
+          resolveOutcome({ kind: "idle", message: lastMessage });
+        }
+      } else if (consumed && event.type === "session.error") {
+        const error = new Error(event.data.message);
+        error.stack = event.data.stack;
+        fail(error);
+      }
+    };
+    const unsubscribe = this.on((event) => {
+      if (event.type !== "user.message" && event.type !== "assistant.message" && event.type !== "session.idle" && event.type !== "session.error") {
+        return;
+      }
+      if (messageId === void 0) {
+        buffered.push(event);
+      } else {
+        observe(event);
+      }
+    });
+    this.pendingStructuredWaits.add(fail);
+    const timer = setTimeout(
+      () => fail(new Error(`Timeout after ${timeout}ms waiting for the structured response`)),
+      timeout
+    );
+    try {
+      const sendOutcome = this.send(options).then(
+        (id) => {
+          if (!id) {
+            throw new Error(
+              "The runtime did not return a message ID for the structured send."
+            );
+          }
+          messageId = id;
+          for (const event of buffered) observe(event);
+          buffered.length = 0;
+          return outcomePromise;
+        },
+        (error) => ({
+          kind: "error",
+          error: error instanceof Error ? error : new Error(String(error))
+        })
+      );
+      const outcome = await Promise.race([sendOutcome, outcomePromise]);
+      if (outcome.kind === "error") throw outcome.error;
+      return outcome.message;
+    } finally {
+      clearTimeout(timer);
+      buffered.length = 0;
+      unsubscribe();
+      this.pendingStructuredWaits.delete(fail);
+    }
+  }
   /** @internal */
   _markDisconnected() {
     if (this.disconnected) {
       return;
     }
     this.disconnected = true;
+    for (const fail of this.pendingStructuredWaits) {
+      fail(new Error("Session disconnected while waiting for a structured response"));
+    }
+    this.pendingStructuredWaits.clear();
     for (const controller of this.pendingExternalTools.values()) {
       controller.abort();
     }

package/dist/cliVersion.d.ts

@@ -1,2 +1,2 @@
-export declare const COPILOT_CLI_VERSION = "1.0.85";
+export declare const COPILOT_CLI_VERSION = "1.0.87-0";
 export declare const COPILOT_CLI_USE_NPM_PACKAGE = false;

package/dist/cliVersion.js

@@ -1,4 +1,4 @@
-const COPILOT_CLI_VERSION = "1.0.85";
+const COPILOT_CLI_VERSION = "1.0.87-0";
 const COPILOT_CLI_USE_NPM_PACKAGE = false;
 export {
   COPILOT_CLI_USE_NPM_PACKAGE,

package/dist/client.d.ts

@@ -6,6 +6,7 @@ export declare class CopilotClient {
     private cliProcess;
     private ffiHost;
     private connection;
+    private requestAdapter;
     private messageWriter;
     private connectionClosed;
     private socket;
@@ -41,6 +42,7 @@ export declare class CopilotClient {
     /** Connection-level session filesystem config, set via constructor option. */
     private sessionFsConfig;
     private requestHandler;
+    private extensionLaunchProvider?;
     private builtinPluginDirectories;
     private onGitHubTelemetry?;
     private clientGlobalHandlers;

package/dist/client.js

@@ -23,13 +23,11 @@ import { COPILOT_CLI_VERSION } from "./cliVersion.js";
 import { createSessionFsAdapter } from "./sessionFsProvider.js";
 import { createCopilotRequestAdapter } from "./copilotRequestHandler.js";
 import { getTraceContext } from "./telemetry.js";
+import { toJsonSchema } from "./schema.js";
 import { ToolSet } from "./toolSet.js";
 import { defaultJoinSessionPermissionHandler } from "./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";
-}
 async function withTimeout(promise, timeoutMs, message) {
   let timeout;
   try {
@@ -74,13 +72,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();
@@ -213,6 +204,7 @@ class CopilotClient {
   cliProcess = null;
   ffiHost = null;
   connection = null;
+  requestAdapter = null;
   messageWriter = null;
   connectionClosed = false;
   socket = null;
@@ -250,6 +242,7 @@ class CopilotClient {
   /** Connection-level session filesystem config, set via constructor option. */
   sessionFsConfig = null;
   requestHandler = null;
+  extensionLaunchProvider;
   builtinPluginDirectories = [];
   onGitHubTelemetry;
   clientGlobalHandlers = {};
@@ -407,6 +400,7 @@ class CopilotClient {
     this.onGetTraceContext = options.onGetTraceContext;
     this.sessionFsConfig = options.sessionFs ?? null;
     this.requestHandler = options.requestHandler ?? null;
+    this.extensionLaunchProvider = options.extensionLaunchProvider;
     this.onGitHubTelemetry = options.onGitHubTelemetry;
     this.setupClientGlobalHandlers();
     const connEnv = conn.kind === "stdio" || conn.kind === "tcp" ? conn.env : void 0;
@@ -509,14 +503,16 @@ class CopilotClient {
   }
   setupClientGlobalHandlers() {
     const handlers = {};
+    handlers.extensionLaunchProvider = this.extensionLaunchProvider;
     if (this.requestHandler) {
-      handlers.llmInference = createCopilotRequestAdapter(this.requestHandler, () => {
+      this.requestAdapter = createCopilotRequestAdapter(this.requestHandler, () => {
         if (!this.connection) {
           return void 0;
         }
         this._rpc ??= createServerRpc(this.connection);
         return this._rpc;
       });
+      handlers.llmInference = this.requestAdapter;
     }
     if (this.onGitHubTelemetry) {
       const onGitHubTelemetry = this.onGitHubTelemetry;
@@ -621,6 +617,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", {
@@ -709,6 +708,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();
@@ -864,6 +864,7 @@ class CopilotClient {
     }
     this.sessions.clear();
     this.githubTokenProviders.clear();
+    this.requestAdapter?.cancelPending();
     if (this.messageWriter) {
       this.messageWriter.suppressWriteErrors = true;
     }
@@ -2272,6 +2273,7 @@ stderr: ${stderrOutput}` : ""}`
       }
       this.sessions.clear();
       this.githubTokenProviders.clear();
+      this.requestAdapter?.cancelPending();
     };
     this.connection.onClose(markDisconnected);
     this.connection.onError(() => {