The Open Framework for Building Agents
fix(eve): keep Workflow root-only (#418)
Ruied8a935ed211
diff --git a/.changeset/limit-workflow-runtime-subagents.md b/.changeset/limit-workflow-runtime-subagents.mdnew file mode 100644index 000000000..f4f016176--- /dev/null+++ b/.changeset/limit-workflow-runtime-subagents.md@@ -0,0 +1,5 @@+---+"eve": patch+---++Keep the `Workflow` orchestration tool root-only. Delegated subagent sessions can still call visible subagent tools directly until the configured depth cap, but eve no longer advertises `Workflow` from those child sessions.diff --git a/docs/subagents.mdx b/docs/subagents.mdxindex 7cb8cf342..bffb44210 100644--- a/docs/subagents.mdx+++ b/docs/subagents.mdx@@ -94,6 +94,8 @@ at depths 1 through 4; a session already at depth 4 cannot delegate again.At the configured depth, eve stops advertising subagent tools, including declared local subagents, remote-agent tools, the built-in `agent` tool, and the `Workflow` orchestration tool when it would only expose subagents. If a stale or forced subagent call still reaches execution, eve blocks it and returns an error tool result instead of starting another child session.+`Workflow` is root-only. Delegated subagent sessions can still call their own visible subagent tools until the depth cap, but they do not receive the `Workflow` orchestration wrapper.+A declared subagent's tool name is the bare path-derived name, with no prefix. `agent/subagents/researcher/` registers as the tool `researcher`. Unlike connection tools (`<connection>__<tool>`), it carries no namespace, so the model, approvals, logs, and evals all reference it by that name. Its input schema is:```tsdiff --git a/e2e/fixtures/agent-subagents/evals/runtime-subagent-workflow.eval.ts b/e2e/fixtures/agent-subagents/evals/runtime-subagent-workflow.eval.tsnew file mode 100644index 000000000..d726d34c3--- /dev/null+++ b/e2e/fixtures/agent-subagents/evals/runtime-subagent-workflow.eval.ts@@ -0,0 +1,29 @@+import { defineEval } from "eve/evals";++const CHILD_TOKEN = "CHILD_WORKFLOW_TOOL_NOT_AVAILABLE";++/**+ * Runtime subagent Workflow visibility: the root delegates to the built-in+ * `agent` child, which should not receive the root-only `Workflow` wrapper.+ */+export default defineEval({+ description: "Runtime subagent sessions do not receive the root-only Workflow tool.",+ async test(t) {+ await t.send(+ [+ "Use the built-in agent subagent exactly once.",+ "Give the child this task:",+ "If a Workflow tool is visible, use Workflow exactly once to call echo-marker with message 'subagent workflow probe', then return WORKFLOW_WAS_VISIBLE.",+ `If no Workflow tool is visible, do not call echo-marker or any other subagent. Return exactly ${CHILD_TOKEN}.`,+ `After the child returns, reply with its exact output and no other token.`,+ ].join(" "),+ );++ t.succeeded();+ t.calledSubagent("agent", { count: 1 });+ t.notCalledTool("Workflow");+ t.notEvent("subagent.called", { data: { name: "echo-marker" } });+ t.messageIncludes(CHILD_TOKEN);+ t.noFailedActions();+ },+});diff --git a/packages/eve/src/evals/assertions/run.test.ts b/packages/eve/src/evals/assertions/run.test.tsindex e9ee68697..538060b37 100644--- a/packages/eve/src/evals/assertions/run.test.ts+++ b/packages/eve/src/evals/assertions/run.test.ts@@ -76,6 +76,33 @@ function actionResult(callId: string, toolName: string): HandleMessageStreamEven};}+function failedSubagentResult(input: {+ callId: string;+ output: unknown;+ subagentName: string;+}): HandleMessageStreamEvent {+ return {+ type: "action.result",+ data: {+ error: {+ code: "SUBAGENT_DEPTH_LIMIT",+ message: "Subagent depth limit reached",+ },+ result: {+ callId: input.callId,+ isError: true,+ kind: "subagent-result",+ output: input.output as never,+ subagentName: input.subagentName,+ },+ sequence: 2,+ status: "failed",+ stepIndex: 0,+ turnId: "t1",+ },+ };+}+describe("run assertions", () => {it("succeeded passes a clean run and fails a failed or parked run", async () => {expect((await Run.succeeded().evaluate(makeResult({ status: "completed" }))).score).toBe(1);@@ -214,6 +241,27 @@ describe("run assertions", () => {expect((await Run.toolOrder(["step-a"]).evaluate(result)).score).toBe(0);});+ it("noFailedActions includes failed action details", async () => {+ const outcome = await Run.noFailedActions().evaluate(+ makeResult({+ events: [+ failedSubagentResult({+ callId: "call-a",+ output: "Subagent recursion stopped before LEVEL_4_REACHED",+ subagentName: "agent",+ }),+ ],+ }),+ );++ expect(outcome.score).toBe(0);+ expect(outcome.message).toContain("subagent-result");+ expect(outcome.message).toContain("agent");+ expect(outcome.message).toContain("call-a");+ expect(outcome.message).toContain("Subagent depth limit reached");+ expect(outcome.message).toContain("Subagent recursion stopped");+ });+it("matches typed event counts and ordered event groups", async () => {const called = {type: "subagent.called",diff --git a/packages/eve/src/evals/assertions/run.ts b/packages/eve/src/evals/assertions/run.tsindex e2aa87837..28313d02e 100644--- a/packages/eve/src/evals/assertions/run.ts+++ b/packages/eve/src/evals/assertions/run.ts@@ -204,10 +204,16 @@ export function noFailedActions(): RunAssertion {(evt.data.status === "failed" || evt.data.result.isError === true),);if (failed.length === 0) return PASS;- const names = failed.map((evt) =>- evt.data.result.kind === "tool-result" ? evt.data.result.toolName : evt.data.result.kind,- );- return fail(`${failed.length} failed action(s): ${names.join(", ")}`);+ const details = failed.map(formatFailedActionResult);+ return fail(`${failed.length} failed action(s): ${details.join("; ")}`, {+ failedActions: failed.map((evt) => ({+ callId: evt.data.result.callId,+ error: evt.data.error,+ kind: evt.data.result.kind,+ output: evt.data.result.output,+ status: evt.data.status,+ })),+ });},};}@@ -371,6 +377,34 @@ function failureDetail(prefix: string, code: string | undefined): string {return code === undefined ? prefix : `${prefix} (code: ${code})`;}+function formatFailedActionResult(+ event: Extract<HandleMessageStreamEvent, { type: "action.result" }>,+): string {+ const { result, status } = event.data;+ const parts = [+ actionResultLabel(result),+ `callId=${result.callId}`,+ `status=${status}`,+ result.isError === true ? "isError=true" : undefined,+ event.data.error?.message === undefined ? undefined : `error=${event.data.error.message}`,+ `output=${truncate(formatUnknown(result.output))}`,+ ];+ return parts.filter((part) => part !== undefined).join(" ");+}++function actionResultLabel(+ result: Extract<HandleMessageStreamEvent, { type: "action.result" }>["data"]["result"],+): string {+ switch (result.kind) {+ case "tool-result":+ return `tool-result:${result.toolName}`;+ case "subagent-result":+ return `subagent-result:${result.subagentName}`;+ case "load-skill-result":+ return result.name === undefined ? "load-skill-result" : `load-skill-result:${result.name}`;+ }+}+function runFailure(result: EveEvalAssertionSubject): AssertionOutcome | undefined {if (result.status === "failed") {return fail(failureDetail("run failed", result.derived.failureCode));@@ -389,6 +423,16 @@ function truncate(text: string | undefined, max = 200): string {return text.length <= max ? text : `${text.slice(0, max)}…`;}+function formatUnknown(value: unknown): string | undefined {+ if (value === undefined) return undefined;+ if (typeof value === "string") return value;+ try {+ return JSON.stringify(value);+ } catch {+ return String(value);+ }+}+function validateCount(count: number | undefined): void {if (count !== undefined && (!Number.isInteger(count) || count < 0)) {throw new TypeError(`Assertion count must be a non-negative integer; received ${count}.`);diff --git a/packages/eve/src/harness/advertised-tools.test.ts b/packages/eve/src/harness/advertised-tools.test.tsindex 50c98bbff..df1851fe6 100644--- a/packages/eve/src/harness/advertised-tools.test.ts+++ b/packages/eve/src/harness/advertised-tools.test.ts@@ -4,7 +4,9 @@ import { describe, expect, it } from "vitest";import { getAdvertisedTools } from "#harness/advertised-tools.js";import { DEFAULT_SUBAGENT_MAX_DEPTH } from "#harness/subagent-depth.js";import type { HarnessToolDefinition } from "#harness/execute-tool.js";-import type { HarnessToolMap } from "#harness/types.js";+import type { HarnessSession, HarnessToolMap } from "#harness/types.js";+import { buildToolSet } from "#harness/tools.js";+import { WORKFLOW_TOOL_NAME } from "#shared/workflow-sandbox.js";describe("getAdvertisedTools", () => {it("keeps subagent tools below the subagent depth limit", () => {@@ -68,6 +70,51 @@ describe("getAdvertisedTools", () => {expect([...belowCustomLimit.keys()]).toEqual(["add", "delegate"]);expect([...atCustomLimit.keys()]).toEqual(["add"]);});++ it("keeps direct subagent tools in runtime subagent sessions below the depth limit", () => {+ const tools = new Map([+ ["add", createTool("add")],+ ["delegate", createSubagentTool("delegate")],+ ]) satisfies HarnessToolMap;++ const advertisedTools = getAdvertisedTools({+ session: { rootSessionId: "root-session", subagentDepth: 1 },+ tools,+ });++ expect([...advertisedTools.keys()]).toEqual(["add", "delegate"]);+ });++ it("does not add Workflow in runtime subagent sessions", async () => {+ const tools = new Map([["delegate", createSubagentTool("delegate")]]) satisfies HarnessToolMap;++ const advertisedTools = await getAdvertisedTools({+ modelTools: buildToolSet({ tools }),+ session: createSession({ rootSessionId: "root-session", subagentDepth: 1 }),+ tools,+ workflow: {},+ });++ expect(Object.keys(advertisedTools.modelTools)).toEqual(["delegate"]);+ expect(advertisedTools.modelTools[WORKFLOW_TOOL_NAME]).toBeUndefined();+ });++ it("adds Workflow in root sessions below the depth limit", async () => {+ const tools = new Map([+ ["add", createTool("add")],+ ["delegate", createSubagentTool("delegate")],+ ]) satisfies HarnessToolMap;++ const advertisedTools = await getAdvertisedTools({+ modelTools: buildToolSet({ tools }),+ session: createSession(),+ tools,+ workflow: {},+ });++ expect([...advertisedTools.harnessTools.keys()]).toEqual(["add", "delegate"]);+ expect(advertisedTools.modelTools[WORKFLOW_TOOL_NAME]).toBeDefined();+ });});describe("getAdvertisedTools for definition arrays", () => {@@ -99,3 +146,18 @@ function createSubagentTool(name: string): HarnessToolDefinition {},};}++function createSession(overrides: Partial<HarnessSession> = {}): HarnessSession {+ return {+ agent: {+ modelReference: { id: "test-model" },+ system: "",+ tools: [],+ },+ compaction: { recentWindowSize: 4, threshold: 1_000_000 },+ continuationToken: "test-token",+ history: [],+ sessionId: "test-session",+ ...overrides,+ };+}diff --git a/packages/eve/src/harness/advertised-tools.ts b/packages/eve/src/harness/advertised-tools.tsindex 6044a0e7b..03b202d7c 100644--- a/packages/eve/src/harness/advertised-tools.ts+++ b/packages/eve/src/harness/advertised-tools.ts@@ -1,18 +1,53 @@+import type { ToolSet } from "ai";import type { HarnessToolDefinition } from "#harness/execute-tool.js";import { resolveSubagentDelegationLimit } from "#harness/subagent-depth.js";+import {+ ensureWorkflowContinuationSecurity,+ getWorkflowContinuationSecurity,+} from "#harness/workflow-continuation-security.js";+import { applyWorkflowTool } from "#harness/workflow-sandbox.js";import type { HarnessSession, HarnessToolMap } from "#harness/types.js";+import type { WorkflowSandboxLifecycle } from "#shared/workflow-sandbox.js";++type AdvertisedToolSession = Pick<+ HarnessSession,+ "rootSessionId" | "subagentDepth" | "subagentMaxDepth"+>;type AdvertisedToolMapInput = {- readonly session: Pick<HarnessSession, "subagentDepth" | "subagentMaxDepth">;+ readonly session: AdvertisedToolSession;readonly tools: HarnessToolMap;};type AdvertisedToolDefinitionsInput = {- readonly session: Pick<HarnessSession, "subagentDepth" | "subagentMaxDepth">;+ readonly session: AdvertisedToolSession;readonly tools: readonly HarnessToolDefinition[];};-type AdvertisedToolsInput = AdvertisedToolMapInput | AdvertisedToolDefinitionsInput;+type AdvertisedModelToolsInput = {+ readonly modelTools: ToolSet;+ readonly session: HarnessSession;+ readonly tools: HarnessToolMap;+ readonly workflow?: {+ readonly lifecycle?: (input: {+ readonly session: HarnessSession;+ readonly tools: HarnessToolMap;+ }) => WorkflowSandboxLifecycle | undefined;+ };+};++type AdvertisedModelTools = {+ readonly harnessTools: HarnessToolMap;+ readonly modelTools: ToolSet;+ readonly session: HarnessSession;+};++type AdvertisedToolsInput =+ | AdvertisedModelToolsInput+ | AdvertisedToolMapInput+ | AdvertisedToolDefinitionsInput;++export function getAdvertisedTools(input: AdvertisedModelToolsInput): Promise<AdvertisedModelTools>;export function getAdvertisedTools(input: AdvertisedToolMapInput): HarnessToolMap;export function getAdvertisedTools(@@ -20,7 +55,11 @@ export function getAdvertisedTools(): readonly HarnessToolDefinition[];export function getAdvertisedTools(input: AdvertisedToolsInput,-): HarnessToolMap | readonly HarnessToolDefinition[] {+): HarnessToolMap | Promise<AdvertisedModelTools> | readonly HarnessToolDefinition[] {+ if ("modelTools" in input) {+ return getAdvertisedModelTools(input);+ }+if (isToolDefinitionList(input.tools)) {return filterSubagentToolDefinitionsAtDepthLimit(input.tools, input.session);}@@ -28,9 +67,45 @@ export function getAdvertisedTools(return filterSubagentToolMapAtDepthLimit(input.tools, input.session);}+async function getAdvertisedModelTools(+ input: AdvertisedModelToolsInput,+): Promise<AdvertisedModelTools> {+ const tools = filterSubagentToolMapAtDepthLimit(input.tools, input.session);+ if (input.workflow === undefined) {+ return {+ harnessTools: tools,+ modelTools: input.modelTools,+ session: input.session,+ };+ }++ const workflowHostTools = filterWorkflowHostToolsForRootSession(tools, input.session);+ if (workflowHostTools.size === 0) {+ return {+ harnessTools: tools,+ modelTools: input.modelTools,+ session: input.session,+ };+ }++ const session = ensureWorkflowContinuationSecurity(input.session);+ const { modelTools } = await applyWorkflowTool({+ continuationSecurity: getWorkflowContinuationSecurity(session),+ harnessTools: workflowHostTools,+ lifecycle: input.workflow.lifecycle?.({ session, tools: workflowHostTools }),+ tools: input.modelTools,+ });++ return {+ harnessTools: tools,+ modelTools,+ session,+ };+}+function filterSubagentToolDefinitionsAtDepthLimit(tools: readonly HarnessToolDefinition[],- session: Pick<HarnessSession, "subagentDepth" | "subagentMaxDepth">,+ session: AdvertisedToolSession,): readonly HarnessToolDefinition[] {const delegationLimit = resolveSubagentDelegationLimit(session);const filteredTools: HarnessToolDefinition[] = [];@@ -46,7 +121,7 @@ function filterSubagentToolDefinitionsAtDepthLimit(function filterSubagentToolMapAtDepthLimit(tools: HarnessToolMap,- session: Pick<HarnessSession, "subagentDepth" | "subagentMaxDepth">,+ session: AdvertisedToolSession,): HarnessToolMap {const delegationLimit = resolveSubagentDelegationLimit(session);const filteredTools = new Map<string, HarnessToolDefinition>();@@ -60,6 +135,25 @@ function filterSubagentToolMapAtDepthLimit(return filteredTools;}+function filterWorkflowHostToolsForRootSession(+ tools: HarnessToolMap,+ session: AdvertisedToolSession,+): HarnessToolMap {+ const filteredTools = new Map<string, HarnessToolDefinition>();+ const delegationLimit = resolveSubagentDelegationLimit(session);++ if (session.rootSessionId !== undefined || delegationLimit.currentDepth > 0) {+ return filteredTools;+ }++ for (const [name, tool] of tools) {+ if (isDelegatedRuntimeActionTool(tool)) {+ filteredTools.set(name, tool);+ }+ }+ return filteredTools;+}+function isDelegatedRuntimeActionTool(definition: HarnessToolDefinition): boolean {const runtimeAction = definition.runtimeAction;return runtimeAction?.kind === "subagent-call" || runtimeAction?.kind === "remote-agent-call";diff --git a/packages/eve/src/harness/tool-loop.test.ts b/packages/eve/src/harness/tool-loop.test.tsindex cd0f5fa47..22a07f49d 100644--- a/packages/eve/src/harness/tool-loop.test.ts+++ b/packages/eve/src/harness/tool-loop.test.ts@@ -803,6 +803,35 @@ describe("createToolLoopHarness", () => {expect(agentCall!.tools).not.toHaveProperty("Workflow");});+ it("omits Workflow from runtime subagent sessions", async () => {+ setupMockAgent({+ finishReason: "stop",+ response: { messages: [{ content: "Hello!", role: "assistant" }] },+ text: "Hello!",+ toolCalls: [],+ toolResults: [],+ });++ const config = createTestConfig("conversation", undefined, {+ workflow: true,+ tools: createDelegationToolMap(),+ });+ const runStep = createToolLoopHarness(config);++ await runStep(+ createTestSession({+ rootSessionId: "root-session",+ subagentDepth: 1,+ }),+ { message: "Hi" },+ );++ const agentCall = vi.mocked(ToolLoopAgent).mock.calls[0]?.[0];+ expect(agentCall).toBeDefined();+ expect(agentCall!.tools).toHaveProperty("delegate");+ expect(agentCall!.tools).not.toHaveProperty("Workflow");+ });+it("forwards the agent reasoning effort to the model call", async () => {setupMockAgent({finishReason: "stop",diff --git a/packages/eve/src/harness/tool-loop.ts b/packages/eve/src/harness/tool-loop.tsindex 9f6aa37fd..5debd46dd 100644--- a/packages/eve/src/harness/tool-loop.ts+++ b/packages/eve/src/harness/tool-loop.ts@@ -49,10 +49,10 @@ import {hydrateSandboxAttachments,stageAttachmentsToSandbox,} from "#harness/attachment-staging.js";-import { applyWorkflowTool, buildWorkflowHostTools } from "#harness/workflow-sandbox.js";+import { buildWorkflowHostTools } from "#harness/workflow-sandbox.js";import {- ensureWorkflowContinuationSecurity,getWorkflowContinuationSecurity,+ readWorkflowContinuationSecurity,} from "#harness/workflow-continuation-security.js";import { createWorkflowLifecycle } from "#harness/workflow-lifecycle.js";import {@@ -480,9 +480,6 @@ export function createToolLoopHarness(config: ToolLoopHarnessConfig): StepFn {}session = pending.session;- if (config.workflow === true) {- session = ensureWorkflowContinuationSecurity(session);- }let messages: ModelMessage[] = pending.messages;if (stepInput.input?.context !== undefined) {@@ -674,24 +671,26 @@ export function createToolLoopHarness(config: ToolLoopHarnessConfig): StepFn {flatTools[FINAL_OUTPUT_TOOL_NAME] = buildFinalOutputTool(session.outputSchema);}- const modelTools =- config.workflow === true- ? (- await applyWorkflowTool({- continuationSecurity: getWorkflowContinuationSecurity(session),- harnessTools: advertisedHarnessTools,- lifecycle:- emit !== undefined- ? createWorkflowLifecycle({- emit,- emissionState,- tools: advertisedHarnessTools,- })- : undefined,- tools: flatTools,+ const workflowLifecycle =+ emit !== undefined+ ? ({ tools }: { readonly tools: HarnessToolMap }) =>+ createWorkflowLifecycle({+ emit,+ emissionState,+ tools,})- ).modelTools- : flatTools;+ : undefined;+ const workflowConfig =+ config.workflow === true ? { lifecycle: workflowLifecycle } : undefined;++ const advertisedModelTools = await getAdvertisedTools({+ modelTools: flatTools,+ session,+ tools: advertisedHarnessTools,+ workflow: workflowConfig,+ });+ session = advertisedModelTools.session;+ const modelTools = advertisedModelTools.modelTools;const effectiveTools = marker ? applyLastToolCacheBreakpoint(modelTools, marker) : modelTools;@@ -1457,9 +1456,14 @@ async function handleStepResult(input: {compaction: createNextCompactionConfig(session.compaction, promptMessages, result),};- if (config.workflow === true) {- const continuationSecurity = getWorkflowContinuationSecurity(baseSession);- const workflowInterrupt = await getWorkflowSandboxInterrupt(result, continuationSecurity);+ const workflowContinuationSecurity =+ config.workflow === true ? readWorkflowContinuationSecurity(baseSession) : undefined;++ if (workflowContinuationSecurity !== undefined) {+ const workflowInterrupt = await getWorkflowSandboxInterrupt(+ result,+ workflowContinuationSecurity,+ );if (workflowInterrupt !== undefined) {if (!isWorkflowRuntimeActionInterrupt(workflowInterrupt)) {throw new Error(`Unsupported Workflow interrupt kind "${workflowInterrupt.payload.kind}".`);diff --git a/packages/eve/src/harness/workflow-continuation-security.test.ts b/packages/eve/src/harness/workflow-continuation-security.test.tsindex 618dfaa6d..33891b318 100644--- a/packages/eve/src/harness/workflow-continuation-security.test.ts+++ b/packages/eve/src/harness/workflow-continuation-security.test.ts@@ -4,6 +4,7 @@ import type { HarnessSession } from "#harness/types.js";import {ensureWorkflowContinuationSecurity,getWorkflowContinuationSecurity,+ readWorkflowContinuationSecurity,} from "#harness/workflow-continuation-security.js";function makeSession(state?: HarnessSession["state"]): HarnessSession {@@ -34,6 +35,7 @@ describe("workflow continuation security", () => {expect(security.maxAgeMs).toBe(365 * 24 * 60 * 60 * 1000);expect(ensureWorkflowContinuationSecurity(secured)).toBe(secured);expect(getWorkflowContinuationSecurity(secured)).toEqual(security);+ expect(readWorkflowContinuationSecurity(secured)).toEqual(security);});it("rejects malformed persisted security state", () => {@@ -47,5 +49,9 @@ describe("workflow continuation security", () => {expect(() => ensureWorkflowContinuationSecurity(session)).toThrow("Workflow continuation security state is missing or invalid.",);+ expect(() => getWorkflowContinuationSecurity(session)).toThrow(+ "Workflow continuation security state is missing or invalid.",+ );+ expect(readWorkflowContinuationSecurity(session)).toBeUndefined();});});diff --git a/packages/eve/src/harness/workflow-continuation-security.ts b/packages/eve/src/harness/workflow-continuation-security.tsindex 75e8fd378..7e4573416 100644--- a/packages/eve/src/harness/workflow-continuation-security.ts+++ b/packages/eve/src/harness/workflow-continuation-security.ts@@ -29,9 +29,9 @@ export function ensureWorkflowContinuationSecurity(session: HarnessSession): Har};}-export function getWorkflowContinuationSecurity(+export function readWorkflowContinuationSecurity(session: HarnessSession,-): WorkflowSandboxContinuationSecurity {+): WorkflowSandboxContinuationSecurity | undefined {const stored = session.state?.[WORKFLOW_CONTINUATION_SECURITY_KEY];if (typeof stored !== "object" ||@@ -40,7 +40,7 @@ export function getWorkflowContinuationSecurity(typeof (stored as { signingKey?: unknown }).signingKey !== "string" ||!/^[A-Za-z0-9_-]{43}$/.test((stored as { signingKey: string }).signingKey)) {- throw new Error("Workflow continuation security state is missing or invalid.");+ return undefined;}return {@@ -49,3 +49,13 @@ export function getWorkflowContinuationSecurity(maxAgeMs: WORKFLOW_CONTINUATION_MAX_AGE_MS,};}++export function getWorkflowContinuationSecurity(+ session: HarnessSession,+): WorkflowSandboxContinuationSecurity {+ const security = readWorkflowContinuationSecurity(session);+ if (security === undefined) {+ throw new Error("Workflow continuation security state is missing or invalid.");+ }+ return security;+}