eve 0.37.0 → 0.38.0

package/dist/src/execution/tasks/parent/continuation-dispatch.d.ts

@@ -0,0 +1,37 @@
+import { type DispatchOutcome, type RuntimeAgentHandleAction, type RuntimeSession } from "#execution/agent-handle-dispatch.js";
+import { settleDelegatedDispatch, type DelegatedTask } from "#execution/tasks/parent/delegate.js";
+import { describeTaskAgent } from "#execution/tasks/parent/agent-identity.js";
+import type { RuntimeSubagentDispatchFailure } from "#runtime/actions/types.js";
+export type PersistedContinuationTask = Awaited<ReturnType<typeof settleDelegatedDispatch>>;
+/** Describes task identity from the stored address when continuing an agent. */
+export declare function describeTaskDispatch(input: {
+    readonly action: RuntimeAgentHandleAction;
+    readonly agentId: string | undefined;
+    readonly parentSessionId: string;
+    readonly parentTurnId: string;
+    readonly session: RuntimeSession;
+}): ReturnType<typeof describeTaskAgent>;
+export declare function checkTaskContinuationAvailability(input: {
+    readonly action: RuntimeAgentHandleAction;
+    readonly agentId: string;
+    readonly parentStepIndex: number;
+    readonly parentTurnId: string;
+    readonly session: RuntimeSession;
+}): Promise<RuntimeSubagentDispatchFailure | undefined>;
+/**
+ * Persists the task's ownership and routing entry in the parent session's
+ * `eve.tasks` index and creates its parked tool-call receipt before dispatch.
+ */
+export declare function persistContinuationTaskInParentSession(input: {
+    readonly action: RuntimeAgentHandleAction;
+    readonly agentId: string;
+    readonly delegated: DelegatedTask;
+    readonly session: RuntimeSession;
+}): Promise<PersistedContinuationTask | undefined>;
+export declare function settleTaskDispatchError(input: {
+    readonly delegated: DelegatedTask;
+    readonly outcome: Extract<DispatchOutcome, {
+        readonly kind: "error";
+    }>;
+    readonly persisted: PersistedContinuationTask | undefined;
+}): Promise<RuntimeSubagentDispatchFailure>;

package/dist/src/execution/tasks/parent/continuation-dispatch.js

@@ -0,0 +1 @@
+import{AGENT_BUSY}from"#harness/agent-handle-errors.js";import{createAgentErrorResult}from"#execution/agent-handle-dispatch.js";import{findActiveTaskForAgent,findTaskAgentAddress}from"#execution/tasks/parent/control-shared.js";import{failDelegatedDispatch,rejectDelegatedDispatch,settleDelegatedDispatch}from"#execution/tasks/parent/delegate.js";import{describeTaskAgent}from"#execution/tasks/parent/agent-identity.js";function describeTaskDispatch(e){let t=describeTaskAgent(e),n=e.agentId===void 0?void 0:findTaskAgentAddress(e.session,e.agentId);return n===void 0?t:{...t,mode:n.address.kind===`agent/remote`?`remote`:`local`}}async function checkTaskContinuationAvailability(r){let i=await findActiveTaskForAgent(r.session,r.agentId,r.parentTurnId,r.parentStepIndex);return i===void 0?void 0:createAgentErrorResult({action:r.action,code:AGENT_BUSY,message:`Agent "${r.agentId}" is busy with task "${i.view.taskId}" (${i.view.status}).`})}async function persistContinuationTaskInParentSession(e){let t=findTaskAgentAddress(e.session,e.agentId);if(t!==void 0)return settleDelegatedDispatch({callId:e.action.callId,session:e.session,subagentName:t.identity.name,task:e.delegated})}async function settleTaskDispatchError(e){return e.persisted!==void 0&&e.outcome.deliveryAmbiguous===!0||await(e.persisted===void 0?rejectDelegatedDispatch:failDelegatedDispatch)({error:e.outcome.result.output,task:e.delegated}),e.persisted===void 0?e.outcome.result:{...e.outcome.result,output:attachTaskId(e.outcome.result.output,e.delegated.taskId)}}function attachTaskId(e,t){return typeof e==`object`&&e&&!Array.isArray(e)?{...e,taskId:t}:{error:e,taskId:t}}export{checkTaskContinuationAvailability,describeTaskDispatch,persistContinuationTaskInParentSession,settleTaskDispatchError};

package/dist/src/execution/tasks/parent/control-shared.d.ts

@@ -0,0 +1,36 @@
+import type { RuntimeSession } from "#execution/agent-handle-dispatch.js";
+import { type AgentHandle } from "#harness/handles/store.js";
+import type { RuntimeActionResult, RuntimeToolCallActionRequest } from "#runtime/actions/types.js";
+import { type SessionTaskIndexEntry } from "#tasks/session-index.js";
+import type { TaskView } from "#tasks/types.js";
+/**
+ * Result and lookup helpers shared by the task-control executors
+ * (`task_peek`/`task_cancel` in the dispatch module,
+ * `task_send` in its own).
+ */
+/** Resolves owned index entries, or the ids this session does not own. */
+export declare function lookupTaskEntries(session: RuntimeSession, taskIds: readonly string[]): {
+    readonly entries: SessionTaskIndexEntry[];
+    readonly kind: "found";
+} | {
+    readonly kind: "unknown";
+    readonly unknown: string[];
+};
+/** Reads the latest view of every entry, defaulting to `working`. */
+export declare function readTaskViews(entries: readonly SessionTaskIndexEntry[]): Promise<TaskView[]>;
+export declare function readTaskView(entry: SessionTaskIndexEntry): Promise<TaskView>;
+/** Finds the persistent address record for one task-owned agent. */
+export declare function findTaskAgentAddress(session: RuntimeSession, agentId: string): Extract<AgentHandle, {
+    phase: "addressed";
+}> | undefined;
+/** Returns the one nonterminal task owning an agent, if any. */
+export declare function findActiveTaskForAgent(session: RuntimeSession, agentId: string, parentTurnId?: string, parentStepIndex?: number): Promise<{
+    readonly entry: SessionTaskIndexEntry;
+    readonly view: TaskView;
+} | undefined>;
+/** One successful task-control result carrying full task views. */
+export declare function createTaskViewsResult(action: RuntimeToolCallActionRequest, views: readonly TaskView[]): RuntimeActionResult;
+/** One task-control error the model can act on. */
+export declare function createTaskControlError(action: RuntimeToolCallActionRequest, message: string): RuntimeActionResult;
+/** The ownership error for ids outside this session's task index. */
+export declare function createUnknownTasksError(action: RuntimeToolCallActionRequest, unknown: readonly string[]): RuntimeActionResult;

package/dist/src/execution/tasks/parent/control-shared.js

@@ -0,0 +1 @@
+import{getAgentHandleStore}from"#harness/handles/store.js";import{readLatestTaskView}from"#execution/tasks/parent/run-parent.js";import{findSessionTaskEntry,getSessionTaskIndex}from"#tasks/session-index.js";import{isTaskWorkflowTargetGone}from"#execution/tasks/workflow-target.js";import{taskViewsToJson}from"#tasks/json.js";function lookupTaskEntries(e,t){let r=[],i=[];for(let a of t){let t=findSessionTaskEntry(e.state,a);t===void 0?i.push(a):r.push(t)}return i.length>0?{kind:`unknown`,unknown:i}:{entries:r,kind:`found`}}async function readTaskViews(e){return Promise.all(e.map(readTaskView))}async function readTaskView(e){try{return await readLatestTaskView({taskRunId:e.taskRunId})??createPendingTaskView(e)}catch(t){if(isTaskWorkflowTargetGone(t)&&e.terminalView!==void 0)return e.terminalView;throw t}}function createPendingTaskView(e){return{metadata:e.metadata,status:`working`,taskId:e.taskId}}function findTaskAgentAddress(t,n){return(getAgentHandleStore(t.state)?.handles??[]).find(e=>e.phase===`addressed`&&e.identity.id===n)}async function findActiveTaskForAgent(e,t,n,i){let a=getSessionTaskIndex(e.state).filter(e=>e.metadata.agentId===t),o=await readTaskViews(a);return a.flatMap((e,t)=>{let r=o[t];return r!==void 0&&(e.createdByTurnId===n&&e.createdByStepIndex===i||r.status===`working`||r.status===`input_required`)?[{entry:e,view:r}]:[]})[0]}function createTaskViewsResult(e,t){return{callId:e.callId,kind:`tool-result`,output:taskViewsToJson(t),toolName:e.toolName}}function createTaskControlError(e,t){return{callId:e.callId,isError:!0,kind:`tool-result`,output:{message:t},toolName:e.toolName}}function createUnknownTasksError(e,t){return createTaskControlError(e,`Unknown task ids: ${t.join(`, `)}. Tasks belong to the session that created them.`)}export{createTaskControlError,createTaskViewsResult,createUnknownTasksError,findActiveTaskForAgent,findTaskAgentAddress,lookupTaskEntries,readTaskView,readTaskViews};

package/dist/src/execution/tasks/parent/delegate.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Delegation policy for the subagent dispatch path: derives task identity,
+ * builds metadata and the parked-tool-call receipt, records the session
+ * index, and defines failure semantics for an unacknowledged dispatch.
+ * Task-run transport (start/command/view) lives in `run-parent.ts`, which
+ * this module composes and which other non-delegation callers share.
+ */
+import type { RuntimeSession } from "#execution/agent-handle-dispatch.js";
+import type { RuntimeSubagentChildResult } from "#runtime/actions/types.js";
+import type { JsonValue } from "#shared/json.js";
+import { type TaskMetadata } from "#tasks/types.js";
+/** A prepared delegated task: identity plus its started durable run. */
+export interface DelegatedTask {
+    readonly taskInboxToken: string;
+    readonly createdByStepIndex?: number;
+    readonly createdByTurnId: string;
+    readonly metadata: TaskMetadata;
+    readonly operationId: string;
+    readonly taskId: string;
+    readonly taskRunId: string;
+}
+/**
+ * Creates the durable task record for one delegated subagent call,
+ * before the child dispatch side effect. The task must exist first so
+ * a fast child always finds a live command hook; a duplicate replay
+ * re-derives the same token and the loser exits on the hook claim.
+ */
+export declare function beginDelegatedTask(input: {
+    readonly agentId: string;
+    readonly callId: string;
+    readonly mode: "local" | "remote";
+    readonly name: string;
+    readonly parentSessionId: string;
+    readonly parentStepIndex?: number;
+    readonly parentTurnId: string;
+    readonly session: RuntimeSession;
+}): Promise<DelegatedTask>;
+/**
+ * Settles a delegated dispatch that acknowledged a child: persists the task
+ * in the session index and returns the receipt that resolves the originating
+ * tool call. Agent identity and routing remain in the persistent address
+ * record; task state owns execution availability.
+ */
+export declare function settleDelegatedDispatch(input: {
+    readonly callId: string;
+    readonly session: RuntimeSession;
+    readonly subagentName: string;
+    readonly task: DelegatedTask;
+}): Promise<{
+    readonly receipt: RuntimeSubagentChildResult;
+    readonly session: RuntimeSession;
+}>;
+/** Releases task events only after the parent session index committed. */
+export declare function acknowledgeDelegatedTasksStep(input: {
+    readonly tasks: readonly {
+        readonly taskInboxToken: string;
+        readonly taskId: string;
+        readonly taskRunId: string;
+    }[];
+}): Promise<void>;
+/** Fails an indexed task whose child dispatch was definitively rejected. */
+export declare function failDelegatedDispatch(input: {
+    readonly error: JsonValue;
+    readonly task: DelegatedTask;
+}): Promise<void>;
+/** Silently terminates a task whose child dispatch failed before parent indexing. */
+export declare function rejectDelegatedDispatch(input: {
+    readonly error: JsonValue;
+    readonly task: DelegatedTask;
+}): Promise<void>;

