eve 0.50.0 → 0.51.0

package/dist/src/execution/tasks/child/update-step.js

@@ -0,0 +1 @@
+import{resumeHook}from"#internal/workflow/runtime.js";async function forwardLocalTaskUpdateStep(e){"use step";await resumeHook(e.parentContinuationToken,e.update)}export{forwardLocalTaskUpdateStep};

package/dist/src/execution/tasks/child/update.d.ts

@@ -1,11 +1,8 @@
 import type { ChannelAdapter } from "#channel/adapter.js";
-import type { RuntimeActionResult } from "#shared/action-types.js";
-import type { TaskControlInvocation } from "#shared/dispatch-action.js";
-/** Sends one child-authored progress update over its existing parent transport. */
-export declare function executeTaskUpdate(input: {
-    readonly action: TaskControlInvocation;
-    readonly adapter: ChannelAdapter | undefined;
-    readonly updateIndex: number;
-    readonly updateEpoch: string;
-    readonly serializedContext: Record<string, unknown> | undefined;
-}): Promise<RuntimeActionResult>;
+import type { TaskInboundUpdate } from "#tasks/types.js";
+/** Delivers a task update through the local child adapter or remote callback. */
+export declare function deliverTaskUpdate(input: {
+    readonly adapter?: ChannelAdapter;
+    readonly callback: unknown;
+    readonly update: TaskInboundUpdate;
+}): Promise<string | undefined>;

package/dist/src/execution/tasks/child/update.js

@@ -1 +1 @@
-import{SessionCallbackKey}from"#context/keys.js";import{resumeHook}from"#internal/workflow/runtime.js";import{readTaskIdFromInboxToken}from"#tasks/task-inbox-token.js";import{SUBAGENT_ADAPTER_KIND,isSubagentAdapterState}from"#execution/subagent-adapter-state.js";import{fireTaskUpdateCallbackStep}from"#execution/session-callback-step.js";import{createTaskControlError}from"#execution/tasks/parent/control-shared.js";async function executeTaskUpdate(n){let r=readUpdateMessage(n.action.input);if(r===void 0)return createTaskControlError(n.action,"Provide a non-empty `message`.");let i=n.serializedContext?.[SessionCallbackKey.name];if(i!==void 0){let e=await fireTaskUpdateCallbackStep({callback:i,callId:n.action.callId,updateIndex:n.updateIndex,updateEpoch:n.updateEpoch,message:r});return e===void 0?createTaskControlError(n.action,`This session is not owned by a parent task.`):createTaskUpdateResult(n.action,e)}let a=n.adapter;if(a?.kind!==SUBAGENT_ADAPTER_KIND||!isSubagentAdapterState(a.state))return createTaskControlError(n.action,`This session is not owned by a parent task.`);let o=a.state.parentContinuationToken,s=readTaskIdFromInboxToken(o);return s===void 0?createTaskControlError(n.action,`This session is not owned by a parent task.`):(await resumeHook(o,{callId:n.action.callId,updateIndex:n.updateIndex,updateEpoch:n.updateEpoch,kind:`task-update`,message:r}),createTaskUpdateResult(n.action,s))}function readUpdateMessage(e){return typeof e.message==`string`&&e.message.trim()!==``?e.message:void 0}function createTaskUpdateResult(e,t){return{callId:e.callId,kind:`tool-result`,output:{status:`sent`,taskId:t},toolName:e.toolName}}export{executeTaskUpdate};
+import{fireTaskUpdateCallbackStep}from"#subagents/callback-step.js";import{forwardLocalTaskUpdateStep}from"#execution/tasks/child/update-step.js";import{SUBAGENT_ADAPTER_KIND,isSubagentAdapterState}from"#subagents/adapter-state.js";async function deliverTaskUpdate(e){let t=e.adapter?.state;return e.adapter?.kind===SUBAGENT_ADAPTER_KIND&&isSubagentAdapterState(t)&&t.taskId!==void 0?(await forwardLocalTaskUpdateStep({parentContinuationToken:t.parentContinuationToken,update:e.update}),t.taskId):await fireTaskUpdateCallbackStep({callback:e.callback,callId:e.update.callId,message:e.update.message,updateEpoch:e.update.updateEpoch,updateIndex:e.update.updateIndex})}export{deliverTaskUpdate};

package/dist/src/execution/tasks/child/workflow.d.ts

@@ -1,34 +1,26 @@
-import type { ActivityObserverConfig } from "#channel/types.js";
-import { type TaskView } from "#tasks/types.js";
-/** Input for one durable task run. */
+import { type WorkflowBodyDefinition } from "#execution/tools/workflow/body.js";
+import { type TaskInputRequest, type TaskView } from "#tasks/types.js";
 export interface TaskRunWorkflowInput {
-    /** Activity sink and work identity for best-effort terminal settlement. */
-    readonly activityObserver?: ActivityObserverConfig;
-    /** Private task inbox token; a routing credential, never model-visible. */
-    readonly taskInboxToken: string;
-    /** The creation view, normally `working`. */
     readonly initialView: TaskView;
-    /** Parent session delivery token used to wake the task's owning parent. */
     readonly parentContinuationToken: string;
+    readonly taskInboxToken: string;
+    readonly workflow?: WorkflowBodyDefinition;
+}
+/** A workflow-body question routed through the task that owns the workflow tool run. */
+interface WorkflowToolRunTaskInputRequestBase {
+    readonly kind: "task-input-request";
+    readonly replyTo: string;
+    readonly sequence: number;
+    readonly stepIndex: number;
+    readonly turnId: string;
 }
-/**
- * The durable task run: single writer for one task's lifecycle.
- *
- * Consumes commands and child wire payloads over its private hook,
- * applies the pure transition function, and appends a full `TaskView`
- * per accepted command to its `eve.task` run stream. Competing
- * completion, cancellation, and input transitions serialize here;
- * rejected commands (for example a late child result after `cancelled`)
- * change nothing.
- *
- * Wake policy: a transition into a ready status — terminal or
- * `input_required` — and an explicit child `task_update` deliver a
- * framework notification to the parent session. A parked parent starts
- * a turn; an active turn observes the delivery at its next safe boundary.
- *
- * The run ends when the task reaches a terminal status. Its view
- * stream stays readable, so terminal tasks remain peekable; the
- * disposed hook makes any later command fail loudly instead of queueing
- * against a finished task.
- */
+export type WorkflowToolRunTaskInputRequest = WorkflowToolRunTaskInputRequestBase & ({
+    readonly request: TaskInputRequest;
+    readonly requests?: never;
+} | {
+    readonly request?: never;
+    readonly requests: readonly TaskInputRequest[];
+});
+/** Owns lifecycle for one background task and consumes its executor traffic. */
 export declare function taskRunWorkflow(input: TaskRunWorkflowInput): Promise<void>;
+export {};

package/dist/src/execution/tasks/child/workflow.js

