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

package/dist/session.js

@@ -3,6 +3,7 @@ import { ConnectionError, ErrorCodes, ResponseError } from "vscode-jsonrpc/node.
 import { createInternalSessionRpc, createSessionRpc } from "./generated/rpc.js";
 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,
@@ -10,6 +11,12 @@ import {
   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";
 }
@@ -19,6 +26,15 @@ function copyDefinedFactoryAgentOption(source, target, key) {
     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";
+}
+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) {
@@ -27,6 +43,18 @@ function throwIfFactoryExecutionIsActive() {
     );
   }
 }
+const workflowExecutionStore = new AsyncLocalStorage();
+function throwIfWorkflowExecutionIsActive() {
+  if (workflowExecutionStore.getStore()?.active) {
+    throw new Error(
+      "workflow.run, workflow.resume, and workflow.pause are not allowed while a workflow body is running on this call path."
+    );
+  }
+}
+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);
@@ -108,6 +136,54 @@ async function runFactoryPipeline(items, ...stages) {
     })
   );
 }
+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);
+  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(() => runInWorkflowHelperScope("parallel", thunk)).catch((error) => {
+        if (isFactoryFatalError(error)) {
+          throw error;
+        }
+        return null;
+      })
+    )
+  );
+}
+async function runWorkflowPipeline(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 runInWorkflowHelperScope(
+            "pipeline",
+            () => stage(previous, item, index)
+          );
+        } catch (error) {
+          if (isFactoryFatalError(error)) {
+            throw error;
+          }
+          return null;
+        }
+      }
+      return previous;
+    })
+  );
+}
 class FactoryProgressBuffer {
   constructor(send) {
     this.send = send;
@@ -187,6 +263,85 @@ class FactoryProgressBuffer {
     }
   }
 }