package/dist/src/execution/tasks/parent/delegate.js

@@ -0,0 +1 @@
+import{sessionCommandHookToken}from"#execution/session-command-token.js";import{deriveAgentOperationId}from"#harness/handles/operation-id.js";import{deriveTaskId,deriveTaskInboxToken}from"#tasks/task-id.js";import{readLatestTaskView,sendTaskCommand,sendTaskCommandToOwner,startTaskRun,waitForTaskCommandOwner}from"#execution/tasks/parent/run-parent.js";import{recordSessionTask}from"#tasks/session-index.js";import{isTerminalTaskStatus}from"#tasks/types.js";async function beginDelegatedTask(n){let r=deriveTaskId({callId:n.callId,parentSessionId:n.parentSessionId,parentTurnId:n.parentTurnId}),i=deriveTaskInboxToken({parentContinuationToken:n.session.continuationToken,taskId:r}),a=deriveAgentOperationId({callId:n.callId,parentSessionId:n.parentSessionId,parentTurnId:n.parentTurnId}),o={agentId:n.agentId,kind:`subagent`,mode:n.mode,name:n.name};await startTaskRun({taskInboxToken:i,initialView:{metadata:o,status:`working`,taskId:r},parentContinuationToken:sessionCommandHookToken(n.session.sessionId)});let s=await waitForTaskCommandOwner({taskInboxToken:i});return{taskInboxToken:i,createdByStepIndex:n.parentStepIndex??0,createdByTurnId:n.parentTurnId,metadata:o,operationId:a,taskId:r,taskRunId:s.runId}}async function settleDelegatedDispatch(e){let t={agentId:e.task.metadata.agentId,status:`working`,taskId:e.task.taskId};return{receipt:{backgroundTask:{status:t.status,taskId:t.taskId},callId:e.callId,kind:`subagent-result`,origin:`child`,outcome:{kind:`parked`,result:{kind:`succeeded`,output:`Delegated as background task ${e.task.taskId} (working).`},usageDelta:{cacheReadTokens:0,cacheWriteTokens:0,inputTokens:0,outputTokens:0}},output:t,subagentName:e.subagentName},session:recordSessionTask(e.session,{taskInboxToken:e.task.taskInboxToken,createdByStepIndex:e.task.createdByStepIndex,createdByTurnId:e.task.createdByTurnId,metadata:e.task.metadata,operationId:e.task.operationId,taskId:e.task.taskId,taskRunId:e.task.taskRunId})}}async function acknowledgeDelegatedTasksStep(e){"use step";for(let t of e.tasks){if(await sendTaskCommandToOwner({command:{kind:`ready`},taskInboxToken:t.taskInboxToken,retryUnreachable:{attempts:20,delayMs:250}})!==void 0)continue;let e=await readLatestTaskView({taskRunId:t.taskRunId});if(!(e!==void 0&&isTerminalTaskStatus(e.status)))throw Error(`Task run "${t.taskId}" did not accept its readiness command.`)}}async function failDelegatedDispatch(e){await sendTaskCommand({command:{data:e.error,kind:`fail`},taskInboxToken:e.task.taskInboxToken,retryUnreachable:{attempts:20,delayMs:250}})}async function rejectDelegatedDispatch(e){await sendTaskCommand({command:{data:e.error,kind:`reject-dispatch`},taskInboxToken:e.task.taskInboxToken,retryUnreachable:{attempts:20,delayMs:250}})}export{acknowledgeDelegatedTasksStep,beginDelegatedTask,failDelegatedDispatch,rejectDelegatedDispatch,settleDelegatedDispatch};

package/dist/src/execution/tasks/parent/dispatch-task-step.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Task-mode sibling of `dispatchRuntimeActionsStep`, selected by the turn
+ * workflow when the agent enables `experimental.tasks`.
+ *
+ * Same plan → dispatch → emit skeleton, but every delegation is wrapped in
+ * the durable task lifecycle: the task record and its inbox token
+ * exist *before* the child dispatch side effect (`beginDelegatedTask`),
+ * continuations pass the availability check and enter the parent session's
+ * task index first, and the task settles against the dispatch outcome.
+ * Children report through their task's inbox token rather than the
+ * parent turn inbox, and every start dispatches a conversation-mode
+ * (persistent) child so the background task stays resumable.
+ *
+ * Task-control calls (`task_peek` / `task_cancel` / `task_send`) execute
+ * inline in this step, which holds the session ownership index and world
+ * access they need.
+ */
+import { type RuntimeActionDispatchInput, type RuntimeActionDispatchResult } from "#execution/dispatch-runtime-actions-shared.js";
+export declare function dispatchTaskStep(input: RuntimeActionDispatchInput): Promise<RuntimeActionDispatchResult>;

package/dist/src/execution/tasks/parent/dispatch-task-step.js

@@ -0,0 +1 @@
+import{createDurableSessionState}from"#execution/durable-session-store.js";import{dispatchToTaskAgentAddress}from"#execution/agent-handle-dispatch.js";import{executeTaskControlAction}from"#execution/tasks/parent/dispatch.js";import{createAgentContinuationBundle}from"#execution/agent-continuation-bundle.js";import{emitSubagentCalled,prepareRuntimeActionDispatch,startSubagent}from"#execution/dispatch-runtime-actions-shared.js";import{beginDelegatedTask,settleDelegatedDispatch}from"#execution/tasks/parent/delegate.js";import{checkTaskContinuationAvailability,describeTaskDispatch,persistContinuationTaskInParentSession,settleTaskDispatchError}from"#execution/tasks/parent/continuation-dispatch.js";async function dispatchTaskStep(r){"use step";let i=await prepareRuntimeActionDispatch({serializedContext:r.serializedContext,sessionState:r.sessionState,taskControls:!0});if(i===void 0)return{results:[],sessionState:r.sessionState,pendingTasks:[]};let{batch:a,bundle:o,session:s}=i,c=r.parentWritable.getWriter(),l=s,u=[],d=[];try{for(let e of i.plan){if(e.kind===`reject`){u.push(e.result);continue}if(e.kind===`task-control`){let t=await executeTaskControlAction({action:e.action,bundle:o,parentStepIndex:a.event.stepIndex,parentTurnId:a.event.turnId,session:l});l=t.session,t.pendingTask!==void 0&&d.push(t.pendingTask),u.push(t.result);continue}if(e.kind===`resume`){let t=await checkTaskContinuationAvailability({action:e.action,agentId:e.agentId,parentStepIndex:a.event.stepIndex,parentTurnId:a.event.turnId,session:l});if(t!==void 0){u.push(t);continue}}let n=await beginDelegatedTask({...describeTaskDispatch({action:e.kind===`resume`?e.action:e.target.action,agentId:e.kind===`resume`?e.agentId:void 0,parentSessionId:s.sessionId,parentTurnId:a.event.turnId,session:l}),parentSessionId:s.sessionId,parentStepIndex:a.event.stepIndex,parentTurnId:a.event.turnId,session:l}),f;e.kind===`resume`&&(f=await persistContinuationTaskInParentSession({action:e.action,agentId:e.agentId,delegated:n,session:l}),l=f?.session??l);let p;switch(e.kind){case`resume`:p=await dispatchToTaskAgentAddress({action:e.action,agentId:e.agentId,bundle:createAgentContinuationBundle({action:e.action,bundle:o,dynamicRemoteAgent:e.dynamicRemoteAgent}),currentSession:l,parentToken:n.taskInboxToken});break;case`start`:p=await startSubagent({auth:i.auth,batchEvent:a.event,bundle:o,callbackBaseUrl:r.callbackBaseUrl,capabilities:i.capabilities,channelMetadata:i.channelMetadata,currentSession:l,fanoutSize:i.fanoutSize,initiatorAuth:i.initiatorAuth,parentContinuationToken:n.taskInboxToken,parentTraceContext:i.parentTraceContext,persistentSessions:!0,serializedContext:i.serializedContext,session:s,taskOwned:!0,target:e.target});break}if(l=p.session,p.kind===`error`){u.push(await settleTaskDispatchError({delegated:n,outcome:p,persisted:f})),f!==void 0&&d.push(n);continue}if(f!==void 0)u.push(f.receipt);else{let e=await settleDelegatedDispatch({callId:p.callId,session:l,subagentName:p.toolName,task:n});l=e.session,u.push(e.receipt)}d.push(n),await emitSubagentCalled({adapter:i.adapter,adapterCtx:i.adapterCtx,batchEvent:a.event,entry:e,outcome:p,sessionId:s.sessionId,writer:c})}}finally{c.releaseLock()}return{results:u,sessionState:l===s?r.sessionState:createDurableSessionState({session:l}),pendingTasks:d}}export{dispatchTaskStep};

package/dist/src/execution/tasks/parent/dispatch.d.ts

@@ -0,0 +1,33 @@
+import type { RuntimeSession } from "#execution/agent-handle-dispatch.js";
+import type { DelegatedTask } from "#execution/tasks/parent/delegate.js";
+import type { RuntimeActionRequest, RuntimeActionResult, RuntimeToolCallActionRequest } from "#runtime/actions/types.js";
+import type { CompiledBundle } from "#runtime/sessions/runtime-context-keys.js";
+import type { SessionTaskIndexEntry } from "#tasks/session-index.js";
+import { type TaskView } from "#tasks/types.js";
+/** True for `task_peek` / `task_cancel` / `task_send` calls. */
+export declare function isTaskControlAction(action: RuntimeActionRequest): action is RuntimeToolCallActionRequest;
+/**
+ * Executes one task-control call inside the dispatch step, which holds
+ * the durable session state (ownership index) and world access the
+ * tools need.
+ *
+ * Returns the (possibly updated) session: `task_send` follow-ups record
+ * new tasks and settle the continued agent handle.
+ */
+export declare function executeTaskControlAction(input: {
+    readonly action: RuntimeToolCallActionRequest;
+    readonly bundle: CompiledBundle;
+    readonly parentStepIndex?: number;
+    readonly parentTurnId: string;
+    readonly session: RuntimeSession;
+}): Promise<{
+    readonly result: RuntimeActionResult;
+    readonly session: RuntimeSession;
+    readonly pendingTask?: DelegatedTask;
+}>;
+/** Commits task cancellation, then propagates it to the addressed executor. */
+export declare function cancelOwnedTask(input: {
+    readonly bundle: CompiledBundle;
+    readonly entry: SessionTaskIndexEntry;
+    readonly session: RuntimeSession;
+}): Promise<TaskView>;

package/dist/src/execution/tasks/parent/dispatch.js

