@github/copilot-sdk 1.0.15-preview.3 → 1.0.15-preview.4

package/dist/session.js

@@ -5,27 +5,12 @@ import { CanvasError } from "./canvas.js";
 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";
 import {
   WORKFLOW_AGENT_OPTION_KEYS,
   getWorkflowDefinition,
   WorkflowResumeError,
   isWorkflowRunTerminal
 } from "./workflow.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";
-}
-function copyDefinedFactoryAgentOption(source, target, key) {
-  const value = source[key];
-  if (value !== void 0) {
-    target[key] = value;
-  }
-}
 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";
 }
@@ -35,14 +20,6 @@ function copyDefinedWorkflowAgentOption(source, target, key) {
     target[key] = value;
   }
 }
-const factoryExecutionStore = new AsyncLocalStorage();
-function throwIfFactoryExecutionIsActive() {
-  if (factoryExecutionStore.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."
-    );
-  }
-}
 const workflowExecutionStore = new AsyncLocalStorage();
 function throwIfWorkflowExecutionIsActive() {
   if (workflowExecutionStore.getStore()?.active) {
@@ -55,10 +32,6 @@ function runInWorkflowHelperScope(helperScope, callback) {
   const current = workflowExecutionStore.getStore();
   return workflowExecutionStore.run({ active: current?.active ?? false, helperScope }, callback);
 }
-function runInFactoryHelperScope(helperScope, callback) {
-  const current = factoryExecutionStore.getStore();
-  return factoryExecutionStore.run({ active: current?.active ?? false, helperScope }, callback);
-}
 function deserializeHookInput(raw) {
   if (!raw || typeof raw !== "object" || typeof raw.timestamp !== "number") {
     return raw;
@@ -81,68 +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) {
-  if (!Array.isArray(thunks)) {
-    throw new Error(
-      "parallel() expects an array of functions, not promises. Wrap each call: () => agent(...)"
-    );
-  }
-  assertFactoryFanoutSize("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(...)"
-    );
-  }
-  return Promise.all(
-    thunks.map(
-      (thunk) => Promise.resolve().then(() => runInFactoryHelperScope("parallel", thunk)).catch((error) => {
-        if (isFactoryFatalError(error)) {
-          throw error;
-        }
-        return null;
-      })
-    )
-  );
-}
-async function runFactoryPipeline(items, ...stages) {
-  if (!Array.isArray(items)) {
-    throw new Error("pipeline(items, ...stages): items must be an array");
-  }
-  assertFactoryFanoutSize("pipeline", items.length);
-  return Promise.all(
-    items.map(async (item, index) => {
-      let previous = item;
-      for (const stage of stages) {
-        try {
-          previous = await runInFactoryHelperScope(
-            "pipeline",
-            () => stage(previous, item, index)
-          );
-        } catch (error) {
-          if (isFactoryFatalError(error)) {
-            throw error;
-          }
-          return null;
-        }
-      }
-      return previous;
-    })
-  );
-}
 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(...)"
@@ -151,7 +76,7 @@ async function runWorkflowParallel(thunks) {
   return Promise.all(
     thunks.map(
       (thunk) => Promise.resolve().then(() => runInWorkflowHelperScope("parallel", thunk)).catch((error) => {
-        if (isFactoryFatalError(error)) {
+        if (isWorkflowFatalError(error)) {
           throw error;
         }
         return null;
@@ -163,7 +88,7 @@ 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;
@@ -174,7 +99,7 @@ async function runWorkflowPipeline(items, ...stages) {
             () => stage(previous, item, index)
           );
         } catch (error) {
-          if (isFactoryFatalError(error)) {
+          if (isWorkflowFatalError(error)) {
             throw error;
           }
           return null;
@@ -184,85 +109,6 @@ async function runWorkflowPipeline(items, ...stages) {
     })
   );
 }
-class FactoryProgressBuffer {
-  constructor(send) {
-    this.send = send;
-  }
-  send;
-  nextSeq = 0;
-  pending = [];
-  flushTimer;
-  flushTail = Promise.resolve();
-  flushError;
-  flushFailed = false;
-  closed = false;
-  enqueue(kind, text) {
-    if (this.closed) {
-      throw new Error("Cannot log after the factory run has settled");
-    }
-    this.pending.push({ seq: this.nextSeq++, kind, text });
-    this.scheduleFlush();
-  }
-  async flush() {
-    this.clearFlushTimer();
-    const lines = this.pending.splice(0);
-    if (lines.length > 0) {
-      this.flushTail = this.flushTail.then(async () => {
-        try {
-          await this.send(lines);
-        } catch (error) {
-          if (!this.flushFailed) {
-            this.flushFailed = true;
-            this.flushError = error;
-          }
-        }
-      });
-    }
-    await this.flushTail;
-    if (this.flushFailed) {
-      throw this.flushError;
-    }
-  }
-  async close() {
-    this.closed = true;
-    this.clearFlushTimer();
-    const lines = this.pending.splice(0);
-    await this.flushTail;
-    if (this.flushFailed) {
-      console.warn(
-        "Ignoring a background factory progress flush failure after the factory body settled",
-        this.flushError
-      );
-    }
-    if (lines.length > 0) {
-      try {
-        await this.send(lines);
-      } catch (error) {
-        console.warn(
-          "Failed to flush final factory progress after the factory body settled",
-          error
-        );
-      }
-    }
-  }
-  scheduleFlush() {
-    if (this.flushTimer !== void 0) {
-      return;
-    }
-    this.flushTimer = setTimeout(() => {
-      this.flushTimer = void 0;
-      void this.flush().catch(() => {
-      });
-    }, FACTORY_LOG_FLUSH_DELAY_MS);
-    this.flushTimer.unref?.();
-  }
-  clearFlushTimer() {
-    if (this.flushTimer !== void 0) {
-      clearTimeout(this.flushTimer);
-      this.flushTimer = void 0;
-    }
-  }
-}
 class WorkflowProgressBuffer {
   constructor(send) {
     this.send = send;
@@ -342,38 +188,30 @@ class WorkflowProgressBuffer {
     }
   }
 }
-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);
   }
 }
-async function awaitWorkflowOperation(operation, signal) {
-  return awaitFactoryOperation(operation, signal);
-}
-function throwIfFactoryAborted(signal) {
-  if (signal.aborted) {
-    throw signal.reason ?? new DOMException("Factory run was aborted", "AbortError");
-  }
-}
 function throwIfWorkflowAborted(signal) {
   if (signal.aborted) {
     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 {
@@ -405,8 +243,6 @@ 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;
@@ -430,68 +266,11 @@ 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 = {
-    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({
-        name,
-        args: options?.args === void 0 ? {} : options.args,
-        options: {
-          limits: options?.limits,
-          notifyOnComplete: options?.notifyOnComplete,
-          logPhaseNames: options?.logPhaseNames
-        }
-      });
-      return this.settleFactoryRun(envelope);
-    }),
-    resume: (async (runId, options) => {
-      throwIfFactoryExecutionIsActive();
-      let response;
-      try {
-        response = await this.rpc.factory.resume({
-          runId,
-          limits: options?.limits,
-          notifyOnComplete: options?.notifyOnComplete,
-          logPhaseNames: options?.logPhaseNames
-        });
-      } 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);
-          }
-        }
-        throw error;
-      }
-      return this.settleFactoryRun(response.run);
-    }),
-    getRun: async (runId) => this.rpc.factory.getRun({ runId }),
-    waitForRun: (runId, options) => this.waitForFactoryRun(runId, options?.signal),
-    listRuns: (async (options) => {
-      const page = await this.rpc.factory.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 }),
-    pause: async (runId) => {
-      throwIfFactoryExecutionIsActive();
-      return this.rpc.factory.pause({ runId });
-    },
-    cancel: async (runId) => this.rpc.factory.cancel({ runId })
-  };
   workflow = {
     run: (async (nameOrHandle, options) => {
       throwIfWorkflowExecutionIsActive();
@@ -542,93 +321,6 @@ class CopilotSession {
     },
     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)) {
-      return Promise.resolve(envelope);
-    }
-    return this.waitForFactoryRun(envelope.runId);
-  }
-  /**
-   * Resolve when a factory 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
-   * overlapping invalidation events cannot interleave — the run's revision
-   * advances once per operation, so a burst of events is common and must
-   * 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");
-    if (signal?.aborted === true) {
-      return Promise.reject(abortError());
-    }
-    return new Promise((resolve, reject) => {
-      let settled = false;
-      let reading = false;
-      let rereadRequested = false;
-      let pollHandle;
-      let unsubscribe;
-      let onAbort;
-      const finish = (complete) => {
-        if (settled) {
-          return;
-        }
-        settled = true;
-        if (pollHandle !== void 0) {
-          clearInterval(pollHandle);
-        }
-        unsubscribe?.();
-        if (onAbort !== void 0) {
-          signal?.removeEventListener("abort", onAbort);
-        }
-        complete();
-      };
-      const read = async () => {
-        if (settled) {
-          return;
-        }
-        if (reading) {
-          rereadRequested = true;
-          return;
-        }
-        reading = true;
-        try {
-          do {
-            rereadRequested = false;
-            const envelope = await this.rpc.factory.getRun({ runId });
-            if (isFactoryRunTerminal(envelope.status)) {
-              finish(() => resolve(envelope));
-              return;
-            }
-          } while (rereadRequested && !settled);
-        } catch (error) {
-          finish(() => reject(error));
-        } finally {
-          reading = false;
-        }
-      };
-      if (signal !== void 0) {
-        onAbort = () => finish(() => reject(abortError()));
-        signal.addEventListener("abort", onAbort, { once: true });
-      }
-      unsubscribe = this.on("factory.run_updated", (event) => {
-        if (event.data.runId === runId) {
-          void read();
-        }
-      });
-      pollHandle = setInterval(() => void read(), 5e3);
-      pollHandle.unref?.();
-      void read();
-    });
-  }
   settleWorkflowRun(envelope) {
     if (isWorkflowRunTerminal(envelope.status)) {
       return Promise.resolve(envelope);
@@ -699,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();
         }
@@ -965,13 +657,6 @@ class CopilotSession {
     this.autoModeSwitchHandler = void 0;
     this.commandHandlers.clear();
     this.canvases.clear();
-    this.factories.clear();
-    for (const controllersForRun of this.factoryAbortControllers.values()) {
-      for (const controller of controllersForRun.values()) {
-        controller.abort();
-      }
-    }
-    this.factoryAbortControllers.clear();
     this.workflows.clear();
     for (const controllersForRun of this.workflowAbortControllers.values()) {
       for (const controller of controllersForRun.values()) {
@@ -1426,192 +1111,6 @@ class CopilotSession {
       }
     };
   }
-  /**
-   * Registers factory closures and reverse-RPC handlers for this session.
-   *
-   * @param factories - Factory 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;
-      return;
-    }
-    for (const handle of factories) {
-      const definition = getFactoryDefinition(handle);
-      if (this.factories.has(definition.meta.name)) {
-        throw new Error(
-          `Duplicate factory name "${definition.meta.name}". Factory names must be unique within a joinSession call.`
-        );
-      }
-      this.factories.set(definition.meta.name, definition);
-    }
-    const self = this;
-    this.clientSessionApis.factory = {
-      async execute(params) {
-        const definition = self.factories.get(params.name);
-        if (!definition) {
-          const message = `No factory registered with name "${params.name}"`;
-          throw new ResponseError(ErrorCodes.InvalidParams, message, {
-            code: "factory_not_found",
-            name: params.name
-          });
-        }
-        const controller = new AbortController();
-        let controllersForRun = self.factoryAbortControllers.get(params.runId);
-        if (controllersForRun === void 0) {
-          controllersForRun = /* @__PURE__ */ new Map();
-          self.factoryAbortControllers.set(params.runId, controllersForRun);
-        }
-        controllersForRun.set(params.executionToken, controller);
-        const progress = new FactoryProgressBuffer(async (lines) => {
-          await self.rpc.factory.log({
-            runId: params.runId,
-            executionToken: params.executionToken,
-            lines
-          });
-        });
-        try {
-          const context = {
-            runId: params.runId,
-            args: params.args,
-            session: self,
-            signal: controller.signal,
-            phase: (title) => {
-              throwIfFactoryAborted(controller.signal);
-              progress.enqueue("phase", title);
-            },
-            log: (message) => {
-              throwIfFactoryAborted(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);
-              }
-              const response = await awaitFactoryOperation(
-                () => self.rpc.factory.agent({
-                  factoryRunId: params.runId,
-                  executionToken: params.executionToken,
-                  prompt,
-                  opts
-                }),
-                controller.signal
-              );
-              return response.result ?? null;
-            },
-            step: async (key, producer, options = {}) => {
-              await progress.flush();
-              if (options.volatile) {
-                throwIfFactoryAborted(controller.signal);
-                return producer();
-              }
-              const cached = await awaitFactoryOperation(
-                () => self.rpc.factory.journal.get({
-                  runId: params.runId,
-                  executionToken: params.executionToken,
-                  key
-                }),
-                controller.signal
-              );
-              if (cached.hit) {
-                if (cached.resultJson === void 0) {
-                  throw new Error(
-                    `step("${key}") journal returned a hit without a result`
-                  );
-                }
-                assertFactoryStepResult(cached.resultJson, key);
-                return cached.resultJson;
-              }
-              const result2 = await producer();
-              assertFactoryStepResult(result2, key);
-              await awaitFactoryOperation(
-                () => self.rpc.factory.journal.put({
-                  runId: params.runId,
-                  executionToken: params.executionToken,
-                  key,
-                  resultJson: result2
-                }),
-                controller.signal
-              );
-              return result2;
-            },
-            pause: async (key) => {
-              if (typeof key !== "string" || key.length === 0) {
-                throw new Error("Factory pause checkpoint key must not be empty");
-              }
-              const helperScope = factoryExecutionStore.getStore()?.helperScope;
-              if (helperScope !== void 0) {
-                throw new Error(
-                  `Factory pause checkpoints are not allowed inside ${helperScope}() branches`
-                );
-              }
-              await progress.flush();
-              const response = await awaitFactoryOperation(
-                () => self.internalRpc.factory.pauseAtCheckpoint({
-                  runId: params.runId,
-                  executionToken: params.executionToken,
-                  key
-                }),
-                controller.signal
-              );
-              switch (response.action) {
-                case "continue":
-                  return;
-                case "pause":
-                  await awaitFactoryOperation(
-                    () => new Promise(() => {
-                    }),
-                    controller.signal
-                  );
-              }
-            },
-            parallel: runFactoryParallel,
-            pipeline: runFactoryPipeline,
-            factory: async () => {
-              throw new Error("nested factories are not supported");
-            }
-          };
-          const execution = { active: true };
-          const result = await factoryExecutionStore.run(execution, async () => {
-            try {
-              return await definition.run(context);
-            } finally {
-              execution.active = false;
-            }
-          });
-          if (result === void 0) {
-            return {};
-          }
-          assertFactoryResult(result);
-          return { result };
-        } finally {
-          try {
-            await progress.close();
-          } finally {
-            const controllersForRun2 = self.factoryAbortControllers.get(params.runId);
-            if (controllersForRun2?.get(params.executionToken) === controller) {
-              controllersForRun2.delete(params.executionToken);
-              if (controllersForRun2.size === 0) {
-                self.factoryAbortControllers.delete(params.runId);
-              }
-            }
-          }
-        }
-      },
-      async abort(params) {
-        const controllersForRun = self.factoryAbortControllers.get(params.runId);
-        const controller = controllersForRun?.get(params.executionToken);
-        if (controller !== void 0) {
-          controller.abort(new DOMException("Factory run was aborted", "AbortError"));
-        }
-        return {};
-      }
-    };
-  }
   /**
    * Registers workflow closures and reverse-RPC handlers for this session.
    *
@@ -2478,20 +1977,6 @@ function assertStrictJson(value, context) {
   };
   visit(value, "$", context.allowTopLevelUndefined);
 }
-function assertFactoryResult(value) {
-  assertStrictJson(value, {
-    code: "factory_result_not_json",
-    label: "Factory result",
-    allowTopLevelUndefined: true
-  });
-}
-function assertFactoryStepResult(value, key) {
-  assertStrictJson(value, {
-    code: "factory_step_not_json",
-    label: `Factory step "${key}" result`,
-    allowTopLevelUndefined: false
-  });
-}
 function assertWorkflowResult(value) {
   assertStrictJson(value, {
     code: "workflow_result_not_json",