@@ -1 +1 @@
-import{createHook}from"#compiled/@workflow/core/index.js";import{claimHookOwnership,disposeHook,isHookConflictError}from"#execution/hook-ownership.js";import{isReadyTaskStatus,isTerminalTaskStatus,readTaskInputRequestId,readTaskUsage}from"#tasks/types.js";import{appendTaskViewStep,deliverTaskInputResponsesStep,wakeTaskAuthorizationParentStep,wakeTaskInputRequestParentStep,wakeTaskParentStep,wakeTaskUpdateParentStep}from"#execution/tasks/child/steps.js";import{applyTaskTransition}from"#tasks/transitions.js";import{translateTaskInboundPayload}from"#tasks/wire.js";import{createChannelReader,raceChannelReads}from"#execution/tool-run/owner-channels.js";import{openRunOwnerChannels}from"#execution/tool-run/owner.js";import{runOutcomeToTaskCommand,runReportToTaskUpdate,runRequestToInputRequestPayload}from"#execution/tool-run/owner-inbox.js";function isTaskRunFinished(e,t){return!isTerminalTaskStatus(e.status)||!t?!1:e.status!==`cancelled`||e.executor?.lifecycle===`terminal`}async function taskRunWorkflow(a){"use workflow";let o=createHook({token:a.taskInboxToken}),l=createChannelReader(`commands`,o),u=a.initialView.metadata.kind===`tool`?openRunOwnerChannels(a.taskInboxToken):void 0,d=u===void 0?[l]:[...u.readers,l],f=!1;try{try{await claimHookOwnership(o),f=!0}catch(e){if(isHookConflictError(e))return;throw e}let e=a.initialView,n,s=[],c=[],l=!1,u=0,p=new Map;for(await appendTaskViewStep({activityObserver:a.activityObserver,view:e});!isTaskRunFinished(e,l);){let t=await raceChannelReads(d);if(t.next.done===!0)return;t.channel===`request`&&p.set(t.next.value.answerToken,{runId:t.next.value.from.runId});let r=t.channel===`report`?runReportToTaskUpdate(t.next.value,e.taskId,u++):t.channel===`request`?runRequestToInputRequestPayload(t.next.value):t.channel===`outcome`?{command:runOutcomeToTaskCommand(t.next.value),kind:`task-command`}:t.next.value,o=r.kind===`subagent-authorization-event`?{...r,kind:`authorization-event`}:r;if(o.kind===`authorization-event`&&(o.event.type===`approval.candidate`||o.event.type===`approval.settled`))continue;let f=o.kind===`task-command`&&o.command.kind===`ready`,m=o.kind===`task-command`&&o.command.kind===`reject-dispatch`;if((f||m)&&(l=!0),o.kind===`subagent-input-request`&&(n=o),o.kind===`authorization-event`&&s.push(o),o.kind===`task-update`){l&&!isTerminalTaskStatus(e.status)?await wakeTaskUpdateParentStep({token:a.parentContinuationToken,update:o,view:e}):c.push(o);continue}let h=e.status===`cancelled`&&o.kind===`runtime-action-result`,g=o.kind===`input-response`,_;if(h)_={kind:`settle-executor`,usage:readTaskUsage(o.results[0]?.outcome?.usageDelta)};else if(g){if(e.status!==`input_required`)continue;_=await resolveAnsweredCommand(e,o,p.get(o.childContinuationToken))}else _=translateTaskInboundPayload(o);if(_===void 0)continue;if(f&&isTerminalTaskStatus(e.status)){for(let t of c)await wakeTaskUpdateParentStep({token:a.parentContinuationToken,update:t,view:e});c=[],await wakeTaskParentStep({token:a.parentContinuationToken,view:e});continue}let v=applyTaskTransition(e,_);if(v.action!==`accepted`)continue;let y=!isTerminalTaskStatus(e.status)&&isTerminalTaskStatus(v.view.status),b=!isReadyTaskStatus(e.status)&&isReadyTaskStatus(v.view.status);e=v.view,await appendTaskViewStep({activityObserver:a.activityObserver,view:e});let x=l&&!y?s:[];for(let t of x)await wakeTaskAuthorizationParentStep({request:t,taskId:e.taskId,token:a.parentContinuationToken});if(l&&c.length>0&&!isTerminalTaskStatus(e.status)){for(let t of c)await wakeTaskUpdateParentStep({token:a.parentContinuationToken,update:t,view:e});c=[]}(y||x.length>0)&&(s=[]),n!==void 0&&l&&e.status===`input_required`?(await wakeTaskInputRequestParentStep({request:n,taskId:e.taskId,token:a.parentContinuationToken}),n=void 0):!m&&x.length===0&&l&&(y||b&&n===void 0)&&await wakeTaskParentStep({token:a.parentContinuationToken,view:e}),e.status!==`input_required`&&(n=void 0)}}finally{f&&(await u?.dispose(),await disposeHook(o))}}async function resolveAnsweredCommand(e,t,n){if(t.taskId!==e.taskId)return;let r=new Set(e.inputRequests.flatMap(e=>{let t=readTaskInputRequestId(e);return t===void 0?[]:[t]})),i=t.inputResponses.map(e=>e.requestId).filter(e=>r.has(e));return i.length===0?void 0:await deliverTaskInputResponsesStep({answer:t,answerHook:n,requestIds:i})===`delivered`?{kind:`answered`,requestIds:i}:void 0}export{taskRunWorkflow};
+import{createHook}from"#compiled/@workflow/core/index.js";import{claimHookOwnership,disposeHook,isHookConflictError}from"#execution/hook-ownership.js";import{isReadyTaskStatus,isTerminalTaskStatus,readTaskInputRequestId}from"#tasks/types.js";import{appendTaskViewStep,deliverTaskInputResponsesStep,wakeTaskAgentRequestParentStep,wakeTaskAuthorizationParentStep,wakeTaskParentStep,wakeTaskUpdateParentStep,wakeWorkflowTaskInputRequestParentStep}from"#execution/tasks/child/steps.js";import{createWorkflowBodyRef,executeWorkflowBody}from"#execution/tools/workflow/body.js";import{deriveWorkflowToolRunOwner}from"#execution/tools/workflow/messages.js";import{createChannelReader,raceChannelReads}from"#execution/tools/workflow/owner-channels.js";import{openWorkflowToolRunOwnerChannels}from"#execution/tools/workflow/owner.js";import{workflowToolRunOutcomeToTaskCommand,workflowToolRunReportToTaskUpdate,workflowToolRunRequestToTaskInputRequest}from"#execution/tools/workflow/owner-inbox.js";import{applyTaskTransition}from"#tasks/transitions.js";async function taskRunWorkflow(a){"use workflow";let o=createHook({token:a.taskInboxToken}),c=openWorkflowToolRunOwnerChannels(a.taskInboxToken),l=[...c.readers,createChannelReader(`commands`,o)],u=!1,d=a.initialView,f=!1,p=!1,m,h=[],g=0,_={ownerRequests:[]},v=new Map,y=new AbortController,b,x=a.workflow===void 0;try{try{await claimHookOwnership(o),u=!0}catch(e){if(isHookConflictError(e))return;throw e}for(await appendTaskViewStep({view:d});!isFinished();){let e=await raceChannelReads(b===void 0?l:[...l,b]);if(e.channel===`body`){if(x=!0,b=void 0,e.next.done)continue;await applyPayload({command:workflowToolRunOutcomeToTaskCommand({from:createWorkflowBodyRef({...a.workflow,execution:`background`}),result:e.next.value}),kind:`task-command`}),d.status===`cancelled`&&f&&!p&&await wakeTaskParentStep({token:a.parentContinuationToken,view:d});continue}if(e.next.done)return;if(e.channel===`report`){await applyPayload(workflowToolRunReportToTaskUpdate(e.next.value,d.taskId,g++));continue}if(e.channel===`outcome`){await applyPayload({command:workflowToolRunOutcomeToTaskCommand(e.next.value),kind:`task-command`});continue}if(e.channel===`request`){let t=e.next.value,n=t.request.kind;if(n===`agent-invoke`||n===`agent-settled`||n===`authorization-request`){await handleOwnerRequest(t);continue}t.requestCoordinates===void 0&&v.set(t.replyTo,{runId:t.from.runId}),await applyPayload(workflowToolRunRequestToTaskInputRequest(t));continue}await applyPayload(e.next.value)}}finally{u&&(await c.dispose(),await disposeHook(o))}function isFinished(){return isTerminalTaskStatus(d.status)&&f&&x}async function handleUpdate(e){f&&!isTerminalTaskStatus(d.status)?await wakeTaskUpdateParentStep({token:a.parentContinuationToken,update:e,view:d}):h.push(e)}async function applyPayload(e){let t=e.kind===`task-command`&&e.command.kind===`ready`,n=e.kind===`task-command`&&e.command.kind===`reject-dispatch`;if((t||n)&&(f=!0),n&&(p=!0),(t||n)&&(n||isTerminalTaskStatus(d.status)?x=!0:a.workflow!==void 0&&b===void 0&&!x&&(b=createChannelReader(`body`,awaitBodyResult(executeWorkflowBody({...a.workflow,execution:`background`,owner:deriveWorkflowToolRunOwner(a.taskInboxToken)},y.signal)))),await flushPendingTraffic()),e.kind===`task-input-request`&&(m=e),e.kind===`task-update`){await handleUpdate(e);return}let r;if(e.kind===`input-response`)r=d.status===`input_required`?await resolveAnsweredCommand(d,e,v.get(e.childContinuationToken)):void 0;else if(e.kind===`task-input-request`)r={inputRequests:e.requests??[e.request],kind:`require-input`};else if(e.kind===`task-command`)r=e.command;else return;if(r===void 0)return;if(t&&isTerminalTaskStatus(d.status)){await flushUpdates(!0),await wakeTaskParentStep({token:a.parentContinuationToken,view:d});return}let o=d,s=applyTaskTransition(d,r);s.action===`accepted`&&(d=s.view,await appendTaskViewStep({view:d}),r.kind===`cancel`&&(y.abort(Error(`Task ${d.taskId} was cancelled.`)),b===void 0&&(x=!0)),isTerminalTaskStatus(d.status)||await flushUpdates(),m!==void 0&&f&&d.status===`input_required`?(await wakeWorkflowTaskInputRequestParentStep({request:m,taskId:d.taskId,token:a.parentContinuationToken}),m=void 0):!p&&f&&(r.kind!==`cancel`||x)&&(!isTerminalTaskStatus(o.status)&&isTerminalTaskStatus(d.status)||!isReadyTaskStatus(o.status)&&isReadyTaskStatus(d.status)&&m===void 0)&&await wakeTaskParentStep({token:a.parentContinuationToken,view:d}),d.status!==`input_required`&&(m=void 0))}async function flushUpdates(e=!1){if(!(!f||isTerminalTaskStatus(d.status)&&!e)){for(let e of h)await wakeTaskUpdateParentStep({token:a.parentContinuationToken,update:e,view:d});h=[]}}async function handleOwnerRequest(e){if(!(p||isTerminalTaskStatus(d.status))){if(!f){_.ownerRequests.push(e);return}await wakeTaskOwnerRequestParent(e)}}async function flushPendingTraffic(){if(!p)for(let e of _.ownerRequests)await wakeTaskOwnerRequestParent(e);_.ownerRequests.length=0}async function wakeTaskOwnerRequestParent(e){if(e.request.kind===`authorization-request`){await wakeTaskAuthorizationParentStep({request:e.request,taskId:d.taskId,token:a.parentContinuationToken});return}await wakeTaskAgentRequestParentStep({request:e,taskId:d.taskId,token:a.parentContinuationToken})}}async function*awaitBodyResult(e){yield await e}async function resolveAnsweredCommand(e,t,n){if(t.taskId!==e.taskId)return;let r=new Set(e.inputRequests.flatMap(e=>{let t=readTaskInputRequestId(e);return t===void 0?[]:[t]})),i=t.inputResponses.map(e=>e.requestId).filter(e=>r.has(e));if(i.length!==0)return await deliverTaskInputResponsesStep({answer:t,answerHook:n,requestIds:i})===`delivered`?{kind:`answered`,requestIds:i}:void 0}export{taskRunWorkflow};

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