@@ -0,0 +1 @@
+import{createLogger,logError}from"#internal/logging.js";import{cancelRemoteAgentTurn,resolveRemoteAgentForAction}from"#execution/remote-agent-dispatch.js";import{requestWorkflowTurnCancellation}from"#execution/workflow-runtime.js";import{TASK_CANCEL_TOOL_NAME,TASK_CONTROL_TOOL_NAMES,TASK_PEEK_TOOL_NAME,TASK_SEND_TOOL_NAME}from"#runtime/framework-tools/tasks.js";import{sendTaskCommand}from"#execution/tasks/parent/run-parent.js";import{isTerminalTaskStatus}from"#tasks/types.js";import{createTaskControlError,createTaskViewsResult,createUnknownTasksError,findTaskAgentAddress,lookupTaskEntries,readTaskView,readTaskViews}from"#execution/tasks/parent/control-shared.js";import{executeTaskSend}from"#execution/tasks/parent/send.js";const log=createLogger(`execution.tasks.dispatch`);function isTaskControlAction(e){return e.kind===`tool-call`&&TASK_CONTROL_TOOL_NAMES.has(e.toolName)}async function executeTaskControlAction(e){let{action:t,session:n}=e;if(t.toolName===TASK_SEND_TOOL_NAME)return executeTaskSend(e);let r=readTaskIds(t.input);if(r===void 0||r.length===0)return{result:createTaskControlError(t,"Provide a non-empty `taskIds` array."),session:n};let i=lookupTaskEntries(n,r);if(i.kind===`unknown`)return{result:createUnknownTasksError(t,i.unknown),session:n};let o=i.entries;switch(t.toolName){case TASK_PEEK_TOOL_NAME:return{result:createTaskViewsResult(t,await readTaskViews(o)),session:n};case TASK_CANCEL_TOOL_NAME:{let r=[];for(let t of o)r.push(await cancelOwnedTask({bundle:e.bundle,entry:t,session:n}));return{result:createTaskViewsResult(t,r),session:n}}default:return{result:createTaskControlError(t,`Unsupported task control "${t.toolName}".`),session:n}}}async function cancelOwnedTask(e){let{entry:t}=e,n=await sendTaskCommand({command:{kind:`cancel`},taskInboxToken:t.taskInboxToken}),r=await readTaskView(t);for(let e=0;e<10&&!isTerminalTaskStatus(r.status);e+=1)await new Promise(e=>setTimeout(e,250)),r=await readTaskView(t);if(!isTerminalTaskStatus(r.status))throw Error(`Task "${t.taskId}" did not commit cancellation before timeout.`);let i=r;return i.status===`cancelled`&&n===`delivered`&&await propagateTaskCancel({bundle:e.bundle,session:e.session,view:i}),i}async function propagateTaskCancel(e){let a=findTaskAgentAddress(e.session,e.view.metadata.agentId);if(a===void 0)return;let o=a.address.sessionId,s=e.view.executor?.childTurnId;if(!(e.view.executor?.childSessionId!==void 0&&e.view.executor.childSessionId!==o))try{if(a.address.kind===`agent/remote`){let t=resolveRemoteAgentForAction({nodeId:a.identity.nodeId,remoteAgentName:a.identity.name,registry:e.bundle.subagentRegistry.subagentsByNodeId}),i={remote:{...t,url:a.address.url},sessionId:o,taskId:e.view.taskId};s!==void 0&&(i.turnId=s),(await cancelRemoteAgentTurn(i)).status===`no_active_turn`&&await cancelRemoteAgentTurn({remote:{...t,url:a.address.url},sessionId:o,taskId:e.view.taskId});return}let t={sessionId:o,taskId:e.view.taskId};s!==void 0&&(t.turnId=s),(await requestWorkflowTurnCancellation(t)).status===`no_active_turn`&&await requestWorkflowTurnCancellation({sessionId:o,taskId:e.view.taskId})}catch(n){logError(log,`task cancel propagation failed; the child may run to completion`,n,{childSessionId:o,taskId:e.view.taskId})}}function readTaskIds(e){let t=e.taskIds;if(Array.isArray(t))return t.filter(e=>typeof e==`string`&&e.trim()!==``)}export{cancelOwnedTask,executeTaskControlAction,isTaskControlAction};

package/dist/src/execution/tasks/parent/hitl-proxy-steps.d.ts

@@ -0,0 +1,29 @@
+import type { SubagentInputRequestHookPayload } from "#channel/types.js";
+import type { SubagentAuthorizationEventHookPayload } from "#channel/types.js";
+import { type DurableSessionState } from "#execution/durable-session-store.js";
+import { type TaskView } from "#tasks/types.js";
+/** Validates and durably records one task-owned child HITL route batch. */
+export declare function recordTaskInputRequestStep(input: {
+    readonly hookPayload: SubagentInputRequestHookPayload;
+    readonly serializedContext: Record<string, unknown>;
+    readonly sessionState: DurableSessionState;
+    readonly taskId: string;
+}): Promise<{
+    readonly accepted: false;
+    readonly sessionState: DurableSessionState;
+} | {
+    readonly accepted: true;
+    readonly hookPayload: SubagentInputRequestHookPayload;
+    readonly sessionState: DurableSessionState;
+}>;
+/** Validates that one task authorization event came from its owned child address. */
+export declare function acceptTaskAuthorizationEventStep(input: {
+    readonly hookPayload: SubagentAuthorizationEventHookPayload;
+    readonly sessionState: DurableSessionState;
+    readonly taskId: string;
+}): Promise<boolean>;
+/** Caches terminal task views before their workflow runs can expire. */
+export declare function recordTerminalTaskViewsStep(input: {
+    readonly sessionState: DurableSessionState;
+    readonly views: readonly TaskView[];
+}): Promise<DurableSessionState>;

package/dist/src/execution/tasks/parent/hitl-proxy-steps.js

@@ -0,0 +1 @@
+import{createEveTaskInputRoutePath}from"#protocol/routes.js";import{isInputRequest}from"#runtime/input/types.js";import{getAgentHandleStore}from"#harness/handles/store.js";import{removeTaskAgentAddressFromState}from"#harness/handles/transitions.js";import{createRemoteTaskInputCallbackUrl}from"#execution/workflow-callback-url.js";import{readDurableSession}from"#execution/durable-session-store.js";import{createTaskInputRequestId,toProxyInputRequestEntries,upsertProxyInputRequestState}from"#harness/proxy-input-requests.js";import{readLatestTaskView}from"#execution/tasks/parent/run-parent.js";import{cacheTerminalTaskView,findSessionTaskEntry}from"#tasks/session-index.js";import{isTerminalTaskStatus}from"#tasks/types.js";import{createTaskInputCapabilityToken}from"#execution/task-input-capability.js";async function recordTaskInputRequestStep(r){"use step";let a=await readDurableSession(r.sessionState),o=findSessionTaskEntry(a.state,r.taskId),s=(getAgentHandleStore(a.state)?.handles??[]).find(e=>e.phase===`addressed`&&e.identity.id===o?.metadata.agentId);if(o===void 0||s?.phase!==`addressed`||s.address.sessionId!==r.hookPayload.childSessionId)return{accepted:!1,sessionState:r.sessionState};let c=await readLatestTaskView({taskRunId:o.taskRunId}),l=r.hookPayload.event.requests.map(e=>e.requestId),u=c?.inputRequests?.map(e=>typeof e==`object`&&e&&!Array.isArray(e)?Reflect.get(e,`requestId`):void 0)??[];if(c?.status!==`input_required`||!r.hookPayload.event.requests.every(isInputRequest)||c.metadata.mode!==(s.address.kind===`agent/remote`?`remote`:`local`)||c.metadata.agentId!==o.metadata.agentId||c.executor?.childSessionId!==r.hookPayload.childSessionId||new Set(l).size!==l.length||l.length!==u.length||l.some((e,t)=>e!==u[t]))return{accepted:!1,sessionState:r.sessionState};let d=namespaceTaskInputRequests(r.hookPayload,r.taskId),f=toProxyInputRequestEntries(d,r.taskId).map(([e,t],n)=>{let i=r.hookPayload.event.requests[n].requestId;return[e,{...t,childRequestId:i}]});if(s.address.kind===`agent/remote`){let t=createRemoteTaskInputCallbackUrl(s.address.url,createEveTaskInputRoutePath(createTaskInputCapabilityToken(r.hookPayload.childContinuationToken)));f=f.map(([e,n])=>[e,{...n,childResponseUrl:t}])}let p=upsertProxyInputRequestState({entries:f,forChildContinuationToken:r.hookPayload.childContinuationToken,state:a.state});return{accepted:!0,hookPayload:d,sessionState:{...r.sessionState,hasProxyInputRequests:!0,snapshot:{session:{...a,state:p},version:r.sessionState.version}}}}function namespaceTaskInputRequests(e,t){return{...e,event:{...e.event,requests:e.event.requests.map(e=>({...e,requestId:createTaskInputRequestId(t,e.requestId)}))}}}async function acceptTaskAuthorizationEventStep(e){"use step";let t=await readDurableSession(e.sessionState),r=findSessionTaskEntry(t.state,e.taskId);if(r===void 0)return!1;let i=(getAgentHandleStore(t.state)?.handles??[]).find(e=>e.phase===`addressed`&&e.identity.id===r.metadata.agentId);if(i?.phase!==`addressed`||i.address.sessionId!==e.hookPayload.childSessionId)return!1;let a=await readLatestTaskView({taskRunId:r.taskRunId});return a!==void 0&&!isTerminalTaskStatus(a.status)&&a.executor?.childSessionId===e.hookPayload.childSessionId&&a.metadata.agentId===r.metadata.agentId}async function recordTerminalTaskViewsStep(e){"use step";let t=await readDurableSession(e.sessionState),n=t.state;for(let t of e.views)n=cacheTerminalTaskView(n,t),t.executor?.lifecycle===`terminal`&&(n=removeTaskAgentAddressFromState(n,t.metadata.agentId));return n===t.state?e.sessionState:{...e.sessionState,snapshot:{session:{...t,state:n},version:e.sessionState.version}}}export{acceptTaskAuthorizationEventStep,recordTaskInputRequestStep,recordTerminalTaskViewsStep};

package/dist/src/execution/tasks/parent/run-parent.d.ts

@@ -0,0 +1,72 @@
+import type { TaskRunWorkflowInput } from "#execution/tasks/child/workflow.js";
+import { type TaskCommand, type TaskRunInboundPayload, type TaskView } from "#tasks/types.js";
+/**
+ * Node-side controls for durable task runs — the generic transport layer.
+ * This module only speaks `TaskCommand`/`TaskView`; it knows nothing about
+ * subagents, receipts, or the session index. Caller-specific policy (e.g.
+ * subagent delegation in `delegate.ts`) composes these primitives.
+ *
+ * Every export must be called from inside a `"use step"` body; none of
+ * these are steps themselves so dispatch and tool steps can compose them
+ * inside one durable boundary.
+ */
+/** Starts the durable run owning one task's lifecycle. */
+export declare function startTaskRun(input: TaskRunWorkflowInput): Promise<void>;
+/** Resolves the task run that won ownership of one replay-stable command token. */
+export declare function waitForTaskCommandOwner(input: {
+    readonly taskInboxToken: string;
+}): Promise<{
+    readonly runId: string;
+}>;
+/**
+ * Submits one command to a task run.
+ *
+ * `unreachable` means the hook is not resumable — either the run
+ * already finished and disposed it (the task is terminal; read the
+ * final view) or, right after creation, the freshly started run has
+ * not registered it yet. Senders racing that startup window pass
+ * `retryUnreachable`; senders addressing an established task treat
+ * `unreachable` as the terminal signal.
+ */
+export declare function sendTaskCommand(input: {
+    readonly command: TaskCommand;
+    readonly taskInboxToken: string;
+    readonly retryUnreachable?: {
+        readonly attempts: number;
+        readonly delayMs: number;
+    };
+}): Promise<"delivered" | "unreachable">;
+/** Delivers one command and returns the accepting task workflow's run id. */
+export declare function sendTaskCommandToOwner(input: {
+    readonly command: TaskCommand;
+    readonly taskInboxToken: string;
+    readonly retryUnreachable?: {
+        readonly attempts: number;
+        readonly delayMs: number;
+    };
+}): Promise<{
+    readonly runId: string;
+} | undefined>;
+/**
+ * Hands one non-command inbound payload to a task run.
+ *
+ * Used for payloads the run must act on before it may record them —
+ * today only answered input batches, which it forwards to the child
+ * first. `unreachable` means the task already finished and disposed its
+ * hook, so the payload is stale by definition.
+ */
+export declare function sendTaskInboundPayload(input: {
+    readonly taskInboxToken: string;
+    readonly payload: TaskRunInboundPayload;
+}): Promise<"delivered" | "unreachable">;
+/**
+ * Reads the latest view a task run has published, or `undefined`
+ * when the run has not committed its first view yet (the caller
+ * already holds the creation receipt, which is `working`).
+ *
+ * Views are trusted without re-validation: the task run is the
+ * single writer and every write passed the transition function.
+ */
+export declare function readLatestTaskView(input: {
+    readonly taskRunId: string;
+}): Promise<TaskView | undefined>;

