@github/copilot-sdk 1.0.15-unstable.35663726336.gcb2a8cc → 1.0.15

package/dist/session.js

@@ -6,31 +6,31 @@ import { getTraceContext } from "./telemetry.js";
 import { isResponseSchema, toJsonSchema } from "./schema.js";
 import { isAttributedPermissionResult } from "./types.js";
 import {
-  FACTORY_AGENT_OPTION_KEYS,
-  getFactoryDefinition,
-  FactoryResumeError,
-  isFactoryRunTerminal
-} from "./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";
+  WORKFLOW_AGENT_OPTION_KEYS,
+  getWorkflowDefinition,
+  WorkflowResumeError,
+  isWorkflowRunTerminal
+} from "./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 AsyncLocalStorage();
-function throwIfFactoryExecutionIsActive() {
-  if (factoryExecutionStore.getStore()?.active) {
+const workflowExecutionStore = new 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") {
@@ -54,20 +54,20 @@ function isOpenCanvasInstance(value) {
 }
 const FACTORY_LOG_FLUSH_DELAY_MS = 10;
 const MAX_FACTORY_FANOUT_ITEMS = 4096;
-function assertFactoryFanoutSize(kind, size) {
+function assertWorkflowFanoutSize(kind, size) {
   if (size > MAX_FACTORY_FANOUT_ITEMS) {
     throw new Error(
       `${kind}() accepts at most ${MAX_FACTORY_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(...)"
@@ -75,8 +75,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;
@@ -84,22 +84,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;
@@ -109,7 +109,7 @@ async function runFactoryPipeline(items, ...stages) {
     })
   );
 }
-class FactoryProgressBuffer {
+class WorkflowProgressBuffer {
   constructor(send) {
     this.send = send;
   }
@@ -123,7 +123,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();
@@ -155,7 +155,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
       );
     }
@@ -164,7 +164,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
         );
       }
@@ -188,30 +188,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 ResponseError || error instanceof ConnectionError;
+function isWorkflowFatalError(error) {
+  return isWorkflowAbortError(error) || error instanceof ResponseError || error instanceof ConnectionError;
 }
 const TOOL_SEARCH_TOOL_NAME = "tool_search_tool";
 class CopilotSession {
@@ -243,8 +243,8 @@ class CopilotSession {
   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;
@@ -266,23 +266,16 @@ class CopilotSession {
   /** @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 : 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 : getWorkflowDefinition(nameOrHandle).meta.name;
+      const envelope = await this.rpc.workflow.run({
         name,
         args: options?.args === void 0 ? {} : options.args,
         options: {
@@ -291,13 +284,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,
@@ -306,43 +299,36 @@ class CopilotSession {
       } catch (error) {
         if (error instanceof ResponseError && typeof error.data === "object" && error.data !== null) {
           const code = error.data.code;
-          if (isFactoryResumeErrorCode(code)) {
-            throw new FactoryResumeError(code, error.message);
+          if (isWorkflowResumeErrorCode(code)) {
+            throw new 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 (isFactoryRunTerminal(envelope.status)) {
+  settleWorkflowRun(envelope) {
+    if (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
@@ -351,8 +337,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());
     }
@@ -389,8 +375,8 @@ class CopilotSession {
         try {
           do {
             rereadRequested = false;
-            const envelope = await this.rpc.factory.getRun({ runId });
-            if (isFactoryRunTerminal(envelope.status)) {
+            const envelope = await this.rpc.workflow.getRun({ runId });
+            if (isWorkflowRunTerminal(envelope.status)) {
               finish(() => resolve(envelope));
               return;
             }
@@ -405,7 +391,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();
         }
@@ -531,6 +517,7 @@ class CopilotSession {
     });
     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") {
@@ -670,13 +657,13 @@ class CopilotSession {
     this.autoModeSwitchHandler = void 0;
     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.workflowAbortControllers.clear();
     this.transformCallbacks?.clear();
   }
   /** @internal */
@@ -1125,46 +1112,46 @@ 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.workflows.clear();
+    if (!workflows || workflows.length === 0) {
+      delete this.clientSessionApis.workflow;
       return;
     }
-    for (const handle of factories) {
-      const definition = getFactoryDefinition(handle);
-      if (this.factories.has(definition.meta.name)) {
+    for (const handle of workflows) {
+      const definition = 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 ResponseError(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
@@ -1177,22 +1164,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 FACTORY_AGENT_OPTION_KEYS) {
-                copyDefinedFactoryAgentOption(options, opts, key);
+              for (const key of 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
@@ -1204,11 +1191,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
@@ -1221,13 +1208,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,
@@ -1239,17 +1226,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
@@ -1260,21 +1247,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 {
@@ -1284,27 +1271,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 {};
       }
@@ -1990,17 +1977,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
   });
 }