@github/copilot-sdk 1.0.15-unstable.35395657398.gad69ee1 → 1.0.15

package/dist/cjs/{factory.js → workflow.js}

@@ -16,26 +16,26 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var factory_exports = {};
-__export(factory_exports, {
-  FACTORY_AGENT_OPTION_KEYS: () => FACTORY_AGENT_OPTION_KEYS,
-  FactoryResumeError: () => FactoryResumeError,
-  defineFactory: () => defineFactory,
-  getFactoryDefinition: () => getFactoryDefinition,
-  isFactoryRunTerminal: () => isFactoryRunTerminal
+var workflow_exports = {};
+__export(workflow_exports, {
+  WORKFLOW_AGENT_OPTION_KEYS: () => WORKFLOW_AGENT_OPTION_KEYS,
+  WorkflowResumeError: () => WorkflowResumeError,
+  defineWorkflow: () => defineWorkflow,
+  getWorkflowDefinition: () => getWorkflowDefinition,
+  isWorkflowRunTerminal: () => isWorkflowRunTerminal
 });
-module.exports = __toCommonJS(factory_exports);
-const FACTORY_TERMINAL_STATUSES = /* @__PURE__ */ new Set([
+module.exports = __toCommonJS(workflow_exports);
+const WORKFLOW_TERMINAL_STATUSES = /* @__PURE__ */ new Set([
   "completed",
   "halted",
   "paused",
   "cancelled",
   "error"
 ]);
-function isFactoryRunTerminal(status) {
-  return FACTORY_TERMINAL_STATUSES.has(status);
+function isWorkflowRunTerminal(status) {
+  return WORKFLOW_TERMINAL_STATUSES.has(status);
 }
-const FACTORY_AGENT_OPTION_KEYS = [
+const WORKFLOW_AGENT_OPTION_KEYS = [
   "label",
   "schema",
   "model",
@@ -43,16 +43,16 @@ const FACTORY_AGENT_OPTION_KEYS = [
   "contextTier",
   "agent"
 ];
-class FactoryResumeError extends Error {
+class WorkflowResumeError extends Error {
   constructor(code, message) {
     super(message);
     this.code = code;
-    this.name = "FactoryResumeError";
+    this.name = "WorkflowResumeError";
   }
   code;
 }
-const factoryHandles = /* @__PURE__ */ new WeakMap();
-const MAX_FACTORY_TIMEOUT_SECONDS = 2147483647e-3;
+const workflowHandles = /* @__PURE__ */ new WeakMap();
+const MAX_WORKFLOW_TIMEOUT_SECONDS = 2147483647e-3;
 const NANO_AIU_PER_AIU = 1e9;
 function deepFreeze(value) {
   if (value !== null && typeof value === "object" && !Object.isFrozen(value)) {
@@ -71,24 +71,24 @@ function validateLimits(meta) {
   for (const field of ["maxConcurrentSubagents", "maxTotalSubagents"]) {
     const value = limits[field];
     if (value !== void 0 && (!Number.isInteger(value) || value <= 0)) {
-      throw new Error(`Factory limit "${field}" must be a positive integer`);
+      throw new Error(`Workflow limit "${field}" must be a positive integer`);
     }
   }
   if (limits.timeoutSeconds !== void 0 && (!Number.isFinite(limits.timeoutSeconds) || limits.timeoutSeconds <= 0)) {
     throw new Error(
-      'Factory limit "timeoutSeconds" must be a positive, finite number of seconds'
+      'Workflow limit "timeoutSeconds" must be a positive, finite number of seconds'
     );
   }
-  if (limits.timeoutSeconds !== void 0 && limits.timeoutSeconds > MAX_FACTORY_TIMEOUT_SECONDS) {
+  if (limits.timeoutSeconds !== void 0 && limits.timeoutSeconds > MAX_WORKFLOW_TIMEOUT_SECONDS) {
     throw new Error(
-      `Factory limit "timeoutSeconds" must not exceed ${MAX_FACTORY_TIMEOUT_SECONDS} seconds`
+      `Workflow limit "timeoutSeconds" must not exceed ${MAX_WORKFLOW_TIMEOUT_SECONDS} seconds`
     );
   }
   if (limits.maxAiCredits !== void 0) {
     const maxNanoAiu = Math.round(limits.maxAiCredits * NANO_AIU_PER_AIU);
     if (!Number.isFinite(limits.maxAiCredits) || limits.maxAiCredits <= 0 || !Number.isSafeInteger(maxNanoAiu) || maxNanoAiu < 1) {
       throw new Error(
-        'Factory limit "maxAiCredits" must be a positive, finite number that rounds to a safe positive integer nano-AIU ceiling'
+        'Workflow limit "maxAiCredits" must be a positive, finite number that rounds to a safe positive integer nano-AIU ceiling'
       );
     }
   }
@@ -97,15 +97,15 @@ function validatePhases(meta) {
   const titles = /* @__PURE__ */ new Set();
   for (const phase of meta.phases) {
     if (phase.title.trim().length === 0) {
-      throw new Error("Factory phase titles must not be empty");
+      throw new Error("Workflow phase titles must not be empty");
     }
     if (titles.has(phase.title)) {
-      throw new Error(`Factory phase title "${phase.title}" is declared more than once`);
+      throw new Error(`Workflow phase title "${phase.title}" is declared more than once`);
     }
     titles.add(phase.title);
   }
 }
-function defineFactory(definition) {
+function defineWorkflow(definition) {
   const meta = deepFreeze(structuredClone(definition.meta));
   validateLimits(meta);
   validatePhases(meta);
@@ -114,21 +114,21 @@ function defineFactory(definition) {
     run: definition.run
   };
   const handle = Object.freeze({ meta });
-  factoryHandles.set(handle, stored);
+  workflowHandles.set(handle, stored);
   return handle;
 }
-function getFactoryDefinition(handle) {
-  const definition = factoryHandles.get(handle);
+function getWorkflowDefinition(handle) {
+  const definition = workflowHandles.get(handle);
   if (!definition) {
-    throw new Error("Invalid factory handle");
+    throw new Error("Invalid workflow handle");
   }
   return definition;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  FACTORY_AGENT_OPTION_KEYS,
-  FactoryResumeError,
-  defineFactory,
-  getFactoryDefinition,
-  isFactoryRunTerminal
+  WORKFLOW_AGENT_OPTION_KEYS,
+  WorkflowResumeError,
+  defineWorkflow,
+  getWorkflowDefinition,
+  isWorkflowRunTerminal
 });

package/dist/cliVersion.d.ts

@@ -1,2 +1,2 @@
-export declare const COPILOT_CLI_VERSION = "1.0.86-unstable.r35389812552.g657d1e5";
+export declare const COPILOT_CLI_VERSION = "1.0.89";
 export declare const COPILOT_CLI_USE_NPM_PACKAGE = false;

package/dist/cliVersion.js

@@ -1,4 +1,4 @@
-const COPILOT_CLI_VERSION = "1.0.86-unstable.r35389812552.g657d1e5";
+const COPILOT_CLI_VERSION = "1.0.89";
 const COPILOT_CLI_USE_NPM_PACKAGE = false;
 export {
   COPILOT_CLI_USE_NPM_PACKAGE,

package/dist/client.d.ts

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

package/dist/client.js

@@ -22,6 +22,9 @@ import { ensureRuntimeBundle } from "./runtimeArtifacts.js";
 import { COPILOT_CLI_VERSION } from "./cliVersion.js";
 import { createSessionFsAdapter } from "./sessionFsProvider.js";
 import { createCopilotRequestAdapter } from "./copilotRequestHandler.js";
+import {
+  createInstallationConfirmationAdapter
+} from "./installationConfirmation.js";
 import { getTraceContext } from "./telemetry.js";
 import { toJsonSchema } from "./schema.js";
 import { ToolSet } from "./toolSet.js";
@@ -204,6 +207,7 @@ class CopilotClient {
   cliProcess = null;
   ffiHost = null;
   connection = null;
+  requestAdapter = null;
   messageWriter = null;
   connectionClosed = false;
   socket = null;
@@ -241,6 +245,8 @@ class CopilotClient {
   /** Connection-level session filesystem config, set via constructor option. */
   sessionFsConfig = null;
   requestHandler = null;
+  extensionLaunchProvider;
+  installationConfirmationHandler;
   builtinPluginDirectories = [];
   onGitHubTelemetry;
   clientGlobalHandlers = {};
@@ -398,6 +404,8 @@ class CopilotClient {
     this.onGetTraceContext = options.onGetTraceContext;
     this.sessionFsConfig = options.sessionFs ?? null;
     this.requestHandler = options.requestHandler ?? null;
+    this.extensionLaunchProvider = options.extensionLaunchProvider;
+    this.installationConfirmationHandler = options.installationConfirmationHandler;
     this.onGitHubTelemetry = options.onGitHubTelemetry;
     this.setupClientGlobalHandlers();
     const connEnv = conn.kind === "stdio" || conn.kind === "tcp" ? conn.env : void 0;
@@ -500,14 +508,16 @@ class CopilotClient {
   }
   setupClientGlobalHandlers() {
     const handlers = {};
+    handlers.extensionLaunchProvider = this.extensionLaunchProvider;
     if (this.requestHandler) {
-      handlers.llmInference = createCopilotRequestAdapter(this.requestHandler, () => {
+      this.requestAdapter = createCopilotRequestAdapter(this.requestHandler, () => {
         if (!this.connection) {
           return void 0;
         }
         this._rpc ??= createServerRpc(this.connection);
         return this._rpc;
       });
+      handlers.llmInference = this.requestAdapter;
     }
     if (this.onGitHubTelemetry) {
       const onGitHubTelemetry = this.onGitHubTelemetry;
@@ -612,6 +622,9 @@ class CopilotClient {
       }
       await this.connectToServer();
       await this.verifyProtocolVersion();
+      if (this.extensionLaunchProvider) {
+        await this.rpc.registerExtensionLaunchProvider();
+      }
       if (this.builtinPluginDirectories.length > 0) {
         try {
           await this.connection.sendRequest("plugins.builtin.set", {
@@ -700,6 +713,7 @@ class CopilotClient {
     }
     this.sessions.clear();
     this.githubTokenProviders.clear();
+    this.requestAdapter?.cancelPending();
     if (this.connection && !this.connectionClosed && (this.cliProcess || this.ffiHost) && !this.isExternalServer) {
       const runtimeShutdownStart = Date.now();
       const shutdownPromise = this.rpc.runtime.shutdown();
@@ -855,6 +869,7 @@ class CopilotClient {
     }
     this.sessions.clear();
     this.githubTokenProviders.clear();
+    this.requestAdapter?.cancelPending();
     if (this.messageWriter) {
       this.messageWriter.suppressWriteErrors = true;
     }
@@ -1205,6 +1220,7 @@ class CopilotClient {
         includeSubAgentStreamingEvents: config.includeSubAgentStreamingEvents ?? true,
         ...this.onGitHubTelemetry != null ? { enableGitHubTelemetryForwarding: true } : {},
         mcpServers: toWireMcpServers(config.mcpServers),
+        ...config.diagnostics !== void 0 ? { diagnostics: config.diagnostics } : {},
         mcpOAuthTokenStorage: config.mcpOAuthTokenStorage,
         authClientIdMetadataUrl: config.authClientIdMetadataUrl,
         envValueMode: "direct",
@@ -1214,6 +1230,7 @@ class CopilotClient {
         agent: config.agent,
         configDir: config.configDirectory,
         enableConfigDiscovery: config.enableConfigDiscovery,
+        refreshCustomInstructions: config.refreshCustomInstructions,
         skipEmbeddingRetrieval: config.skipEmbeddingRetrieval,
         embeddingCacheStorage: config.embeddingCacheStorage,
         organizationCustomInstructions: config.organizationCustomInstructions,
@@ -1306,10 +1323,11 @@ class CopilotClient {
     return this.resumeSessionInternal(sessionId, config);
   }
   /** @internal */
-  async resumeSessionForExtension(sessionId, config, factories, extensionOptions) {
-    return this.resumeSessionInternal(sessionId, config, factories, extensionOptions);
+  async resumeSessionForExtension(sessionId, config, contributions = {}, extensionOptions) {
+    return this.resumeSessionInternal(sessionId, config, contributions, extensionOptions);
   }
-  async resumeSessionInternal(sessionId, config, factories, extensionOptions) {
+  async resumeSessionInternal(sessionId, config, contributions = {}, extensionOptions) {
+    const { workflows } = contributions;
     if (config.gitHubToken !== void 0 && config.gitHubTokenProvider !== void 0) {
       throw new Error("gitHubToken and gitHubTokenProvider are mutually exclusive");
     }
@@ -1329,7 +1347,7 @@ class CopilotClient {
     session.registerTools(config.tools);
     session.registerCanvases(config.canvases);
     session.registerCommands(config.commands);
-    session.registerFactories(factories);
+    session.registerWorkflows(workflows);
     const {
       wireProvider: bearerWireProvider,
       wireProviders: bearerWireProviders,
@@ -1410,7 +1428,7 @@ class CopilotClient {
         })),
         toolSearch: config.toolSearch,
         canvases: config.canvases?.map((canvas) => canvas.declaration),
-        factories: factories?.map((factory) => factory.meta),
+        workflows: workflows?.map((workflow) => workflow.meta),
         requestCanvasRenderer: config.requestCanvasRenderer,
         requestExtensions: config.requestExtensions,
         extensionSdkPath: config.extensionSdkPath,
@@ -1451,6 +1469,7 @@ class CopilotClient {
         includeSubAgentStreamingEvents: config.includeSubAgentStreamingEvents ?? true,
         ...this.onGitHubTelemetry != null ? { enableGitHubTelemetryForwarding: true } : {},
         mcpServers: toWireMcpServers(config.mcpServers),
+        ...config.diagnostics !== void 0 ? { diagnostics: config.diagnostics } : {},
         mcpOAuthTokenStorage: config.mcpOAuthTokenStorage,
         authClientIdMetadataUrl: config.authClientIdMetadataUrl,
         envValueMode: "direct",
@@ -1871,6 +1890,9 @@ class CopilotClient {
     if (this.options.mode === "empty") {
       env.COPILOT_DISABLE_KEYTAR = "1";
     }
+    if (this.options.mode !== "empty") {
+      env.COPILOT_RUNTIME_PROCESS_FILE_LOGGING = "1";
+    }
     if (this.options.telemetry) {
       const t = this.options.telemetry;
       env.COPILOT_OTEL_ENABLED = "true";
@@ -2245,6 +2267,16 @@ stderr: ${stderrOutput}` : ""}`
       return session.clientSessionApis;
     });
     registerClientGlobalApiHandlers(this.connection, this.clientGlobalHandlers);
+    if (this.installationConfirmationHandler) {
+      const confirmation = createInstallationConfirmationAdapter(
+        this.connection,
+        this.installationConfirmationHandler
+      );
+      this.connection.onRequest(
+        "installations.confirm",
+        (params, token) => confirmation.confirm(params, token)
+      );
+    }
     this.connection.onRequest(
       "hooks.invoke",
       async (params) => {
@@ -2263,6 +2295,7 @@ stderr: ${stderrOutput}` : ""}`
       }
       this.sessions.clear();
       this.githubTokenProviders.clear();
+      this.requestAdapter?.cancelPending();
     };
     this.connection.onClose(markDisconnected);
     this.connection.onError(() => {

package/dist/copilotRequestHandler.js

@@ -1,5 +1,6 @@
 const sharedTextDecoder = new TextDecoder("utf-8", { fatal: false });
 const sharedTextEncoder = new TextEncoder();
+const HTTP_RESPONSE_READ_AHEAD_BYTES = 32 * 1024;
 const kBridge = /* @__PURE__ */ Symbol("copilotWebSocketResponseBridge");
 const kCompletion = /* @__PURE__ */ Symbol("copilotWebSocketCompletion");
 const kOpen = /* @__PURE__ */ Symbol("copilotWebSocketOpen");
@@ -238,7 +239,9 @@ function createCopilotRequestAdapter(handler, getServerRpc) {
       const message = err instanceof Error ? err.message : String(err);
       await finalize(exchange, 502, message);
     } finally {
-      pending.delete(exchange.requestId);
+      if (pending.get(exchange.requestId) === exchange) {
+        pending.delete(exchange.requestId);
+      }
     }
   }
   return {
@@ -251,6 +254,13 @@ function createCopilotRequestAdapter(handler, getServerRpc) {
     async httpRequestChunk(params) {
       routeChunk(getOrCreate(params.requestId), params);
       return {};
+    },
+    cancelPending() {
+      const exchanges = [...pending.values()];
+      pending.clear();
+      for (const exchange of exchanges) {
+        exchange.pushCancel("RPC connection closed");
+      }
     }
   };
 }
@@ -499,30 +509,156 @@ async function drainAsync(stream) {
   return out;
 }
 async function streamResponse(response, exchange) {
-  await exchange.startResponse({
-    status: response.status,
-    statusText: response.statusText || void 0,
-    headers: headersToMultiMap(response.headers)
-  });
-  const body = response.body;
-  if (!body) {
-    await exchange.endResponse();
-    return;
-  }
-  const reader = body.getReader();
+  const reader = response.body ? new HttpResponseReader(response.body, exchange.signal) : void 0;
   try {
-    for (; ; ) {
-      const { value, done } = await reader.read();
-      if (done) {
-        break;
-      }
-      if (value && value.byteLength > 0) {
-        await exchange.writeResponse(value);
+    await exchange.startResponse({
+      status: response.status,
+      statusText: response.statusText || void 0,
+      headers: headersToMultiMap(response.headers)
+    });
+    if (reader) {
+      for (; ; ) {
+        const chunk = await reader.nextChunk();
+        if (!chunk) {
+          break;
+        }
+        await exchange.writeResponse(chunk);
       }
     }
     await exchange.endResponse();
   } finally {
-    reader.releaseLock();
+    await reader?.dispose();
+  }
+}
+class HttpResponseReader {
+  #reader;
+  #signal;
+  #frames = [];
+  #pump;
+  #onAbort;
+  #queued = 0;
+  #done = false;
+  #cancelled = false;
+  #hasError = false;
+  #error;
+  #dataWaker;
+  #spaceWaker;
+  #cancelPromise;
+  constructor(body, signal) {
+    this.#reader = body.getReader();
+    this.#signal = signal;
+    this.#onAbort = () => {
+      void this.cancel(signal.reason);
+    };
+    signal.addEventListener("abort", this.#onAbort, { once: true });
+    this.#pump = this.#pumpSource();
+    if (signal.aborted) {
+      this.#onAbort();
+    }
+  }
+  async nextChunk() {
+    while (this.#frames.length === 0 && !this.#done && !this.#hasError) {
+      await new Promise((resolve) => {
+        this.#dataWaker = resolve;
+      });
+    }
+    if (this.#frames.length > 0) {
+      const chunk = this.#takeQueued();
+      this.#wakeSpace();
+      return chunk;
+    }
+    if (this.#hasError) {
+      this.#hasError = false;
+      throw this.#error;
+    }
+    return void 0;
+  }
+  #takeQueued() {
+    const frames = this.#frames;
+    const total = this.#queued;
+    this.#queued = 0;
+    if (frames.length === 1) {
+      return frames.pop();
+    }
+    const chunk = new Uint8Array(total);
+    let offset = 0;
+    for (const frame of frames) {
+      chunk.set(frame, offset);
+      offset += frame.byteLength;
+    }
+    frames.length = 0;
+    return chunk;
+  }
+  async dispose() {
+    this.#signal.removeEventListener("abort", this.#onAbort);
+    if (!this.#done) {
+      await this.cancel();
+    } else if (this.#cancelPromise) {
+      await this.#cancelPromise;
+    }
+    await this.#pump;
+  }
+  cancel(reason) {
+    if (this.#done) {
+      return Promise.resolve();
+    }
+    if (!this.#cancelPromise) {
+      this.#cancelled = true;
+      this.#done = true;
+      this.#hasError = true;
+      this.#error = reason instanceof Error ? reason : new Error("HTTP response body cancelled.");
+      this.#frames.length = 0;
+      this.#queued = 0;
+      this.#wakeData();
+      this.#wakeSpace();
+      this.#cancelPromise = this.#reader.cancel(reason).catch(() => void 0);
+    }
+    return this.#cancelPromise;
+  }
+  async #pumpSource() {
+    try {
+      while (!this.#cancelled) {
+        while (this.#queued >= HTTP_RESPONSE_READ_AHEAD_BYTES && !this.#cancelled) {
+          await new Promise((resolve) => {
+            this.#spaceWaker = resolve;
+          });
+        }
+        if (this.#cancelled) {
+          return;
+        }
+        const { value, done } = await this.#reader.read();
+        if (done) {
+          return;
+        }
+        if (value.byteLength > 0) {
+          this.#frames.push(value);
+          this.#queued += value.byteLength;
+          this.#wakeData();
+          continue;
+        }
+        await new Promise((resolve) => setImmediate(resolve));
+      }
+    } catch (error) {
+      if (!this.#cancelled) {
+        this.#hasError = true;
+        this.#error = error;
+      }
+    } finally {
+      this.#done = true;
+      this.#wakeData();
+      this.#wakeSpace();
+      this.#reader.releaseLock();
+    }
+  }
+  #wakeData() {
+    const waker = this.#dataWaker;
+    this.#dataWaker = void 0;
+    waker?.();
+  }
+  #wakeSpace() {
+    const waker = this.#spaceWaker;
+    this.#spaceWaker = void 0;
+    waker?.();
   }
 }
 function headersToMultiMap(headers) {

package/dist/extension.d.ts

@@ -1,6 +1,6 @@
 import type { CopilotSession } from "./session.js";
 import { type PermissionHandler, type ResumeSessionConfig } from "./types.js";
-import type { FactoryHandle } from "./factory.js";
+import type { WorkflowHandle } from "./workflow.js";
 export { Canvas, CanvasError, createCanvas, type CanvasAction, type CanvasDeclaration, type CanvasHostContext, type CanvasJsonSchema, type CanvasOptions, } from "./canvas.js";
 export type JoinSessionConfig = Omit<ResumeSessionConfig, "onPermissionRequest" | "extensionSdkPath"> & {
     onPermissionRequest?: PermissionHandler;
@@ -34,15 +34,15 @@ export type JoinSessionConfig = Omit<ResumeSessionConfig, "onPermissionRequest"
      */
     requestedEnvironmentVariables?: string[];
     /**
-     * Factory handles to register when the extension joins the session.
+     * Workflow handles to register when the extension joins the session.
      *
-     * @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.
      */
-    factories?: FactoryHandle[];
+    workflows?: WorkflowHandle[];
 };
-export type { ExtensionInfo, FactoryLimits, FactoryMeta } from "./types.js";
-export { defineFactory, FactoryResumeError, isFactoryRunTerminal, type RunOptions, type ResumeOptions, type FactoryResumeErrorCode, type SessionFactoryApi, type FactoryAgentOptions, type FactoryContext, type FactoryDefinition, type FactoryHandle, type FactoryJsonSchema, type JsonValue, type FactoryPipelineStage, type FactoryStepOptions, type FactoryRunResult, type FactoryRunStatus, type FactoryRunSummary, type FactoryListRunsOptions, type FactoryRunsPage, type FactoryRunDetail, type FactoryProgressPage, type FactoryProgressLine, type FactoryPhaseObservation, type FactoryPhaseStatus, type FactoryAgentSummary, } from "./factory.js";
+export type { ExtensionInfo } from "./types.js";
+export { defineWorkflow, WorkflowResumeError, isWorkflowRunTerminal, type WorkflowRunOptions, type WorkflowResumeOptions, type WorkflowLimitOverrides, type WorkflowResumeErrorCode, type SessionWorkflowApi, type WorkflowAgentOptions, type WorkflowContext, type WorkflowDefinition, type WorkflowHandle, type JsonValue, type WorkflowJsonSchema, type WorkflowLimits, type WorkflowMeta, type WorkflowPipelineStage, type WorkflowStepOptions, type WorkflowRunResult, type WorkflowRunStatus, type WorkflowRunSummary, type WorkflowListRunsOptions, type WorkflowRunsPage, type WorkflowRunDetail, type WorkflowProgressPage, type WorkflowProgressLine, type WorkflowPhaseObservation, type WorkflowPhaseStatus, type WorkflowAgentSummary, } from "./workflow.js";
 /**
  * Joins the current foreground session.
  *

package/dist/extension.js

@@ -8,10 +8,10 @@ import {
   createCanvas
 } from "./canvas.js";
 import {
-  defineFactory,
-  FactoryResumeError,
-  isFactoryRunTerminal
-} from "./factory.js";
+  defineWorkflow,
+  WorkflowResumeError,
+  isWorkflowRunTerminal
+} from "./workflow.js";
 async function joinSession(config = {}) {
   const sessionId = process.env.SESSION_ID;
   if (!sessionId) {
@@ -22,7 +22,7 @@ async function joinSession(config = {}) {
   const client = new CopilotClient({ _internalConnection: { kind: "parent-process" } });
   const {
     extensionSdkPath: _stripped,
-    factories,
+    workflows,
     requestedEnvironmentVariables,
     ...rest
   } = config;
@@ -34,16 +34,16 @@ async function joinSession(config = {}) {
       onPermissionRequest: config.onPermissionRequest ?? defaultJoinSessionPermissionHandler,
       suppressResumeEvent: config.suppressResumeEvent ?? true
     },
-    factories,
+    { workflows },
     requestedEnvironmentVariables?.length ? { requestedEnvironmentVariables } : void 0
   );
 }
 export {
   Canvas,
   CanvasError,
-  FactoryResumeError,
+  WorkflowResumeError,
   createCanvas,
-  defineFactory,
-  isFactoryRunTerminal,
+  defineWorkflow,
+  isWorkflowRunTerminal,
   joinSession
 };