package/dist/src/execution/tasks/parent/run-parent.js

@@ -0,0 +1 @@
+import{startWorkflowPreferLatest,taskRunWorkflowReference,waitForCommandHookOwner}from"#execution/workflow-runtime.js";import{getRun,resumeHook}from"#internal/workflow/runtime.js";import{isTaskWorkflowTargetGone}from"#execution/tasks/workflow-target.js";import{TASK_VIEW_STREAM_NAMESPACE}from"#tasks/types.js";const TASK_VIEW_READ_TIMEOUT_MS=1e4;async function startTaskRun(n){await startWorkflowPreferLatest(taskRunWorkflowReference,[n])}async function waitForTaskCommandOwner(e){return await waitForCommandHookOwner(e.taskInboxToken)}async function sendTaskCommand(e){return await sendTaskCommandToOwner(e)===void 0?`unreachable`:`delivered`}async function sendTaskCommandToOwner(e){let t={command:e.command,kind:`task-command`},n=Math.max(1,e.retryUnreachable?.attempts??1);for(let r=0;;r+=1)try{let n=await resumeHook(e.taskInboxToken,t);if(typeof n!=`object`||!n||!(`runId`in n)||typeof n.runId!=`string`)throw Error(`Task inbox hook "${e.taskInboxToken}" returned no owner run id.`);return{runId:n.runId}}catch(t){if(!isTaskWorkflowTargetGone(t))throw t;if(r+1>=n)return;await new Promise(t=>setTimeout(t,e.retryUnreachable?.delayMs??250))}}async function sendTaskInboundPayload(e){try{return await resumeHook(e.taskInboxToken,e.payload),`delivered`}catch(e){if(!isTaskWorkflowTargetGone(e))throw e;return`unreachable`}}async function readLatestTaskView(e){let t=getRun(e.taskRunId).getReadable({namespace:TASK_VIEW_STREAM_NAMESPACE,startIndex:-1}),n=await t.getTailIndex(),i=t.getReader();try{return n<0?void 0:await readWithTimeout(i,`latest task view`)}finally{await i.cancel(`eve task view read complete`).catch(()=>{}),i.releaseLock()}}async function readWithTimeout(e,t){let n;try{let r=await Promise.race([e.read().then(e=>({kind:`read`,read:e})),new Promise(e=>{n=setTimeout(()=>e({kind:`timeout`}),TASK_VIEW_READ_TIMEOUT_MS)})]);if(r.kind===`timeout`)throw Error(`Timed out reading ${t} after ${TASK_VIEW_READ_TIMEOUT_MS}ms.`);return r.read.done?void 0:r.read.value}finally{n!==void 0&&clearTimeout(n)}}export{readLatestTaskView,sendTaskCommand,sendTaskCommandToOwner,sendTaskInboundPayload,startTaskRun,waitForTaskCommandOwner};

package/dist/src/execution/tasks/parent/send.d.ts

@@ -0,0 +1,25 @@
+import { type RuntimeSession } from "#execution/agent-handle-dispatch.js";
+import { type DelegatedTask } from "#execution/tasks/parent/delegate.js";
+import type { RuntimeActionResult, RuntimeToolCallActionRequest } from "#runtime/actions/types.js";
+import type { CompiledBundle } from "#runtime/sessions/runtime-context-keys.js";
+/**
+ * Routes one `task_send`:
+ *
+ * - `working` tasks are busy — the send surfaces `AGENT_BUSY` instead
+ *   of queueing (settled decision; queueing is the reversible follow-up);
+ * - `input_required` tasks reject model-authored sends; clients answer
+ *   them through the parent channel's direct HITL route;
+ * - terminal tasks accept a `message` follow-up, which starts a new
+ *   task bound to the same child session and returns its receipt.
+ */
+export declare function executeTaskSend(input: {
+    readonly action: RuntimeToolCallActionRequest;
+    readonly bundle: CompiledBundle;
+    readonly parentStepIndex?: number;
+    readonly parentTurnId: string;
+    readonly session: RuntimeSession;
+}): Promise<{
+    readonly result: RuntimeActionResult;
+    readonly session: RuntimeSession;
+    readonly pendingTask?: DelegatedTask;
+}>;

package/dist/src/execution/tasks/parent/send.js

@@ -0,0 +1 @@
+import{AGENT_BUSY,AGENT_UNREACHABLE}from"#harness/agent-handle-errors.js";import{dispatchToTaskAgentAddress}from"#execution/agent-handle-dispatch.js";import{findSessionTaskEntry}from"#tasks/session-index.js";import{createTaskControlError,createUnknownTasksError,findActiveTaskForAgent,findTaskAgentAddress,readTaskView}from"#execution/tasks/parent/control-shared.js";import{beginDelegatedTask,failDelegatedDispatch,settleDelegatedDispatch}from"#execution/tasks/parent/delegate.js";async function executeTaskSend(t){let{action:n,session:a}=t,o=readTaskSendInput(n.input);if(o.kind===`invalid`)return{result:createTaskControlError(n,o.message),session:a};let c=findSessionTaskEntry(a.state,o.taskId);if(c===void 0)return{result:createUnknownTasksError(n,[o.taskId]),session:a};let l=await readTaskView(c);return l.status===`working`?{result:createTaskControlError(n,`${AGENT_BUSY}: task "${l.taskId}" is still working. Let it finish, or cancel it first.`),session:a}:l.status===`input_required`?{result:createTaskControlError(n,`Task "${l.taskId}" is waiting on input; the human must answer through the parent channel.`),session:a}:followUpTerminalTask({action:n,bundle:t.bundle,message:o.message,parentStepIndex:t.parentStepIndex,parentTurnId:t.parentTurnId,session:a,view:l})}async function followUpTerminalTask(r){let{action:i,view:s}=r,u=await findActiveTaskForAgent(r.session,s.metadata.agentId,r.parentTurnId,r.parentStepIndex);if(u!==void 0)return{result:createTaskControlError(i,`${AGENT_BUSY}: agent "${s.metadata.agentId}" is busy with task "${u.view.taskId}" (${u.view.status}).`),session:r.session};let d=findTaskAgentAddress(r.session,s.metadata.agentId);if(d===void 0)return{result:createTaskControlError(i,`${AGENT_UNREACHABLE}: task "${s.taskId}"'s agent is no longer addressable.`),session:r.session};let f=d.address.kind===`agent/remote`?{callId:i.callId,description:``,input:{message:r.message},kind:`remote-agent-call`,name:d.identity.name,nodeId:d.identity.nodeId,remoteAgentName:d.identity.name}:{callId:i.callId,description:``,input:{message:r.message},kind:`subagent-call`,name:d.identity.name,nodeId:d.identity.nodeId,subagentName:d.identity.name},p=await beginDelegatedTask({agentId:d.identity.id,callId:i.callId,mode:d.address.kind===`agent/remote`?`remote`:`local`,name:d.identity.name,parentSessionId:r.session.sessionId,parentStepIndex:r.parentStepIndex,parentTurnId:r.parentTurnId,session:r.session}),m=await settleDelegatedDispatch({callId:i.callId,session:r.session,subagentName:d.identity.name,task:p}),h=await dispatchToTaskAgentAddress({action:f,agentId:d.identity.id,bundle:r.bundle,currentSession:m.session,parentToken:p.taskInboxToken});return h.kind===`error`?(h.deliveryAmbiguous!==!0&&await failDelegatedDispatch({error:h.result.output,task:p}),{result:{callId:i.callId,isError:!0,kind:`tool-result`,output:{error:h.result.output,taskId:p.taskId},toolName:i.toolName},session:h.session,pendingTask:p}):{result:{callId:i.callId,kind:`tool-result`,output:{agentId:p.metadata.agentId,status:`working`,taskId:p.taskId},toolName:i.toolName},session:h.session,pendingTask:p}}function readTaskSendInput(e){let t=typeof e.taskId==`string`&&e.taskId.trim()!==``?e.taskId:void 0;if(t===void 0)return{kind:`invalid`,message:"Provide the `taskId` from a task receipt."};let n=typeof e.message==`string`&&e.message.trim()!==``?e.message:void 0;return n===void 0?{kind:`invalid`,message:"Provide a non-empty `message`."}:{kind:`send`,message:n,taskId:t}}export{executeTaskSend};

package/dist/src/execution/tasks/workflow-target.d.ts

@@ -0,0 +1,2 @@
+/** Whether a workflow hook or run can no longer accept task traffic. */
+export declare function isTaskWorkflowTargetGone(error: unknown): boolean;

package/dist/src/execution/tasks/workflow-target.js

@@ -0,0 +1 @@
+import{walkCauseChain}from"#shared/errors.js";import{EntityConflictError,HookNotFoundError,RunExpiredError,WorkflowRunNotFoundError}from"#compiled/@workflow/errors/index.js";function isTaskWorkflowTargetGone(e){for(let t of walkCauseChain(e))if(HookNotFoundError.is(t)||WorkflowRunNotFoundError.is(t)||RunExpiredError.is(t)||EntityConflictError.is(t))return!0;return!1}export{isTaskWorkflowTargetGone};

package/dist/src/execution/terminate-child-sessions-step.d.ts

@@ -11,5 +11,6 @@ import { type DurableSessionState } from "#execution/durable-session-store.js";
  * remote-termination protocol exists.
  */
 export declare function terminateChildSessionsStep(input: {
+    readonly serializedContext?: Record<string, unknown>;
     readonly sessionState: DurableSessionState;
 }): Promise<void>;

package/dist/src/execution/terminate-child-sessions-step.js