@@ -1,9 +1,7 @@
-import type { RuntimeSession } from "#execution/agent-handle-dispatch.js";
-import { type AgentHandle } from "#harness/handles/store.js";
-import type { RuntimeActionResult } from "#shared/action-types.js";
-import type { TaskControlInvocation } from "#shared/dispatch-action.js";
+import type { HarnessSession as RuntimeSession } from "#harness/types.js";
+import type { RuntimeActionResult, RuntimeToolCallActionRequest } from "#shared/action-types.js";
 import { type SessionTaskIndexEntry } from "#tasks/session-index.js";
-import { type TaskView } from "#tasks/types.js";
+import type { TaskView } from "#tasks/types.js";
 /**
  * Result and lookup helpers shared by the task-control executors
  * (`task_cancel` in the dispatch module,
@@ -20,18 +18,9 @@ export declare function lookupTaskEntries(session: RuntimeSession, taskIds: read
 /** 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: TaskControlInvocation, views: readonly TaskView[]): RuntimeActionResult;
+export declare function createTaskViewsResult(action: RuntimeToolCallActionRequest, views: readonly TaskView[]): RuntimeActionResult;
 /** One task-control error the model can act on. */
-export declare function createTaskControlError(action: TaskControlInvocation, message: string): RuntimeActionResult;
+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: TaskControlInvocation, unknown: readonly string[]): RuntimeActionResult;
+export declare function createUnknownTasksError(action: RuntimeToolCallActionRequest, unknown: readonly string[]): RuntimeActionResult;

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

@@ -1 +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{readSubagentTaskMetadata}from"#tasks/types.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){let t={metadata:e.metadata,status:`working`,taskId:e.taskId};return e.executor===void 0?t:{...t,executor:{binding:e.executor}}}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 o=getSessionTaskIndex(e.state).filter(e=>readSubagentTaskMetadata(e)?.agentId===t),s=await readTaskViews(o);return o.flatMap((e,t)=>{let r=s[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};
+import{readLatestTaskView}from"#execution/tasks/parent/run-parent.js";import{findSessionTaskEntry}from"#tasks/session-index.js";import{isTaskWorkflowTargetGone}from"#execution/tasks/workflow-target.js";import{taskViewsToJson}from"#tasks/json.js";function lookupTaskEntries(e,n){let r=[],i=[];for(let a of n){let n=findSessionTaskEntry(e.state,a);n===void 0?i.push(a):r.push(n)}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(t){try{return await readLatestTaskView({taskRunId:t.taskRunId})??createPendingTaskView(t)}catch(e){if(isTaskWorkflowTargetGone(e)&&t.terminalView!==void 0)return t.terminalView;throw e}}function createPendingTaskView(e){let t={metadata:e.metadata,status:`working`,taskId:e.taskId};return e.executor===void 0?t:{...t,executor:{binding:e.executor}}}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,lookupTaskEntries,readTaskView,readTaskViews};

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

@@ -1,72 +1,41 @@
 /**
- * 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.
+ * Generic task creation, readiness acknowledgement, and dispatch rejection.
  * Task-run transport (start/command/view) lives in `run-parent.ts`, which
- * this module composes and which other non-delegation callers share.
+ * Callers compose these primitives around their own executor policy.
  */
-import type { ActivityObserverConfig } from "#channel/types.js";
-import type { RuntimeSession } from "#execution/agent-handle-dispatch.js";
-import type { RuntimeSubagentChildResult } from "#shared/action-types.js";
+import type { HarnessSession } from "#harness/types.js";
 import type { JsonValue } from "#shared/json.js";
 import type { TaskExecutorBinding } from "#tools/task.js";
-import { type DurableTaskMetadata } from "#tasks/types.js";
+import { type TaskMetadata } from "#tasks/types.js";
 /** A prepared background task: identity plus its started durable run. */
 export interface BackgroundTask {
     readonly taskInboxToken: string;
     readonly createdByStepIndex?: number;
     readonly createdByTurnId: string;
     readonly executor?: TaskExecutorBinding;
-    readonly metadata: DurableTaskMetadata;
+    readonly metadata: TaskMetadata;
     readonly taskId: string;
     readonly taskRunId: string;
 }
-/** A subagent task also carries its deterministic agent-handle operation. */
-export interface DelegatedTask extends BackgroundTask {
-    readonly operationId: 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 activityObserver?: ActivityObserverConfig;
-    readonly agentId: string;
+type BackgroundTaskDraft = Omit<BackgroundTask, "taskRunId">;
+/** Derives the replay-stable task identity before its owning run is started. */
+export declare function prepareBackgroundTask(input: {
     readonly callId: string;
-    readonly mode: "local" | "remote";
-    readonly name: string;
+    readonly metadata: TaskMetadata;
     readonly parentSessionId: string;
     readonly parentStepIndex?: number;
     readonly parentTurnId: string;
-    readonly session: RuntimeSession;
-}): Promise<DelegatedTask>;
-/** Creates a replay-stable task run before a background tool starts external work. */
+    readonly session: HarnessSession;
+}): BackgroundTaskDraft;
+/** Starts a lifecycle-only task run for a non-workflow external executor. */
 export declare function beginBackgroundTask(input: {
-    readonly activityObserver?: ActivityObserverConfig;
     readonly callId: string;
-    readonly metadata: DurableTaskMetadata;
+    readonly metadata: TaskMetadata;
     readonly parentSessionId: string;
     readonly parentStepIndex?: number;
     readonly parentTurnId: string;
-    readonly session: RuntimeSession;
+    readonly session: HarnessSession;
 }): Promise<BackgroundTask>;
