@github/copilot-language-server 1.551.1 → 1.551.3

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

@@ -26,28 +26,41 @@ 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) {
-  return value === "not_found" || value === "non_resumable" || value === "already_active" || value === "factory_already_running" || value === "factory_limits_invalid" || value === "factory_session_disposed" || value === "factory_storage_unavailable" || value === "factory_storage_corrupt";
+var import_workflow = require("./workflow.js");
+function isWorkflowResumeErrorCode(value) {
+  return value === "not_found" || value === "non_resumable" || value === "workflow_run_not_resumable" || value === "already_active" || value === "workflow_already_running" || value === "workflow_limits_invalid" || value === "workflow_session_disposed" || value === "workflow_storage_unavailable" || value === "workflow_storage_corrupt";
 }
-function copyDefinedFactoryAgentOption(source, target, key) {
+function copyDefinedWorkflowAgentOption(source, target, key) {
   const value = source[key];
   if (value !== void 0) {
     target[key] = value;
   }
 }
-const factoryExecutionStore = new import_node_async_hooks.AsyncLocalStorage();
-function throwIfFactoryExecutionIsActive() {
-  if (factoryExecutionStore.getStore()?.active) {
+function toToolDefinition(tool) {
+  return {
+    name: tool.name,
+    description: tool.description ?? "",
+    parameters: (0, import_schema.toJsonSchema)(tool.parameters),
+    overridesBuiltInTool: tool.overridesBuiltInTool,
+    skipPermission: tool.skipPermission,
+    defer: tool.defer,
+    metadata: tool.metadata,
+    isTerminal: tool.isTerminal
+  };
+}
+const workflowExecutionStore = new import_node_async_hooks.AsyncLocalStorage();
+function throwIfWorkflowExecutionIsActive() {
+  if (workflowExecutionStore.getStore()?.active) {
     throw new Error(
-      "factory.run, factory.resume, and factory.pause are not allowed while a factory body is running on this call path."
+      "workflow.run, workflow.resume, and workflow.pause are not allowed while a workflow body is running on this call path."
     );
   }
 }
-function runInFactoryHelperScope(helperScope, callback) {
-  const current = factoryExecutionStore.getStore();
-  return factoryExecutionStore.run({ active: current?.active ?? false, helperScope }, callback);
+function runInWorkflowHelperScope(helperScope, callback) {
+  const current = workflowExecutionStore.getStore();
+  return workflowExecutionStore.run({ active: current?.active ?? false, helperScope }, callback);
 }
 function deserializeHookInput(raw) {
   if (!raw || typeof raw !== "object" || typeof raw.timestamp !== "number") {
@@ -69,22 +82,22 @@ function isOpenCanvasInstance(value) {
   const instance = value;
   return typeof instance.instanceId === "string" && instance.instanceId.length > 0 && typeof instance.extensionId === "string" && instance.extensionId.length > 0 && typeof instance.canvasId === "string" && instance.canvasId.length > 0;
 }
-const FACTORY_LOG_FLUSH_DELAY_MS = 10;
-const MAX_FACTORY_FANOUT_ITEMS = 4096;
-function assertFactoryFanoutSize(kind, size) {
-  if (size > MAX_FACTORY_FANOUT_ITEMS) {
+const WORKFLOW_LOG_FLUSH_DELAY_MS = 10;
+const MAX_WORKFLOW_FANOUT_ITEMS = 4096;
+function assertWorkflowFanoutSize(kind, size) {
+  if (size > MAX_WORKFLOW_FANOUT_ITEMS) {
     throw new Error(
-      `${kind}() accepts at most ${MAX_FACTORY_FANOUT_ITEMS} items; got ${size}.`
+      `${kind}() accepts at most ${MAX_WORKFLOW_FANOUT_ITEMS} items; got ${size}.`
     );
   }
 }
-async function runFactoryParallel(thunks) {
+async function runWorkflowParallel(thunks) {
   if (!Array.isArray(thunks)) {
     throw new Error(
       "parallel() expects an array of functions, not promises. Wrap each call: () => agent(...)"
     );
   }
-  assertFactoryFanoutSize("parallel", thunks.length);
+  assertWorkflowFanoutSize("parallel", thunks.length);
   if (thunks.some((thunk) => typeof thunk !== "function")) {
     throw new Error(
       "parallel() expects an array of functions, not promises. Wrap each call: () => agent(...)"
@@ -92,8 +105,8 @@ async function runFactoryParallel(thunks) {
   }
   return Promise.all(
     thunks.map(
-      (thunk) => Promise.resolve().then(() => runInFactoryHelperScope("parallel", thunk)).catch((error) => {
-        if (isFactoryFatalError(error)) {
+      (thunk) => Promise.resolve().then(() => runInWorkflowHelperScope("parallel", thunk)).catch((error) => {
+        if (isWorkflowFatalError(error)) {
           throw error;
         }
         return null;
@@ -101,22 +114,22 @@ async function runFactoryParallel(thunks) {
     )
   );
 }
-async function runFactoryPipeline(items, ...stages) {
+async function runWorkflowPipeline(items, ...stages) {
   if (!Array.isArray(items)) {
     throw new Error("pipeline(items, ...stages): items must be an array");
   }
-  assertFactoryFanoutSize("pipeline", items.length);
+  assertWorkflowFanoutSize("pipeline", items.length);
   return Promise.all(
     items.map(async (item, index) => {
       let previous = item;
       for (const stage of stages) {
         try {
-          previous = await runInFactoryHelperScope(
+          previous = await runInWorkflowHelperScope(
             "pipeline",
             () => stage(previous, item, index)
           );
         } catch (error) {
-          if (isFactoryFatalError(error)) {
+          if (isWorkflowFatalError(error)) {
             throw error;
           }
           return null;
@@ -126,7 +139,7 @@ async function runFactoryPipeline(items, ...stages) {
     })
   );
 }
-class FactoryProgressBuffer {
+class WorkflowProgressBuffer {
   constructor(send) {
     this.send = send;
   }
@@ -140,7 +153,7 @@ class FactoryProgressBuffer {
   closed = false;
   enqueue(kind, text) {
     if (this.closed) {
-      throw new Error("Cannot log after the factory run has settled");
+      throw new Error("Cannot log after the workflow run has settled");
     }
     this.pending.push({ seq: this.nextSeq++, kind, text });
     this.scheduleFlush();
@@ -172,7 +185,7 @@ class FactoryProgressBuffer {
     await this.flushTail;
     if (this.flushFailed) {
       console.warn(
-        "Ignoring a background factory progress flush failure after the factory body settled",
+        "Ignoring a background workflow progress flush failure after the workflow body settled",
         this.flushError
       );
     }
@@ -181,7 +194,7 @@ class FactoryProgressBuffer {
         await this.send(lines);
       } catch (error) {
         console.warn(
-          "Failed to flush final factory progress after the factory body settled",
+          "Failed to flush final workflow progress after the workflow body settled",
           error
         );
       }
@@ -195,7 +208,7 @@ class FactoryProgressBuffer {
       this.flushTimer = void 0;
       void this.flush().catch(() => {
       });
-    }, FACTORY_LOG_FLUSH_DELAY_MS);
+    }, WORKFLOW_LOG_FLUSH_DELAY_MS);
     this.flushTimer.unref?.();
   }
   clearFlushTimer() {
@@ -205,30 +218,30 @@ class FactoryProgressBuffer {
     }
   }
 }
-async function awaitFactoryOperation(operation, signal) {
+async function awaitWorkflowOperation(operation, signal) {
   let rejectAbort;
   const abortPromise = new Promise((_resolve, reject) => {
     rejectAbort = reject;
   });
-  const onAbort = () => rejectAbort?.(signal.reason ?? new DOMException("Factory run was aborted", "AbortError"));
+  const onAbort = () => rejectAbort?.(signal.reason ?? new DOMException("Workflow run was aborted", "AbortError"));
   signal.addEventListener("abort", onAbort, { once: true });
   try {
-    throwIfFactoryAborted(signal);
+    throwIfWorkflowAborted(signal);
     return await Promise.race([operation(), abortPromise]);
   } finally {
     signal.removeEventListener("abort", onAbort);
   }
 }
-function throwIfFactoryAborted(signal) {
+function throwIfWorkflowAborted(signal) {
   if (signal.aborted) {
-    throw signal.reason ?? new DOMException("Factory run was aborted", "AbortError");
+    throw signal.reason ?? new DOMException("Workflow run was aborted", "AbortError");
   }
 }
-function isFactoryAbortError(error) {
+function isWorkflowAbortError(error) {
   return typeof error === "object" && error !== null && "name" in error && error.name === "AbortError";
 }
-function isFactoryFatalError(error) {
-  return isFactoryAbortError(error) || error instanceof import_node.ResponseError || error instanceof import_node.ConnectionError;
+function isWorkflowFatalError(error) {
+  return isWorkflowAbortError(error) || error instanceof import_node.ResponseError || error instanceof import_node.ConnectionError;
 }
 const TOOL_SEARCH_TOOL_NAME = "tool_search_tool";
 class CopilotSession {
@@ -253,21 +266,25 @@ class CopilotSession {
   sessionId;
   connection;
   _workspacePath;
+  _transcriptRecovery;
   eventHandlers = /* @__PURE__ */ new Set();
   typedEventHandlers = /* @__PURE__ */ new Map();
   toolHandlers = /* @__PURE__ */ new Map();
+  /** Settles once every earlier `setTools` call has finished. */
+  setToolsQueue = Promise.resolve();
   pendingExternalTools = /* @__PURE__ */ new Map();
   canvases = /* @__PURE__ */ new Map();
   bearerTokenProviders = /* @__PURE__ */ new Map();
   commandHandlers = /* @__PURE__ */ new Map();
-  factories = /* @__PURE__ */ new Map();
-  factoryAbortControllers = /* @__PURE__ */ new Map();
+  workflows = /* @__PURE__ */ new Map();
+  workflowAbortControllers = /* @__PURE__ */ new Map();
   permissionHandler;
   mcpAuthHandler;
   userInputHandler;
   elicitationHandler;
   exitPlanModeHandler;
   autoModeSwitchHandler;
+  skillProvider;
   hooks;
   transformCallbacks;
   _rpc = null;
@@ -277,28 +294,23 @@ class CopilotSession {
   _capabilities = {};
   openCanvasInstances = [];
   disconnected = false;
+  pendingResponseWaits = /* @__PURE__ */ new Set();
+  pendingStructuredWaits = /* @__PURE__ */ new Set();
   disconnecting = false;
   onDisconnected;
   /** @internal Client session API handlers, populated by CopilotClient during create/resume. */
   clientSessionApis = {};
   /**
-   * Friendly factory API for running registered factories by name or handle.
+   * Friendly workflow API for running registered workflows by name or handle.
    *
-   * @experimental Part of the experimental Agent Factories surface and may
+   * @experimental Part of the experimental Dynamic Workflows surface and may
    * change or be removed in future SDK or CLI releases.
    */
-  factory = {
+  workflow = {
     run: (async (nameOrHandle, options) => {
-      throwIfFactoryExecutionIsActive();
-      const name = typeof nameOrHandle === "string" ? nameOrHandle : (0, import_factory.getFactoryDefinition)(nameOrHandle).meta.name;
-      if (options?.resumeFromRunId !== void 0) {
-        return this.factory.resume(options.resumeFromRunId, {
-          limits: options.limits,
-          notifyOnComplete: options.notifyOnComplete,
-          logPhaseNames: options.logPhaseNames
-        });
-      }
-      const envelope = await this.rpc.factory.run({
+      throwIfWorkflowExecutionIsActive();
+      const name = typeof nameOrHandle === "string" ? nameOrHandle : (0, import_workflow.getWorkflowDefinition)(nameOrHandle).meta.name;
+      const envelope = await this.rpc.workflow.run({
         name,
         args: options?.args === void 0 ? {} : options.args,
         options: {
@@ -307,13 +319,13 @@ class CopilotSession {
           logPhaseNames: options?.logPhaseNames
         }
       });
-      return this.settleFactoryRun(envelope);
+      return this.settleWorkflowRun(envelope);
     }),
     resume: (async (runId, options) => {
-      throwIfFactoryExecutionIsActive();
+      throwIfWorkflowExecutionIsActive();
       let response;
       try {
-        response = await this.rpc.factory.resume({
+        response = await this.rpc.workflow.resume({
           runId,
           limits: options?.limits,
           notifyOnComplete: options?.notifyOnComplete,
@@ -322,43 +334,36 @@ class CopilotSession {
       } catch (error) {
         if (error instanceof import_node.ResponseError && typeof error.data === "object" && error.data !== null) {
           const code = error.data.code;
-          if (isFactoryResumeErrorCode(code)) {
-            throw new import_factory.FactoryResumeError(code, error.message);
+          if (isWorkflowResumeErrorCode(code)) {
+            throw new import_workflow.WorkflowResumeError(code, error.message);
           }
         }
         throw error;
       }
-      return this.settleFactoryRun(response.run);
+      return this.settleWorkflowRun(response.run);
     }),
-    getRun: async (runId) => this.rpc.factory.getRun({ runId }),
-    waitForRun: (runId, options) => this.waitForFactoryRun(runId, options?.signal),
+    getRun: async (runId) => this.rpc.workflow.getRun({ runId }),
+    waitForRun: (runId, options) => this.waitForWorkflowRun(runId, options?.signal),
     listRuns: (async (options) => {
-      const page = await this.rpc.factory.listRuns(options ?? {});
+      const page = await this.rpc.workflow.listRuns(options ?? {});
       return options === void 0 ? page.runs : page;
     }),
-    getRunDetail: (runId) => this.rpc.factory.getRunDetail({ runId }),
-    getRunProgress: (runId, options = {}) => this.rpc.factory.getRunProgress({ runId, ...options }),
+    getRunDetail: (runId) => this.rpc.workflow.getRunDetail({ runId }),
+    getRunProgress: (runId, options = {}) => this.rpc.workflow.getRunProgress({ runId, ...options }),
     pause: async (runId) => {
-      throwIfFactoryExecutionIsActive();
-      return this.rpc.factory.pause({ runId });
+      throwIfWorkflowExecutionIsActive();
+      return this.rpc.workflow.pause({ runId });
     },
-    cancel: async (runId) => this.rpc.factory.cancel({ runId })
+    cancel: async (runId) => this.rpc.workflow.cancel({ runId })
   };
-  /**
-   * Resolve a start/resume envelope into the terminal envelope callers expect.
-   *
-   * The CLI may answer `session.factory.run` and `session.factory.resume`
-   * before the run settles, so a non-terminal envelope is followed by a wait
-   * on the run's terminal state.
-   */
-  settleFactoryRun(envelope) {
-    if ((0, import_factory.isFactoryRunTerminal)(envelope.status)) {
+  settleWorkflowRun(envelope) {
+    if ((0, import_workflow.isWorkflowRunTerminal)(envelope.status)) {
       return Promise.resolve(envelope);
     }
-    return this.waitForFactoryRun(envelope.runId);
+    return this.waitForWorkflowRun(envelope.runId);
   }
   /**
-   * Resolve when a factory run reaches a terminal status.
+   * Resolve when a workflow run reaches a terminal status.
    *
    * The subscription is installed *before* the first read so a transition
    * landing between the two cannot be missed, and re-reads are serialized so
@@ -367,8 +372,8 @@ class CopilotSession {
    * collapse into a single in-flight read. A bounded periodic re-read keeps a
    * dropped invalidation from leaving the wait pending forever.
    */
-  waitForFactoryRun(runId, signal) {
-    const abortError = () => signal?.reason ?? new DOMException("Factory run wait was aborted", "AbortError");
+  waitForWorkflowRun(runId, signal) {
+    const abortError = () => signal?.reason ?? new DOMException("Workflow run wait was aborted", "AbortError");
     if (signal?.aborted === true) {
       return Promise.reject(abortError());
     }
@@ -405,8 +410,8 @@ class CopilotSession {
         try {
           do {
             rereadRequested = false;
-            const envelope = await this.rpc.factory.getRun({ runId });
-            if ((0, import_factory.isFactoryRunTerminal)(envelope.status)) {
+            const envelope = await this.rpc.workflow.getRun({ runId });
+            if ((0, import_workflow.isWorkflowRunTerminal)(envelope.status)) {
               finish(() => resolve(envelope));
               return;
             }
@@ -421,7 +426,7 @@ class CopilotSession {
         onAbort = () => finish(() => reject(abortError()));
         signal.addEventListener("abort", onAbort, { once: true });
       }
-      unsubscribe = this.on("factory.run_updated", (event) => {
+      unsubscribe = this.on("workflow.run_updated", (event) => {
         if (event.data.runId === runId) {
           void read();
         }
@@ -455,6 +460,14 @@ class CopilotSession {
   get workspacePath() {
     return this._workspacePath;
   }
+  /** Recovery observed while loading this session; undefined on a clean resume. */
+  get transcriptRecovery() {
+    return this._transcriptRecovery;
+  }
+  /** @internal */
+  setTranscriptRecovery(recovery) {
+    this._transcriptRecovery = recovery;
+  }
   /**
    * Host capabilities reported when the session was created or resumed.
    * Use this to check feature support before calling capability-gated APIs.
@@ -493,19 +506,61 @@ 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;
     });
     let lastAssistantMessage;
     const unsubscribe = this.on((event) => {
+      if (event.agentId) return;
       if (event.type === "assistant.message") {
         lastAssistantMessage = event;
       } else if (event.type === "session.idle" && event.data.mode !== "autopilot") {
@@ -516,6 +571,8 @@ class CopilotSession {
         resolveOutcome({ kind: "error", error });
       }
     });
+    const fail = (error) => resolveOutcome({ kind: "error", error });
+    this.pendingResponseWaits.add(fail);
     let timeoutId;
     try {
       await this.send(options);
@@ -539,6 +596,91 @@ class CopilotSession {
         clearTimeout(timeoutId);
       }
       unsubscribe();
+      this.pendingResponseWaits.delete(fail);
+    }
+  }
+  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);
+    }
+  }
+  assertConnected() {
+    if (this.disconnected) {
+      throw new Error("Session is disconnected");
     }
   }
   /** @internal */
@@ -547,40 +689,62 @@ class CopilotSession {
       return;
     }
     this.disconnected = true;
+    for (const fail of this.pendingResponseWaits) {
+      fail(new Error("Session disconnected while waiting for a response"));
+    }
+    this.pendingResponseWaits.clear();
+    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();
     }
     this.pendingExternalTools.clear();
-    this._runOnDisconnected();
     this.eventHandlers.clear();
     this.typedEventHandlers.clear();
     this.toolHandlers.clear();
     this.permissionHandler = void 0;
+    this.mcpAuthHandler = void 0;
     this.userInputHandler = void 0;
     this.elicitationHandler = void 0;
     this.exitPlanModeHandler = void 0;
     this.autoModeSwitchHandler = void 0;
+    this.skillProvider = void 0;
+    this.hooks = void 0;
+    this.traceContextProvider = void 0;
+    this.bearerTokenProviders.clear();
     this.commandHandlers.clear();
     this.canvases.clear();
-    this.factories.clear();
-    for (const controllersForRun of this.factoryAbortControllers.values()) {
+    this.workflows.clear();
+    for (const controllersForRun of this.workflowAbortControllers.values()) {
       for (const controller of controllersForRun.values()) {
         controller.abort();
       }
     }
-    this.factoryAbortControllers.clear();
-    this.transformCallbacks?.clear();
+    this.workflowAbortControllers.clear();
+    this.transformCallbacks = void 0;
+    delete this.clientSessionApis.providerToken;
+    delete this.clientSessionApis.canvas;
+    delete this.clientSessionApis.workflow;
+    delete this.clientSessionApis.sessionFs;
+    this._runOnDisconnected();
   }
   /** @internal */
   _runOnDisconnected() {
-    this.onDisconnected?.();
+    const callback = this.onDisconnected;
     this.onDisconnected = void 0;
+    callback?.();
   }
   /** @internal */
   _setOnDisconnected(callback) {
+    this.assertConnected();
     this.onDisconnected = callback;
   }
   on(eventTypeOrHandler, handler) {
+    if (this.disconnected) {
+      throw new Error("Session is disconnected");
+    }
     if (typeof eventTypeOrHandler === "string" && handler) {
       const eventType = eventTypeOrHandler;
       if (!this.typedEventHandlers.has(eventType)) {
@@ -651,7 +815,8 @@ class CopilotSession {
           args,
           handler,
           traceparent,
-          tracestate
+          tracestate,
+          event.agentId || void 0
         );
       }
     } else if (event.type === "external_tool.completed") {
@@ -742,7 +907,7 @@ class CopilotSession {
    * Executes a tool handler and sends the result back via RPC.
    * @internal
    */
-  async _executeToolAndRespond(requestId, toolName, toolCallId, args, handler, traceparent, tracestate) {
+  async _executeToolAndRespond(requestId, toolName, toolCallId, args, handler, traceparent, tracestate, agentId) {
     const controller = new AbortController();
     if (this.disconnected || this.pendingExternalTools.has(requestId)) {
       return;
@@ -780,7 +945,9 @@ class CopilotSession {
         availableTools,
         traceparent,
         tracestate,
-        signal: controller.signal
+        signal: controller.signal,
+        agentId,
+        requestId
       });
       let result;
       if (rawResult == null) {
@@ -941,13 +1108,27 @@ class CopilotSession {
    * @internal This method is typically called internally when creating a session with tools.
    */
   registerTools(tools) {
+    this.assertConnected();
     this.toolHandlers.clear();
     if (!tools) {
       return;
     }
     for (const tool of tools) {
       if (tool.handler) {
-        this.toolHandlers.set(tool.name, tool.handler);
+        const handler = tool.handler;
+        if (tool.name === "apply_patch" && tool.overridesBuiltInTool && (0, import_schema.toJsonSchema)(tool.parameters)?.type === "string") {
+          this.toolHandlers.set(tool.name, (args, invocation) => {
+            if (typeof args === "string") {
+              return handler(args, invocation);
+            }
+            if (typeof args === "object" && args !== null && "input" in args && typeof args.input === "string") {
+              return handler(args.input, invocation);
+            }
+            throw new TypeError("apply_patch string override requires a string input");
+          });
+        } else {
+          this.toolHandlers.set(tool.name, handler);
+        }
       }
     }
   }
@@ -968,6 +1149,7 @@ class CopilotSession {
    * @internal Called by the SDK when creating/resuming a session with `canvases`.
    */
   registerCanvases(canvases) {
+    this.assertConnected();
     this.canvases.clear();
     if (!canvases || canvases.length === 0) {
       delete this.clientSessionApis.canvas;
@@ -1017,46 +1199,47 @@ class CopilotSession {
     };
   }
   /**
-   * Registers factory closures and reverse-RPC handlers for this session.
+   * Registers workflow closures and reverse-RPC handlers for this session.
    *
-   * @param factories - Factory handles declared by the joining extension.
+   * @param workflows - Workflow handles declared by the joining extension.
    * @internal Called by the SDK when an extension joins a session.
    */
-  registerFactories(factories) {
-    this.factories.clear();
-    if (!factories || factories.length === 0) {
-      delete this.clientSessionApis.factory;
+  registerWorkflows(workflows) {
+    this.assertConnected();
+    this.workflows.clear();
+    if (!workflows || workflows.length === 0) {
+      delete this.clientSessionApis.workflow;
       return;
     }
-    for (const handle of factories) {
-      const definition = (0, import_factory.getFactoryDefinition)(handle);
-      if (this.factories.has(definition.meta.name)) {
+    for (const handle of workflows) {
+      const definition = (0, import_workflow.getWorkflowDefinition)(handle);
+      if (this.workflows.has(definition.meta.name)) {
         throw new Error(
-          `Duplicate factory name "${definition.meta.name}". Factory names must be unique within a joinSession call.`
+          `Duplicate workflow name "${definition.meta.name}". Workflow names must be unique within a joinSession call.`
         );
       }
-      this.factories.set(definition.meta.name, definition);
+      this.workflows.set(definition.meta.name, definition);
     }
     const self = this;
-    this.clientSessionApis.factory = {
+    this.clientSessionApis.workflow = {
       async execute(params) {
-        const definition = self.factories.get(params.name);
+        const definition = self.workflows.get(params.name);
         if (!definition) {
-          const message = `No factory registered with name "${params.name}"`;
+          const message = `No workflow registered with name "${params.name}"`;
           throw new import_node.ResponseError(import_node.ErrorCodes.InvalidParams, message, {
-            code: "factory_not_found",
+            code: "workflow_not_found",
             name: params.name
           });
         }
         const controller = new AbortController();
-        let controllersForRun = self.factoryAbortControllers.get(params.runId);
+        let controllersForRun = self.workflowAbortControllers.get(params.runId);
         if (controllersForRun === void 0) {
           controllersForRun = /* @__PURE__ */ new Map();
-          self.factoryAbortControllers.set(params.runId, controllersForRun);
+          self.workflowAbortControllers.set(params.runId, controllersForRun);
         }
         controllersForRun.set(params.executionToken, controller);
-        const progress = new FactoryProgressBuffer(async (lines) => {
-          await self.rpc.factory.log({
+        const progress = new WorkflowProgressBuffer(async (lines) => {
+          await self.rpc.workflow.log({
             runId: params.runId,
             executionToken: params.executionToken,
             lines
@@ -1069,22 +1252,22 @@ class CopilotSession {
             session: self,
             signal: controller.signal,
             phase: (title) => {
-              throwIfFactoryAborted(controller.signal);
+              throwIfWorkflowAborted(controller.signal);
               progress.enqueue("phase", title);
             },
             log: (message) => {
-              throwIfFactoryAborted(controller.signal);
+              throwIfWorkflowAborted(controller.signal);
               progress.enqueue("log", message);
             },
             agent: async (prompt, options = {}) => {
               await progress.flush();
               const opts = {};
-              for (const key of import_factory.FACTORY_AGENT_OPTION_KEYS) {
-                copyDefinedFactoryAgentOption(options, opts, key);
+              for (const key of import_workflow.WORKFLOW_AGENT_OPTION_KEYS) {
+                copyDefinedWorkflowAgentOption(options, opts, key);
               }
-              const response = await awaitFactoryOperation(
-                () => self.rpc.factory.agent({
-                  factoryRunId: params.runId,
+              const response = await awaitWorkflowOperation(
+                () => self.rpc.workflow.agent({
+                  workflowRunId: params.runId,
                   executionToken: params.executionToken,
                   prompt,
                   opts
@@ -1096,11 +1279,11 @@ class CopilotSession {
             step: async (key, producer, options = {}) => {
               await progress.flush();
               if (options.volatile) {
-                throwIfFactoryAborted(controller.signal);
+                throwIfWorkflowAborted(controller.signal);
                 return producer();
               }
-              const cached = await awaitFactoryOperation(
-                () => self.rpc.factory.journal.get({
+              const cached = await awaitWorkflowOperation(
+                () => self.rpc.workflow.journal.get({
                   runId: params.runId,
                   executionToken: params.executionToken,
                   key
@@ -1113,13 +1296,13 @@ class CopilotSession {
                     `step("${key}") journal returned a hit without a result`
                   );
                 }
-                assertFactoryStepResult(cached.resultJson, key);
+                assertWorkflowStepResult(cached.resultJson, key);
                 return cached.resultJson;
               }
               const result2 = await producer();
-              assertFactoryStepResult(result2, key);
-              await awaitFactoryOperation(
-                () => self.rpc.factory.journal.put({
+              assertWorkflowStepResult(result2, key);
+              await awaitWorkflowOperation(
+                () => self.rpc.workflow.journal.put({
                   runId: params.runId,
                   executionToken: params.executionToken,
                   key,
@@ -1131,17 +1314,17 @@ class CopilotSession {
             },
             pause: async (key) => {
               if (typeof key !== "string" || key.length === 0) {
-                throw new Error("Factory pause checkpoint key must not be empty");
+                throw new Error("Workflow pause checkpoint key must not be empty");
               }
-              const helperScope = factoryExecutionStore.getStore()?.helperScope;
+              const helperScope = workflowExecutionStore.getStore()?.helperScope;
               if (helperScope !== void 0) {
                 throw new Error(
-                  `Factory pause checkpoints are not allowed inside ${helperScope}() branches`
+                  `Workflow pause checkpoints are not allowed inside ${helperScope}() branches`
                 );
               }
               await progress.flush();
-              const response = await awaitFactoryOperation(
-                () => self.internalRpc.factory.pauseAtCheckpoint({
+              const response = await awaitWorkflowOperation(
+                () => self.internalRpc.workflow.pauseAtCheckpoint({
                   runId: params.runId,
                   executionToken: params.executionToken,
                   key
@@ -1152,21 +1335,21 @@ class CopilotSession {
                 case "continue":
                   return;
                 case "pause":
-                  await awaitFactoryOperation(
+                  await awaitWorkflowOperation(
                     () => new Promise(() => {
                     }),
                     controller.signal
                   );
               }
             },
-            parallel: runFactoryParallel,
-            pipeline: runFactoryPipeline,
-            factory: async () => {
-              throw new Error("nested factories are not supported");
+            parallel: runWorkflowParallel,
+            pipeline: runWorkflowPipeline,
+            workflow: async () => {
+              throw new Error("nested workflows are not supported");
             }
           };
           const execution = { active: true };
-          const result = await factoryExecutionStore.run(execution, async () => {
+          const result = await workflowExecutionStore.run(execution, async () => {
             try {
               return await definition.run(context);
             } finally {
@@ -1176,27 +1359,27 @@ class CopilotSession {
           if (result === void 0) {
             return {};
           }
-          assertFactoryResult(result);
+          assertWorkflowResult(result);
           return { result };
         } finally {
           try {
             await progress.close();
           } finally {
-            const controllersForRun2 = self.factoryAbortControllers.get(params.runId);
+            const controllersForRun2 = self.workflowAbortControllers.get(params.runId);
             if (controllersForRun2?.get(params.executionToken) === controller) {
               controllersForRun2.delete(params.executionToken);
               if (controllersForRun2.size === 0) {
-                self.factoryAbortControllers.delete(params.runId);
+                self.workflowAbortControllers.delete(params.runId);
               }
             }
           }
         }
       },
       async abort(params) {
-        const controllersForRun = self.factoryAbortControllers.get(params.runId);
+        const controllersForRun = self.workflowAbortControllers.get(params.runId);
         const controller = controllersForRun?.get(params.executionToken);
         if (controller !== void 0) {
-          controller.abort(new DOMException("Factory run was aborted", "AbortError"));
+          controller.abort(new DOMException("Workflow run was aborted", "AbortError"));
         }
         return {};
       }
@@ -1215,6 +1398,7 @@ class CopilotSession {
    * @internal This method is called internally when creating/resuming a session.
    */
   registerBearerTokenProviders(providers) {
+    this.assertConnected();
     this.bearerTokenProviders.clear();
     if (!providers || providers.size === 0) {
       delete this.clientSessionApis.providerToken;
@@ -1226,6 +1410,7 @@ class CopilotSession {
     const self = this;
     this.clientSessionApis.providerToken = {
       async getToken(params) {
+        self.assertConnected();
         const callback = self.bearerTokenProviders.get(params.providerName);
         if (!callback) {
           throw new Error(
@@ -1247,6 +1432,7 @@ class CopilotSession {
    * @internal This method is typically called internally when creating/resuming a session.
    */
   registerCommands(commands) {
+    this.assertConnected();
     this.commandHandlers.clear();
     if (!commands) {
       return;
@@ -1262,6 +1448,7 @@ class CopilotSession {
    * @internal This method is typically called internally when creating/resuming a session.
    */
   registerElicitationHandler(handler) {
+    this.assertConnected();
     this.elicitationHandler = handler;
   }
   /**
@@ -1271,6 +1458,7 @@ class CopilotSession {
    * @internal This method is typically called internally when creating/resuming a session.
    */
   registerExitPlanModeHandler(handler) {
+    this.assertConnected();
     this.exitPlanModeHandler = handler;
   }
   /**
@@ -1280,6 +1468,7 @@ class CopilotSession {
    * @internal This method is typically called internally when creating/resuming a session.
    */
   registerAutoModeSwitchHandler(handler) {
+    this.assertConnected();
     this.autoModeSwitchHandler = handler;
   }
   /**
@@ -1318,6 +1507,7 @@ class CopilotSession {
    * @internal
    */
   async _handleExitPlanModeRequest(request) {
+    this.assertConnected();
     if (!this.exitPlanModeHandler) {
       return { approved: true };
     }
@@ -1328,6 +1518,7 @@ class CopilotSession {
    * @internal
    */
   async _handleAutoModeSwitchRequest(request) {
+    this.assertConnected();
     if (!this.autoModeSwitchHandler) {
       return "no";
     }
@@ -1439,6 +1630,7 @@ class CopilotSession {
    * @internal This method is typically called internally when creating a session.
    */
   registerPermissionHandler(handler) {
+    this.assertConnected();
     this.permissionHandler = handler;
   }
   /**
@@ -1451,8 +1643,73 @@ class CopilotSession {
    * @internal This method is typically called internally when creating a session.
    */
   registerUserInputHandler(handler) {
+    this.assertConnected();
     this.userInputHandler = handler;
   }
+  /**
+   * Registers the session's skill provider.
+   *
+   * @param provider - The skill provider, or undefined to remove it
+   * @internal This method is typically called internally when creating a session.
+   */
+  registerSkillProvider(provider) {
+    this.assertConnected();
+    this.skillProvider = provider;
+  }
+  /**
+   * Handles a `skillProvider.list` request from the runtime.
+   *
+   * @internal This method is for internal use by the SDK.
+   */
+  async _handleSkillProviderList(token) {
+    const provider = this.requireSkillProvider();
+    return await this.callSkillProvider("listSkills", token, async (options) => ({
+      skills: await provider.listSkills(options) ?? []
+    }));
+  }
+  /**
+   * Handles a `skillProvider.read` request from the runtime.
+   *
+   * @internal This method is for internal use by the SDK.
+   */
+  async _handleSkillProviderRead(name, token) {
+    const provider = this.requireSkillProvider();
+    return await this.callSkillProvider("readSkill", token, async (options) => ({
+      markdown: await provider.readSkill(name, options) ?? null
+    }));
+  }
+  requireSkillProvider() {
+    this.assertConnected();
+    if (!this.skillProvider) {
+      throw new Error(`No skill provider for session: ${this.sessionId}`);
+    }
+    return this.skillProvider;
+  }
+  /**
+   * Runs a provider call with an abort signal tied to the runtime's request
+   * cancellation. Failures are logged locally and reported generically.
+   */
+  async callSkillProvider(operation, token, call) {
+    const controller = new AbortController();
+    const subscription = token?.onCancellationRequested(() => controller.abort());
+    if (token?.isCancellationRequested) {
+      controller.abort();
+    }
+    try {
+      return await call({ signal: controller.signal });
+    } catch (error) {
+      if (controller.signal.aborted) {
+        throw new import_node.ResponseError(-32800, `Skill provider ${operation} cancelled`);
+      }
+      console.error(`Skill provider ${operation} failed`, {
+        sessionId: this.sessionId,
+        error
+      });
+      throw skillProviderFailure(operation);
+    } finally {
+      subscription?.dispose();
+    }
+  }
   /**
    * Registers hook handlers for session lifecycle events.
    *
@@ -1463,6 +1720,7 @@ class CopilotSession {
    * @internal This method is typically called internally when creating a session.
    */
   registerHooks(hooks) {
+    this.assertConnected();
     this.hooks = hooks;
   }
   /**
@@ -1472,6 +1730,7 @@ class CopilotSession {
    * @internal This method is typically called internally when creating a session.
    */
   registerTransformCallbacks(callbacks) {
+    this.assertConnected();
     this.transformCallbacks = callbacks;
   }
   /**
@@ -1483,6 +1742,7 @@ class CopilotSession {
    * @internal This method is for internal use by the SDK.
    */
   async _handleSystemMessageTransform(sections) {
+    this.assertConnected();
     const result = {};
     for (const [sectionId, { content }] of Object.entries(sections)) {
       const callback = this.transformCallbacks?.get(sectionId);
@@ -1507,6 +1767,7 @@ class CopilotSession {
    * @internal This method is for internal use by the SDK.
    */
   async _handleUserInputRequest(request) {
+    this.assertConnected();
     if (!this.userInputHandler) {
       throw new Error("User input requested but no handler registered");
     }
@@ -1528,6 +1789,7 @@ class CopilotSession {
    * @internal This method is for internal use by the SDK.
    */
   async _handleHooksInvoke(hookType, input) {
+    this.assertConnected();
     if (!this.hooks) {
       return void 0;
     }
@@ -1542,7 +1804,9 @@ class CopilotSession {
       sessionStart: this.hooks.onSessionStart,
       sessionEnd: this.hooks.onSessionEnd,
       errorOccurred: this.hooks.onErrorOccurred,
-      agentStop: this.hooks.onAgentStop
+      agentStop: this.hooks.onAgentStop,
+      subagentStart: this.hooks.onSubagentStart,
+      subagentStop: this.hooks.onSubagentStop
     };
     const handler = handlerMap[hookType];
     if (!handler) {
@@ -1706,6 +1970,62 @@ class CopilotSession {
   async setAutoTier(autoTier) {
     return await this.rpc.model.switchAutoTier({ autoTier });
   }
+  /**
+   * Replace the tools this client supplies to the session.
+   *
+   * `tools` becomes the complete set of tools this client implements,
+   * replacing the ones it supplied when the session was created or resumed,
+   * or in an earlier call. Built-in, MCP, and plugin tools, and tools other
+   * connected clients supply, are unaffected. Pass an empty array to remove
+   * all of this client's tools.
+   *
+   * Tools are defined the same way as for `createSession`: calls to tools
+   * with a `handler` are dispatched to it, and tools without one are
+   * declaration-only. Once the runtime accepts the replacement, every tool
+   * call this session dispatches uses the new handlers; calls already
+   * running finish on their original handlers. If the runtime rejects the
+   * replacement, this rejects and the previous tools and handlers stay in
+   * place. Concurrent calls on the same session are applied one at a time,
+   * in the order they are made.
+   *
+   * The agent sees the new tools from its next model request, which can fall
+   * within a turn in progress. A model request already in flight was made
+   * with the previous tools, so the agent can still call a tool you removed.
+   * This session doesn't answer that call, and it can stay pending until the
+   * turn is aborted. If a running turn might still call a tool you remove,
+   * replace tools while the session is idle.
+   *
+   * @param tools - The complete set of tools this client supplies
+   * @throws Error if the session disconnects before the replacement is applied
+   *
+   * @experimental Wraps the experimental `session.tools.set` RPC and may change
+   * or be removed in a future release.
+   *
+   * @example
+   * ```typescript
+   * await session.setTools([
+   *     defineTool("search_issues", {
+   *         description: "Search the issues shown on the current page",
+   *         parameters: z.object({ query: z.string() }),
+   *         handler: async ({ query }) => searchIssues(query),
+   *     }),
+   * ]);
+   * ```
+   */
+  async setTools(tools) {
+    this.assertConnected();
+    const definitions = tools.map(toToolDefinition);
+    const replacement = this.setToolsQueue.then(async () => {
+      this.assertConnected();
+      await this.rpc.tools.set({ tools: definitions });
+      this.registerTools(tools);
+    });
+    this.setToolsQueue = replacement.then(
+      () => void 0,
+      () => void 0
+    );
+    await replacement;
+  }
   /**
    * Log a message to the session timeline.
    * The message appears in the session event stream and is visible to SDK consumers
@@ -1751,6 +2071,9 @@ function toCanvasRpcError(error) {
   const message = error instanceof Error ? error.message : String(error);
   return new import_node.ResponseError(import_node.ErrorCodes.InternalError, message, { code, message });
 }
+function skillProviderFailure(operation) {
+  return new import_node.ResponseError(import_node.ErrorCodes.InternalError, `Skill provider ${operation} failed`);
+}
 function strictJsonValidationError(context, category, message, path) {
   return new import_node.ResponseError(import_node.ErrorCodes.InternalError, message, {
     code: context.code,
@@ -1882,17 +2205,17 @@ function assertStrictJson(value, context) {
   };
   visit(value, "$", context.allowTopLevelUndefined);
 }
-function assertFactoryResult(value) {
+function assertWorkflowResult(value) {
   assertStrictJson(value, {
-    code: "factory_result_not_json",
-    label: "Factory result",
+    code: "workflow_result_not_json",
+    label: "Workflow result",
     allowTopLevelUndefined: true
   });
 }
-function assertFactoryStepResult(value, key) {
+function assertWorkflowStepResult(value, key) {
   assertStrictJson(value, {
-    code: "factory_step_not_json",
-    label: `Factory step "${key}" result`,
+    code: "workflow_step_not_json",
+    label: `Workflow step "${key}" result`,
     allowTopLevelUndefined: false
   });
 }