+class WorkflowProgressBuffer {
+  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 workflow 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 workflow progress flush failure after the workflow body settled",
+        this.flushError
+      );
+    }
+    if (lines.length > 0) {
+      try {
+        await this.send(lines);
+      } catch (error) {
+        console.warn(
+          "Failed to flush final workflow progress after the workflow 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;
+    }
+  }
+}
 async function awaitFactoryOperation(operation, signal) {
   let rejectAbort;
   const abortPromise = new Promise((_resolve, reject) => {
@@ -201,11 +356,19 @@ async function awaitFactoryOperation(operation, signal) {
     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) {
   return typeof error === "object" && error !== null && "name" in error && error.name === "AbortError";
 }
@@ -244,6 +407,8 @@ class CopilotSession {
   commandHandlers = /* @__PURE__ */ new Map();
   factories = /* @__PURE__ */ new Map();
   factoryAbortControllers = /* @__PURE__ */ new Map();
+  workflows = /* @__PURE__ */ new Map();
+  workflowAbortControllers = /* @__PURE__ */ new Map();
   permissionHandler;
   mcpAuthHandler;
   userInputHandler;
@@ -259,6 +424,7 @@ class CopilotSession {
   _capabilities = {};
   openCanvasInstances = [];
   disconnected = false;
+  pendingStructuredWaits = /* @__PURE__ */ new Set();
   disconnecting = false;
   onDisconnected;
   /** @internal Client session API handlers, populated by CopilotClient during create/resume. */
@@ -326,6 +492,56 @@ class CopilotSession {
     },
     cancel: async (runId) => this.rpc.factory.cancel({ runId })
   };
+  workflow = {
+    run: (async (nameOrHandle, options) => {
+      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: {
+          limits: options?.limits,
+          notifyOnComplete: options?.notifyOnComplete,
+          logPhaseNames: options?.logPhaseNames
+        }
+      });
+      return this.settleWorkflowRun(envelope);
+    }),
+    resume: (async (runId, options) => {
+      throwIfWorkflowExecutionIsActive();
+      let response;
+      try {
+        response = await this.rpc.workflow.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 (isWorkflowResumeErrorCode(code)) {
+            throw new WorkflowResumeError(code, error.message);
+          }
+        }
+        throw error;
+      }
+      return this.settleWorkflowRun(response.run);
+    }),
+    getRun: async (runId) => this.rpc.workflow.getRun({ runId }),
+    waitForRun: (runId, options) => this.waitForWorkflowRun(runId, options?.signal),
+    listRuns: (async (options) => {
+      const page = await this.rpc.workflow.listRuns(options ?? {});
+      return options === void 0 ? page.runs : page;
+    }),
+    getRunDetail: (runId) => this.rpc.workflow.getRunDetail({ runId }),
+    getRunProgress: (runId, options = {}) => this.rpc.workflow.getRunProgress({ runId, ...options }),
+    pause: async (runId) => {
+      throwIfWorkflowExecutionIsActive();
+      return this.rpc.workflow.pause({ runId });
+    },
+    cancel: async (runId) => this.rpc.workflow.cancel({ runId })
+  };
   /**
    * Resolve a start/resume envelope into the terminal envelope callers expect.
    *
@@ -413,6 +629,86 @@ class CopilotSession {
       void read();
     });
   }
+  settleWorkflowRun(envelope) {
+    if (isWorkflowRunTerminal(envelope.status)) {
+      return Promise.resolve(envelope);
+    }
+    return this.waitForWorkflowRun(envelope.runId);
+  }
+  /**
+   * 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
+   * 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.
+   */
+  waitForWorkflowRun(runId, signal) {
+    const abortError = () => signal?.reason ?? new DOMException("Workflow 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.workflow.getRun({ runId });
+            if (isWorkflowRunTerminal(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();
+    });
+  }
   /**
    * Typed session-scoped RPC methods.
    */
@@ -475,13 +771,54 @@ class CopilotSession {
       attachments: options.attachments,
       mode: options.mode,
       agentMode: options.agentMode,
-      requestHeaders: options.requestHeaders
+      requestHeaders: options.requestHeaders,
+      ...options.responseSchema ? {
+        responseFormat: {
+          type: "json_schema",
+          jsonSchema: {
+            name: "response",
+            strict: true,
+            schema: 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 = 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;
@@ -523,12 +860,95 @@ class CopilotSession {
       unsubscribe();
     }
   }
+  async sendAndWaitForStructuredMessage(options, timeout) {
+    if (this.disconnected) {
+      throw new Error("Session is disconnected");
+    }
+    let resolveOutcome;
+    const outcomePromise = new Promise((resolve) => {
+      resolveOutcome = resolve;
+    });
+    const fail = (error) => resolveOutcome({ kind: "error", error });
+    let messageId;
+    let consumed = false;
+    let lastMessage;
+    const buffered = [];
+    const observe = (event) => {
+      if (event.agentId) return;
+      if (event.type === "user.message" && event.data.messageId === messageId) {
+        consumed = true;
+      } else if (event.type === "assistant.message" && event.data.originatingMessageId === messageId) {
+        consumed = true;
+        lastMessage = event.data.toolRequests?.length ? void 0 : event;
+      } else if (consumed && event.type === "session.idle" && event.data.mode !== "autopilot") {
+        if (event.data.aborted) {
+          fail(
+            new Error(
+              "The requested run was aborted before a structured result was completed."
+            )
+          );
+        } else {
+          resolveOutcome({ kind: "idle", message: lastMessage });
+        }
+      } else if (consumed && event.type === "session.error") {
+        const error = new Error(event.data.message);
+        error.stack = event.data.stack;
+        fail(error);
+      }
+    };
+    const unsubscribe = this.on((event) => {
+      if (event.type !== "user.message" && event.type !== "assistant.message" && event.type !== "session.idle" && event.type !== "session.error") {
+        return;
+      }
+      if (messageId === void 0) {
+        buffered.push(event);
+      } else {
+        observe(event);
+      }
+    });
+    this.pendingStructuredWaits.add(fail);
+    const timer = setTimeout(
+      () => fail(new Error(`Timeout after ${timeout}ms waiting for the structured response`)),
+      timeout
+    );
+    try {
+      const sendOutcome = this.send(options).then(
+        (id) => {
+          if (!id) {
+            throw new Error(
+              "The runtime did not return a message ID for the structured send."
+            );
+          }
+          messageId = id;
+          for (const event of buffered) observe(event);
+          buffered.length = 0;
+          return outcomePromise;
+        },
+        (error) => ({
+          kind: "error",
+          error: error instanceof Error ? error : new Error(String(error))
+        })
+      );
+      const outcome = await Promise.race([sendOutcome, outcomePromise]);
+      if (outcome.kind === "error") throw outcome.error;
+      return outcome.message;
+    } finally {
+      clearTimeout(timer);
+      buffered.length = 0;
+      unsubscribe();
+      this.pendingStructuredWaits.delete(fail);
+    }
+  }
   /** @internal */
   _markDisconnected() {
     if (this.disconnected) {
       return;
     }
     this.disconnected = true;
+    for (const fail of this.pendingStructuredWaits) {
+      fail(new Error("Session disconnected while waiting for a structured response"));
+    }
+    this.pendingStructuredWaits.clear();
     for (const controller of this.pendingExternalTools.values()) {
       controller.abort();
     }
@@ -551,6 +971,13 @@ class CopilotSession {
       }
     }
     this.factoryAbortControllers.clear();
+    this.workflows.clear();
+    for (const controllersForRun of this.workflowAbortControllers.values()) {
+      for (const controller of controllersForRun.values()) {
+        controller.abort();
+      }
+    }
+    this.workflowAbortControllers.clear();
     this.transformCallbacks?.clear();
   }
   /** @internal */
@@ -1184,6 +1611,192 @@ class CopilotSession {
       }
     };
   }
+  /**
+   * Registers workflow closures and reverse-RPC handlers for this session.
+   *
+   * @param workflows - Workflow handles declared by the joining extension.
+   * @internal Called by the SDK when an extension joins a session.
+   */
+  registerWorkflows(workflows) {
+    this.workflows.clear();
+    if (!workflows || workflows.length === 0) {
+      delete this.clientSessionApis.workflow;
+      return;
+    }
+    for (const handle of workflows) {
+      const definition = getWorkflowDefinition(handle);
+      if (this.workflows.has(definition.meta.name)) {
+        throw new Error(
+          `Duplicate workflow name "${definition.meta.name}". Workflow names must be unique within a joinSession call.`
+        );
+      }
+      this.workflows.set(definition.meta.name, definition);
+    }
+    const self = this;
+    this.clientSessionApis.workflow = {
+      async execute(params) {
+        const definition = self.workflows.get(params.name);
+        if (!definition) {
+          const message = `No workflow registered with name "${params.name}"`;
+          throw new ResponseError(ErrorCodes.InvalidParams, message, {
+            code: "workflow_not_found",
+            name: params.name
+          });
+        }
+        const controller = new AbortController();
+        let controllersForRun = self.workflowAbortControllers.get(params.runId);
+        if (controllersForRun === void 0) {
+          controllersForRun = /* @__PURE__ */ new Map();
+          self.workflowAbortControllers.set(params.runId, controllersForRun);
+        }
+        controllersForRun.set(params.executionToken, controller);
+        const progress = new WorkflowProgressBuffer(async (lines) => {
+          await self.rpc.workflow.log({
+            runId: params.runId,
+            executionToken: params.executionToken,
+            lines
+          });
+        });
+        try {
+          const context = {
+            runId: params.runId,
+            args: params.args,
+            session: self,
+            signal: controller.signal,
+            phase: (title) => {
+              throwIfWorkflowAborted(controller.signal);
+              progress.enqueue("phase", title);
+            },
+            log: (message) => {
+              throwIfWorkflowAborted(controller.signal);
+              progress.enqueue("log", message);
+            },
+            agent: async (prompt, options = {}) => {
+              await progress.flush();
+              const opts = {};
+              for (const key of WORKFLOW_AGENT_OPTION_KEYS) {
+                copyDefinedWorkflowAgentOption(options, opts, key);
+              }
+              const response = await awaitWorkflowOperation(
+                () => self.rpc.workflow.agent({
+                  workflowRunId: params.runId,
+                  executionToken: params.executionToken,
+                  prompt,
+                  opts
+                }),
+                controller.signal
+              );
+              return response.result ?? null;
+            },
+            step: async (key, producer, options = {}) => {
+              await progress.flush();
+              if (options.volatile) {
+                throwIfWorkflowAborted(controller.signal);
+                return producer();
+              }
+              const cached = await awaitWorkflowOperation(
+                () => self.rpc.workflow.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`
+                  );
+                }
+                assertWorkflowStepResult(cached.resultJson, key);
+                return cached.resultJson;
+              }
+              const result2 = await producer();
+              assertWorkflowStepResult(result2, key);
+              await awaitWorkflowOperation(
+                () => self.rpc.workflow.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("Workflow pause checkpoint key must not be empty");
+              }
+              const helperScope = workflowExecutionStore.getStore()?.helperScope;
+              if (helperScope !== void 0) {
+                throw new Error(
+                  `Workflow pause checkpoints are not allowed inside ${helperScope}() branches`
+                );
+              }
+              await progress.flush();
+              const response = await awaitWorkflowOperation(
+                () => self.internalRpc.workflow.pauseAtCheckpoint({
+                  runId: params.runId,
+                  executionToken: params.executionToken,
+                  key
+                }),
+                controller.signal
+              );
+              switch (response.action) {
+                case "continue":
+                  return;
+                case "pause":
+                  await awaitWorkflowOperation(
+                    () => new Promise(() => {
+                    }),
+                    controller.signal
+                  );
+              }
+            },
+            parallel: runWorkflowParallel,
+            pipeline: runWorkflowPipeline,
+            workflow: async () => {
+              throw new Error("nested workflows are not supported");
+            }
+          };
+          const execution = { active: true };
+          const result = await workflowExecutionStore.run(execution, async () => {
+            try {
+              return await definition.run(context);
+            } finally {
+              execution.active = false;
+            }
+          });
+          if (result === void 0) {
+            return {};
+          }
+          assertWorkflowResult(result);
+          return { result };
+        } finally {
+          try {
+            await progress.close();
+          } finally {
+            const controllersForRun2 = self.workflowAbortControllers.get(params.runId);
+            if (controllersForRun2?.get(params.executionToken) === controller) {
+              controllersForRun2.delete(params.executionToken);
+              if (controllersForRun2.size === 0) {
+                self.workflowAbortControllers.delete(params.runId);
+              }
+            }
+          }
+        }
+      },
+      async abort(params) {
+        const controllersForRun = self.workflowAbortControllers.get(params.runId);
+        const controller = controllersForRun?.get(params.executionToken);
+        if (controller !== void 0) {
+          controller.abort(new DOMException("Workflow run was aborted", "AbortError"));
+        }
+        return {};
+      }
+    };
+  }
   /**
    * Registers per-provider {@link BearerTokenProvider} callbacks for BYOK providers
    * configured with managed-identity / on-demand bearer-token auth.
@@ -1878,6 +2491,20 @@ function assertFactoryStepResult(value, key) {
     allowTopLevelUndefined: false
   });
 }
+function assertWorkflowResult(value) {
+  assertStrictJson(value, {
+    code: "workflow_result_not_json",
+    label: "Workflow result",
+    allowTopLevelUndefined: true
+  });
+}
+function assertWorkflowStepResult(value, key) {
+  assertStrictJson(value, {
+    code: "workflow_step_not_json",
+    label: `Workflow step "${key}" result`,
+    allowTopLevelUndefined: false
+  });
+}
 export {
   CopilotSession
 };