-/**
- * 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 {
@@ -75,13 +44,9 @@ export declare function acknowledgeDelegatedTasksStep(input: {
         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: BackgroundTask;
 }): Promise<void>;
+export {};

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

@@ -1 +1 @@
-import{sessionCommandHookToken}from"#execution/session-command-token.js";import{deriveAgentOperationId}from"#harness/handles/operation-id.js";import{readLatestTaskView,sendTaskCommand,sendTaskCommandToOwner,startTaskRun,waitForTaskCommandOwner}from"#execution/tasks/parent/run-parent.js";import{recordSessionTask}from"#tasks/session-index.js";import{createSubagentTaskMetadata,isTerminalTaskStatus,readSubagentTaskMetadata}from"#tasks/types.js";import{deriveTaskId,deriveTaskInboxToken}from"#tasks/task-id.js";async function beginDelegatedTask(e){return{...await beginBackgroundTask({activityObserver:e.activityObserver,callId:e.callId,metadata:createSubagentTaskMetadata({agentId:e.agentId,mode:e.mode,name:e.name}),parentSessionId:e.parentSessionId,parentStepIndex:e.parentStepIndex,parentTurnId:e.parentTurnId,session:e.session}),operationId:deriveAgentOperationId({callId:e.callId,parentSessionId:e.parentSessionId,parentTurnId:e.parentTurnId})}}async function beginBackgroundTask(t){let n=deriveTaskId({callId:t.callId,parentSessionId:t.parentSessionId,parentTurnId:t.parentTurnId}),r=deriveTaskInboxToken({parentContinuationToken:t.session.continuationToken,taskId:n});await startTaskRun({activityObserver:t.activityObserver,taskInboxToken:r,initialView:{metadata:t.metadata,status:`working`,taskId:n},parentContinuationToken:sessionCommandHookToken(t.session.sessionId)});let i=await waitForTaskCommandOwner({taskInboxToken:r});return{taskInboxToken:r,createdByStepIndex:t.parentStepIndex??0,createdByTurnId:t.parentTurnId,metadata:t.metadata,taskId:n,taskRunId:i.runId}}async function settleDelegatedDispatch(e){let t=readSubagentTaskMetadata(e.task);if(t===void 0)throw Error(`Task "${e.task.taskId}" is not a subagent task.`);let n={agentId:t.agentId,status:`working`,taskId:e.task.taskId};return{receipt:{backgroundTask:{status:n.status,taskId:n.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:n,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,beginBackgroundTask,beginDelegatedTask,failDelegatedDispatch,rejectDelegatedDispatch,settleDelegatedDispatch};
+import{sessionCommandHookToken}from"#execution/session-command-token.js";import{readLatestTaskView,sendTaskCommand,sendTaskCommandToOwner,startTaskRun,waitForTaskCommandOwner}from"#execution/tasks/parent/run-parent.js";import{isTerminalTaskStatus}from"#tasks/types.js";import{deriveTaskId,deriveTaskInboxToken}from"#tasks/task-id.js";function prepareBackgroundTask(e){let t=deriveTaskId({callId:e.callId,parentSessionId:e.parentSessionId,parentTurnId:e.parentTurnId});return{taskInboxToken:deriveTaskInboxToken({parentContinuationToken:e.session.continuationToken,taskId:t}),createdByStepIndex:e.parentStepIndex??0,createdByTurnId:e.parentTurnId,metadata:e.metadata,taskId:t}}async function beginBackgroundTask(t){let n=prepareBackgroundTask(t);await startTaskRun({taskInboxToken:n.taskInboxToken,initialView:{metadata:n.metadata,status:`working`,taskId:n.taskId},parentContinuationToken:sessionCommandHookToken(t.session.sessionId)});let r=await waitForTaskCommandOwner({taskInboxToken:n.taskInboxToken});return{...n,taskRunId:r.runId}}async function acknowledgeDelegatedTasksStep(e){"use step";for(let n of e.tasks){if(await sendTaskCommandToOwner({command:{kind:`ready`},taskInboxToken:n.taskInboxToken,retryUnreachable:{attempts:20,delayMs:250}})!==void 0)continue;let e=await readLatestTaskView({taskRunId:n.taskRunId});if(!(e!==void 0&&isTerminalTaskStatus(e.status)))throw Error(`Task run "${n.taskId}" did not accept its readiness command.`)}}async function rejectDelegatedDispatch(e){await sendTaskCommand({command:{data:e.error,kind:`reject-dispatch`},taskInboxToken:e.task.taskInboxToken,retryUnreachable:{attempts:20,delayMs:250}})}export{acknowledgeDelegatedTasksStep,beginBackgroundTask,prepareBackgroundTask,rejectDelegatedDispatch};

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

@@ -1,24 +1,22 @@
-import type { RuntimeSession } from "#execution/agent-handle-dispatch.js";
 import type { ChannelAdapter } from "#channel/adapter.js";
-import type { DelegatedTask } from "#execution/tasks/parent/delegate.js";
-import type { RuntimeActionResult } from "#shared/action-types.js";
-import type { PendingDispatchAction, PendingTaskControlAction } from "#shared/dispatch-action.js";
-import type { CompiledBundle } from "#runtime/sessions/runtime-context-keys.js";
+import type { HarnessSession as RuntimeSession } from "#harness/types.js";
+import type { BackgroundTask } from "#execution/tasks/parent/delegate.js";
+import { type TaskExecutorCancel } from "#execution/tasks/parent/task-cancel.js";
+import type { RuntimeActionResult, RuntimeToolCallActionRequest } from "#shared/action-types.js";
 import type { SessionTaskIndexEntry } from "#tasks/session-index.js";
-import { type SubagentExecutorData, type TaskView } from "#tasks/types.js";
-/** True for task-control calls dispatched outside the model loop. */
-export declare function isTaskControlAction(action: PendingDispatchAction): action is PendingTaskControlAction;
-/**
- * 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 current session alongside the action result.
- */
+import { type TaskInboundUpdate, type TaskView } from "#tasks/types.js";
+export type DeliverTaskUpdate = (input: {
+    readonly adapter?: ChannelAdapter;
+    readonly callback: unknown;
+    readonly update: TaskInboundUpdate;
+}) => Promise<string | undefined>;
+export declare function isTaskControlAction(action: RuntimeToolCallActionRequest): boolean;
 export declare function executeTaskControlAction(input: {
-    readonly action: PendingTaskControlAction;
+    readonly action: RuntimeToolCallActionRequest;
     readonly adapter?: ChannelAdapter;
-    readonly bundle: CompiledBundle;
+    readonly bundle: import("#runtime/sessions/runtime-context-keys.js").CompiledBundle;
+    readonly cancelOwnedWork?: TaskExecutorCancel;
+    readonly deliverUpdate?: DeliverTaskUpdate;
     readonly parentStepIndex?: number;
     readonly parentTurnId: string;
     readonly serializedContext?: Record<string, unknown>;
@@ -26,25 +24,12 @@ export declare function executeTaskControlAction(input: {
 }): Promise<{
     readonly result: RuntimeActionResult;
     readonly session: RuntimeSession;
-    readonly pendingTask?: DelegatedTask;
+    readonly pendingTask?: BackgroundTask;
 }>;
-/** Commits task cancellation, then propagates it to the addressed executor. */
+/** Commits cancellation, then stops task-owned child work and its lifecycle run. */
 export declare function cancelOwnedTask(input: {
-    readonly bundle: CompiledBundle;
+    readonly cancelOwnedWork?: TaskExecutorCancel;
     readonly entry: SessionTaskIndexEntry;
     readonly serializedContext?: Record<string, unknown>;
-    readonly session: RuntimeSession;
+    readonly session?: RuntimeSession;
 }): Promise<TaskView>;
-/**
- * Sends the cooperative abort to the child identified by a subagent
- * executor binding. Failures are logged, never thrown: the task is already
- * terminal when this runs, so the worst outcome is a child that runs to
- * completion and has its callback refused.
- */
-export declare function propagateSubagentExecutorCancel(input: {
-    readonly bundle: CompiledBundle | undefined;
-    readonly childTurnId?: string;
-    readonly executor: SubagentExecutorData;
-    readonly serializedContext?: Record<string, unknown>;
-    readonly taskId: string;
-}): Promise<void>;

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

@@ -1 +1 @@
-import{createLogger,logError}from"#internal/logging.js";import{requestWorkflowTurnCancellation}from"#execution/workflow-runtime.js";import{cancelRemoteAgentTurn,resolveRemoteAgentForAction,resolveRemoteAgentStreamHeaders}from"#execution/remote-agent-dispatch.js";import{deserializeContext}from"#context/serialize.js";import{cancelToolRun}from"#execution/tool-run/cancel.js";import{getDynamicSubagentSelection}from"#context/dynamic-subagent-lifecycle.js";import{readWorkflowToolExecutor}from"#execution/tool-run/background.js";import{sendTaskCommand}from"#execution/tasks/parent/run-parent.js";import{isTerminalTaskStatus,readSubagentExecutor,readSubagentTaskMetadata}from"#tasks/types.js";import{createTaskControlError,createTaskViewsResult,createUnknownTasksError,findTaskAgentAddress,lookupTaskEntries,readTaskView}from"#execution/tasks/parent/control-shared.js";import{executeTaskUpdate}from"#execution/tasks/child/update.js";const log=createLogger(`execution.tasks.dispatch`);function isTaskControlAction(e){return e.target.kind===`task-cancel`||e.target.kind===`task-update`}async function executeTaskControlAction(e){let{action:t,session:n}=e;if(t.target.kind===`task-update`)return{result:await executeTaskUpdate({action:t,adapter:e.adapter,updateIndex:e.parentStepIndex??0,updateEpoch:e.parentTurnId,serializedContext:e.serializedContext}),session:n};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 a=i.entries,o=[];for(let t of a)o.push(await cancelOwnedTask({bundle:e.bundle,entry:t,serializedContext:e.serializedContext,session:n}));return{result:createTaskViewsResult(t,o),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,serializedContext:e.serializedContext,entry:t,session:e.session,view:i}),i}async function propagateTaskCancel(e){let t=readWorkflowToolExecutor(e.view.executor?.binding);if(t!==void 0){await cancelToolRun(t,`Task ${e.entry.taskId} was cancelled.`),await sendTaskCommand({command:{kind:`settle-executor`},taskInboxToken:e.entry.taskInboxToken});return}let n=readSubagentTaskMetadata(e.view);if(n===void 0)return;let r=readSubagentExecutor(e.view.executor)??findTaskAgentAddress(e.session,n.agentId);r!==void 0&&(e.view.executor?.childSessionId!==void 0&&e.view.executor.childSessionId!==r.address.sessionId||await propagateSubagentExecutorCancel({bundle:e.bundle,childTurnId:e.view.executor?.childTurnId,executor:r,serializedContext:e.serializedContext,taskId:e.view.taskId}))}async function propagateSubagentExecutorCancel(e){let{address:s,identity:c}=e.executor,l=s.sessionId,u=e.childTurnId;try{if(s.kind===`agent/remote`){if(e.bundle===void 0)throw Error(`No compiled bundle is available to resolve the remote agent.`);let t=s.credentialResolver,n;if(t===void 0&&e.serializedContext!==void 0){let t=getDynamicSubagentSelection(await deserializeContext(e.serializedContext),c.nodeId);n=t?.kind===`remote`?t.remoteAgent:void 0}let d=t===void 0?resolveRemoteAgentForAction({dynamicRemoteAgent:n,nodeId:c.nodeId,remoteAgentName:c.name,registry:e.bundle.subagentRegistry.subagentsByNodeId}):{name:c.name,url:s.url},f=t===void 0&&d.url!==s.url,p=f?{}:t?.resolverId===void 0?t===void 0?void 0:{}:await resolveRemoteAgentStreamHeaders({bundle:e.bundle,name:c.name,resolverId:t.resolverId,url:s.url}),m=f?{name:c.name,url:s.url}:{...d,url:s.url},h={remote:m,sessionId:l,taskId:e.taskId};if(p!==void 0&&(h.headers=p),u!==void 0&&(h.turnId=u),(await cancelRemoteAgentTurn(h)).status===`no_active_turn`){let t={remote:m,sessionId:l,taskId:e.taskId};p!==void 0&&(t.headers=p),await cancelRemoteAgentTurn(t)}return}let t={sessionId:l,taskId:e.taskId};u!==void 0&&(t.turnId=u),(await requestWorkflowTurnCancellation(t)).status===`no_active_turn`&&await requestWorkflowTurnCancellation({sessionId:l,taskId:e.taskId})}catch(n){logError(log,`task cancel propagation failed; the child may run to completion`,n,{childSessionId:l,taskId:e.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,propagateSubagentExecutorCancel};
+import{sendTaskCommand}from"#execution/tasks/parent/run-parent.js";import{isTerminalTaskStatus}from"#tasks/types.js";import{createTaskControlError,createTaskViewsResult,createUnknownTasksError,lookupTaskEntries,readTaskView}from"#execution/tasks/parent/control-shared.js";import{cancelTaskOwnedWork}from"#execution/tasks/parent/task-cancel.js";import{TASK_CANCEL_TOOL_NAME,TASK_TOOL_NAMES,TASK_UPDATE_TOOL_NAME}from"#tools/framework/task-contract.js";function isTaskControlAction(e){return e.kind===`tool-call`&&TASK_TOOL_NAMES.has(e.toolName)}async function executeTaskControlAction(e){let{action:t,session:o}=e;if(t.toolName===TASK_UPDATE_TOOL_NAME){let r=t.input.message;if(typeof r!=`string`||r.trim()===``)return{result:createTaskControlError(t,"Provide a non-empty `message`."),session:o};let i={callId:t.callId,kind:`task-update`,message:r,updateEpoch:e.parentTurnId,updateIndex:e.parentStepIndex??0},a=await e.deliverUpdate?.({adapter:e.adapter,callback:e.serializedContext?.[`eve.sessionCallback`],update:i});return{result:a===void 0?createTaskControlError(t,`task_update requires a task-owned session.`):{callId:t.callId,kind:`tool-result`,output:{status:`sent`,taskId:a},toolName:t.toolName},session:o}}let s=readTaskIds(t.input);if(s===void 0||s.length===0)return{result:createTaskControlError(t,"Provide a non-empty `taskIds` array."),session:o};let c=lookupTaskEntries(o,s);if(c.kind===`unknown`)return{result:createUnknownTasksError(t,c.unknown),session:o};if(t.toolName!==TASK_CANCEL_TOOL_NAME)return{result:createTaskControlError(t,`Unsupported task control "${t.toolName}".`),session:o};let l=[];for(let t of c.entries)l.push(await cancelOwnedTask({cancelOwnedWork:e.cancelOwnedWork,entry:t,serializedContext:e.serializedContext,session:o}));return{result:createTaskViewsResult(t,l),session:o}}async function cancelOwnedTask(n){let r=await sendTaskCommand({command:{kind:`cancel`},taskInboxToken:n.entry.taskInboxToken}),i=await readTaskView(n.entry);for(let e=0;e<10&&!isTerminalTaskStatus(i.status);e+=1)await new Promise(e=>setTimeout(e,250)),i=await readTaskView(n.entry);if(!isTerminalTaskStatus(i.status))throw Error(`Task "${n.entry.taskId}" did not commit cancellation before timeout.`);return i.status!==`cancelled`||r!==`delivered`||await cancelTaskOwnedWork({cancelOwnedWork:n.cancelOwnedWork,entry:n.entry,serializedContext:n.serializedContext,session:n.session}),i}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

@@ -1,28 +1,18 @@
-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. */
+import type { TaskInputRequestDelivery, TaskView } from "#tasks/types.js";
+/** Validates and records a generic task-owned workflow request. */
 export declare function recordTaskInputRequestStep(input: {
-    readonly hookPayload: SubagentInputRequestHookPayload;
-    readonly serializedContext: Record<string, unknown>;
+    readonly request: TaskInputRequestDelivery;
     readonly sessionState: DurableSessionState;
-    readonly taskId: string;
 }): Promise<{
     readonly accepted: false;
     readonly sessionState: DurableSessionState;
 } | {
     readonly accepted: true;
-    readonly hookPayload: SubagentInputRequestHookPayload;
+    readonly request: TaskInputRequestDelivery;
     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. */
+/** Caches terminal task views before their workflow runs expire. */
 export declare function recordTerminalTaskViewsStep(input: {
     readonly sessionState: DurableSessionState;
     readonly views: readonly TaskView[];

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

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

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

@@ -3,8 +3,8 @@ import { type TaskCommand, type TaskRunInboundPayload, type TaskView } from "#ta
 /**
  * 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.
+ * executor implementations, receipts, or the session index. Caller-specific
+ * policy 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

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

@@ -0,0 +1,11 @@
+import type { SessionTaskIndexEntry } from "#tasks/session-index.js";
+export interface TaskExecutorCancelContext {
+    readonly entry: SessionTaskIndexEntry;
+    readonly serializedContext?: Record<string, unknown>;
+    readonly session?: unknown;
+}
+export type TaskExecutorCancel = (input: TaskExecutorCancelContext) => Promise<void>;
+/** Cancels policy-specific work associated with one task. */
+export declare function cancelTaskOwnedWork(input: TaskExecutorCancelContext & {
+    readonly cancelOwnedWork?: TaskExecutorCancel;
+}): Promise<void>;

package/dist/src/execution/tasks/parent/task-cancel.js

@@ -0,0 +1 @@
+import{cancelRun,getRun,getWorld}from"#internal/workflow/runtime.js";import{cancelWorkflowToolRun}from"#execution/tools/workflow/cancel.js";import{readWorkflowToolExecutorAddress}from"#execution/tools/workflow/types.js";async function cancelTaskOwnedWork(t){let n=readWorkflowToolExecutorAddress(t.entry.executor);n!==void 0&&await cancelWorkflowToolRun(n,`Task ${t.entry.taskId} was cancelled.`),await t.cancelOwnedWork?.(t);let r=Date.now()+1e3;for(;Date.now()<r;){try{let e=await getRun(t.entry.taskRunId).status;if(e!==`pending`&&e!==`running`)return}catch{return}await new Promise(e=>setTimeout(e,50))}try{await cancelRun(await getWorld(),t.entry.taskRunId,{cancelReason:`Task ${t.entry.taskId} was cancelled.`})}catch{}}export{cancelTaskOwnedWork};

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

@@ -10,7 +10,7 @@ export declare function runBackgroundStep(ctx: ContextContainer, session: Harnes
 /**
  * Makes background tool work transactional with the harness step.
  *
- * Concretely: when the model calls a background tool (e.g. a subagent spawn),
+ * Concretely: when the model calls a background tool,
  * the tool does real external work mid-step — it creates a task run and
  * delivers commands to its inbox — while the step itself can still fail. This
  * provider scopes that work to the step so it either lands with the step or
@@ -23,8 +23,7 @@ export declare function runBackgroundStep(ctx: ContextContainer, session: Harnes
  *
  * - `commit` — step succeeded. Compensates executions that never settled
  *   (the tool neither delegated nor completed its task), then records the
- *   task entries and executor-owned session writes onto the session being
- *   persisted.
+ *   task entries onto the session being persisted.
  * - `rollback` — step failed. Compensates incomplete executions, and settled
  *   ones too — unless the cause is turn cancellation: those tasks are already
  *   running, so they are retained for {@link readRetainedBackgroundToolResult}

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

@@ -1 +1 @@
-import{createEveCallbackRoutePath}from"#protocol/routes.js";import{loadContext}from"#context/container.js";import{parseJsonValue}from"#shared/json.js";import{BundleKey}from"#runtime/sessions/runtime-context-keys.js";import{getHarnessEmissionState}from"#harness/emission.js";import{recordTaskAgentAddress}from"#harness/handles/transitions.js";import{createWorkflowCallbackUrl}from"#execution/workflow-callback-url.js";import{cancelToolRun}from"#execution/tool-run/cancel.js";import{runStep}from"#context/run-step.js";import{activeTurnId}from"#harness/active-turn-id.js";import{propagateSubagentExecutorCancel}from"#execution/tasks/parent/dispatch.js";import{isTurnCancellation}from"#harness/turn-cancellation.js";import{readWorkflowToolExecutor}from"#execution/tool-run/background.js";import{CallbackBaseUrlKey,isAuthorizationSignal}from"#harness/authorization.js";import{sendTaskCommand,sendTaskInboundPayload}from"#execution/tasks/parent/run-parent.js";import{recordSessionTask}from"#tasks/session-index.js";import{readSubagentExecutor}from"#tasks/types.js";import{beginBackgroundTask,rejectDelegatedDispatch}from"#execution/tasks/parent/delegate.js";import{BackgroundToolExecutorKey}from"#harness/background-tools.js";import{isAsyncIterable}from"#shared/async-iterable.js";import{createTaskDelegated,isTaskDelegated}from"#tools/task.js";function runBackgroundStep(e,t,n){return runStep(e,t,n,[backgroundToolExecutionProvider])}const backgroundToolExecutionProvider={key:BackgroundToolExecutorKey,create(e,t){return{value:new BackgroundToolExecutionScope(t,e.get(BundleKey))}},async commit(e,t){return await requireExecutionScope(e).commit(t)},async rollback(e,t){await requireExecutionScope(e).rollback(t)},decorateStepResult(e,t){return requireExecutionScope(e).decorate(t)}};function readRetainedBackgroundToolResult(e){let t=e.get(BackgroundToolExecutorKey);return t instanceof BackgroundToolExecutionScope?t.retainedResult():void 0}var BackgroundToolExecutionScope=class{bundle;executions=new Map;records=[];retained=!1;initialSession;constructor(e,t){this.bundle=t,this.initialSession=e}execute(e){let t=this.executions.get(e.options.toolCallId);if(t!==void 0)return t;if(!e.batch.calls.some(t=>t.callId===e.options.toolCallId))throw Error(`Background tool call "${e.options.toolCallId}" was not registered before execution.`);let n=this.start(e);return this.executions.set(e.options.toolCallId,n),n}async commit(e){let t=this.records.filter(e=>!e.settled);return t.length>0&&await compensateBackgroundToolExecution(t,Error(`Background tool execution did not delegate or complete its task.`),this.bundle),this.apply(e)}decorate(e){let t=this.resultFields();return t===void 0?e:{...e,...t}}async rollback(e){let t=this.records.filter(e=>e.settled),n=this.records.filter(e=>!e.settled);if(n.length>0&&await compensateBackgroundToolExecution(n,e,this.bundle),t.length!==0){if(isTurnCancellation(e)){this.retained=!0;return}await compensateBackgroundToolExecution(t,e,this.bundle)}}retainedResult(){return this.retained?this.resultFields():void 0}apply(e){let t=e;for(let e of this.records){if(!e.settled||e.task===void 0)continue;let n=readSubagentExecutor(e.task.executor);n!==void 0&&(t=recordTaskAgentAddress(t,n)),t=recordSessionTask(t,e.task)}return t}resultFields(){let e=this.records.flatMap(e=>e.settled&&e.task!==void 0?[e.task]:[]);if(e.length!==0)return{backgroundTaskSession:this.apply(this.initialSession),backgroundTasks:e.map(({taskInboxToken:e,taskId:t,taskRunId:n})=>({taskInboxToken:e,taskId:t,taskRunId:n}))}}async start(r){let a={settled:!1};this.records.push(a);let o=getHarnessEmissionState(this.initialSession.state),s=await beginBackgroundTask({callId:r.options.toolCallId,metadata:{kind:`tool`,name:r.definition.name},parentSessionId:this.initialSession.sessionId,parentStepIndex:o.stepIndex,parentTurnId:activeTurnId(o),session:this.initialSession});a.task=s;let c=loadContext().get(CallbackBaseUrlKey),l={taskId:s.taskId,token:s.taskInboxToken,...c===void 0?{}:{url:createWorkflowCallbackUrl(c,createEveCallbackRoutePath(s.taskInboxToken))}},u={batch:r.batch.calls,binding:l,delegated:({executor:e,receipt:t})=>createTaskDelegated({binding:l,executor:e,receipt:t}),send:createTaskSender(s,r.options.toolCallId),session:this.initialSession,task:s},d=r.definition.execute(r.toolInput,r.options,u);if(isAsyncIterable(d))throw Error(`Background tools cannot return AsyncIterable output.`);let f=await d;return isAuthorizationSignal(f)?f:isTaskDelegated(f)?(await deliverTaskCommand(s,{executor:f.executor,kind:`bind`}),a.task={...s,executor:f.executor},a.settled=!0,f.receipt):(await deliverTaskCommand(s,{data:parseJsonValue(f),kind:`complete`}),a.settled=!0,f)}};function requireExecutionScope(e){if(!(e instanceof BackgroundToolExecutionScope))throw Error(`The background tool executor is not owned by the task runtime.`);return e}async function deliverTaskCommand(e,t){if(await sendTaskCommand({command:t,taskInboxToken:e.taskInboxToken})!==`delivered`)throw Error(`Task run "${e.taskId}" did not accept "${t.kind}".`)}function createTaskSender(e,t){let n=0;return async r=>{if(r.kind!==`update`){await deliverTaskCommand(e,r);return}if(await sendTaskInboundPayload({payload:{callId:t,kind:`task-update`,message:r.message,updateEpoch:e.taskId,updateIndex:n++},taskInboxToken:e.taskInboxToken})!==`delivered`)throw Error(`Task run "${e.taskId}" did not accept "${r.kind}".`)}}async function compensateBackgroundToolExecution(e,t,n){let r=[];for(let i of e.toReversed()){if(i.task===void 0)continue;try{await rejectDelegatedDispatch({error:{code:`PARENT_STEP_FAILED`,message:t instanceof Error?t.message:String(t)},task:i.task})}catch(e){r.push(e)}let e=readSubagentExecutor(i.task.executor);e!==void 0&&await propagateSubagentExecutorCancel({bundle:n,executor:e,taskId:i.task.taskId});let a=readWorkflowToolExecutor(i.task.executor);a!==void 0&&await cancelToolRun(a,`The step that started the tool failed.`)}if(r.length>0)throw AggregateError([t,...r],`Background tool execution failed and its tasks could not all be rejected.`,{cause:t})}export{backgroundToolExecutionProvider,readRetainedBackgroundToolResult,runBackgroundStep};
+import{createEveCallbackRoutePath}from"#protocol/routes.js";import{sessionCommandHookToken}from"#execution/session-command-token.js";import{loadContext}from"#context/container.js";import{parseJsonValue}from"#shared/json.js";import{buildCallbackContext}from"#context/build-callback-context.js";import{BundleKey}from"#runtime/sessions/runtime-context-keys.js";import{parseWorkflowToolInput}from"#execution/tools/workflow/background.js";import{getHarnessEmissionState}from"#harness/emission.js";import{deriveAgentOperationId}from"#subagents/handles/operation-id.js";import{getAgentHandleStore,writeHandles}from"#subagents/handles/store.js";import{getDynamicSubagentSelection}from"#context/dynamic-subagent-lifecycle.js";import{runStep}from"#context/run-step.js";import{activeTurnId}from"#harness/active-turn-id.js";import{AGENT_BUSY,AGENT_MISMATCH,AGENT_UNREACHABLE,formatAgentBusyMessage}from"#subagents/agent-handle-errors.js";import{isTurnCancellation}from"#harness/turn-cancellation.js";import{CallbackBaseUrlKey,isAuthorizationSignal}from"#harness/authorization.js";import{sendTaskCommand,sendTaskInboundPayload,startTaskRun,waitForTaskCommandOwner}from"#execution/tasks/parent/run-parent.js";import{recordSessionTask}from"#tasks/session-index.js";import{applyTaskAgentHandleCommand}from"#subagents/handles/transitions.js";import{createWorkflowCallbackUrl}from"#execution/workflow-callback-url.js";import{BackgroundToolExecutorKey}from"#harness/background-tools.js";import{isAsyncIterable}from"#shared/async-iterable.js";import{createTaskDelegated,isTaskDelegated}from"#tools/task.js";import{beginBackgroundTask,prepareBackgroundTask,rejectDelegatedDispatch}from"#execution/tasks/parent/delegate.js";import{createSubagentReceiptIdentity}from"#execution/tools/subagent/receipt-identity.js";const IN_PROCESS_WORKFLOW_EXECUTOR={data:{},kind:`workflow-task`};function runBackgroundStep(e,t,n){return runStep(e,t,n,[backgroundToolExecutionProvider])}const backgroundToolExecutionProvider={key:BackgroundToolExecutorKey,create(e,t){return{value:new BackgroundToolExecutionScope(t)}},async commit(e,t){return await requireExecutionScope(e).commit(t)},async rollback(e,t){await requireExecutionScope(e).rollback(t)},decorateStepResult(e,t){return requireExecutionScope(e).decorate(t)}};function readRetainedBackgroundToolResult(e){let t=e.get(BackgroundToolExecutorKey);return t instanceof BackgroundToolExecutionScope?t.retainedResult():void 0}var BackgroundToolExecutionScope=class{executions=new Map;records=[];agentHandleSession;agentHandlesChanged=!1;retained=!1;initialSession;constructor(e){this.initialSession=e,this.agentHandleSession=e}execute(e){let t=this.executions.get(e.options.toolCallId);if(t!==void 0)return t;if(!e.batch.calls.some(t=>t.callId===e.options.toolCallId))throw Error(`Background tool call "${e.options.toolCallId}" was not registered before execution.`);let n=this.start(e);return this.executions.set(e.options.toolCallId,n),n}async readAgentViews(){return(getAgentHandleStore(this.agentHandleSession.state)?.handles??[]).flatMap(e=>e.phase===`reserved`?[]:e.phase===`available`?[{availability:`available`,id:e.identity.id,name:e.identity.name}]:e.phase===`claimed`?[{availability:`busy`,id:e.identity.id,name:e.identity.name,taskId:e.ownerId,taskStatus:`working`}]:[])}async commit(e){let t=this.records.filter(e=>!e.settled);return t.length>0&&await this.compensate(t,Error(`Background tool execution did not delegate or complete its task.`)),this.apply(e)}decorate(e){let t=this.resultFields();return t===void 0?e:{...e,...t}}async rollback(e){let t=this.records.filter(e=>e.settled),n=this.records.filter(e=>!e.settled);if(n.length>0&&await this.compensate(n,e),t.length!==0){if(isTurnCancellation(e)){this.retained=!0;return}await this.compensate(t,e)}}retainedResult(){return this.retained?this.resultFields():void 0}apply(e){let t=e;for(let e of this.records)!e.settled||e.task===void 0||(t=recordSessionTask(t,e.task));return this.agentHandlesChanged&&(t=writeHandles(t,getAgentHandleStore(this.agentHandleSession.state)?.handles??[])),t}resultFields(){let e=this.records.flatMap(e=>e.settled&&e.task!==void 0?[e.task]:[]);if(e.length!==0)return{backgroundTaskSession:this.apply(this.initialSession),backgroundTasks:e.map(({taskInboxToken:e,taskId:t,taskRunId:n})=>({taskInboxToken:e,taskId:t,taskRunId:n}))}}async start(t){let i={settled:!1};this.records.push(i);let a=getHarnessEmissionState(this.initialSession.state),o=loadContext(),c=await this.startTask({ctx:o,emission:a,input:t,record:i}),l=c.task;i.task=l;let u=o.get(CallbackBaseUrlKey),d={taskId:l.taskId,token:l.taskInboxToken,...u===void 0?{}:{url:createWorkflowCallbackUrl(u,createEveCallbackRoutePath(l.taskInboxToken))}},f={batch:t.batch.calls,binding:d,delegated:({executor:e,receipt:t})=>createTaskDelegated({binding:d,executor:e,receipt:t}),send:createTaskSender(l,t.options.toolCallId),session:this.initialSession,task:l};if(t.definition.workflowId!==void 0)return i.settled=!0,{...c.receipt,status:`working`,taskId:l.taskId};let p=t.definition.execute(t.toolInput,t.options,f);if(isAsyncIterable(p))throw Error(`Background tools cannot return AsyncIterable output.`);let m=await p;return isAuthorizationSignal(m)?m:isTaskDelegated(m)?(m.executor!==void 0&&(await deliverTaskCommand(l,{executor:m.executor,kind:`bind`}),i.task={...l,executor:m.executor}),i.settled=!0,c.receipt===void 0?m.receipt:{...m.receipt,...c.receipt}):(await deliverTaskCommand(l,{data:parseJsonValue(m),kind:`complete`}),i.settled=!0,m)}async startTask(e){let n=e.input.definition.workflowId===void 0?void 0:{...e.input.definition,workflowId:e.input.definition.workflowId},r=n===void 0?void 0:parseWorkflowToolInput(e.input.toolInput,e.input.definition.name),a=activeTurnId(e.emission),s=n?.resultKind===`subagent`&&r!==void 0?projectSubagentTask({ctx:e.ctx,input:r,name:e.input.definition.name,nodeId:n.nodeId??e.input.definition.name,taskInput:{callId:e.input.options.toolCallId,parentSessionId:this.initialSession.sessionId,parentTurnId:a}}):void 0;if(s!==void 0&&s.identity===void 0&&!hasAgentHandle(this.agentHandleSession,s.metadata.agentId)){let{agentId:t,...i}=r;r=i,s=projectSubagentTask({ctx:e.ctx,input:i,name:e.input.definition.name,nodeId:n.nodeId??e.input.definition.name,taskInput:{callId:e.input.options.toolCallId,parentSessionId:this.initialSession.sessionId,parentTurnId:a}})}let l={callId:e.input.options.toolCallId,metadata:s?.metadata??{kind:`tool`,name:e.input.definition.name},parentSessionId:this.initialSession.sessionId,parentStepIndex:e.emission.stepIndex,parentTurnId:a,session:this.initialSession};if(n===void 0)return{task:await beginBackgroundTask({callId:l.callId,metadata:l.metadata,parentSessionId:l.parentSessionId,parentStepIndex:l.parentStepIndex,parentTurnId:l.parentTurnId,session:l.session})};if(r===void 0)throw Error(`Background workflow tool "${e.input.definition.name}" has no input.`);let u=prepareBackgroundTask(l);if(n.resultKind===`subagent`&&s!==void 0&&s.identity!==void 0){let t=s.identity;if(this.applyAgentHandleCommand({identity:t.identity,callId:l.callId,kind:`reserve`,operationId:t.operation.id,ownerId:u.taskId}).kind!==`ready`)throw Error(`Agent handle store rejected start operation "${t.operation.id}".`);e.record.reservation={agentId:t.identity.id,operationId:t.operation.id}}if(n.resultKind===`subagent`&&s!==void 0&&s.identity===void 0){let t=deriveAgentOperationId({callId:l.callId,parentSessionId:l.parentSessionId,parentTurnId:a}),n=this.applyAgentHandleCommand({agentId:s.metadata.agentId,callId:l.callId,expectedTarget:s.metadata.mode,invokedName:s.metadata.name,kind:`claim`,operationId:t,ownerId:u.taskId});readClaimedHandle(n)?e.record.claim={operationId:t,taskId:u.taskId}:throwAgentClaimError(s.metadata.agentId,n)}await startTaskRun({initialView:{metadata:u.metadata,status:`working`,taskId:u.taskId},parentContinuationToken:sessionCommandHookToken(this.initialSession.sessionId),taskInboxToken:u.taskInboxToken,workflow:{callId:l.callId,executeInput:n.executeInput?.(r),input:r,resultKind:n.resultKind,session:buildCallbackContext().session,stepIndex:e.emission.stepIndex,toolName:e.input.definition.name,workflowId:n.workflowId}});let d=await waitForTaskCommandOwner({taskInboxToken:u.taskInboxToken}),f={...u,executor:IN_PROCESS_WORKFLOW_EXECUTOR,taskRunId:d.runId};return e.record.task=f,n.resultKind!==`subagent`||s===void 0?{task:f}:(s.identity,{receipt:s.receipt,task:f})}applyAgentHandleCommand(e){let t=applyTaskAgentHandleCommand(this.agentHandleSession,e);return t.session!==this.agentHandleSession&&(this.agentHandleSession=t.session,this.agentHandlesChanged=!0),t.result}async compensate(e,t){let n=[];for(let r of e.toReversed()){if(r.task!==void 0)try{await rejectDelegatedDispatch({error:{code:`PARENT_STEP_FAILED`,message:t instanceof Error?t.message:String(t)},task:r.task})}catch(e){n.push(e)}r.claim!==void 0&&this.applyAgentHandleCommand({kind:`release-owner`,ownerId:r.claim.taskId}),r.reservation!==void 0&&r.task!==void 0&&this.applyAgentHandleCommand({agentId:r.reservation.agentId,kind:`remove`,ownerId:r.task.taskId})}if(n.length>0)throw AggregateError([t,...n],`Background tool execution failed and its tasks could not all be rejected.`,{cause:t})}};function hasAgentHandle(e,t){return getAgentHandleStore(e.state)?.handles.some(e=>e.identity.id===t)===!0}function projectSubagentTask(e){let t=e.input.agentId;if(typeof t==`string`&&t.trim()!==``)return{metadata:{agentId:t,kind:`subagent`,mode:readSubagentTaskMode(e.ctx,e.nodeId),name:e.name},receipt:{agentId:t}};let n=createSubagentReceiptIdentity({callId:e.taskInput.callId,nodeId:e.nodeId,parentSessionId:e.taskInput.parentSessionId,parentTurnId:e.taskInput.parentTurnId,subagentName:e.name});return{identity:n,metadata:{agentId:n.identity.id,kind:`subagent`,mode:readSubagentTaskMode(e.ctx,e.nodeId),name:e.name},receipt:{agentId:n.identity.id}}}function readSubagentTaskMode(e,t){let n=getDynamicSubagentSelection(e,t);return n===void 0?(e.get(BundleKey)?.subagentRegistry.subagentsByNodeId.get(t))?.definition.kind===`remote`?`remote`:`local`:n.kind===`remote`?`remote`:`local`}function requireExecutionScope(e){if(!(e instanceof BackgroundToolExecutionScope))throw Error(`The background tool executor is not owned by the task runtime.`);return e}async function deliverTaskCommand(e,t){if(await sendTaskCommand({command:t,taskInboxToken:e.taskInboxToken})!==`delivered`)throw Error(`Task run "${e.taskId}" did not accept "${t.kind}".`)}function createTaskSender(e,t){let n=0;return async r=>{if(r.kind!==`update`){await deliverTaskCommand(e,r);return}if(await sendTaskInboundPayload({payload:{callId:t,kind:`task-update`,message:r.message,updateEpoch:e.taskId,updateIndex:n++},taskInboxToken:e.taskInboxToken})!==`delivered`)throw Error(`Task run "${e.taskId}" did not accept "${r.kind}".`)}}function readClaimedHandle(e){return e.kind===`ready`&&e.handle?.phase===`claimed`}function throwAgentClaimError(e,t){throw t.kind===`mismatch`?Error(JSON.stringify({code:AGENT_MISMATCH,message:`Agent "${e}" no longer matches this subagent definition. Start a new agent instead.`})):t.kind===`busy`?Error(JSON.stringify({code:AGENT_BUSY,message:formatAgentBusyMessage({agentId:e,agentName:t.handle.identity.name,ownerId:`ownerId`in t.handle?t.handle.ownerId:void 0})})):Error(JSON.stringify({code:AGENT_UNREACHABLE,message:`Agent with id "${e}" is no longer reachable.`}))}export{backgroundToolExecutionProvider,readRetainedBackgroundToolResult,runBackgroundStep};

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

@@ -1 +1 @@
-import{createLogger,logError}from"#internal/logging.js";import{BundleKey}from"#runtime/sessions/runtime-context-keys.js";import{cancelRun,getWorld}from"#internal/workflow/runtime.js";import{resetRemoteAgentSession,resolveRemoteAgentForAction,resolveRemoteAgentStreamHeaders}from"#execution/remote-agent-dispatch.js";import{getAgentHandleStore}from"#harness/handles/store.js";import{deserializeContext}from"#context/serialize.js";import{readDurableSession}from"#execution/durable-session-store.js";import{getDynamicSubagentSelection}from"#context/dynamic-subagent-lifecycle.js";import{hydrateDurableSession}from"#execution/session.js";import{resolveEffectiveAgentRuntime}from"#execution/effective-agent-config.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 o;try{o=await readDurableSession(e.sessionState)}catch(n){logError(log,`failed to read child sessions for termination`,n,{parentSessionId:e.sessionState.sessionId});return}let s=readSessionTaskIndex(o.state,o.sessionId),c=getAgentHandleStore(o.state)?.handles??[],l=c.some(e=>e.phase!==`starting`&&e.address.kind===`agent/remote`),u;if(s.length>0||l){if(e.serializedContext===void 0)throw Error(`Child finalization requires serialized runtime context.`);let t=await deserializeContext(e.serializedContext);u={bundle:t.require(BundleKey),ctx:t}}if(s.length>0){let{bundle:n,ctx:r}=u,i=resolveEffectiveAgentRuntime(n,r),a=hydrateDurableSession({durable:o,turnAgent:i.turnAgent});for(let r of s)try{await cancelOwnedTask({bundle:n,entry:r,serializedContext:e.serializedContext,session:a})}catch(e){logError(log,`failed to cancel task during parent finalization`,e,{parentSessionId:o.sessionId,taskId:r.taskId})}}if(c.length!==0)for(let e of c){if(e.phase===`starting`){log.debug(`skipping starting child without a session id`,{agentId:e.identity.id,kind:e.target.kind,parentSessionId:o.sessionId});continue}try{if(e.address.kind===`agent/remote`)if(e.address.credentialResolver!==void 0){let t=e.address.credentialResolver.resolverId;await resetRemoteAgentSession({headers:t===void 0?{}:await resolveRemoteAgentStreamHeaders({bundle:u.bundle,name:e.identity.name,resolverId:t,url:e.address.url}),remote:{name:e.identity.name,url:e.address.url},sessionId:e.address.sessionId})}else{let t=getDynamicSubagentSelection(u.ctx,e.identity.nodeId),n=resolveRemoteAgentForAction({dynamicRemoteAgent:t?.kind===`remote`?t.remoteAgent:void 0,nodeId:e.identity.nodeId,registry:u.bundle.subagentRegistry.subagentsByNodeId,remoteAgentName:e.identity.name});n.url===e.address.url?await resetRemoteAgentSession({remote:n,sessionId:e.address.sessionId}):await resetRemoteAgentSession({headers:{},remote:{name:e.identity.name,url:e.address.url},sessionId:e.address.sessionId})}else 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:o.sessionId})}}}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};
+import{createLogger,logError}from"#internal/logging.js";import{BundleKey}from"#runtime/sessions/runtime-context-keys.js";import{cancelRun,getWorld}from"#internal/workflow/runtime.js";import{deserializeContext}from"#context/serialize.js";import{readDurableSession}from"#execution/durable-session-store.js";import{resetRemoteAgentSession,resolveRemoteAgentForAction,resolveRemoteAgentStreamHeaders}from"#subagents/remote-dispatch.js";import{getAgentHandleStore}from"#subagents/handles/store.js";import{getDynamicSubagentSelection}from"#context/dynamic-subagent-lifecycle.js";import{hydrateDurableSession}from"#execution/session.js";import{resolveEffectiveAgentRuntime}from"#execution/effective-agent-config.js";import{cancelOwnedTask}from"#execution/tasks/parent/dispatch.js";import{cancelBackgroundAgentTask}from"#execution/tools/subagent/task-cancel.js";import{getSessionTaskIndex}from"#tasks/session-index.js";const log=createLogger(`execution.terminate-child-sessions`);async function terminateChildSessionsStep(e){"use step";let o;try{o=await readDurableSession(e.sessionState)}catch(n){logError(log,`failed to read child sessions for termination`,n,{parentSessionId:e.sessionState.sessionId});return}let s=readSessionTaskIndex(o.state,o.sessionId),c=getAgentHandleStore(o.state)?.handles??[],l=c.some(e=>`address`in e&&e.address.kind===`agent/remote`),u;if(s.length>0||l){if(e.serializedContext===void 0)throw Error(`Child finalization requires serialized runtime context.`);let t=await deserializeContext(e.serializedContext);u={bundle:t.require(BundleKey),ctx:t}}if(s.length>0){let{bundle:n,ctx:r}=u,i=resolveEffectiveAgentRuntime(n,r),a=hydrateDurableSession({durable:o,turnAgent:i.turnAgent});for(let n of s)try{await cancelOwnedTask({cancelOwnedWork:cancelBackgroundAgentTask,entry:n,serializedContext:e.serializedContext,session:a})}catch(e){logError(log,`failed to cancel task during parent finalization`,e,{parentSessionId:o.sessionId,taskId:n.taskId})}}if(c.length!==0)for(let e of c){if(!(`address`in e)){log.debug(`skipping unaddressed child`,{agentId:e.identity.id,parentSessionId:o.sessionId});continue}try{if(e.address.kind===`agent/remote`)if(e.address.credentialResolver!==void 0){let t=e.address.credentialResolver.resolverId;await resetRemoteAgentSession({headers:t===void 0?{}:await resolveRemoteAgentStreamHeaders({bundle:u.bundle,name:e.identity.name,resolverId:t,url:e.address.url}),remote:{name:e.identity.name,url:e.address.url},sessionId:e.address.sessionId})}else{let t=getDynamicSubagentSelection(u.ctx,e.identity.nodeId),n=resolveRemoteAgentForAction({dynamicRemoteAgent:t?.kind===`remote`?t.remoteAgent:void 0,nodeId:e.identity.nodeId,registry:u.bundle.subagentRegistry.subagentsByNodeId,remoteAgentName:e.identity.name});n.url===e.address.url?await resetRemoteAgentSession({remote:n,sessionId:e.address.sessionId}):await resetRemoteAgentSession({headers:{},remote:{name:e.identity.name,url:e.address.url},sessionId:e.address.sessionId})}else 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:o.sessionId})}}}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/tools/subagent/accept-event-step.d.ts

@@ -0,0 +1,7 @@
+import { type DurableSessionState } from "#execution/durable-session-store.js";
+import { type TaskAuthorizationEventDelivery } from "#tasks/types.js";
+/** Validates that a task child's authorization event came from an agent the task owns. */
+export declare function acceptTaskAuthorizationEventStep(input: {
+    readonly delivery: TaskAuthorizationEventDelivery;
+    readonly sessionState: DurableSessionState;
+}): Promise<boolean>;

package/dist/src/execution/tools/subagent/accept-event-step.js

@@ -0,0 +1 @@
+import{readDurableSession}from"#execution/durable-session-store.js";import{getAgentHandleStore}from"#subagents/handles/store.js";import{readLatestTaskView}from"#execution/tasks/parent/run-parent.js";import{findSessionTaskEntry}from"#tasks/session-index.js";import{isTerminalTaskStatus}from"#tasks/types.js";async function acceptTaskAuthorizationEventStep(t){"use step";let{hookPayload:n,taskId:r}=t.delivery,i=await readDurableSession(t.sessionState),a=findSessionTaskEntry(i.state,r);if(a===void 0)return!1;let o=getAgentHandleStore(i.state)?.handles??[],s=o.find(e=>e.phase===`claimed`&&e.ownerId===r&&e.identity.name===n.subagentName&&e.address.sessionId===n.childSessionId),c=o.filter(e=>e.phase===`reserved`&&e.ownerId===r&&e.identity.name===n.subagentName);if(s===void 0&&c.length!==1)return!1;let l=await readLatestTaskView({taskRunId:a.taskRunId});return l!==void 0&&!isTerminalTaskStatus(l.status)}export{acceptTaskAuthorizationEventStep};

package/dist/src/execution/tools/subagent/emit-called-step.d.ts

@@ -0,0 +1,9 @@
+import { type UnstampedMessageStreamEvent } from "#protocol/message.js";
+/** Emits an already-projected task-owned `subagent.called` event on the parent stream. */
+export declare function emitTaskSubagentCalledStep(input: {
+    readonly event: UnstampedMessageStreamEvent;
+    readonly parentWritable: WritableStream<Uint8Array>;
+    readonly serializedContext: Record<string, unknown>;
+}): Promise<{
+    readonly serializedContext: Record<string, unknown>;
+}>;

package/dist/src/execution/tools/subagent/emit-called-step.js

@@ -0,0 +1 @@
+import{callAdapterEventHandler}from"#channel/adapter.js";import{encodeMessageStreamEvent,stampMessageStreamEvent}from"#protocol/message.js";import{ChannelKey}from"#runtime/sessions/runtime-context-keys.js";import{deserializeContext,serializeContext}from"#context/serialize.js";import{buildAdapterContext}from"#channel/adapter-context.js";async function emitTaskSubagentCalledStep(e){"use step";let t=await deserializeContext(e.serializedContext),n=t.require(ChannelKey),r=await callAdapterEventHandler(n,e.event,buildAdapterContext(n,t)),i=e.parentWritable.getWriter();try{await i.write(encodeMessageStreamEvent(stampMessageStreamEvent(r)))}finally{i.releaseLock()}return{serializedContext:serializeContext(t)}}export{emitTaskSubagentCalledStep};