@@ -1 +1 @@
-import{createLogger,logError}from"#internal/logging.js";import{readDurableSession}from"#execution/durable-session-store.js";import{getAgentHandleStore}from"#harness/handles/store.js";import{cancelRun,getWorld}from"#internal/workflow/runtime.js";const log=createLogger(`execution.terminate-child-sessions`);async function terminateChildSessionsStep(e){"use step";let r;try{r=await readDurableSession(e.sessionState)}catch(n){logError(log,`failed to read child sessions for termination`,n,{parentSessionId:e.sessionState.sessionId});return}let i=(getAgentHandleStore(r.state)?.handles??[]).filter(isLocalChildHandle);if(i.length!==0)for(let e of i){if(e.phase===`starting`){log.debug(`skipping starting child without a session id`,{agentId:e.identity.id,kind:e.target.kind,parentSessionId:r.sessionId});continue}try{await cancelRun(await getWorld(),e.address.sessionId,{cancelReason:`Parent session ended`})}catch(n){logError(log,`failed to terminate child session`,n,{agentId:e.identity.id,childSessionId:e.address.sessionId,kind:e.address.kind,parentSessionId:r.sessionId})}}}function isLocalChildHandle(e){let t=e.phase===`starting`?e.target.kind:e.address.kind;return t===`agent/local`||t===`agent/self`}export{terminateChildSessionsStep};
+import{createLogger,logError}from"#internal/logging.js";import{BundleKey}from"#runtime/sessions/runtime-context-keys.js";import{getAgentHandleStore}from"#harness/handles/store.js";import{deserializeContext}from"#context/serialize.js";import{readDurableSession}from"#execution/durable-session-store.js";import{hydrateDurableSession}from"#execution/session.js";import{resolveEffectiveAgentRuntime}from"#execution/effective-agent-config.js";import{cancelRun,getWorld}from"#internal/workflow/runtime.js";import{cancelOwnedTask}from"#execution/tasks/parent/dispatch.js";import{getSessionTaskIndex}from"#tasks/session-index.js";const log=createLogger(`execution.terminate-child-sessions`);async function terminateChildSessionsStep(e){"use step";let s;try{s=await readDurableSession(e.sessionState)}catch(n){logError(log,`failed to read child sessions for termination`,n,{parentSessionId:e.sessionState.sessionId});return}let c=readSessionTaskIndex(s.state,s.sessionId);if(c.length>0){if(e.serializedContext===void 0)throw Error(`Task finalization requires serialized runtime context.`);let r=await deserializeContext(e.serializedContext),i=r.require(BundleKey),a=resolveEffectiveAgentRuntime(i,r),o=hydrateDurableSession({durable:s,turnAgent:a.turnAgent});for(let e of c)try{await cancelOwnedTask({bundle:i,entry:e,session:o})}catch(n){logError(log,`failed to cancel task during parent finalization`,n,{parentSessionId:s.sessionId,taskId:e.taskId})}}let l=(getAgentHandleStore(s.state)?.handles??[]).filter(isLocalChildHandle);if(l.length!==0)for(let e of l){if(e.phase===`starting`){log.debug(`skipping starting child without a session id`,{agentId:e.identity.id,kind:e.target.kind,parentSessionId:s.sessionId});continue}try{await cancelRun(await getWorld(),e.address.sessionId,{cancelReason:`Parent session ended`})}catch(n){logError(log,`failed to terminate child session`,n,{agentId:e.identity.id,childSessionId:e.address.sessionId,kind:e.address.kind,parentSessionId:s.sessionId})}}}function isLocalChildHandle(e){let t=e.phase===`starting`?e.target.kind:e.address.kind;return t===`agent/local`||t===`agent/self`}function readSessionTaskIndex(e,n){try{return getSessionTaskIndex(e)}catch(e){return logError(log,`failed to read the task index during parent finalization`,e,{parentSessionId:n}),[]}}export{terminateChildSessionsStep};

package/dist/src/execution/turn-control-receiver.d.ts

