eve 0.67.2 → 0.69.0

package/dist/src/execution/tools/workflow/body.d.ts

@@ -1,16 +1,19 @@
 import type { SessionContext } from "#context/session-context.js";
-import type { WorkflowToolContext } from "#tools/workflow-definition.js";
-import { type WorkflowToolRunOutcome, type WorkflowToolRunOwner, type WorkflowToolRunRef } from "#execution/tools/workflow/messages.js";
+import type { AgentSessionContext } from "#execution/agent-sessions/context.js";
+import { type RunUsageTally } from "#execution/agent-sessions/usage.js";
+import type { AgentSession, WorkflowSharedContext } from "#tools/workflow-definition.js";
+import { WorkflowToolRunAsks } from "#execution/tools/workflow/ask.js";
+import type { WorkflowBodyCommand, WorkflowToolRunOutcome, WorkflowToolRunRef } from "#execution/tools/workflow/messages.js";
+import type { WorkflowToolRunInbox } from "#execution/tools/workflow/owner.js";
+import type { WorkflowToolRunEntry } from "#shared/action-types.js";
 import type { JsonObject, JsonValue } from "#shared/json.js";
+import type { ToolContext } from "#tools/definition.js";
 export interface WorkflowBodyDefinition {
-    /** Snapshot added for new runs; absent only when resuming an older durable payload. */
-    readonly agents?: WorkflowToolContext["agents"];
+    /** Everything the run needs to open `ctx.agent` sessions for its caller, and `ctx.agents`. */
+    readonly agentContext: AgentSessionContext;
     readonly callId: string;
-    /**
-     * Whether the owning session can reach a human. `false` makes `ctx.ask()`
-     * resolve as `unavailable` instead of waiting for an answer no one can give.
-     */
-    readonly canRequestInput?: boolean;
+    /** The entry point the run invokes, which decides the body's context. */
+    readonly entry: WorkflowToolRunEntry;
     readonly executeInput?: JsonValue;
     readonly input: JsonObject;
     readonly session: SessionContext["session"];
@@ -19,18 +22,56 @@ export interface WorkflowBodyDefinition {
     readonly workflowId: string;
 }
 export interface WorkflowBodyInput extends WorkflowBodyDefinition {
-    readonly owner: WorkflowToolRunOwner;
+    /** The run's control hook, which the session answers the body's questions on. */
+    readonly hookToken: string;
+    readonly owner: WorkflowToolRunInbox;
+    readonly runId?: string;
 }
-export interface WorkflowBodyResult {
-    readonly outcome: WorkflowToolRunOutcome;
-    readonly reportCount: number;
+/**
+ * How the session's commands reach a running body. What a command means
+ * depends on the entry point: a cancel ends an `execute` or `task` call, but
+ * only the current stretch of work of a `serve` task.
+ */
+export interface WorkflowBodyControl {
+    /** Aborts when the run stops for good; the run then settles as cancelled. */
+    readonly runSignal: AbortSignal;
+    /** The body is winding down cancelled work, which the run bounds with its cleanup deadline. */
+    readonly unwinding: boolean;
+    apply(command: WorkflowBodyCommand): void;
 }
-/** Executes one registered workflow body and reports progress to its owner. */
-export declare function executeWorkflowBody(input: WorkflowBodyInput & {
-    readonly execution: "background" | "blocking";
-    readonly runId?: string;
-}, signal: AbortSignal): Promise<WorkflowBodyResult>;
+/** A body the run started and how its commands reach it. */
+export interface StartedWorkflowBody {
+    /** The body's pending questions, which the session's decisions settle. */
+    readonly asks: WorkflowToolRunAsks;
+    /** Releases what the body opened, such as its `ctx.agent` sessions, once the run ends. */
+    close(): Promise<void>;
+    readonly control: WorkflowBodyControl;
+    readonly outcome: Promise<WorkflowToolRunOutcome>;
+    /** What the body's `ctx.agent` sessions spent, which the run's outcome carries. */
+    readonly usage: RunUsageTally;
+}
+/** Starts the body of an `execute` or `task` call, which serves the call the run started with. */
+export declare function startCallBody(input: WorkflowBodyInput): StartedWorkflowBody;
+/** A body's failure, or its cancellation when the run stopped. */
+export declare function toFailedOutcome(error: unknown, runSignal: AbortSignal): WorkflowToolRunOutcome;
 export declare function createWorkflowBodyRef(input: WorkflowBodyDefinition & {
-    readonly execution: "background" | "blocking";
     readonly runId?: string;
 }): WorkflowToolRunRef;
+export declare function resolveWorkflowEntryPoint<TEntryPoint>(input: WorkflowBodyInput): TEntryPoint;
+/**
+ * The members every entry point's context shares, bound to the run. `ask`
+ * is the entry point's own, since what it may ask for depends on its calls.
+ * The members that describe a call, `abortSignal`, `agents`, `callId`, and
+ * `session` (whose turn is the call's), come from the entry point, which
+ * knows its calls.
+ */
+export declare function createSharedContext(input: WorkflowBodyInput, agent: (name: string) => AgentSession, askPerson: WorkflowSharedContext["ask"]): Omit<ToolContext & WorkflowSharedContext, "abortSignal" | "agents" | "callId" | "messages" | "session">;
+/** `ctx.agents` for a call: the agents its context lists, frozen. */
+export declare function createAgentsView(context: AgentSessionContext): WorkflowSharedContext["agents"];
+export declare class WorkflowToolRunCancelledError extends Error {
+    constructor(reason: string);
+}
+/** Why an `execute` call's `abortSignal` aborted when a steering message arrived. */
+export declare class WorkflowToolRunInterruptedError extends Error {
+    constructor();
+}

package/dist/src/execution/tools/workflow/body.js

@@ -1 +1 @@
-import{getWorkflowMetadata}from"#compiled/@workflow/core/index.js";import{normalizeSerializableError}from"#execution/workflow-errors.js";import{resumeHookStep}from"#execution/tools/workflow/resume-hook-step.js";import{ask,attachWorkflowToolRunContext}from"#execution/tools/workflow/ask.js";import{agent}from"#execution/tools/subagent/invoke-agent.js";import"#execution/tools/workflow/messages.js";import{readRegisteredWorkflow}from"#execution/workflow-registry.js";async function executeWorkflowBody(e,t){let n=createWorkflowBodyRef(e),r=createWorkflowBodyContext(e,t);attachWorkflowToolRunContext(r,{canRequestInput:e.canRequestInput,from:n,owner:e.owner});let i=0;try{let t=resolveWorkflowToolExecute(e)(e.executeInput??e.input,r),a;if(!isAsyncIterable(t))a=await t;else{let r=t[Symbol.asyncIterator](),o,s=await r.next();for(;s.done!==!0;){o=s.value;let t={from:n,update:s.value};await resumeHookStep(e.owner.inbox,{kind:`report`,...t}),i+=1,s=await r.next()}a=s.value??(e.execution===`blocking`?o:void 0)??null}return{outcome:{output:a,status:`completed`},reportCount:i}}catch(e){return t.aborted?{outcome:{reason:t.reason instanceof Error?t.reason.message:String(t.reason??``),status:`cancelled`},reportCount:i}:{outcome:{error:normalizeSerializableError(e),status:`failed`},reportCount:i}}}function createWorkflowBodyRef(e){return{callId:e.callId,execution:e.execution,input:e.input,runId:e.runId??getWorkflowMetadata().workflowRunId,sequence:e.session.turn.sequence,stepIndex:e.stepIndex,toolName:e.toolName,turnId:e.session.turn.id}}function resolveWorkflowToolExecute(e){let t=readRegisteredWorkflow(e.workflowId);if(typeof t!=`function`)throw Error(`Tool "${e.toolName}" is not registered as a workflow in this deployment (${e.workflowId}). The tool was renamed or removed after this run started.`);return t}function createWorkflowBodyContext(e,t){let unavailable=(t,n)=>{throw Error(`ctx.${t} is not available inside a workflow tool; ${n}. Tool "${e.toolName}" runs as a durable workflow body, which only replays deterministic code.`)},n={agent:((e,t)=>agent(n,e,t)),agents:Object.freeze(Object.fromEntries(Object.entries(e.agents??{}).map(([e,t])=>[e,Object.freeze({...t})]))),ask:e=>ask(n,e),abortSignal:t,callId:e.callId,getSandbox:()=>unavailable(`getSandbox()`,`the session sandbox belongs to the turn`),getToken:()=>unavailable(`getToken()`,`pass ctx directly to a "use step" helper to resolve credentials`),requireAuth:()=>unavailable(`requireAuth()`,`pass ctx directly to a "use step" helper to request authorization`),session:e.session,toolName:e.toolName};return n}function isAsyncIterable(e){return typeof e==`object`&&!!e&&typeof e[Symbol.asyncIterator]==`function`}export{createWorkflowBodyRef,executeWorkflowBody};
+import{getWorkflowMetadata}from"#compiled/@workflow/core/index.js";import{normalizeSerializableError}from"#execution/workflow-errors.js";import{createRunUsageTally}from"#execution/agent-sessions/usage.js";import{createAgentSessions}from"#execution/agent-sessions/session.js";import{WorkflowToolRunAsks,ask,attachWorkflowToolRunContext}from"#execution/tools/workflow/ask.js";import{readRegisteredWorkflow}from"#execution/workflow-registry.js";const INTERRUPTED_OUTPUT={interrupted:!0};var WorkflowCallSignals=class{body=new AbortController;run=new AbortController;asks;constructor(e){this.asks=e}get abortSignal(){return this.body.signal}get runSignal(){return this.run.signal}get interrupted(){return this.body.signal.aborted&&!this.run.signal.aborted}get unwinding(){return this.run.signal.aborted}apply(e){switch(e.kind){case`cancel`:case`end`:this.asks.cancelAll(),this.run.abort(new WorkflowToolRunCancelledError(e.reason)),this.body.abort(this.run.signal.reason);return;case`interrupt`:this.body.abort(new WorkflowToolRunInterruptedError);return;case`call`:return}}};function startCallBody(e){let t=createWorkflowBodyRef(e),n=new WorkflowToolRunAsks(t.runId),r=new WorkflowCallSignals(n),i={agentContext:e.agentContext,asks:n,auth:e.session.auth,control:e.hookToken,from:t,owner:e.owner},a=createRunUsageTally(),o=createAgentSessions(i,a),s=createCallContext(e,r,o.open);return attachWorkflowToolRunContext(s,i),{asks:n,close:o.close,control:r,outcome:executeCallBody(e,s,r,t),usage:a}}async function executeCallBody(e,t,n,r){try{let n=resolveWorkflowEntryPoint(e)(e.executeInput??e.input,t),i;if(!isAsyncIterable(n))i=await n;else{let t=n[Symbol.asyncIterator](),a,o=await t.next();for(;o.done!==!0;)a=o.value,await e.owner.send({from:r,kind:`report`,update:o.value}),o=await t.next();i=o.value??a??null}return{output:i,status:`completed`}}catch(e){return n.interrupted?{output:INTERRUPTED_OUTPUT,status:`completed`}:toFailedOutcome(e,n.runSignal)}}function toFailedOutcome(e,t){if(t.aborted){let{reason:e}=t;return{reason:e instanceof Error?e.message:String(e??``),status:`cancelled`}}return{error:normalizeSerializableError(e),status:`failed`}}function createWorkflowBodyRef(e){let t={callId:e.callId,input:e.input,runId:e.runId??getWorkflowMetadata().workflowRunId,sequence:e.session.turn.sequence,stepIndex:e.stepIndex,toolName:e.toolName,turnId:e.session.turn.id};return e.entry.entryPoint===`execute`?t:{...t,taskId:e.entry.taskId}}function resolveWorkflowEntryPoint(e){let t=readRegisteredWorkflow(e.workflowId);if(typeof t!=`function`)throw Error(`Tool "${e.toolName}" is not registered as a workflow in this deployment (${e.workflowId}). The tool was renamed or removed after this run started.`);return t}function createSharedContext(e,t,n){let unavailable=(t,n)=>{throw Error(`ctx.${t} is not available inside a workflow tool; ${n}. Tool "${e.toolName}" runs as a durable workflow body, which only replays deterministic code.`)};return{agent:t,ask:n,getSandbox:()=>unavailable(`getSandbox()`,`the session sandbox belongs to the turn`),getToken:()=>unavailable(`getToken()`,`pass ctx directly to a "use step" helper to resolve credentials`),requireAuth:()=>unavailable(`requireAuth()`,`pass ctx directly to a "use step" helper to request authorization`),toolName:e.toolName}}function createAgentsView(e){return Object.freeze(Object.fromEntries(Object.entries(e.agents).map(([e,t])=>[e,Object.freeze({...t})])))}function createCallContext(e,t,n){let r={...createSharedContext(e,n,(e,t)=>ask(r,e,t)),abortSignal:t.abortSignal,agents:createAgentsView(e.agentContext),callId:e.callId,session:e.session};return r}function isAsyncIterable(e){return typeof e==`object`&&!!e&&typeof e[Symbol.asyncIterator]==`function`}var WorkflowToolRunCancelledError=class extends Error{constructor(e){super(e),this.name=`WorkflowToolRunCancelledError`}},WorkflowToolRunInterruptedError=class extends Error{constructor(){super(`A new message arrived while the turn waited on this call.`),this.name=`WorkflowToolRunInterruptedError`}};export{WorkflowToolRunCancelledError,WorkflowToolRunInterruptedError,createAgentsView,createSharedContext,createWorkflowBodyRef,resolveWorkflowEntryPoint,startCallBody,toFailedOutcome};

package/dist/src/execution/tools/workflow/cancel.d.ts

@@ -1,8 +1,13 @@
+import type { WorkflowToolRunControlMessage } from "#execution/tools/workflow/messages.js";
 import type { WorkflowToolRunAddress } from "#execution/tools/workflow/types.js";
+/** How a run is told to stop: `end` also finishes a `serve` task's run, which a cancel keeps. */
+export type WorkflowToolRunStop = Extract<WorkflowToolRunControlMessage, {
+    readonly kind: "cancel" | "end";
+}>;
 /**
- * Asks the run to cancel itself, then bounds cooperative cleanup. Failures are
+ * Asks the run to stop itself, then bounds cooperative cleanup. Failures are
  * logged: the caller has already committed cancellation of the calling turn.
  */
-export declare function cancelWorkflowToolRun(run: WorkflowToolRunAddress, reason: string): Promise<void>;
+export declare function cancelWorkflowToolRun(run: WorkflowToolRunAddress, stop: WorkflowToolRunStop): Promise<void>;
 /** Allows cooperative cleanup, then forcibly stops a still-live run. */
 export declare function settleWorkflowToolRunCancellation(runId: string, reason: string, cooperative?: boolean): Promise<void>;

package/dist/src/execution/tools/workflow/cancel.js

@@ -1 +1 @@
-import{createLogger,logError}from"#internal/logging.js";import{cancelRun,getRun,getWorld,resumeHook}from"#internal/workflow/runtime.js";import{isTaskWorkflowTargetGone}from"#execution/tasks/workflow-target.js";import{WORKFLOW_CANCELLATION_SETTLE_MS}from"#execution/tools/workflow/cancellation-policy.js";const log=createLogger(`execution.workflow-tool-run`);async function cancelWorkflowToolRun(e,t){let n={kind:`cancel`,reason:t},r=!1;try{await resumeHook(e.hookToken,n),r=!0}catch(t){isTaskWorkflowTargetGone(t)||logError(log,`failed to signal a workflow tool run to cancel; cancelling it outright`,t,{runId:e.runId})}try{await settleWorkflowToolRunCancellation(e.runId,t,r)}catch(t){if(isTaskWorkflowTargetGone(t))return;logError(log,`failed to cancel workflow tool run; it may run to completion`,t,{runId:e.runId})}}async function settleWorkflowToolRunCancellation(e,t,n=!0){if(n){let t=Date.now()+WORKFLOW_CANCELLATION_SETTLE_MS;for(;Date.now()<t;){try{let t=await getRun(e).status;if(t!==`pending`&&t!==`running`)return}catch(e){if(isTaskWorkflowTargetGone(e))return;throw e}await new Promise(e=>setTimeout(e,250))}}try{await cancelRun(await getWorld(),e,{cancelReason:t})}catch(e){if(isTaskWorkflowTargetGone(e))return;throw e}}export{cancelWorkflowToolRun,settleWorkflowToolRunCancellation};
+import{createLogger,logError}from"#internal/logging.js";import{cancelRun,getRun,getWorld,resumeHook}from"#internal/workflow/runtime.js";import{isTaskWorkflowTargetGone}from"#execution/tasks/workflow-target.js";import{WORKFLOW_CANCELLATION_SETTLE_MS}from"#execution/tools/workflow/cancellation-policy.js";const log=createLogger(`execution.workflow-tool-run`);async function cancelWorkflowToolRun(e,t){let{reason:n}=t,r=!1;try{await resumeHook(e.hookToken,t),r=!0}catch(t){isTaskWorkflowTargetGone(t)||logError(log,`failed to signal a workflow tool run to cancel; cancelling it outright`,t,{runId:e.runId})}try{await settleWorkflowToolRunCancellation(e.runId,n,r)}catch(t){if(isTaskWorkflowTargetGone(t))return;logError(log,`failed to cancel workflow tool run; it may run to completion`,t,{runId:e.runId})}}async function settleWorkflowToolRunCancellation(e,t,n=!0){if(n){let t=Date.now()+WORKFLOW_CANCELLATION_SETTLE_MS;for(;Date.now()<t;){try{let t=await getRun(e).status;if(t!==`pending`&&t!==`running`)return}catch(e){if(isTaskWorkflowTargetGone(e))return;throw e}await new Promise(e=>setTimeout(e,250))}}try{await cancelRun(await getWorld(),e,{cancelReason:t})}catch(e){if(isTaskWorkflowTargetGone(e))return;throw e}}export{cancelWorkflowToolRun,settleWorkflowToolRunCancellation};

package/dist/src/execution/tools/workflow/emit-workflow-tool-run-report-step.d.ts

@@ -1,7 +1,13 @@
-import type { WorkflowToolRunRef } from "#execution/tools/workflow/messages.js";
+import { type SessionStepState } from "#execution/publish-session-events.js";
+import { type SessionStateTransition } from "#execution/session/state-delta.js";
+import type { WorkflowToolRunAgentStartedMessage, WorkflowToolRunRef } from "#execution/tools/workflow/messages.js";
 import type { JsonValue } from "#shared/json.js";
-export declare function emitWorkflowToolRunReportStep(input: {
+/** Publishes a workflow tool run's `ctx.report()` update as `action.partial`. */
+export declare function emitWorkflowToolRunReportStep(input: SessionStepState & {
     readonly from: WorkflowToolRunRef;
-    readonly sessionWritable: WritableStream<Uint8Array>;
     readonly update: JsonValue;
-}): Promise<void>;
+}): Promise<SessionStateTransition>;
+/** Publishes `agent.started`, in order, for sessions workflow tool runs opened. */
+export declare function emitAgentStartedStep(input: SessionStepState & {
+    readonly messages: readonly WorkflowToolRunAgentStartedMessage[];
+}): Promise<SessionStateTransition>;

package/dist/src/execution/tools/workflow/emit-workflow-tool-run-report-step.js

@@ -1 +1 @@
-import{createActionPartialEvent,encodeMessageStreamEvent,stampMessageStreamEvent}from"#protocol/message.js";import{createRuntimeToolResultFromValue}from"#harness/action-result-helpers.js";async function emitWorkflowToolRunReportStep(e){"use step";let t=createActionPartialEvent({result:createRuntimeToolResultFromValue({callId:e.from.callId,output:e.update,toolName:e.from.toolName}),sequence:e.from.sequence,stepIndex:e.from.stepIndex,turnId:e.from.turnId}),n=e.sessionWritable.getWriter();try{await n.write(encodeMessageStreamEvent(stampMessageStreamEvent(t)))}finally{n.releaseLock()}}export{emitWorkflowToolRunReportStep};
+import{createActionPartialEvent,createAgentStartedEvent}from"#protocol/message.js";import{publishSessionEvents}from"#execution/publish-session-events.js";import{withSessionStateDelta}from"#execution/session/state-delta.js";import{createRuntimeToolResultFromValue}from"#harness/action-result-helpers.js";async function emitWorkflowToolRunReportStep(e){"use step";let t=createActionPartialEvent({result:createRuntimeToolResultFromValue({callId:e.from.callId,output:e.update,toolName:e.from.toolName}),sequence:e.from.sequence,stepIndex:e.from.stepIndex,turnId:e.from.turnId});return await withSessionStateDelta(e,e=>publishSessionEvents(e,[t]))}async function emitAgentStartedStep(e){"use step";let t=e.messages.map(({from:t,session:n})=>createAgentStartedEvent({callId:t.callId,name:n.name,parentSessionId:e.sessionState.sessionId,remote:n.kind===`remote`?{url:n.url,...n.resolverId!==void 0&&{resolverId:n.resolverId}}:void 0,sessionId:n.sessionId,...t.taskId!==void 0&&{taskId:t.taskId},turnId:t.turnId}));return await withSessionStateDelta(e,e=>publishSessionEvents(e,t))}export{emitAgentStartedStep,emitWorkflowToolRunReportStep};

package/dist/src/execution/tools/workflow/{background.d.ts → harness-definition.d.ts}

@@ -1,14 +1,14 @@
 import type { HarnessToolDefinition } from "#harness/execute-tool.js";
 import type { PreparedRuntimeTool } from "#runtime/sessions/turn.js";
-import { parseJsonObject, type JsonValue } from "#shared/json.js";
-interface WorkflowToolHarnessDefinitionInput {
+import type { JsonValue } from "#shared/json.js";
+export interface WorkflowToolHarnessDefinitionInput {
     readonly definition: HarnessToolDefinition;
     readonly executeInput?: (input: unknown) => JsonValue;
-    /** Selected agent definition's runtime graph ID; absent for authored workflow tools. */
-    readonly nodeId?: string;
     readonly workflowId: string;
 }
+/**
+ * Workflow tools run outside the model step, so the harness definition carries
+ * no `execute`. A `serve` tool's model input gains `taskId`.
+ */
 export declare function createWorkflowToolHarnessDefinition(input: WorkflowToolHarnessDefinitionInput): HarnessToolDefinition;
 export declare function createPreparedWorkflowToolHarnessDefinition(tool: PreparedRuntimeTool): HarnessToolDefinition;
-export declare function parseWorkflowToolInput(toolInput: unknown, toolName: string): ReturnType<typeof parseJsonObject>;
-export {};

package/dist/src/execution/tools/workflow/harness-definition.js

@@ -0,0 +1 @@
+import{UNSPECIFIED_INPUT_SCHEMA,toInputSchema,toOutputSchema}from"#tools/schema.js";import{workflowIdForHandling}from"#runtime/subagents/workflow-reference.js";import{withTaskIdInput}from"#execution/tasks/task-id-input.js";import{entryPointOf}from"#execution/tasks/tool-entry-point.js";function createWorkflowToolHarnessDefinition(e){return{...entryPointOf(e.definition)===`serve`?withTaskIdInput(e.definition):e.definition,execute:void 0,executeInput:e.executeInput,workflowId:e.workflowId}}function createPreparedWorkflowToolHarnessDefinition(e){let t=workflowIdForHandling(e.behavior?.handling);if(t===void 0)throw Error(`Prepared tool "${e.name}" is not backed by a workflow.`);return createWorkflowToolHarnessDefinition({definition:{behavior:e.behavior,description:e.description,inputSchema:toInputSchema(e.inputSchema)??UNSPECIFIED_INPUT_SCHEMA,name:e.name,outputSchema:toOutputSchema(e.outputSchema),rootOnly:e.rootOnly},workflowId:t})}export{createPreparedWorkflowToolHarnessDefinition,createWorkflowToolHarnessDefinition};

package/dist/src/execution/tools/workflow/interrupt.d.ts

@@ -0,0 +1,6 @@
+import type { WorkflowToolRunAddress } from "#execution/tools/workflow/types.js";
+/**
+ * Aborts the `execute` call's `abortSignal`. A run that already finished has nothing
+ * left to interrupt, so a missing hook is not an error.
+ */
+export declare function interruptWorkflowToolRun(run: WorkflowToolRunAddress): Promise<void>;

package/dist/src/execution/tools/workflow/interrupt.js

@@ -0,0 +1 @@
+import{resumeHookStep}from"#execution/tools/workflow/resume-hook-step.js";const INTERRUPT={kind:`interrupt`};async function interruptWorkflowToolRun(e){await resumeHookStep(e.hookToken,INTERRUPT,{ifPresent:!0})}export{interruptWorkflowToolRun};

package/dist/src/execution/tools/workflow/messages.d.ts

@@ -1,16 +1,16 @@
 import type { SubagentAuthorizationEventHookPayload } from "#channel/types.js";
-import type { AgentInvocationRequest, AgentSettlementRequest } from "#execution/tools/subagent/invoke-agent.js";
+import type { SessionInboxAddress } from "#execution/session-inbox/address.js";
+import type { RemoteAgentBinding } from "#eve-channel/support.js";
+import type { SessionAuth } from "#context/session-context.js";
+import type { AgentSessionContext } from "#execution/agent-sessions/context.js";
+import type { AgentSessionAddress } from "#execution/agent-sessions/steps.js";
 import type { InputRequest } from "#shared/input.js";
 import type { JsonObject, JsonValue } from "#shared/json.js";
-import type { ToolInputRequest } from "#tools/definition.js";
+import type { TokenUsage } from "#shared/token-usage.js";
+import type { ToolInputRequest, ToolInputResponse } from "#tools/definition.js";
 export interface WorkflowToolRunOwner {
     readonly inbox: string;
 }
-/**
- * Requests the owner must apply on the run's behalf because they touch
- * owner-held state: spawning an agent and releasing its handle afterwards.
- */
-export type WorkflowToolAgentRequest = AgentInvocationRequest | AgentSettlementRequest;
 /**
  * A child authorization event the owner should display. Unlike input requests
  * it has no answer: the authorization callback completes against the child
@@ -22,6 +22,8 @@ export interface WorkflowToolAuthorizationRequest {
 }
 /** A question authored with `ask()` from `eve/workflow`, before owner normalization. */
 export interface WorkflowToolAskRequest {
+    /** The run's control hook, where the session sends its decision on the question. */
+    readonly control: string;
     readonly kind: "ask";
     readonly request: ToolInputRequest;
 }
@@ -33,15 +35,16 @@ export interface WorkflowToolInputRequestBatch {
     readonly kind: "input-batch";
     readonly requests: readonly InputRequest[];
 }
-export type WorkflowToolRequest = WorkflowToolAgentRequest | WorkflowToolAuthorizationRequest | WorkflowToolAskRequest | InputRequest | WorkflowToolInputRequestBatch;
+export type WorkflowToolRequest = WorkflowToolAuthorizationRequest | WorkflowToolAskRequest | InputRequest | WorkflowToolInputRequestBatch;
 /** Identifies the sending workflow tool run to an owner shared by many runs. */
 export interface WorkflowToolRunRef {
     readonly callId: string;
-    readonly execution: "background" | "blocking";
     readonly input: JsonObject;
     readonly runId: string;
     readonly sequence: number;
     readonly stepIndex: number;
+    /** Set when the run does a task's work; the session routes its messages by it. */
+    readonly taskId?: string;
     readonly toolName: string;
     readonly turnId: string;
 }
@@ -60,7 +63,12 @@ export interface WorkflowToolRunReport {
     readonly update: JsonValue;
 }
 export interface WorkflowToolRunRequestMessage {
+    readonly childSessionInbox?: SessionInboxAddress;
+    readonly remote?: RemoteAgentBinding & {
+        readonly sessionId: string;
+    };
     readonly from: WorkflowToolRunRef;
+    readonly inputSource?: string;
     readonly replyTo: string;
     readonly request: WorkflowToolRequest;
     readonly requestCoordinates?: {
@@ -72,16 +80,133 @@ export interface WorkflowToolRunRequestMessage {
 export interface WorkflowToolRunOutcomeMessage {
     readonly from: WorkflowToolRunRef;
     readonly result: WorkflowToolRunOutcome;
+    /** What the run's `ctx.agent` sessions spent in all, once any of their turns ended. */
+    readonly usage?: TokenUsage;
+}
+/**
+ * The run asks the session to withdraw the `ctx.ask()` question sent under
+ * `replyTo`. The session answers `withdrawn` on `control`, unless it accepted
+ * an answer first.
+ */
+export interface WorkflowToolRunWithdrawMessage {
+    readonly control: string;
+    readonly from: WorkflowToolRunRef;
+    readonly replyTo: string;
+}
+/** The run opened a session with `ctx.agent`, which its session announces as `agent.started`. */
+export interface WorkflowToolRunAgentStartedMessage {
+    readonly from: WorkflowToolRunRef;
+    readonly session: AgentSessionAddress;
+}
+/**
+ * A `serve` body's reply, sent once for each `ctx.reply()`. It settles every
+ * call the body received since its last reply, so the session settles them
+ * together and the model receives the reply once.
+ */
+export interface WorkflowToolRunReplyMessage {
+    /** The calls the reply settles, oldest first. */
+    readonly callIds: readonly string[];
+    /** The latest call the reply settles, which the body serves now. */
+    readonly from: WorkflowToolRunRef;
+    readonly output: JsonValue;
+    /**
+     * What the run's `ctx.agent` sessions spent so far, once any of their turns
+     * ended. A running total, so the session counts only what it adds to the
+     * last one it counted, and a redelivered reply adds nothing.
+     */
+    readonly usage?: TokenUsage;
+}
+/**
+ * A `serve` body's delegated spend that no reply carries: its `ctx.agent`
+ * sessions ended a turn while no call waited for a reply, such as a turn a
+ * cancel stopped. A running total, like a reply's.
+ */
+export interface WorkflowToolRunUsageMessage {
+    readonly from: WorkflowToolRunRef;
+    readonly usage: TokenUsage;
+}
+/** A task's run can take commands: its control hook is registered. */
+export interface WorkflowToolRunStartedMessage {
+    readonly from: WorkflowToolRunRef;
 }
 export type WorkflowToolRunMessage = ({
+    readonly kind: "agent-started";
+} & WorkflowToolRunAgentStartedMessage) | ({
+    readonly kind: "started";
+} & WorkflowToolRunStartedMessage) | ({
     readonly kind: "report";
 } & WorkflowToolRunReport) | ({
+    readonly kind: "reply";
+} & WorkflowToolRunReplyMessage) | ({
     readonly kind: "request";
 } & WorkflowToolRunRequestMessage) | ({
+    readonly kind: "withdraw";
+} & WorkflowToolRunWithdrawMessage) | ({
+    readonly kind: "usage";
+} & WorkflowToolRunUsageMessage) | ({
     readonly kind: "outcome";
 } & WorkflowToolRunOutcomeMessage);
-export type WorkflowToolRunControlMessage = {
+/**
+ * A later call to a `serve` task, which its run hands to `receive()`. It
+ * carries everything the session knew of the call when it admitted it, as a
+ * run's input does for the call that started it: the coordinates of the model
+ * step that made it, the caller's auth, and the context of sessions opened
+ * for it, with the agents it may open. Everything the run does while serving
+ * the call comes from these.
+ */
+export interface WorkflowToolRunCall extends Pick<WorkflowToolRunRef, "callId" | "sequence" | "stepIndex" | "turnId"> {
+    /** Sessions opened while serving the call are its children, in its trace. */
+    readonly agentContext: AgentSessionContext;
+    /** The caller's auth the session admitted the call with, which messages sent while serving it carry. */
+    readonly auth: SessionAuth;
+    readonly executeInput?: JsonValue;
+    /** The call's input, without the `taskId` that named the task. */
+    readonly input: JsonObject;
+}
+/** A person's answer to a `ctx.ask()` question, as the session accepted it. */
+export type WorkflowToolRunAnswer = Extract<ToolInputResponse, {
+    readonly status: "answered";
+}>;
+/**
+ * The session's decision on one `ctx.ask()` question: it accepted an answer,
+ * or it withdrew the question first. It decides once, and the ask resolves
+ * from that decision alone.
+ */
+export type WorkflowToolRunAskDecision = {
+    readonly kind: "answer";
+    readonly requestId: string;
+    readonly response: WorkflowToolRunAnswer;
+} | {
+    readonly kind: "withdrawn";
+    readonly requestId: string;
+};
+/**
+ * Commands the body applies, in the order the session sent them.
+ *
+ * - `cancel` stops the current work: an `execute` or `task` call's run, or a
+ *   `serve` task's current stretch of work, after which it waits for more calls.
+ * - `end` stops the run for good, because the session ended.
+ * - `interrupt` aborts an `execute` call's `abortSignal` without cancelling the
+ *   call, because steering arrived while the turn waits on it.
+ * - `call` delivers a later call to a `serve` task.
+ */
+export type WorkflowBodyCommand = {
+    readonly kind: "call";
+    readonly call: WorkflowToolRunCall;
+} | {
     readonly kind: "cancel";
     readonly reason: string;
+} | {
+    readonly kind: "end";
+    readonly reason: string;
+} | {
+    readonly kind: "interrupt";
 };
+/**
+ * Everything the session sends a run, on the run's control hook: its one
+ * inbox. Only the session writes to it, so the run receives commands and
+ * decisions in the order the session made them.
+ */
+export type WorkflowToolRunControlMessage = WorkflowBodyCommand | WorkflowToolRunAskDecision;
 export declare function isWorkflowToolRunControlMessage(value: unknown): value is WorkflowToolRunControlMessage;
+export declare function isWorkflowToolRunAskDecision(message: WorkflowToolRunControlMessage): message is WorkflowToolRunAskDecision;

package/dist/src/execution/tools/workflow/messages.js

@@ -1 +1 @@
-function isWorkflowToolRunControlMessage(e){if(typeof e!=`object`||!e)return!1;let{kind:t,reason:n}=e;return t===`cancel`&&typeof n==`string`}export{isWorkflowToolRunControlMessage};
+function isWorkflowToolRunControlMessage(e){if(typeof e!=`object`||!e)return!1;let{call:t,kind:n,reason:r,requestId:i,response:a}=e;switch(n){case`interrupt`:return!0;case`cancel`:case`end`:return typeof r==`string`;case`call`:return isWorkflowToolRunCall(t);case`answer`:return typeof i==`string`&&isWorkflowToolRunAnswer(a);case`withdrawn`:return typeof i==`string`;default:return!1}}function isWorkflowToolRunAskDecision(e){return e.kind===`answer`||e.kind===`withdrawn`}function isWorkflowToolRunAnswer(e){if(typeof e!=`object`||!e)return!1;let{optionId:t,responder:n,status:r,text:i}=e;return r===`answered`&&(t===void 0||typeof t==`string`)&&(n===void 0||isToolInputResponseResponder(n))&&(i===void 0||typeof i==`string`)}function isToolInputResponseResponder(e){if(typeof e!=`object`||!e)return!1;let{authenticator:t,principalId:n,principalType:r}=e;return typeof t==`string`&&typeof n==`string`&&typeof r==`string`}function isWorkflowToolRunCall(e){if(typeof e!=`object`||!e)return!1;let{agentContext:t,auth:n,callId:r,input:i,sequence:a,stepIndex:o,turnId:s}=e;return typeof t==`object`&&!!t&&typeof n==`object`&&!!n&&typeof r==`string`&&typeof i==`object`&&!!i&&typeof a==`number`&&typeof o==`number`&&typeof s==`string`}export{isWorkflowToolRunAskDecision,isWorkflowToolRunControlMessage};

package/dist/src/execution/tools/workflow/owner-inbox.js

@@ -1 +1 @@
-import{parseJsonValue}from"#shared/json.js";function workflowToolRunOutcomeToToolResult(e){let{from:t,result:n}=e;return n.status===`completed`?{callId:t.callId,kind:`tool-result`,output:n.output,toolName:t.toolName}:{callId:t.callId,isError:!0,kind:`tool-result`,output:n.status===`failed`?workflowToolRunFailureOutput(e):n.reason??`The workflow tool run was cancelled.`,toolName:t.toolName}}function workflowToolRunFailureOutput(e){if(e.result.status!==`failed`)throw TypeError(`Expected a failed workflow outcome.`);let t=parseJsonValueOrUndefined(e.result.error);return t!==void 0&&typeof t==`object`&&t&&!Array.isArray(t)&&typeof Reflect.get(t,`code`)==`string`?t:errorMessage(e.result.error)}function errorMessage(e){if(typeof e==`object`&&e&&`message`in e){let t=e.message;if(typeof t==`string`)return t}return String(e)}function parseJsonValueOrUndefined(e){try{return parseJsonValue(e)}catch{return}}function workflowToolRunRequestToInputRequestPayload(e){let{from:t,replyTo:n,requestCoordinates:r}=e;return{callId:t.callId,childContinuationToken:n,childSessionId:t.runId,event:{requests:workflowToolRunInputRequests(e),sequence:r?.sequence??t.sequence,stepIndex:r?.stepIndex??t.stepIndex,turnId:r?.turnId??t.turnId},kind:`subagent-input-request`,subagentName:t.toolName}}function workflowToolRunInputRequests(e){return e.request.kind===`input-batch`?e.request.requests:[normalizeInputRequest(e.request,e.from,e.replyTo)]}function normalizeInputRequest(e,t,n){switch(e.kind){case`agent-invoke`:case`agent-settled`:throw TypeError(`A workflow agent request cannot be normalized as human input.`);case`authorization-request`:throw TypeError(`A workflow authorization event cannot be normalized as human input.`);case`ask`:return normalizeAskRequest(e.request,t,n);default:return e}}function normalizeAskRequest(e,t,n){if(typeof e.prompt!=`string`||e.prompt.length===0)throw TypeError("A workflow tool run request needs a non-empty `prompt`.");let r={action:{callId:t.callId,input:t.input,kind:`tool-call`,toolName:t.toolName},kind:`question`,prompt:e.prompt,requestId:n};return e.allowFreeform!==void 0&&(r.allowFreeform=e.allowFreeform),e.display!==void 0&&(r.display=e.display),e.options!==void 0&&(r.options=[...e.options]),r}export{workflowToolRunFailureOutput,workflowToolRunInputRequests,workflowToolRunOutcomeToToolResult,workflowToolRunRequestToInputRequestPayload};
+import{parseJsonValue}from"#shared/json.js";function workflowToolRunOutcomeToToolResult(e){let{from:t,result:n}=e;return n.status===`completed`?{callId:t.callId,kind:`tool-result`,output:n.output,toolName:t.toolName}:{callId:t.callId,isError:!0,kind:`tool-result`,output:n.status===`failed`?workflowToolRunFailureOutput(e):n.reason??`The workflow tool run was cancelled.`,toolName:t.toolName}}function workflowToolRunFailureOutput(e){if(e.result.status!==`failed`)throw TypeError(`Expected a failed workflow outcome.`);let t=parseJsonValueOrUndefined(e.result.error);return t!==void 0&&typeof t==`object`&&t&&!Array.isArray(t)&&typeof Reflect.get(t,`code`)==`string`?t:errorMessage(e.result.error)}function errorMessage(e){if(typeof e==`object`&&e&&`message`in e){let t=e.message;if(typeof t==`string`)return t}return String(e)}function parseJsonValueOrUndefined(e){try{return parseJsonValue(e)}catch{return}}function workflowToolRunRequestToInputRequestPayload(e){let{from:t,replyTo:n,requestCoordinates:r}=e;return{callId:t.callId,childContinuationToken:n,childSessionId:t.runId,childSessionInbox:e.childSessionInbox,remote:e.remote,inputSource:e.inputSource,event:{requests:workflowToolRunInputRequests(e),sequence:r?.sequence??t.sequence,stepIndex:r?.stepIndex??t.stepIndex,taskId:t.taskId,turnId:r?.turnId??t.turnId},kind:`subagent-input-request`,subagentName:t.toolName}}function workflowToolRunInputRequests(e){return e.request.kind===`input-batch`?e.request.requests:[normalizeInputRequest(e.request,e.from,e.replyTo)]}function normalizeInputRequest(e,t,n){switch(e.kind){case`authorization-request`:throw TypeError(`A workflow authorization event cannot be normalized as human input.`);case`ask`:return normalizeAskRequest(e.request,t,n);default:return e}}function normalizeAskRequest(e,t,n){if(typeof e.prompt!=`string`||e.prompt.length===0)throw TypeError("A workflow tool run request needs a non-empty `prompt`.");let r={action:{callId:t.callId,input:t.input,kind:`tool-call`,toolName:t.toolName},kind:`question`,prompt:e.prompt,requestId:n};return e.allowFreeform!==void 0&&(r.allowFreeform=e.allowFreeform),e.display!==void 0&&(r.display=e.display),e.options!==void 0&&(r.options=[...e.options]),r}export{workflowToolRunFailureOutput,workflowToolRunInputRequests,workflowToolRunOutcomeToToolResult,workflowToolRunRequestToInputRequestPayload};

package/dist/src/execution/tools/workflow/owner.d.ts

@@ -1,11 +1,22 @@
-import type { WorkflowToolRunMessage, WorkflowToolRunRequestMessage, WorkflowToolAuthorizationRequest, WorkflowToolRunOwner } from "#execution/tools/workflow/messages.js";
+import type { WorkflowToolRunMessage, WorkflowToolRunRequestMessage, WorkflowToolAuthorizationRequest } from "#execution/tools/workflow/messages.js";
 import { type ChannelReader } from "#execution/tools/workflow/owner-channels.js";
+/**
+ * The run's inbox as its body sees it. Everything the body sends its session,
+ * except the outcome, goes through the run, which relays each message before
+ * the outcome.
+ */
+export interface WorkflowToolRunInbox {
+    /** Messages that reached the run's inbox so far. */
+    readonly sent: number;
+    send(message: Exclude<WorkflowToolRunMessage, {
+        readonly kind: "outcome";
+    }>): Promise<void>;
+}
 export interface WorkflowToolRunOwnerInbox {
-    dispose(): Promise<void>;
-    readonly owner: WorkflowToolRunOwner;
+    readonly owner: WorkflowToolRunInbox;
     readonly reader: ChannelReader<"workflow", WorkflowToolRunMessage>;
 }
-/** Receives body messages before routing them to the turn or session owner. */
+/** Receives body messages before routing them to the waiting turn. */
 export declare function openWorkflowToolRunOwnerInbox(): WorkflowToolRunOwnerInbox;
 /** Acknowledge only step-owned events, after delivery or deliberate discard. */
 export declare function deliverWorkflowAuthorization(message: WorkflowToolRunRequestMessage & {

package/dist/src/execution/tools/workflow/owner.js

@@ -1 +1 @@
-import{createHook}from"#compiled/@workflow/core/index.js";import{disposeHook}from"#execution/hook-ownership.js";import{resumeHookStep}from"#execution/tools/workflow/resume-hook-step.js";import{createChannelReader}from"#execution/tools/workflow/owner-channels.js";function openWorkflowToolRunOwnerInbox(){let e=createHook();return{dispose:()=>disposeHook(e),owner:{inbox:e.token},reader:createChannelReader(`workflow`,e)}}async function deliverWorkflowAuthorization(e,t){await t(),e.request.event.childSessionId===e.from.runId&&await resumeHookStep(e.replyTo,null,{ifPresent:!0})}export{deliverWorkflowAuthorization,openWorkflowToolRunOwnerInbox};
+import{createHook}from"#compiled/@workflow/core/index.js";import{resumeHookStep}from"#execution/tools/workflow/resume-hook-step.js";import{createChannelReader}from"#execution/tools/workflow/owner-channels.js";function openWorkflowToolRunOwnerInbox(){let e=createHook(),t=0;return{owner:{get sent(){return t},async send(n){await resumeHookStep(e.token,n),t+=1}},reader:createChannelReader(`workflow`,e)}}async function deliverWorkflowAuthorization(e,t){await t(),e.request.event.childSessionId===e.from.runId&&await resumeHookStep(e.replyTo,null,{ifPresent:!0})}export{deliverWorkflowAuthorization,openWorkflowToolRunOwnerInbox};

package/dist/src/execution/tools/workflow/serve.d.ts

@@ -0,0 +1,3 @@
+import { type StartedWorkflowBody, type WorkflowBodyInput } from "#execution/tools/workflow/body.js";
+/** Starts a `serve` body, which runs once for its task and serves every call to it. */
+export declare function startServeBody(input: WorkflowBodyInput): StartedWorkflowBody;

package/dist/src/execution/tools/workflow/serve.js

@@ -0,0 +1 @@
+import{createRunUsageTally}from"#execution/agent-sessions/usage.js";import{createAgentSessions}from"#execution/agent-sessions/session.js";import{WorkflowToolRunAsks,ask,attachWorkflowToolRunContext}from"#execution/tools/workflow/ask.js";import{WorkflowToolRunCancelledError,createAgentsView,createSharedContext,createWorkflowBodyRef,resolveWorkflowEntryPoint,toFailedOutcome}from"#execution/tools/workflow/body.js";var WorkflowServeCalls=class{asks;run=new AbortController;first;runRef;runSession;owner;usage=createRunUsageTally(()=>this.sendUncarriedUsage());carriedUsage;toolName;seenCallIds;firstReceived=!1;arrived=[];waiting;latest;pendingReceive;stretch;unwindingCancel=!1;endedBy;replies=Promise.resolve();constructor(e){this.runRef=createWorkflowBodyRef(e),this.asks=new WorkflowToolRunAsks(this.runRef.runId),this.runSession=e.session,this.owner=e.owner,this.toolName=e.toolName,this.seenCallIds=new Set([e.callId]),this.first=this.serve({agentContext:e.agentContext,auth:e.session.auth,callId:this.runRef.callId,executeInput:e.executeInput,input:this.runRef.input,sequence:this.runRef.sequence,stepIndex:this.runRef.stepIndex,turnId:this.runRef.turnId}),this.waiting=[this.first],this.latest=this.first}get runSignal(){return this.run.signal}get unwinding(){return this.run.signal.aborted||this.unwindingCancel}get currentSignal(){return this.stretch?.signal??this.run.signal}get current(){return this.latest}apply(e){switch(e.kind){case`call`:this.accept(e.call);return;case`cancel`:this.cancel(new WorkflowToolRunCancelledError(e.reason));return;case`end`:this.end(new WorkflowToolRunCancelledError(e.reason));return;case`interrupt`:return}}receive(){if(!this.firstReceived)return this.firstReceived=!0,Promise.resolve(this.first.call);if(this.unwindingCancel=!1,this.pendingReceive!==void 0)return this.pendingReceive.promise;if(this.endedBy!==void 0)return Promise.reject(this.endedBy);let e=this.arrived.shift();return e===void 0?(this.pendingReceive=createPendingReceive(),this.pendingReceive.promise):(this.take(e),Promise.resolve(e.call))}reply(e){let t=this.waiting;if(t.length===0)return;this.waiting=[],this.arrived.length===0&&(this.stretch=void 0),this.asks.withdrawAll();let n=this.replies;this.replies=n.then(()=>this.deliverReply(t,e))}assertWaiting(){if(!(this.waiting.length>0))throw Error(`ctx.ask() needs a call waiting for a result, but tool "${this.toolName}" already replied to every call it received.`)}async flush(){await this.asks.flush(),await this.replies}sendUncarriedUsage(){if(this.waiting.length>0||this.endedBy!==void 0)return;let{from:e}=this.latest;this.replies=this.replies.then(async()=>{let t=this.usage.total();t===void 0||isSameUsage(t,this.carriedUsage)||(this.carriedUsage=t,await this.owner.send({from:e,kind:`usage`,usage:t}))})}accept(e){if(this.endedBy!==void 0||this.seenCallIds.has(e.callId))return;this.seenCallIds.add(e.callId);let t=this.serve(e),n=this.pendingReceive;if(n===void 0){this.arrived.push(t);return}this.pendingReceive=void 0,this.take(t),n.resolve(t.call)}take(e){this.waiting.push(e),this.latest=e}cancel(e){this.pendingReceive===void 0&&(this.unwindingCancel=!0),this.stretch?.abort(e),this.stretch=void 0,this.waiting=[],this.arrived=[]}end(e){this.asks.cancelAll(),this.endedBy=e,this.run.abort(e),this.stretch?.abort(e);let t=this.pendingReceive;this.pendingReceive=void 0,t?.reject(e)}serve(e){return this.stretch??=new AbortController,{agentContext:e.agentContext,agents:createAgentsView(e.agentContext),call:{abortSignal:this.stretch.signal,callId:e.callId,input:e.executeInput??e.input},from:{...this.runRef,callId:e.callId,input:e.input,sequence:e.sequence,stepIndex:e.stepIndex,turnId:e.turnId},session:{...this.runSession,auth:e.auth,turn:{id:e.turnId,sequence:e.sequence}}}}async deliverReply(e,t){let n=e.at(-1);if(n===void 0)return;let r=e.map(e=>e.from.callId),i=this.usage.total();this.carriedUsage=i,await this.owner.send({callIds:r,from:n.from,kind:`reply`,output:t,...i!==void 0&&{usage:i}})}};function isSameUsage(e,t){return t!==void 0&&e.inputTokens===t.inputTokens&&e.outputTokens===t.outputTokens&&e.cacheReadTokens===t.cacheReadTokens&&e.cacheWriteTokens===t.cacheWriteTokens&&e.costUsd===t.costUsd}function startServeBody(e){let t=new WorkflowServeCalls(e),n={get agentContext(){return t.current.agentContext},asks:t.asks,get auth(){return t.current.session.auth},control:e.hookToken,get from(){return t.current.from},owner:e.owner},r=createAgentSessions(n,t.usage),i=createServeContext(e,t,r.open);return attachWorkflowToolRunContext(i,n),{asks:t.asks,close:r.close,control:t,outcome:executeServeBody(e,t,i),usage:t.usage}}async function executeServeBody(e,t,n){let r;try{r={output:await resolveWorkflowEntryPoint(e)(()=>t.receive(),n),status:`completed`}}catch(e){r=toFailedOutcome(e,t.runSignal)}return await t.flush(),r}function createServeContext(e,t,n){let r={...createSharedContext(e,n,(e,n)=>(t.assertWaiting(),ask(r,e,n))),get abortSignal(){return t.currentSignal},get agents(){return t.current.agents},get callId(){return t.current.from.callId},get session(){return t.current.session},reply:e=>t.reply(e)};return r}function createPendingReceive(){let e,t;return{promise:new Promise((n,r)=>{e=n,t=r}),reject:t,resolve:e}}export{startServeBody};

package/dist/src/execution/tools/workflow/start.d.ts

@@ -1,26 +1,33 @@
 import type { SessionAuth, SessionParent } from "#context/session-context.js";
-import type { RuntimeSession } from "#subagents/handle-dispatch.js";
-import type { RuntimeToolResultActionResult, RuntimeWorkflowTaskRequest } from "#shared/action-types.js";
+import type { AgentSessionContext } from "#execution/agent-sessions/context.js";
+import type { HarnessSession } from "#harness/types.js";
+import type { RuntimeToolResultActionResult, RuntimeWorkflowTaskRequest, WorkflowToolRunEntry } from "#shared/action-types.js";
 import type { WorkflowToolRunAddress, WorkflowToolRunInput } from "#execution/tools/workflow/types.js";
 import type { WorkflowToolRunOwner } from "#execution/tools/workflow/messages.js";
 /** Starts a new run for each dispatch attempt. Call from a `"use step"` body. */
 export declare function startWorkflowToolRun(input: Omit<WorkflowToolRunInput, "hookToken">): Promise<WorkflowToolRunAddress>;
-/** Starts one durable workflow task and records it on the owning session. */
-export declare function startWorkflowTask(input: {
-    readonly agents: WorkflowToolRunInput["agents"];
-    readonly auth: SessionAuth["current"];
-    readonly canRequestInput: boolean;
+/** Everything the session knows when it starts one workflow tool call's run. */
+export interface StartWorkflowTaskInput {
+    /** Captured for this call, as the context of the sessions opened for it. */
+    readonly agentContext: AgentSessionContext;
+    /** The caller's auth the session admits the call with. */
+    readonly auth: SessionAuth;
     readonly batchEvent: {
         readonly sequence: number;
         readonly stepIndex: number;
         readonly turnId: string;
     };
-    readonly initiatorAuth: SessionAuth["initiator"];
     readonly owner: WorkflowToolRunOwner;
     readonly parentSession: SessionParent | undefined;
-    readonly session: RuntimeSession;
+    readonly session: HarnessSession;
     readonly task: RuntimeWorkflowTaskRequest;
-}): Promise<{
+}
+/** Starts the run for one call, which invokes `entry`. */
+export declare function startWorkflowToolCallRun(input: StartWorkflowTaskInput, entry: WorkflowToolRunEntry): Promise<WorkflowToolRunAddress>;
+/** Starts the run of an `execute` call the turn waits on and records it on the owning session. */
+export declare function startWorkflowTask(input: StartWorkflowTaskInput): Promise<{
     readonly result?: RuntimeToolResultActionResult;
-    readonly session: RuntimeSession;
+    readonly session: HarnessSession;
 }>;
+/** The call's tool result when its run could not start. */
+export declare function startFailureResult(task: RuntimeWorkflowTaskRequest, error: unknown): RuntimeToolResultActionResult;

package/dist/src/execution/tools/workflow/start.js

@@ -1 +1 @@
-import{createLogger,logError}from"#internal/logging.js";import{toError}from"#shared/errors.js";import{startWorkflowOnCurrentDeployment,workflowToolRunWorkflowReference}from"#execution/workflow-runtime.js";import{registerWorkflowToolRun}from"#harness/workflow-tool-runs.js";import{createRuntimeToolResultFromValue}from"#harness/action-result-helpers.js";const log=createLogger(`execution.workflow-tool-run`);async function startWorkflowToolRun(e){let t=crypto.randomUUID();return{hookToken:t,runId:(await startWorkflowOnCurrentDeployment(workflowToolRunWorkflowReference,[{...e,hookToken:t}])).runId}}async function startWorkflowTask(e){let{task:t,batchEvent:n,session:r}=e;try{let i=await startWorkflowToolRun({agents:e.agents,callId:t.callId,canRequestInput:e.canRequestInput,executeInput:t.executeInput,input:t.input,owner:e.owner,session:{auth:{current:e.auth,initiator:e.initiatorAuth},id:r.sessionId,parent:e.parentSession,turn:{id:n.turnId,sequence:n.sequence}},stepIndex:n.stepIndex,toolName:t.toolName,workflowId:t.workflowId});return{session:registerWorkflowToolRun(r,{callId:t.callId,lifetime:`turn`,origin:{turnId:n.turnId,stepIndex:n.stepIndex},address:i,toolName:t.toolName})}}catch(e){return logError(log,`workflow tool run failed to start`,e,{callId:t.callId,toolName:t.toolName}),{result:createRuntimeToolResultFromValue({callId:t.callId,isError:!0,output:toError(e),toolName:t.toolName}),session:r}}}export{startWorkflowTask,startWorkflowToolRun};
+import{createLogger,logError}from"#internal/logging.js";import{toError}from"#shared/errors.js";import{startWorkflowOnCurrentDeployment,workflowToolRunWorkflowReference}from"#execution/workflow-runtime.js";import{registerWorkflowToolRun}from"#harness/workflow-tool-runs.js";import{createRuntimeToolResultFromValue}from"#harness/action-result-helpers.js";const log=createLogger(`execution.workflow-tool-run`);async function startWorkflowToolRun(e){let t=e.entry.entryPoint===`execute`?crypto.randomUUID():taskRunHookToken(e.session.id,e.entry.taskId);return{hookToken:t,runId:(await startWorkflowOnCurrentDeployment(workflowToolRunWorkflowReference,[{...e,hookToken:t}])).runId}}function taskRunHookToken(e,t){return`eve:task:${e}:${t}`}async function startWorkflowToolCallRun(e,t){let{task:n,batchEvent:r,session:i}=e;return await startWorkflowToolRun({agentContext:e.agentContext,callId:n.callId,entry:t,executeInput:n.executeInput,input:n.input,owner:e.owner,session:{auth:e.auth,id:i.sessionId,parent:e.parentSession,turn:{id:r.turnId,sequence:r.sequence}},stepIndex:r.stepIndex,toolName:n.toolName,workflowId:n.workflowId})}async function startWorkflowTask(e){let{task:t,batchEvent:n,session:r}=e;try{let i=await startWorkflowToolCallRun(e,{entryPoint:`execute`});return{session:registerWorkflowToolRun(r,{callId:t.callId,origin:{turnId:n.turnId,stepIndex:n.stepIndex},address:i,toolName:t.toolName})}}catch(e){return logError(log,`workflow tool run failed to start`,e,{callId:t.callId,toolName:t.toolName}),{result:startFailureResult(t,e),session:r}}}function startFailureResult(e,t){return createRuntimeToolResultFromValue({callId:e.callId,isError:!0,output:toError(t),toolName:e.toolName})}export{startFailureResult,startWorkflowTask,startWorkflowToolCallRun,startWorkflowToolRun};

package/dist/src/execution/tools/workflow/step-execution.js

@@ -1 +1 @@
-import{ContextContainer,contextStorage}from"#context/container.js";import{AuthKey,InitiatorAuthKey,SessionIdKey,SessionKey}from"#context/keys.js";import{getStepMetadata}from"#compiled/@workflow/core/index.js";import{AuthorizationHookKey,CallbackBaseUrlKey,PendingAuthorizationResultKey,isAuthorizationSignal}from"#harness/authorization.js";import{resolveWorkflowCallbackBaseUrl}from"#execution/workflow-callback-url.js";import{buildBaseToolContext}from"#context/build-base-tool-context.js";import{createAuthorizationContext}from"#runtime/authorization-context.js";import{isConnectionAuthorizationFailedError}from"#connections/errors.js";import{completeWorkflowStepAuthorization}from"#execution/tools/workflow/authorization-completion.js";import"#execution/tools/workflow/step-context.js";function withWorkflowStepAuthorization(e){let wrapped=async function(t){let{args:n,context:r}=t;getStepMetadata();let i=new ContextContainer;return i.set(AuthKey,r.session.auth.current),i.set(InitiatorAuthKey,r.session.auth.initiator),i.set(SessionIdKey,r.session.id),i.setVirtualContext(SessionKey,{...r.session,sessionId:r.session.id}),i.set(CallbackBaseUrlKey,resolveWorkflowCallbackBaseUrl(r.baseUrl)),i.setVirtualContext(AuthorizationHookKey,r.token),i.setVirtualContext(PendingAuthorizationResultKey,r.authorizationResults),contextStorage.run(i,async()=>{let a=createAuthorizationContext({scope:r.toolName,completeAuthorization:completeWorkflowStepAuthorization}),o={...buildBaseToolContext({toolName:r.toolName,options:{abortSignal:r.abortSignal,toolCallId:r.callId}}),agent:()=>unavailableInStep(`ctx.agent()`,`Call ctx.agent() in the workflow body.`),ask:()=>unavailableInStep(`ctx.ask()`,`Call ctx.ask() in the workflow body.`),getToken:a.getToken,requireAuth:a.requireAuth};Object.defineProperty(o,"agents",{get:()=>unavailableInStep(`ctx.agents`,`Read ctx.agents in the workflow body and pass the required serializable metadata into the step.`)});let s;try{s=await a.run(()=>Reflect.apply(e,this,n.map((e,n)=>t.contextIndexes.includes(n)?o:e)))}catch(e){throw isConnectionAuthorizationFailedError(e)&&!e.retryable&&Object.assign(e,{fatal:!0}),e}let c=i.get(PendingAuthorizationResultKey)??[],l=r.authorizationResults.filter(e=>!c.includes(e)).map(e=>e.attemptId);return isAuthorizationSignal(s)?{kind:`authorization-required`,signal:s,authorized:l}:{kind:`result`,output:s,authorized:l}})};return Object.defineProperty(wrapped,"maxRetries",{get:()=>Reflect.get(e,`maxRetries`)}),wrapped}function unavailableInStep(e,t){throw Object.assign(Error(`${e} is unavailable inside a "use step" function. ${t}`),{fatal:!0})}export{withWorkflowStepAuthorization};
+import{ContextContainer,contextStorage}from"#context/container.js";import{AuthKey,InitiatorAuthKey,SessionIdKey,SessionKey}from"#context/keys.js";import{getStepMetadata}from"#compiled/@workflow/core/index.js";import{resolveWorkflowCallbackBaseUrl}from"#execution/workflow-callback-url.js";import{AuthorizationHookKey,CallbackBaseUrlKey,PendingAuthorizationResultKey,isAuthorizationSignal}from"#harness/authorization.js";import{buildBaseToolContext}from"#context/build-base-tool-context.js";import{createAuthorizationContext}from"#runtime/authorization-context.js";import{isConnectionAuthorizationFailedError}from"#connections/errors.js";import{completeWorkflowStepAuthorization}from"#execution/tools/workflow/authorization-completion.js";import"#execution/tools/workflow/step-context.js";function withWorkflowStepAuthorization(e){let wrapped=async function(t){let{args:n,context:r}=t;getStepMetadata();let i=new ContextContainer;return i.set(AuthKey,r.session.auth.current),i.set(InitiatorAuthKey,r.session.auth.initiator),i.set(SessionIdKey,r.session.id),i.setVirtualContext(SessionKey,{...r.session,sessionId:r.session.id}),i.set(CallbackBaseUrlKey,resolveWorkflowCallbackBaseUrl(r.baseUrl)),i.setVirtualContext(AuthorizationHookKey,r.token),i.setVirtualContext(PendingAuthorizationResultKey,r.authorizationResults),contextStorage.run(i,async()=>{let a=createAuthorizationContext({scope:r.toolName,completeAuthorization:completeWorkflowStepAuthorization}),o={...buildBaseToolContext({toolName:r.toolName,options:{abortSignal:r.abortSignal,toolCallId:r.callId}}),agent:()=>unavailableInStep(`ctx.agent()`,`Call ctx.agent() in the workflow body.`),ask:()=>unavailableInStep(`ctx.ask()`,`Call ctx.ask() in the workflow body.`),getToken:a.getToken,requireAuth:a.requireAuth};Object.defineProperty(o,"agents",{get:()=>unavailableInStep(`ctx.agents`,`Read ctx.agents in the workflow body and pass the required serializable metadata into the step.`)});let s;try{s=await a.run(()=>Reflect.apply(e,this,n.map((e,n)=>t.contextIndexes.includes(n)?o:e)))}catch(e){throw isConnectionAuthorizationFailedError(e)&&!e.retryable&&Object.assign(e,{fatal:!0}),e}let c=i.get(PendingAuthorizationResultKey)??[],l=r.authorizationResults.filter(e=>!c.includes(e)).map(e=>e.attemptId);return isAuthorizationSignal(s)?{kind:`authorization-required`,signal:s,authorized:l}:{kind:`result`,output:s,authorized:l}})};return Object.defineProperty(wrapped,"maxRetries",{get:()=>Reflect.get(e,`maxRetries`)}),wrapped}function unavailableInStep(e,t){throw Object.assign(Error(`${e} is unavailable inside a "use step" function. ${t}`),{fatal:!0})}export{withWorkflowStepAuthorization};

package/dist/src/execution/tools/workflow/step.js

@@ -1 +1 @@
-import{createAuthorizationCompletedEvent,createAuthorizationRequiredEvent}from"#protocol/message.js";import{createHook,getWorkflowMetadata}from"#compiled/@workflow/core/index.js";import{disposeHook}from"#execution/hook-ownership.js";import{resumeHookStep}from"#execution/tools/workflow/resume-hook-step.js";import{findWorkflowToolRunContext}from"#execution/tools/workflow/ask.js";function workflowToolStep(e,t){return new Proxy(e,{apply(e,n,r){let i=findWorkflowContextArgument(r);return i===void 0?Reflect.apply(e,n,r):executeAuthorizedStep(t,n,r,i)}})}function findWorkflowContextArgument(e){for(let t of e){let e=findWorkflowToolRunContext(t);if(e!==void 0)return{ctx:t,run:e}}}async function executeAuthorizedStep(e,t,n,r){let{ctx:i,run:a}=r,o=[],s=new Map;for(;;){let r=createHook();try{let c;try{c=await invokeAuthorizedStep({args:n,authorizationResults:o,callbackToken:r.token,ctx:i,execute:e,receiver:t})}catch(e){throw i.abortSignal.aborted||await reportPendingAsFailed(a,i.abortSignal,s),e}if(await reconcileCompletedAuthorizations(a,i.abortSignal,s,o,c.authorized),c.kind===`result`)return await reportPendingAsFailed(a,i.abortSignal,s),c.output;await collectAuthorizationCallbacks({authorizationResults:o,callback:r,challenges:c.signal.challenges,ctx:i,pending:s,run:a})}finally{await disposeHook(r)}}}async function invokeAuthorizedStep(e){let{args:t,authorizationResults:n,callbackToken:r,ctx:i,execute:a,receiver:o}=e,s={callId:i.callId,toolName:i.toolName,session:i.session,abortSignal:i.abortSignal,baseUrl:getWorkflowMetadata().url,token:r,authorizationResults:n},c={args:t.map(e=>e===i?null:e),context:s,contextIndexes:t.flatMap((e,t)=>e===i?[t]:[])};return await a.call(o,c)}async function reconcileCompletedAuthorizations(e,t,n,r,i){let a=new Set(i);for(let r of a){let i=n.get(r);i!==void 0&&await reportAuthorization(e,t,i,`authorized`),n.delete(r)}for(let e=r.length-1;e>=0;e--){let t=r[e];t!==void 0&&a.has(t.attemptId)&&r.splice(e,1)}}async function collectAuthorizationCallbacks(e){let{authorizationResults:t,callback:n,challenges:r,ctx:i,pending:a,run:o}=e;for(let e of r){let r=requireAttemptId(e);a.set(r.attemptId,r),await reportAuthorization(o,i.abortSignal,r);try{let e=await waitForCallback(n,r,i.abortSignal);t.push({name:r.name,instanceId:r.instanceId,attemptId:r.attemptId,hookUrl:r.hookUrl,principal:r.principal,resume:r.resume,callback:e})}catch(e){throw i.abortSignal.aborted||await reportAuthorization(o,i.abortSignal,r,`failed`),e}}}function requireAttemptId(e){if(e.attemptId===void 0)throw Error(`Workflow authorization challenge "${e.name}" has no attempt id.`);return e}async function reportPendingAsFailed(e,t,n){for(let r of n.values())await reportAuthorization(e,t,r,`failed`)}async function reportAuthorization(e,t,n,r){let i={attemptId:n.attemptId,name:n.name,sequence:e.from.sequence,stepIndex:e.from.stepIndex,turnId:e.from.turnId,authorization:n.challenge},a=r===void 0?createAuthorizationRequiredEvent({...i,description:`Sign in to ${n.name} to continue.`,webhookUrl:n.hookUrl}):createAuthorizationCompletedEvent({...i,outcome:r}),o=createHook();try{await withAbort(resumeHookStep(e.owner.inbox,{kind:`request`,from:e.from,replyTo:o.token,request:{kind:`authorization-request`,event:{kind:`subagent-authorization-event`,callId:e.from.callId,childSessionId:e.from.runId,subagentName:e.from.toolName,event:a}}}),t),await withAbort(o,t)}finally{await disposeHook(o)}}async function waitForCallback(e,t,n){let r=e[Symbol.asyncIterator]();for(;;){let e=await withAbort(r.next(),n);if(e.done)throw Error(`Authorization callback closed before sign-in completed.`);let i=readCallback(e.value,t);if(i!==void 0)return i}}async function withAbort(e,t){let abort,n=new Promise((e,n)=>{abort=()=>n(t.reason??Error(`Workflow authorization cancelled.`)),t.addEventListener(`abort`,abort,{once:!0}),t.aborted&&abort()});try{return await Promise.race([e,n])}finally{t.removeEventListener(`abort`,abort)}}function readCallback(e,t){if(typeof e==`object`&&e&&`payloads`in e&&Array.isArray(e.payloads))for(let n of e.payloads){let e=n?.authorizationCallback;if(e?.attemptId!==t.attemptId||e?.connectionName!==t.name)continue;let r=e.callback;if(!(typeof r?.method!=`string`||typeof r.params!=`object`||r.params===null||Array.isArray(r.params))&&Object.values(r.params).every(e=>typeof e==`string`)&&(r.body===void 0||typeof r.body==`string`))return r}}export{workflowToolStep};
+import{createAuthorizationCompletedEvent,createAuthorizationRequiredEvent}from"#protocol/message.js";import{createHook,getWorkflowMetadata}from"#compiled/@workflow/core/index.js";import{disposeHook}from"#execution/hook-ownership.js";import{authorizationEventFields}from"#harness/authorization-event-fields.js";import{findWorkflowToolRunContext}from"#execution/tools/workflow/ask.js";function workflowToolStep(e,t){return new Proxy(e,{apply(e,n,r){let i=findWorkflowContextArgument(r);return i===void 0?Reflect.apply(e,n,r):executeAuthorizedStep(t,n,r,i)}})}function findWorkflowContextArgument(e){for(let t of e){let e=findWorkflowToolRunContext(t);if(e!==void 0)return{ctx:t,run:e}}}async function executeAuthorizedStep(e,t,n,r){let{ctx:i,run:a}=r,o=[],s=new Map;for(;;){let r=createHook();try{let c;try{c=await invokeAuthorizedStep({args:n,authorizationResults:o,callbackToken:r.token,ctx:i,execute:e,receiver:t})}catch(e){throw i.abortSignal.aborted||await reportPendingAsFailed(a,i.abortSignal,s),e}if(await reconcileCompletedAuthorizations(a,i.abortSignal,s,o,c.authorized),c.kind===`result`)return await reportPendingAsFailed(a,i.abortSignal,s),c.output;await collectAuthorizationCallbacks({authorizationResults:o,callback:r,challenges:c.signal.challenges,ctx:i,pending:s,run:a})}finally{await disposeHook(r)}}}async function invokeAuthorizedStep(e){let{args:t,authorizationResults:n,callbackToken:r,ctx:i,execute:a,receiver:o}=e,s={callId:i.callId,toolName:i.toolName,session:i.session,abortSignal:i.abortSignal,baseUrl:getWorkflowMetadata().url,token:r,authorizationResults:n},c={args:t.map(e=>e===i?null:e),context:s,contextIndexes:t.flatMap((e,t)=>e===i?[t]:[])};return await a.call(o,c)}async function reconcileCompletedAuthorizations(e,t,n,r,i){let a=new Set(i);for(let r of a){let i=n.get(r);i!==void 0&&await reportAuthorization(e,t,i,`authorized`),n.delete(r)}for(let e=r.length-1;e>=0;e--){let t=r[e];t!==void 0&&a.has(t.attemptId)&&r.splice(e,1)}}async function collectAuthorizationCallbacks(e){let{authorizationResults:t,callback:n,challenges:r,ctx:i,pending:a,run:o}=e;for(let e of r){let r=requireAttemptId(e);a.set(r.attemptId,r),await reportAuthorization(o,i.abortSignal,r);try{let e=await waitForCallback(n,r,i.abortSignal);t.push({name:r.name,instanceId:r.instanceId,attemptId:r.attemptId,hookUrl:r.hookUrl,principal:r.principal,resume:r.resume,callback:e})}catch(e){throw i.abortSignal.aborted||await reportAuthorization(o,i.abortSignal,r,`failed`),e}}}function requireAttemptId(e){if(e.attemptId===void 0)throw Error(`Workflow authorization challenge "${e.name}" has no attempt id.`);return e}async function reportPendingAsFailed(e,t,n){for(let r of n.values())await reportAuthorization(e,t,r,`failed`)}async function reportAuthorization(e,t,n,r){let i={...authorizationEventFields(n),sequence:e.from.sequence,stepIndex:e.from.stepIndex,taskId:e.from.taskId,turnId:e.from.turnId},a=r===void 0?createAuthorizationRequiredEvent({...i,description:`Sign in to ${n.name} to continue.`,webhookUrl:n.hookUrl}):createAuthorizationCompletedEvent({...i,outcome:r}),o=createHook();try{await withAbort(e.owner.send({kind:`request`,from:e.from,replyTo:o.token,request:{kind:`authorization-request`,event:{kind:`subagent-authorization-event`,callId:e.from.callId,childSessionId:e.from.runId,subagentName:e.from.toolName,event:a}}}),t),await withAbort(o,t)}finally{await disposeHook(o)}}async function waitForCallback(e,t,n){let r=e[Symbol.asyncIterator]();for(;;){let e=await withAbort(r.next(),n);if(e.done)throw Error(`Authorization callback closed before sign-in completed.`);let i=readCallback(e.value,t);if(i!==void 0)return i}}async function withAbort(e,t){let abort,n=new Promise((e,n)=>{abort=()=>n(t.reason??Error(`Workflow authorization cancelled.`)),t.addEventListener(`abort`,abort,{once:!0}),t.aborted&&abort()});try{return await Promise.race([e,n])}finally{t.removeEventListener(`abort`,abort)}}function readCallback(e,t){if(typeof e==`object`&&e&&`payloads`in e&&Array.isArray(e.payloads))for(let n of e.payloads){let e=n?.authorizationCallback;if(e?.attemptId!==t.attemptId||e?.connectionName!==t.name)continue;let r=e.callback;if(!(typeof r?.method!=`string`||typeof r.params!=`object`||r.params===null||Array.isArray(r.params))&&Object.values(r.params).every(e=>typeof e==`string`)&&(r.body===void 0||typeof r.body==`string`))return r}}export{workflowToolStep};

package/dist/src/execution/tools/workflow/types.d.ts

@@ -1,9 +1,6 @@
-import type { ActivityObserverConfig } from "#channel/types.js";
-import type { TaskView } from "#tasks/types.js";
 import type { WorkflowBodyDefinition } from "#execution/tools/workflow/body.js";
 import type { WorkflowToolRunOwner } from "#execution/tools/workflow/messages.js";
 export interface WorkflowToolRunInput extends WorkflowBodyDefinition {
-    readonly execution?: "background" | "blocking";
     readonly hookToken: string;
     readonly owner: WorkflowToolRunOwner;
 }
@@ -11,10 +8,3 @@ export interface WorkflowToolRunAddress {
     readonly hookToken: string;
     readonly runId: string;
 }
-export interface BackgroundWorkflowToolRunInput {
-    readonly activityObserver?: ActivityObserverConfig;
-    readonly initialView: TaskView;
-    readonly parentContinuationToken: string;
-    readonly taskInboxToken: string;
-    readonly workflow: WorkflowBodyDefinition;
-}