@@ -9,11 +9,17 @@ export declare class TurnControlReceiver {
     private readonly commandInbox;
     private readonly control;
     private readonly controlIterator;
+    private readonly expectedTurnId;
+    private readonly cancelledTaskIds;
+    private readonly seenTaskDeliveries;
     private pendingControl;
     constructor(input: {
         readonly bufferedDeliveries: DeliverHookPayload[];
         readonly bufferedSessionControls: Array<"clear" | "compact" | "expired" | "reset">;
+        readonly cancelledTaskIds?: Set<string>;
         readonly commandInbox: SessionCommandInbox;
+        readonly expectedTurnId: string;
+        readonly seenTaskDeliveries?: Set<string>;
         readonly token: string;
     });
     /** Token passed to the turn workflow so it can publish control messages. */
@@ -38,4 +44,8 @@ export declare class TurnControlReceiver {
      * accepted by the turn and ahead of deliveries that arrived later.
      */
     private awaitForwardedDelivery;
+    private acceptTaskDelivery;
+    private discardTaskDeliveries;
+    private originatesFromCancelledTask;
+    private shouldDiscard;
 }

package/dist/src/execution/turn-control-receiver.js

@@ -1 +1 @@
-import{sendCommandToDelivery}from"#execution/session-command-wire.js";import{createHook}from"#compiled/@workflow/core/index.js";import{closeHookIterator,disposeHook}from"#execution/hook-ownership.js";import{turnCancellationHookToken}from"#execution/turn-cancellation-token.js";import{forwardTurnCancellationStep}from"#execution/forward-turn-cancellation-step.js";import{forwardTurnDeliveryStep}from"#execution/forward-turn-delivery-step.js";import{rebuildSerializableError}from"#execution/workflow-errors.js";var TurnControlReceiver=class{bufferedDeliveries;bufferedSessionControls;commandInbox;control;controlIterator;pendingControl=null;constructor(e){this.bufferedDeliveries=e.bufferedDeliveries,this.bufferedSessionControls=e.bufferedSessionControls,this.commandInbox=e.commandInbox,this.control=createHook({token:e.token}),this.controlIterator=this.control[Symbol.asyncIterator]()}get token(){return this.control.token}async dispose(){await closeHookIterator(this.controlIterator),await disposeHook(this.control)}async waitForAction(){for(;;){let e=await this.nextControlOrCommand();if(e.kind===`command`){let t=await this.handleSessionCommand(e.command);if(t!==void 0)return t;continue}let t=e.payload,n=this.readTerminalControl(t);if(n!==void 0)return n;if(t.kind===`turn-delivery-request`){let e=await this.serviceDeliveryRequest(t);if(e!==void 0)return e}}}async handleSessionCommand(t){if(t.kind===`deliver`){await this.bufferDelivery(t);return}if(t.kind===`send`){await this.bufferDelivery(sendCommandToDelivery(t));return}if(t.kind===`clear`||t.kind===`compact`){this.bufferedSessionControls.push(t.kind);return}if(t.kind===`session-timeout`){this.bufferedSessionControls.push(`expired`);return}if(t.kind!==`runtime-action-result`){if(t.kind===`cancel`){await forwardTurnCancellationStep({payload:t.turnId===void 0?{}:{turnId:t.turnId},token:turnCancellationHookToken(this.control.token)});return}if(t.kind===`reset`){await forwardTurnCancellationStep({payload:{},token:turnCancellationHookToken(this.control.token)}),this.bufferedSessionControls.push(`reset`);return}return unsupportedSessionCommand(t)}}async bufferDelivery(e){this.bufferedDeliveries.push(e),!(e.turnPolicy!==`steer`||!deliveryHasMessage(e))&&await forwardTurnCancellationStep({payload:{},token:turnCancellationHookToken(this.control.token)})}bufferTurnDeliveries(e){e.bufferedDeliveries!==void 0&&this.bufferedDeliveries.unshift(...e.bufferedDeliveries)}consumeControl(){this.pendingControl=null}getControlPromise(){return this.pendingControl??=this.controlIterator.next(),this.pendingControl}async nextControlOrCommand(){let e=await Promise.race([this.getControlPromise().then(e=>({kind:`control`,value:e})),this.commandInbox.next().then(e=>({kind:`command`,value:e}))]);if(e.kind===`command`){if(e.value.done)throw Error(`Session command inbox closed before the active turn settled.`);return this.commandInbox.consumeNext(),{command:e.value.value,kind:`command`}}if(this.consumeControl(),e.value.done)throw Error(`Turn control hook closed before delivering a result.`);let t=e.value.value;if(t.kind===`turn-error`)throw rebuildSerializableError(t.error);return t.kind===`turn-continuation-token`?(await this.commandInbox.rekeyContinuation(t.continuationToken),await this.nextControlOrCommand()):{kind:`control`,payload:t}}readTerminalControl(e){if(e.kind===`turn-error`)throw rebuildSerializableError(e.error);if(e.kind===`turn-result`)return this.bufferTurnDeliveries(e),e.action}async serviceDeliveryRequest(t){await this.commandInbox.rekeyContinuation(t.continuationToken);let n=this.takeInputResponseDelivery();for(;n===void 0;){let r=await Promise.race([this.getControlPromise().then(e=>({kind:`control`,value:e})),this.commandInbox.next().then(e=>({kind:`command`,value:e}))]);if(r.kind===`control`){if(this.consumeControl(),r.value.done)throw Error(`Turn control hook closed during a delivery request.`);if(r.value.value.kind===`turn-continuation-token`){await this.commandInbox.rekeyContinuation(r.value.value.continuationToken);continue}let e=this.readTerminalControl(r.value.value);if(e!==void 0)return e;if(r.value.value.kind===`turn-delivery-cancelled`&&r.value.value.requestId===t.requestId)return;continue}if(r.value.done)throw Error(`Session command inbox closed during a turn delivery request.`);if(this.commandInbox.consumeNext(),r.value.value.kind===`deliver`||r.value.value.kind===`send`){let t=r.value.value.kind===`deliver`?r.value.value:sendCommandToDelivery(r.value.value);deliveryHasMessage(t)?await this.bufferDelivery(t):n=t;continue}let i=await this.handleSessionCommand(r.value.value);if(i!==void 0)return i}try{await forwardTurnDeliveryStep({inboxToken:t.inboxToken,payload:{delivery:n,kind:`driver-delivery`,requestId:t.requestId}})}catch(e){if(!(e instanceof Error&&e.name===`HookNotFoundError`))throw e}return await this.awaitForwardedDelivery(t.requestId,n)}takeInputResponseDelivery(){let e=this.bufferedDeliveries.findIndex(e=>!deliveryHasMessage(e));if(e!==-1)return this.bufferedDeliveries.splice(e,1)[0]}async awaitForwardedDelivery(e,t){for(;;){let n=await this.nextControlOrCommand();if(n.kind===`command`){let e=await this.handleSessionCommand(n.command);if(e!==void 0)return this.bufferedDeliveries.unshift(t),e;continue}let r=n.payload;if(r.kind===`turn-delivery-accepted`){if(r.requestId===e)return;continue}if(r.kind===`turn-delivery-cancelled`&&r.requestId===e){this.bufferedDeliveries.unshift(t);return}r.kind===`turn-result`&&this.bufferedDeliveries.unshift(t);let i=this.readTerminalControl(r);if(i!==void 0)return i}}};function deliveryHasMessage(e){return e.payloads.some(e=>e.message!==void 0)}function unsupportedSessionCommand(e){throw Error(`Unsupported session command: ${JSON.stringify(e)}`)}export{TurnControlReceiver};
+import{sendCommandToDelivery}from"#execution/session-command-wire.js";import{createHook}from"#compiled/@workflow/core/index.js";import{closeHookIterator,disposeHook}from"#execution/hook-ownership.js";import{turnCancellationHookToken}from"#execution/turn-cancellation-token.js";import{forwardTurnCancellationStep}from"#execution/forward-turn-cancellation-step.js";import{forwardTurnDeliveryStep}from"#execution/forward-turn-delivery-step.js";import{rebuildSerializableError}from"#execution/workflow-errors.js";var TurnControlReceiver=class{bufferedDeliveries;bufferedSessionControls;commandInbox;control;controlIterator;expectedTurnId;cancelledTaskIds;seenTaskDeliveries;pendingControl=null;constructor(e){this.bufferedDeliveries=e.bufferedDeliveries,this.bufferedSessionControls=e.bufferedSessionControls,this.cancelledTaskIds=e.cancelledTaskIds??new Set,this.commandInbox=e.commandInbox,this.seenTaskDeliveries=e.seenTaskDeliveries??new Set,this.control=createHook({token:e.token}),this.controlIterator=this.control[Symbol.asyncIterator](),this.expectedTurnId=e.expectedTurnId}get token(){return this.control.token}async dispose(){await closeHookIterator(this.controlIterator),await disposeHook(this.control)}async waitForAction(){for(;;){let e=await this.nextControlOrCommand();if(e.kind===`command`){let t=await this.handleSessionCommand(e.command);if(t!==void 0)return t;continue}let t=e.payload,n=this.readTerminalControl(t);if(n!==void 0)return n;if(t.kind===`turn-delivery-request`){let e=await this.serviceDeliveryRequest(t);if(e!==void 0)return e}}}async handleSessionCommand(t){if(t.kind===`deliver`){if(!this.acceptTaskDelivery(t))return;await this.bufferDelivery(t);return}if(t.kind===`send`){if(!this.acceptTaskDelivery(t))return;await this.bufferDelivery(sendCommandToDelivery(t));return}if(t.kind===`clear`||t.kind===`compact`){this.bufferedSessionControls.push(t.kind);return}if(t.kind===`session-timeout`){this.bufferedSessionControls.push(`expired`);return}if(t.kind!==`runtime-action-result`){if(t.kind===`cancel`){t.taskId!==void 0&&this.discardTaskDeliveries(t.taskId);let e=t.taskId!==void 0&&t.turnId!==void 0&&t.turnId!==this.expectedTurnId?void 0:t.turnId;await forwardTurnCancellationStep({payload:e===void 0?{}:{turnId:e},token:turnCancellationHookToken(this.control.token)});return}if(t.kind===`reset`){await forwardTurnCancellationStep({payload:{},token:turnCancellationHookToken(this.control.token)}),this.bufferedSessionControls.push(`reset`);return}return unsupportedSessionCommand(t)}}async bufferDelivery(e){this.bufferedDeliveries.push(e),!(e.turnPolicy!==`steer`||!deliveryHasMessage(e))&&await forwardTurnCancellationStep({payload:{},token:turnCancellationHookToken(this.control.token)})}bufferTurnDeliveries(e){e.bufferedDeliveries!==void 0&&this.bufferedDeliveries.unshift(...e.bufferedDeliveries.filter(e=>!this.shouldDiscard(e)))}consumeControl(){this.pendingControl=null}getControlPromise(){return this.pendingControl??=this.controlIterator.next(),this.pendingControl}async nextControlOrCommand(){let e=await Promise.race([this.getControlPromise().then(e=>({kind:`control`,value:e})),this.commandInbox.next().then(e=>({kind:`command`,value:e}))]);if(e.kind===`command`){if(e.value.done)throw Error(`Session command inbox closed before the active turn settled.`);return this.commandInbox.consumeNext(),{command:e.value.value,kind:`command`}}if(this.consumeControl(),e.value.done)throw Error(`Turn control hook closed before delivering a result.`);let t=e.value.value;if(t.kind===`turn-error`)throw rebuildSerializableError(t.error);return t.kind===`turn-continuation-token`?(await this.commandInbox.rekeyContinuation(t.continuationToken),await this.nextControlOrCommand()):{kind:`control`,payload:t}}readTerminalControl(e){if(e.kind===`turn-error`)throw rebuildSerializableError(e.error);if(e.kind===`turn-result`)return this.bufferTurnDeliveries(e),e.action}async serviceDeliveryRequest(t){await this.commandInbox.rekeyContinuation(t.continuationToken);let n=this.takeInputResponseDelivery();for(;n===void 0;){let r=await Promise.race([this.getControlPromise().then(e=>({kind:`control`,value:e})),this.commandInbox.next().then(e=>({kind:`command`,value:e}))]);if(r.kind===`control`){if(this.consumeControl(),r.value.done)throw Error(`Turn control hook closed during a delivery request.`);if(r.value.value.kind===`turn-continuation-token`){await this.commandInbox.rekeyContinuation(r.value.value.continuationToken);continue}let e=this.readTerminalControl(r.value.value);if(e!==void 0)return e;if(r.value.value.kind===`turn-delivery-cancelled`&&r.value.value.requestId===t.requestId)return;continue}if(r.value.done)throw Error(`Session command inbox closed during a turn delivery request.`);if(this.commandInbox.consumeNext(),r.value.value.kind===`deliver`){if(!this.acceptTaskDelivery(r.value.value))continue;deliveryHasMessage(r.value.value)?await this.bufferDelivery(r.value.value):n=r.value.value;continue}if(r.value.value.kind===`send`){if(!this.acceptTaskDelivery(r.value.value))continue;let t=sendCommandToDelivery(r.value.value);deliveryHasMessage(t)?await this.bufferDelivery(t):n=t;continue}let i=await this.handleSessionCommand(r.value.value);if(i!==void 0)return i}try{await forwardTurnDeliveryStep({inboxToken:t.inboxToken,payload:{delivery:n,kind:`driver-delivery`,requestId:t.requestId}})}catch(e){if(!(e instanceof Error&&e.name===`HookNotFoundError`))throw e}return await this.awaitForwardedDelivery(t.requestId,n)}takeInputResponseDelivery(){let e=this.bufferedDeliveries.findIndex(e=>!deliveryHasMessage(e));if(e!==-1)return this.bufferedDeliveries.splice(e,1)[0]}async awaitForwardedDelivery(e,t){for(;;){let n=await this.nextControlOrCommand();if(n.kind===`command`){let e=await this.handleSessionCommand(n.command);if(e!==void 0)return this.shouldDiscard(t)||this.bufferedDeliveries.unshift(t),e;continue}let r=n.payload;if(r.kind===`turn-delivery-accepted`){if(r.requestId===e)return;continue}if(r.kind===`turn-delivery-cancelled`&&r.requestId===e){this.shouldDiscard(t)||this.bufferedDeliveries.unshift(t);return}r.kind===`turn-result`&&(this.shouldDiscard(t)||this.bufferedDeliveries.unshift(t));let i=this.readTerminalControl(r);if(i!==void 0)return i}}acceptTaskDelivery(e){let t=e.taskDeliveryId??e.caller?.taskId;return t===void 0?!0:this.originatesFromCancelledTask(t)||this.seenTaskDeliveries.has(t)?!1:(this.seenTaskDeliveries.add(t),!0)}discardTaskDeliveries(e){this.cancelledTaskIds.add(e);let t=this.bufferedDeliveries.filter(e=>!this.shouldDiscard(e));this.bufferedDeliveries.splice(0,this.bufferedDeliveries.length,...t)}originatesFromCancelledTask(e){return[...this.cancelledTaskIds].some(t=>deliveryOriginatesFromTask(e,t))}shouldDiscard(e){let t=e.taskDeliveryId??e.caller?.taskId;return t!==void 0&&this.originatesFromCancelledTask(t)}};function deliveryOriginatesFromTask(e,t){return e===t||e.startsWith(`${t}:`)}function deliveryHasMessage(e){return e.payloads.some(e=>e.message!==void 0)}function unsupportedSessionCommand(e){throw Error(`Unsupported session command: ${JSON.stringify(e)}`)}export{TurnControlReceiver};

package/dist/src/execution/turn-dispatch.d.ts

@@ -21,11 +21,13 @@ export declare function dispatchAndAwaitTurn(input: {
     readonly bufferedDeliveries: DeliverHookPayload[];
     readonly bufferedSessionControls: Array<"clear" | "compact" | "expired" | "reset">;
     readonly capabilities?: SessionCapabilities;
+    readonly cancelledTaskIds?: Set<string>;
     readonly controlToken: string;
     readonly delivery: HookPayload;
     readonly commandInbox: SessionCommandInbox;
     readonly mode: RunMode;
     readonly parentWritable: WritableStream<Uint8Array>;
     readonly serializedContext: Record<string, unknown>;
+    readonly seenTaskDeliveries?: Set<string>;
     readonly sessionState: DurableSessionState;
 }): Promise<DispatchedTurn>;

package/dist/src/execution/turn-dispatch.js

@@ -1 +1 @@
-import{dispatchTurnStep}from"#execution/dispatch-turn-step.js";import{TurnControlReceiver}from"#execution/turn-control-receiver.js";async function dispatchAndAwaitTurn(t){let n=new TurnControlReceiver({bufferedDeliveries:t.bufferedDeliveries,bufferedSessionControls:t.bufferedSessionControls,commandInbox:t.commandInbox,token:t.controlToken});try{return await dispatchTurnStep({capabilities:t.capabilities,completionToken:n.token,delivery:t.delivery,mode:t.mode,parentWritable:t.parentWritable,serializedContext:t.serializedContext,sessionState:t.sessionState}),{action:await n.waitForAction(),dispose:()=>n.dispose()}}catch(e){throw await n.dispose(),e}}export{dispatchAndAwaitTurn};
+import{activeTurnId}from"#harness/active-turn-id.js";import{dispatchTurnStep}from"#execution/dispatch-turn-step.js";import{TurnControlReceiver}from"#execution/turn-control-receiver.js";async function dispatchAndAwaitTurn(t){let n=new TurnControlReceiver({bufferedDeliveries:t.bufferedDeliveries,bufferedSessionControls:t.bufferedSessionControls,cancelledTaskIds:t.cancelledTaskIds,commandInbox:t.commandInbox,expectedTurnId:activeTurnId(t.sessionState.emissionState),seenTaskDeliveries:t.seenTaskDeliveries??new Set,token:t.controlToken});try{return await dispatchTurnStep({capabilities:t.capabilities,completionToken:n.token,delivery:t.delivery,mode:t.mode,parentWritable:t.parentWritable,serializedContext:t.serializedContext,sessionState:t.sessionState}),{action:await n.waitForAction(),dispose:()=>n.dispose()}}catch(e){throw await n.dispose(),e}}export{dispatchAndAwaitTurn};

package/dist/src/execution/turn-execution-cursor.d.ts

@@ -2,6 +2,7 @@ import type { DeliverHookPayload } from "#channel/types.js";
 import type { TurnControlPayload } from "#execution/turn-control-protocol.js";
 import type { DurableSessionState } from "#execution/durable-session-store.js";
 import type { TurnStepInput, TurnStepPayload } from "#execution/durable-session-migrations/turn-workflow.js";
+import { SessionStateCursor } from "#execution/session-state-cursor.js";
 import type { SettledTurn } from "#harness/types.js";
 import type { TokenUsage } from "#shared/token-usage.js";
 interface TurnTransition {
@@ -22,11 +23,9 @@ type TurnTerminalAction = {
     readonly settled?: SettledTurn;
 };
 /** Owns the mutable durable state cursor for one active turn workflow. */
-export declare class TurnExecutionCursor {
+export declare class TurnExecutionCursor extends SessionStateCursor {
     readonly controlToken: string;
     readonly parentWritable: WritableStream<Uint8Array>;
-    private currentSerializedContext;
-    private currentSessionState;
     private lastReportedContinuationToken;
     constructor(input: {
         readonly controlToken: string;
@@ -34,10 +33,6 @@ export declare class TurnExecutionCursor {
         readonly serializedContext: Record<string, unknown>;
         readonly sessionState: DurableSessionState;
     });
-    /** Latest serialized runtime context adopted by the active turn. */
-    get serializedContext(): Record<string, unknown>;
-    /** Latest durable session state adopted by the active turn. */
-    get sessionState(): DurableSessionState;
     /** Adopts a state transition and reports any continuation-token change once. */
     adopt(transition: TurnTransition): Promise<void>;
     /** Builds the next atomic turn-step input from the cursor's current state. */
@@ -50,6 +45,5 @@ export declare class TurnExecutionCursor {
     finish(transition: TurnTransition, action: TurnTerminalAction, bufferedDeliveries: readonly DeliverHookPayload[]): Promise<void>;
     /** Sends one control payload to the session driver. */
     send(payload: TurnControlPayload): Promise<void>;
-    private setState;
 }
 export {};

package/dist/src/execution/turn-execution-cursor.js

@@ -1 +1 @@
-import{sendTurnControlStep}from"#execution/turn-control-protocol.js";var TurnExecutionCursor=class{controlToken;parentWritable;currentSerializedContext;currentSessionState;lastReportedContinuationToken;constructor(e){this.controlToken=e.controlToken,this.currentSerializedContext=e.serializedContext,this.currentSessionState=e.sessionState,this.lastReportedContinuationToken=e.sessionState.continuationToken,this.parentWritable=e.parentWritable}get serializedContext(){return this.currentSerializedContext}get sessionState(){return this.currentSessionState}async adopt(e){this.setState(e);let t=e.sessionState.continuationToken;t===``||t===this.lastReportedContinuationToken||(this.lastReportedContinuationToken=t,await this.send({continuationToken:t,kind:`turn-continuation-token`}))}createStepInput(e,t){return{abortSignal:t,input:e,parentWritable:this.parentWritable,serializedContext:this.currentSerializedContext,sessionState:this.currentSessionState}}async finish(e,t,n){this.setState(e),await this.send({action:{...t,serializedContext:this.currentSerializedContext,sessionState:this.currentSessionState},bufferedDeliveries:n.length===0?void 0:[...n],kind:`turn-result`})}async send(t){await sendTurnControlStep({controlToken:this.controlToken,payload:t})}setState(e){this.currentSerializedContext=e.serializedContext??this.currentSerializedContext,this.currentSessionState=e.sessionState}};export{TurnExecutionCursor};
+import{sendTurnControlStep}from"#execution/turn-control-protocol.js";import{SessionStateCursor}from"#execution/session-state-cursor.js";var TurnExecutionCursor=class extends SessionStateCursor{controlToken;parentWritable;lastReportedContinuationToken;constructor(e){super({serializedContext:e.serializedContext,sessionState:e.sessionState}),this.controlToken=e.controlToken,this.lastReportedContinuationToken=e.sessionState.continuationToken,this.parentWritable=e.parentWritable}async adopt(e){this.adoptState(e);let t=e.sessionState.continuationToken;t===``||t===this.lastReportedContinuationToken||(this.lastReportedContinuationToken=t,await this.send({continuationToken:t,kind:`turn-continuation-token`}))}createStepInput(e,t){return{abortSignal:t,input:e,parentWritable:this.parentWritable,serializedContext:this.serializedContext,sessionState:this.sessionState}}async finish(e,t,n){this.adoptState(e),await this.send({action:{...t,serializedContext:this.serializedContext,sessionState:this.sessionState},bufferedDeliveries:n.length===0?void 0:[...n],kind:`turn-result`})}async send(t){await sendTurnControlStep({controlToken:this.controlToken,payload:t})}};export{TurnExecutionCursor};

package/dist/src/execution/turn-workflow.js

@@ -1 +1 @@
-import{resolveWorkflowCallbackBaseUrl}from"#execution/workflow-callback-url.js";import{activeTurnId}from"#harness/active-turn-id.js";import{migrateTurnWorkflowInput}from"#execution/durable-session-migrations/turn-workflow.js";import{dispatchRuntimeActionsStep}from"#execution/dispatch-runtime-actions-step.js";import{routeDeliverToChildren}from"#execution/route-child-delivery.js";import{createHook,getWorkflowMetadata,sleep}from"#compiled/@workflow/core/index.js";import{claimHookOwnership,disposeHook,isHookConflictError}from"#execution/hook-ownership.js";import{normalizeSerializableError}from"#execution/workflow-errors.js";import{sendTurnControlStep}from"#execution/turn-control-protocol.js";import{isInboxSubagentResultFromRunningHandle}from"#harness/handles/query.js";import{cancelDescendantTurnsStep}from"#execution/cancel-descendant-turns-step.js";import{dispatchWorkflowRuntimeActionsStep}from"#execution/dispatch-workflow-runtime-actions-step.js";import{runProxySubagentEventStep}from"#execution/subagent-event-proxy-step.js";import{createTurnCancellationControl}from"#execution/turn-cancellation-control.js";import{TurnExecutionCursor}from"#execution/turn-execution-cursor.js";import{turnStep}from"#execution/workflow-steps.js";import{getRuntimeActionResultKey}from"#runtime/actions/keys.js";import{resolveRuntimeActionResultsForKeys}from"#runtime/actions/results.js";const TASK_MODE_WAIT_ERROR_MESSAGE="Task mode cannot wait for follow-up input (`next: null`).";async function turnWorkflow(e){"use workflow";let t=migrateTurnWorkflowInput(e);return t.driverCapabilities?.turnInbox===!0?runTurnOwnedWorkflow(t):runLegacyTurnWorkflow(t)}async function runTurnOwnedWorkflow(n){let i=createHook({token:`${n.completionToken}:inbox`}),s=i[Symbol.asyncIterator](),u=new TurnExecutionCursor({controlToken:n.completionToken,parentWritable:n.stepInput.parentWritable,serializedContext:n.stepInput.serializedContext,sessionState:n.stepInput.sessionState}),d=0,nextDeliveryRequestId=()=>`${i.token}:delivery:${String(d++)}`,f=[],p=n.stepInput.input,m=!1,h;try{try{await claimHookOwnership(i),m=!0}catch(e){if(isHookConflictError(e))return;throw e}for(n.driverCapabilities?.cancelledTurnSettle===!0&&(h=await createTurnCancellationControl({controlToken:n.completionToken,expectedTurnId:activeTurnId(n.stepInput.sessionState.emissionState)}));;){let t=await turnStep(u.createStepInput(p,h?.signal)),a=t.action===`dispatch-workflow-runtime-actions`||t.action===`park`?t.pendingRuntimeActionKeys:void 0;if(t.action===`cancelled`||h?.signal.aborted===!0&&a===void 0){await finishCancelledTurn({bufferedDeliveries:f,cancellation:h,cursor:u});return}if(t.sleepDurationMs!==void 0&&await waitForTurnSleep(t.sleepDurationMs,h)===`cancel`){await finishCancelledTurn({bufferedDeliveries:f,cancellation:h,cursor:u});return}if(t.action===`done`){await h?.dispose(),await u.finish(t,{kind:`done`,output:t.output??``,isError:t.isError,usage:t.usage,usageDelta:t.usageDelta},f);return}if(a!==void 0){await u.adopt(t);let n=await(t.action===`dispatch-workflow-runtime-actions`?dispatchWorkflowRuntimeActionsStep:dispatchRuntimeActionsStep)({callbackBaseUrl:resolveWorkflowCallbackBaseUrl(getWorkflowMetadata().url),parentContinuationToken:i.token,parentWritable:u.parentWritable,serializedContext:u.serializedContext,sessionState:u.sessionState}),c=n.results.length===0?void 0:Date.now();await u.adopt(n);let l=await waitForRuntimeActionResults({bufferedDeliveries:f,cancellation:h,cursor:u,inboxToken:i.token,initialAcceptedAtMs:c,initialResults:n.results,iterator:s,nextDeliveryRequestId,pendingActionKeys:a});if(l===`cancelled`){p=void 0;continue}if(l===`cancel-turn`){await finishCancelledTurn({bufferedDeliveries:f,cancellation:h,cursor:u});return}p={kind:`runtime-action-result`,...l};continue}if(t.action===`park`){if(!(t.hasPendingAuthorization||t.hasPendingInputBatch&&n.capabilities?.requestInput===!0||n.mode===`conversation`))throw Error(TASK_MODE_WAIT_ERROR_MESSAGE);await h?.dispose(),await u.finish(t,{authorizationAttemptIds:t.authorizationAttemptIds,authorizationNames:t.authorizationNames,kind:`park`,settled:t.settled},f);return}await u.adopt(t),p=void 0}}catch(e){throw await u.send({error:normalizeSerializableError(e),kind:`turn-error`}),e}finally{h!==void 0&&await h.dispose(),m&&await disposeHook(i)}}async function finishCancelledTurn(e){await cancelDescendantTurnsStep({serializedContext:e.cursor.serializedContext,sessionState:e.cursor.sessionState}),await e.cancellation?.dispose(),await e.cursor.finish({sessionState:e.cursor.sessionState},{cancelled:!0,kind:`park`},e.bufferedDeliveries)}async function waitForTurnSleep(e,t){if(t?.signal.aborted===!0)return`cancel`;let n=sleep(e).then(()=>`slept`);return t===void 0?n:Promise.race([n,t.requested])}async function waitForRuntimeActionResults(e){let t,n=[...e.initialResults],r=new Map;if(e.initialAcceptedAtMs!==void 0)for(let t of e.initialResults)r.set(getRuntimeActionResultKey(t),e.initialAcceptedAtMs);for(;;){let a=resolveRuntimeActionResultsForKeys({pendingKeys:e.pendingActionKeys,results:n});if(a!==void 0)return t!==void 0&&await e.cursor.send({kind:`turn-delivery-cancelled`,requestId:t}),{acceptedAtMsByCallId:Object.fromEntries(a.map(e=>[e.callId,r.get(getRuntimeActionResultKey(e))])),results:a};e.cursor.sessionState.hasProxyInputRequests&&t===void 0&&(t=e.nextDeliveryRequestId(),await e.cursor.send({continuationToken:e.cursor.sessionState.continuationToken,inboxToken:e.inboxToken,kind:`turn-delivery-request`,requestId:t}));let o=e.iterator.next();o.catch(()=>{});let s=await(e.cancellation===void 0?o:Promise.race([o,e.cancellation.requested]));if(s===`cancel`)return t!==void 0&&await e.cursor.send({kind:`turn-delivery-cancelled`,requestId:t}),`cancelled`;if(s.done)throw Error(`Turn inbox closed before runtime actions completed.`);let c=s.value;if(c.kind===`runtime-action-result`){let t=e.cursor.sessionState.snapshot?.session.state,i=c.results.filter(e=>isInboxSubagentResultFromRunningHandle(t,e));if(i.length>0){let e=Date.now();n.push(...i);for(let t of i)r.set(getRuntimeActionResultKey(t),e)}continue}if(c.kind===`subagent-input-request`||c.kind===`subagent-authorization-event`){let t=await runProxySubagentEventStep({hookPayload:c,parentWritable:e.cursor.parentWritable,serializedContext:e.cursor.serializedContext,sessionState:e.cursor.sessionState});await e.cursor.adopt(t);continue}if(c.kind===`driver-delivery`&&c.requestId===t){await e.cursor.send({kind:`turn-delivery-accepted`,requestId:c.requestId}),t=void 0;let n=await routeDeliverToChildren({delivery:c.delivery,parentWritable:e.cursor.parentWritable,sessionState:e.cursor.sessionState});if(await e.cursor.adopt(n),n.kind===`cancel-turn`)return n.kind;n.remainder!==void 0&&e.bufferedDeliveries.push(n.remainder)}}}async function runLegacyTurnWorkflow(e){let t=e.stepInput;try{for(;;){let n=await turnStep(t);if(n.action!==`cancelled`&&n.sleepDurationMs!==void 0&&await sleep(n.sleepDurationMs),n.action===`done`){await sendTurnControlStep({controlToken:e.completionToken,payload:{action:{kind:`done`,output:n.output??``,isError:n.isError,serializedContext:n.serializedContext,sessionState:n.sessionState,usage:n.usage,usageDelta:n.usageDelta},kind:`turn-result`}});return}if(n.action===`dispatch-workflow-runtime-actions`){await sendTurnControlStep({controlToken:e.completionToken,payload:{action:{kind:`dispatch-workflow-runtime-actions`,pendingActionKeys:n.pendingRuntimeActionKeys,serializedContext:n.serializedContext,sessionState:n.sessionState},kind:`turn-result`}});return}if(n.action===`park`){let t=n.pendingRuntimeActionKeys;if(!(t!==void 0||n.hasPendingAuthorization||n.hasPendingInputBatch&&e.capabilities?.requestInput===!0||e.mode===`conversation`))throw Error(TASK_MODE_WAIT_ERROR_MESSAGE);let r=t===void 0?{kind:`park`,serializedContext:n.serializedContext,sessionState:n.sessionState,authorizationAttemptIds:n.authorizationAttemptIds,authorizationNames:n.authorizationNames,settled:n.settled}:{kind:`dispatch-runtime-actions`,pendingActionKeys:t,serializedContext:n.serializedContext,sessionState:n.sessionState};await sendTurnControlStep({controlToken:e.completionToken,payload:{action:r,kind:`turn-result`}});return}t={input:void 0,parentWritable:t.parentWritable,serializedContext:n.serializedContext,sessionState:n.sessionState}}}catch(t){throw await sendTurnControlStep({controlToken:e.completionToken,payload:{error:normalizeSerializableError(t),kind:`turn-error`}}),t}}export{turnWorkflow};
+import{resolveWorkflowCallbackBaseUrl}from"#execution/workflow-callback-url.js";import{migrateTurnWorkflowInput}from"#execution/durable-session-migrations/turn-workflow.js";import{dispatchRuntimeActionsStep}from"#execution/dispatch-runtime-actions-step.js";import{dispatchTaskStep}from"#execution/tasks/parent/dispatch-task-step.js";import{routeDeliverToChildren}from"#execution/route-child-delivery.js";import{runProxySubagentEventStep}from"#execution/subagent-event-proxy-step.js";import{createHook,getWorkflowMetadata,sleep}from"#compiled/@workflow/core/index.js";import{claimHookOwnership,disposeHook,isHookConflictError}from"#execution/hook-ownership.js";import{activeTurnId}from"#harness/active-turn-id.js";import{acknowledgeDelegatedTasksStep}from"#execution/tasks/parent/delegate.js";import{normalizeSerializableError}from"#execution/workflow-errors.js";import{sendTurnControlStep}from"#execution/turn-control-protocol.js";import{isInboxSubagentResultFromRunningHandle}from"#harness/handles/query.js";import{preserveSerializedSessionDynamicModelSelection}from"#context/serialized-dynamic-model-selection.js";import{cancelDescendantTurnsStep}from"#execution/cancel-descendant-turns-step.js";import{dispatchWorkflowRuntimeActionsStep}from"#execution/dispatch-workflow-runtime-actions-step.js";import{createTurnCancellationControl}from"#execution/turn-cancellation-control.js";import{TurnExecutionCursor}from"#execution/turn-execution-cursor.js";import{turnStep}from"#execution/workflow-steps.js";import{getRuntimeActionResultKey}from"#runtime/actions/keys.js";import{resolveRuntimeActionResultsForKeys}from"#runtime/actions/results.js";const TASK_MODE_WAIT_ERROR_MESSAGE="Task mode cannot wait for follow-up input (`next: null`).";async function turnWorkflow(e){"use workflow";let n=migrateTurnWorkflowInput(e);return n.driverCapabilities?.turnInbox===!0?runTurnOwnedWorkflow(n):runLegacyTurnWorkflow(n)}async function runTurnOwnedWorkflow(t){let i=createHook({token:`${t.completionToken}:inbox`}),a=i[Symbol.asyncIterator](),c=new TurnExecutionCursor({controlToken:t.completionToken,parentWritable:t.stepInput.parentWritable,serializedContext:t.stepInput.serializedContext,sessionState:t.stepInput.sessionState}),m=0,nextDeliveryRequestId=()=>`${i.token}:delivery:${String(m++)}`,h=[],g=t.stepInput.input,_=!1,v;try{try{await claimHookOwnership(i),_=!0}catch(e){if(isHookConflictError(e))return;throw e}for(t.driverCapabilities?.cancelledTurnSettle===!0&&(v=await createTurnCancellationControl({controlToken:t.completionToken,expectedTurnId:activeTurnId(t.stepInput.sessionState.emissionState)}));;){let o=await turnStep(c.createStepInput(g,v?.signal)),l=o.action===`dispatch-workflow-runtime-actions`||o.action===`park`?o.pendingRuntimeActionKeys:void 0;if(o.action===`cancelled`){await c.adopt(o),await finishCancelledTurn({bufferedDeliveries:h,cancellation:v,cursor:c});return}if(v?.signal.aborted===!0&&l===void 0){await c.adopt({serializedContext:preserveSerializedSessionDynamicModelSelection(c.serializedContext,o.serializedContext),sessionState:c.sessionState}),await finishCancelledTurn({bufferedDeliveries:h,cancellation:v,cursor:c});return}if(o.sleepDurationMs!==void 0&&await waitForTurnSleep(o.sleepDurationMs,v)===`cancel`){await finishCancelledTurn({bufferedDeliveries:h,cancellation:v,cursor:c});return}if(o.action===`done`){await v?.dispose(),await c.finish(o,{kind:`done`,output:o.output??``,isError:o.isError,usage:o.usage,usageDelta:o.usageDelta},h);return}if(l!==void 0){await c.adopt(o);let t=o.action===`park`&&o.tasksEnabled,u;u=o.action===`dispatch-workflow-runtime-actions`?dispatchWorkflowRuntimeActionsStep:t?dispatchTaskStep:dispatchRuntimeActionsStep;let d=await u({callbackBaseUrl:resolveWorkflowCallbackBaseUrl(getWorkflowMetadata().url),parentContinuationToken:i.token,parentWritable:c.parentWritable,serializedContext:c.serializedContext,sessionState:c.sessionState}),f=d.results.length===0?void 0:Date.now();await c.adopt(d),await acknowledgeDelegatedTasksStep({tasks:d.pendingTasks});let p=await waitForRuntimeActionResults({bufferedDeliveries:h,cancellation:v,cursor:c,inboxToken:i.token,initialAcceptedAtMs:f,initialResults:d.results,iterator:a,nextDeliveryRequestId,pendingActionKeys:l});if(p===`cancelled`){g=void 0;continue}if(p===`cancel-turn`){await finishCancelledTurn({bufferedDeliveries:h,cancellation:v,cursor:c});return}g={kind:`runtime-action-result`,...p};continue}if(o.action===`park`){if(!(o.hasPendingAuthorization||o.hasPendingInputBatch&&t.capabilities?.requestInput===!0||t.mode===`conversation`))throw Error(TASK_MODE_WAIT_ERROR_MESSAGE);await v?.dispose(),await c.finish(o,{authorizationAttemptIds:o.authorizationAttemptIds,authorizationNames:o.authorizationNames,kind:`park`,settled:o.settled},h);return}await c.adopt(o),g=void 0}}catch(e){throw await c.send({error:normalizeSerializableError(e),kind:`turn-error`}),e}finally{v!==void 0&&await v.dispose(),_&&await disposeHook(i)}}async function finishCancelledTurn(e){await cancelDescendantTurnsStep({serializedContext:e.cursor.serializedContext,sessionState:e.cursor.sessionState}),await e.cancellation?.dispose(),await e.cursor.finish({sessionState:e.cursor.sessionState},{cancelled:!0,kind:`park`},e.bufferedDeliveries)}async function waitForTurnSleep(e,t){if(t?.signal.aborted===!0)return`cancel`;let n=sleep(e).then(()=>`slept`);return t===void 0?n:Promise.race([n,t.requested])}async function waitForRuntimeActionResults(e){let t,n=[...e.initialResults],r=new Map;if(e.initialAcceptedAtMs!==void 0)for(let t of e.initialResults)r.set(getRuntimeActionResultKey(t),e.initialAcceptedAtMs);for(;;){let o=resolveRuntimeActionResultsForKeys({pendingKeys:e.pendingActionKeys,results:n});if(o!==void 0)return t!==void 0&&await e.cursor.send({kind:`turn-delivery-cancelled`,requestId:t}),{acceptedAtMsByCallId:Object.fromEntries(o.map(e=>[e.callId,r.get(getRuntimeActionResultKey(e))])),results:o};e.cursor.sessionState.hasProxyInputRequests&&t===void 0&&(t=e.nextDeliveryRequestId(),await e.cursor.send({continuationToken:e.cursor.sessionState.continuationToken,inboxToken:e.inboxToken,kind:`turn-delivery-request`,requestId:t}));let s=e.iterator.next();s.catch(()=>{});let c=await(e.cancellation===void 0?s:Promise.race([s,e.cancellation.requested]));if(c===`cancel`)return t!==void 0&&await e.cursor.send({kind:`turn-delivery-cancelled`,requestId:t}),`cancelled`;if(c.done)throw Error(`Turn inbox closed before runtime actions completed.`);let l=c.value;if(l.kind===`runtime-action-result`){let t=e.cursor.sessionState.snapshot?.session.state,i=l.results.filter(e=>isInboxSubagentResultFromRunningHandle(t,e));if(i.length>0){let e=Date.now();n.push(...i);for(let t of i)r.set(getRuntimeActionResultKey(t),e)}continue}if(l.kind===`subagent-input-request`||l.kind===`subagent-authorization-event`){let t=await runProxySubagentEventStep({hookPayload:l,parentWritable:e.cursor.parentWritable,serializedContext:e.cursor.serializedContext,sessionState:e.cursor.sessionState});await e.cursor.adopt(t);continue}if(l.kind===`driver-delivery`&&l.requestId===t){await e.cursor.send({kind:`turn-delivery-accepted`,requestId:l.requestId}),t=void 0;let n=await routeDeliverToChildren({delivery:l.delivery,parentWritable:e.cursor.parentWritable,serializedContext:e.cursor.serializedContext,sessionState:e.cursor.sessionState});if(await e.cursor.adopt({serializedContext:n.serializedContext??e.cursor.serializedContext,sessionState:n.sessionState??e.cursor.sessionState}),n.kind===`cancel-turn`)return n.kind;n.remainder!==void 0&&e.bufferedDeliveries.push(n.remainder)}}}async function runLegacyTurnWorkflow(e){let t=e.stepInput;try{for(;;){let n=await turnStep(t);if(n.action!==`cancelled`&&n.sleepDurationMs!==void 0&&await sleep(n.sleepDurationMs),n.action===`done`){await sendTurnControlStep({controlToken:e.completionToken,payload:{action:{kind:`done`,output:n.output??``,isError:n.isError,serializedContext:n.serializedContext,sessionState:n.sessionState,usage:n.usage,usageDelta:n.usageDelta},kind:`turn-result`}});return}if(n.action===`dispatch-workflow-runtime-actions`){await sendTurnControlStep({controlToken:e.completionToken,payload:{action:{kind:`dispatch-workflow-runtime-actions`,pendingActionKeys:n.pendingRuntimeActionKeys,serializedContext:n.serializedContext,sessionState:n.sessionState},kind:`turn-result`}});return}if(n.action===`park`){let t=n.pendingRuntimeActionKeys;if(!(t!==void 0||n.hasPendingAuthorization||n.hasPendingInputBatch&&e.capabilities?.requestInput===!0||e.mode===`conversation`))throw Error(TASK_MODE_WAIT_ERROR_MESSAGE);let r=t===void 0?{kind:`park`,serializedContext:n.serializedContext,sessionState:n.sessionState,authorizationAttemptIds:n.authorizationAttemptIds,authorizationNames:n.authorizationNames,settled:n.settled}:{kind:`dispatch-runtime-actions`,pendingActionKeys:t,serializedContext:n.serializedContext,sessionState:n.sessionState};await sendTurnControlStep({controlToken:e.completionToken,payload:{action:r,kind:`turn-result`}});return}t={input:void 0,parentWritable:t.parentWritable,serializedContext:n.serializedContext,sessionState:n.sessionState}}}catch(t){throw await sendTurnControlStep({controlToken:e.completionToken,payload:{error:normalizeSerializableError(t),kind:`turn-error`}}),t}}export{turnWorkflow};