eve 0.50.0 → 0.51.0

package/dist/src/{harness → subagents}/handles/store.d.ts

@@ -80,21 +80,13 @@ export type AgentAddress = {
     };
 };
 /**
- * Durable ownership record for one delegated child.
- *
- * Outside tasks mode, the store owns the full nonterminal lifecycle:
+ * Parent-turn-owned lifecycle: `starting → running → parked ↔ running`.
  *
- * - `starting` — the parent committed intent to start; the child may or
- *   may not exist yet.
- * - `running` — one identified child turn is outstanding.
- * - `parked` — the child is idle and resumable; only this phase is
- *   model-visible.
- *
- * A terminal child has no legacy handle: settlement deletes it. Tasks mode
- * instead keeps an `addressed` record whose availability is derived from the
- * tasks bound to its persistent child session.
+ * `starting` owns a start intent before the child has an address, `running`
+ * owns one outstanding child turn, and `parked` retains an idle, resumable
+ * child. A terminal child or dead dispatch leaves this union entirely.
  */
-export type AgentHandle = {
+export type TurnOwnedAgentHandle = {
     readonly phase: "starting";
     readonly identity: AgentIdentity;
     readonly operation: StartOperation;
@@ -109,18 +101,93 @@ export type AgentHandle = {
     readonly identity: AgentIdentity;
     readonly address: AgentAddress;
     readonly lastStatus: string;
+};
+/**
+ * Workflow-owner lifecycle: `reserved → claimed → available ↔ claimed`.
+ *
+ * `reserved` leases a fresh identity before start, `claimed` leases an
+ * addressed child turn to one task or workflow-tool run, and `available`
+ * retains the idle address between invocations. A terminal child leaves this
+ * union entirely.
+ */
+export type TaskOwnedAgentHandle = {
+    /** Fresh identity leased to one owner before the child's address is confirmed. */
+    readonly phase: "reserved";
+    readonly identity: AgentIdentity;
+    readonly operationId: string;
+    readonly callId?: string;
+    readonly ownerId: string;
+} | {
+    /** Addressed child turn leased until its owner releases it. */
+    readonly phase: "claimed";
+    readonly identity: AgentIdentity;
+    readonly operationId: string;
+    readonly callId?: string;
+    readonly address: AgentAddress;
+    readonly ownerId: string;
 } | {
-    /** Persistent task-mode identity and routing, with no execution claim. */
-    readonly phase: "addressed";
+    /** Idle addressed child with no owner lease, ready for a later invocation to claim. */
+    readonly phase: "available";
     readonly identity: AgentIdentity;
     readonly address: AgentAddress;
 };
+/**
+ * Durable ownership record for one delegated child.
+ *
+ * The two execution policies share an identity namespace and serialized store,
+ * but their lifecycle states and transitions are disjoint. A terminal child has
+ * no handle: settlement deletes it.
+ */
+export type AgentHandle = TurnOwnedAgentHandle | TaskOwnedAgentHandle;
 /** Lifecycle phase of a delegated agent handle. */
 export type AgentHandlePhase = AgentHandle["phase"];
 /** Session-state collection of delegated agent handles. */
 export interface AgentHandleStore {
     readonly handles: readonly AgentHandle[];
 }
+export declare const EMPTY_AGENT_HANDLE_STORE: AgentHandleStore;
+/** One serialized owner-lease mutation against the shared agent handle store. */
+export type AgentHandleStoreCommand = {
+    readonly kind: "read";
+} | {
+    readonly identity: AgentIdentity;
+    readonly kind: "reserve";
+    readonly operationId: string;
+    readonly callId?: string;
+    readonly ownerId: string;
+} | {
+    readonly address: AgentAddress;
+    readonly kind: "confirm";
+    readonly operationId: string;
+    readonly ownerId: string;
+} | {
+    readonly agentId: string;
+    readonly expectedTarget: "local" | "remote";
+    readonly callId?: string;
+    readonly invokedName: string;
+    readonly kind: "claim";
+    readonly operationId: string;
+    readonly ownerId: string;
+} | {
+    readonly agentId: string;
+    readonly kind: "remove";
+    readonly ownerId: string;
+} | {
+    readonly kind: "release-owner";
+    readonly ownerId: string;
+};
+export type AgentHandleStoreCommandResult = {
+    readonly kind: "ready";
+    readonly handle?: TaskOwnedAgentHandle;
+} | {
+    readonly kind: "busy";
+    readonly handle: AgentHandle;
+} | {
+    readonly kind: "mismatch";
+    readonly handle: AgentHandle;
+} | {
+    readonly kind: "unknown";
+};
 /** Derives the model-visible agent id from the first start operation. */
 export declare function deriveAgentId(name: string, startOperationId: string): string;
 /** Collapses whitespace and truncates output into a handle status line. */
@@ -132,6 +199,8 @@ export declare function formatAgentStatus(output: unknown): string;
  * driver-side reader (`query.ts`) trust stored values without revalidating.
  */
 export declare function assertPersistableAgentHandleStore(store: AgentHandleStore): AgentHandleStore;
+/** Parses one complete command before the session inbox routes it to the handle store. */
+export declare function parseAgentHandleStoreCommand(value: unknown): AgentHandleStoreCommand | undefined;
 /**
  * Reads and validates the agent handle store from session state.
  *
@@ -140,3 +209,9 @@ export declare function assertPersistableAgentHandleStore(store: AgentHandleStor
  * transition silently replace every delegated child's delivery coordinates.
  */
 export declare function getAgentHandleStore(state: SessionStateMap | undefined): AgentHandleStore | undefined;
+/** Writes the validated agent handle store under its single session-state key. */
+export declare function setAgentHandleStore(state: SessionStateMap | undefined, store: AgentHandleStore): SessionStateMap;
+/** Writes a validated handle list to a session-shaped value. */
+export declare function writeHandles<Session extends {
+    readonly state?: SessionStateMap;
+}>(session: Session, handles: readonly AgentHandle[]): Session;

package/dist/src/subagents/handles/store.js

@@ -0,0 +1 @@
+import{AGENT_HANDLES_STATE_KEY}from"./state-key.js";import{z}from"#compiled/zod/index.js";const EMPTY_AGENT_HANDLE_STORE={handles:[]},nonEmptyString=z.string().min(1),identitySchema=z.strictObject({id:nonEmptyString,name:nonEmptyString,nodeId:nonEmptyString}),startOperationSchema=z.strictObject({callId:nonEmptyString,id:nonEmptyString,kind:z.literal(`start`),parentTurnId:nonEmptyString}),continueOperationSchema=z.strictObject({callId:nonEmptyString,id:nonEmptyString,kind:z.literal(`continue`),parentTurnId:nonEmptyString,previousStatus:z.string().max(120)}),startTargetSchema=z.discriminatedUnion(`kind`,[z.strictObject({continuationToken:nonEmptyString,kind:z.literal(`agent/local`)}),z.strictObject({continuationToken:nonEmptyString,kind:z.literal(`agent/self`)}),z.strictObject({callbackBaseUrl:z.url(),credentialResolver:z.strictObject({resolverId:nonEmptyString.optional()}).optional(),kind:z.literal(`agent/remote`),url:z.url()})]),addressSchema=z.discriminatedUnion(`kind`,[z.strictObject({continuationToken:nonEmptyString,kind:z.literal(`agent/local`),sessionId:nonEmptyString}),z.strictObject({continuationToken:nonEmptyString,kind:z.literal(`agent/self`),sessionId:nonEmptyString}),z.strictObject({callbackBaseUrl:z.url(),credentialResolver:z.strictObject({resolverId:nonEmptyString.optional()}).optional(),kind:z.literal(`agent/remote`),sessionId:nonEmptyString,url:z.url()})]),agentHandleStoreCommandSchema=z.discriminatedUnion(`kind`,[z.strictObject({kind:z.literal(`read`)}),z.strictObject({identity:identitySchema,callId:nonEmptyString.optional(),kind:z.literal(`reserve`),operationId:nonEmptyString,ownerId:nonEmptyString}),z.strictObject({address:addressSchema,kind:z.literal(`confirm`),operationId:nonEmptyString,ownerId:nonEmptyString}),z.strictObject({agentId:nonEmptyString,callId:nonEmptyString.optional(),expectedTarget:z.enum([`local`,`remote`]),invokedName:nonEmptyString,kind:z.literal(`claim`),operationId:nonEmptyString,ownerId:nonEmptyString}),z.strictObject({agentId:nonEmptyString,kind:z.literal(`remove`),ownerId:nonEmptyString}),z.strictObject({kind:z.literal(`release-owner`),ownerId:nonEmptyString})]),turnOwnedAgentHandleSchema=z.discriminatedUnion(`phase`,[z.strictObject({identity:identitySchema,operation:startOperationSchema,phase:z.literal(`starting`),target:startTargetSchema}),z.strictObject({address:addressSchema,identity:identitySchema,operation:z.discriminatedUnion(`kind`,[startOperationSchema,continueOperationSchema]),phase:z.literal(`running`)}),z.strictObject({address:addressSchema,identity:identitySchema,lastStatus:z.string().max(120),phase:z.literal(`parked`)})]),taskOwnedAgentHandleSchema=z.discriminatedUnion(`phase`,[z.strictObject({callId:nonEmptyString.optional(),identity:identitySchema,operationId:nonEmptyString,phase:z.literal(`reserved`),ownerId:nonEmptyString}),z.strictObject({address:addressSchema,callId:nonEmptyString.optional(),identity:identitySchema,operationId:nonEmptyString,phase:z.literal(`claimed`),ownerId:nonEmptyString}),z.strictObject({address:addressSchema,identity:identitySchema,phase:z.literal(`available`)})]),agentHandleSchema=z.union([turnOwnedAgentHandleSchema,taskOwnedAgentHandleSchema]),agentHandleStoreSchema=z.strictObject({handles:z.array(agentHandleSchema)}).refine(e=>new Set(e.handles.map(e=>e.identity.id)).size===e.handles.length,{message:`Agent handle ids must be unique.`});function deriveAgentId(e,t){return`ag_${e}:${t.slice(0,12)}`}function formatAgentStatus(e){return(typeof e==`string`?e:JSON.stringify(e)??``).replaceAll(/\s+/g,` `).trim().slice(0,120)}function assertPersistableAgentHandleStore(e){let t=agentHandleStoreSchema.safeParse(e);if(!t.success)throw Error(`Refusing to persist a corrupt agent handle store: ${t.error.message}`);return t.data}function parseAgentHandleStoreCommand(e){let t=agentHandleStoreCommandSchema.safeParse(e);return t.success?t.data:void 0}function getAgentHandleStore(t){let n=t?.[AGENT_HANDLES_STATE_KEY];if(n===void 0)return;let r=agentHandleStoreSchema.safeParse(n);if(!r.success)throw Error(`Corrupt agent handle store under session state key "${AGENT_HANDLES_STATE_KEY}": ${r.error.message}`);return r.data}function setAgentHandleStore(t,n){return{...t,[AGENT_HANDLES_STATE_KEY]:assertPersistableAgentHandleStore(n)}}function writeHandles(e,t){return{...e,state:setAgentHandleStore(e.state,{handles:t})}}export{AGENT_HANDLES_STATE_KEY,EMPTY_AGENT_HANDLE_STORE,assertPersistableAgentHandleStore,deriveAgentId,formatAgentStatus,getAgentHandleStore,parseAgentHandleStoreCommand,setAgentHandleStore,writeHandles};

package/dist/src/subagents/handles/transitions.d.ts

@@ -0,0 +1,103 @@
+import { type AgentAddress, type AgentHandleStore, type AgentHandleStoreCommand, type AgentHandleStoreCommandResult, type AgentIdentity, type StartOperation, type TurnOwnedAgentHandle } from "#subagents/handles/store.js";
+import type { HarnessSession, SessionStateMap } from "#harness/types.js";
+import type { AgentTurnOutcome } from "#shared/agent-turn-outcome.js";
+/**
+ * Records intent to start a fresh child. Must be applied to the step's
+ * working snapshot before the start side effect runs, so the returned state
+ * owns any child the step may have created.
+ *
+ * The guarantee is intra-step, not exactly-once: the prepared handle
+ * durably commits only when the enclosing dispatch step's result commits.
+ * A crash between an accepted start and that commit replays the step from
+ * the pre-step snapshot and re-runs the side effect.
+ *
+ * Throws when the identity or operation already exists: fresh starts mint
+ * a new identity, so a collision means corrupted derivation, not a replay.
+ */
+export declare function prepareAgentStart(session: HarnessSession, input: {
+    readonly identity: AgentIdentity;
+    readonly operation: StartOperation;
+    readonly target: AgentStartTargetInput;
+}): HarnessSession;
+type AgentStartTargetInput = Extract<TurnOwnedAgentHandle, {
+    phase: "starting";
+}>["target"];
+/**
+ * Confirms a started child: `starting` becomes `running` with the child's
+ * confirmed address. Throws when no starting handle carries the operation,
+ * because confirming an unprepared start means ownership was never
+ * committed. Re-confirming an already-running handle with the same
+ * operation and address is a replay no-op.
+ */
+export declare function confirmAgentStarted(session: HarnessSession, input: {
+    readonly operationId: string;
+    readonly address: AgentAddress;
+}): HarnessSession;
+/**
+ * Resolves a dispatch that definitively failed.
+ *
+ * - A dead start or dead continuation deletes the handle: there is no
+ *   child left to own.
+ * - A retryable continuation failure restores `parked` with the status the
+ *   handle showed before the delivery, so the model may retry the same
+ *   `agentId` later.
+ *
+ * Unknown operations are a no-op: the failure raced a settlement that
+ * already resolved the handle.
+ */
+export declare function rejectAgentEffect(session: HarnessSession, input: {
+    readonly operationId: string;
+    readonly disposition: "dead" | "retryable";
+}): HarnessSession;
+/**
+ * Parks every running child when the parent abandons a cancelled turn.
+ *
+ * Cancellation requests each running descendant's cancellation and then
+ * tears down the turn inbox — the only hook a child settlement can
+ * resume — so no later settlement can move these handles. Without this
+ * transition they would stay `running` forever: invisible to the model,
+ * unresumable, and retried by every future cancellation.
+ *
+ * A cancelled child settles its own turn as a park, so `parked` with
+ * `"(cancelled)"` mirrors {@link settleAgentTurn}'s cancelled outcome. If
+ * the child instead died, a later continuation attempt discovers the dead
+ * session and {@link rejectAgentEffect} deletes the handle.
+ */
+export declare function abandonRunningAgentTurns(session: HarnessSession): HarnessSession;
+/** Result of applying a settled child turn to the store. */
+export type SettleAgentTurnResult = {
+    readonly kind: "settled";
+    readonly session: HarnessSession;
+} | {
+    readonly kind: "ignored";
+    readonly reason: "unknown-operation";
+};
+/**
+ * Applies one settled child turn: `running` becomes `parked` for a parked
+ * outcome or is deleted for a terminal outcome.
+ *
+ * The settlement must carry the operation currently recorded on the
+ * running handle; anything else is ignored so a stale delivery can never
+ * move a newer turn.
+ */
+export declare function settleAgentTurn(session: HarnessSession, input: {
+    readonly operationId: string;
+    readonly outcome: AgentTurnOutcome;
+}): SettleAgentTurnResult;
+/** Applies one atomic owner lease command to the shared agent handle store. */
+export declare function applyAgentHandleStoreCommand(store: AgentHandleStore, command: AgentHandleStoreCommand): {
+    readonly result: AgentHandleStoreCommandResult;
+    readonly store: AgentHandleStore;
+};
+/** Parks child turns still owned by workflow runs when their parent turn is cancelled. */
+export declare function abandonAgentInvocationOwners<Session extends {
+    readonly state?: SessionStateMap;
+}>(session: Session, ownerIds: ReadonlySet<string>): Session;
+/** Applies one owner-scoped handle transition to a harness session. */
+export declare function applyTaskAgentHandleCommand<Session extends {
+    readonly state?: SessionStateMap;
+}>(session: Session, command: AgentHandleStoreCommand): {
+    readonly result: AgentHandleStoreCommandResult;
+    readonly session: Session;
+};
+export {};

package/dist/src/subagents/handles/transitions.js

@@ -0,0 +1 @@
+import{EMPTY_AGENT_HANDLE_STORE,formatAgentStatus,getAgentHandleStore,writeHandles}from"#subagents/handles/store.js";function prepareAgentStart(e,t){let i=getAgentHandleStore(e.state)?.handles??[];if(i.some(e=>e.identity.id===t.identity.id))throw Error(`Agent handle "${t.identity.id}" already exists.`);return writeHandles(e,[...i,{identity:t.identity,operation:t.operation,phase:`starting`,target:t.target}])}function findActiveHandle(e,t){return e.find(e=>(e.phase===`starting`||e.phase===`running`)&&e.operation.id===t)}function confirmAgentStarted(e,t){let i=getAgentHandleStore(e.state)?.handles??[],a=findActiveHandle(i,t.operationId);if(a===void 0)throw Error(`No prepared agent handle for operation "${t.operationId}".`);return a.phase===`running`?e:writeHandles(e,i.map(e=>e===a?{address:t.address,identity:a.identity,operation:a.operation,phase:`running`}:e))}function rejectAgentEffect(e,t){let i=getAgentHandleStore(e.state)?.handles??[],a=findActiveHandle(i,t.operationId);if(a===void 0)return e;if(t.disposition===`retryable`&&a.phase===`running`){let{operation:t}=a;if(t.kind===`continue`)return writeHandles(e,i.map(e=>e===a?{address:a.address,identity:a.identity,lastStatus:t.previousStatus,phase:`parked`}:e))}return writeHandles(e,i.filter(e=>e!==a))}function abandonRunningAgentTurns(e){let t=getAgentHandleStore(e.state)?.handles??[];return t.some(e=>e.phase===`running`)?writeHandles(e,t.map(e=>e.phase===`running`?{address:e.address,identity:e.identity,lastStatus:`(cancelled)`,phase:`parked`}:e)):e}function settleAgentTurn(e,i){let a=getAgentHandleStore(e.state)?.handles??[],o=a.find(e=>e.phase===`running`&&e.operation.id===i.operationId);if(o===void 0||o.phase!==`running`)return{kind:`ignored`,reason:`unknown-operation`};if(i.outcome.kind===`terminal`)return{kind:`settled`,session:writeHandles(e,a.filter(e=>e!==o))};let{result:s}=i.outcome,c=s.kind===`succeeded`?formatAgentStatus(s.output):s.kind===`failed`?formatAgentStatus(s.error):`(cancelled)`;return{kind:`settled`,session:writeHandles(e,a.map(e=>e===o?{address:o.address,identity:o.identity,lastStatus:c,phase:`parked`}:e))}}function applyAgentHandleStoreCommand(e,t){switch(t.kind){case`read`:return{result:{kind:`ready`},store:e};case`reserve`:{let n=e.handles.find(e=>e.identity.id===t.identity.id);if(n!==void 0)return(n.phase===`reserved`||n.phase===`claimed`)&&n.operationId===t.operationId&&n.ownerId===t.ownerId?{result:{handle:n,kind:`ready`},store:e}:{result:{handle:n,kind:`busy`},store:e};let r={callId:t.callId,identity:t.identity,operationId:t.operationId,phase:`reserved`,ownerId:t.ownerId};return{result:{handle:r,kind:`ready`},store:{handles:[...e.handles,r]}}}case`confirm`:{let n=e.handles.find(e=>(e.phase===`claimed`||e.phase===`reserved`)&&e.operationId===t.operationId&&e.ownerId===t.ownerId);return n===void 0?{result:{kind:`unknown`},store:e}:n.phase===`claimed`?{result:{handle:n,kind:`ready`},store:e}:replaceHandle(e,n,{address:t.address,callId:n.callId,identity:n.identity,operationId:n.operationId,phase:`claimed`,ownerId:n.ownerId})}case`claim`:{let n=e.handles.find(e=>e.identity.id===t.agentId);return n===void 0?{result:{kind:`unknown`},store:e}:n.phase===`starting`||n.phase===`running`||n.identity.name!==t.invokedName||n.phase!==`reserved`&&n.address.kind===`agent/remote`!=(t.expectedTarget===`remote`)?{result:{handle:n,kind:`mismatch`},store:e}:n.phase===`claimed`?n.operationId===t.operationId&&n.ownerId===t.ownerId?{result:{handle:n,kind:`ready`},store:e}:{result:{handle:n,kind:`busy`},store:e}:n.phase===`reserved`?{result:{handle:n,kind:`busy`},store:e}:replaceHandle(e,n,{address:n.address,callId:t.callId,identity:n.identity,operationId:t.operationId,phase:`claimed`,ownerId:t.ownerId})}case`remove`:{let n=e.handles.find(e=>e.identity.id===t.agentId);return n===void 0?{result:{kind:`ready`},store:e}:n.phase===`claimed`&&n.ownerId!==t.ownerId?{result:{handle:n,kind:`busy`},store:e}:{result:{kind:`ready`},store:{handles:e.handles.filter(e=>e!==n)}}}case`release-owner`:{let n=e.handles.flatMap(e=>e.phase===`reserved`&&e.ownerId===t.ownerId?[]:e.phase!==`claimed`||e.ownerId!==t.ownerId?[e]:[{address:e.address,identity:e.identity,phase:`available`}]);return{result:{kind:`ready`},store:handlesEqual(e.handles,n)?e:{handles:n}}}}}function abandonAgentInvocationOwners(e,t){let i=getAgentHandleStore(e.state)?.handles??[],a=i.flatMap(e=>e.phase===`reserved`&&t.has(e.ownerId)?[]:e.phase!==`claimed`||!t.has(e.ownerId)?[e]:[{address:e.address,identity:e.identity,lastStatus:`(cancelled)`,phase:`parked`}]);return handlesEqual(i,a)?e:writeHandles(e,a)}function applyTaskAgentHandleCommand(t,i){let a=getAgentHandleStore(t.state)??EMPTY_AGENT_HANDLE_STORE,o=applyAgentHandleStoreCommand(a,i);return{result:o.result,session:o.store===a?t:writeHandles(t,o.store.handles)}}function replaceHandle(e,t,n){return{result:{handle:n,kind:`ready`},store:{handles:e.handles.map(e=>e===t?n:e)}}}function handlesEqual(e,t){return e.length===t.length&&e.every((e,n)=>e===t[n])}export{abandonAgentInvocationOwners,abandonRunningAgentTurns,applyAgentHandleStoreCommand,applyTaskAgentHandleCommand,confirmAgentStarted,prepareAgentStart,rejectAgentEffect,settleAgentTurn};

package/dist/src/{execution/delegated-parent-notification.d.ts → subagents/parent-notification.d.ts}

@@ -41,18 +41,12 @@ export declare function notifyTurnCallerStep(input: {
     readonly sessionId: string;
     readonly settled: SettledTurnNotification;
 }): Promise<void>;
-/** Settles a task-owned caller after the child turn is cooperatively cancelled. */
+/** Settles a workflow-owned caller after the child turn is cooperatively cancelled. */
 export declare function notifyCancelledTaskCallerStep(input: {
     readonly caller: TurnCaller | undefined;
     readonly sessionId: string;
     readonly usage?: TokenUsage;
 }): Promise<void>;
-/** Binds a durable task to the exact child turn before execution starts. */
-export declare function notifyTaskTurnStartedStep(input: {
-    readonly caller: TurnCaller | undefined;
-    readonly childSessionId: string;
-    readonly childTurnId: string;
-}): Promise<void>;
 /** Resolves the caller that created a delegated conversation session. */
 export declare function resolveInitialTurnCallerStep(input: {
     readonly serializedContext: Record<string, unknown>;

package/dist/src/subagents/parent-notification.js

@@ -0,0 +1 @@
+import{createLogger}from"#internal/logging.js";import{ActivityObserverKey,SessionCallbackKey}from"#context/keys.js";import{toErrorMessage}from"#shared/errors.js";import{parseJsonValue}from"#shared/json.js";import{ChannelKey}from"#runtime/sessions/runtime-context-keys.js";import{parseSessionCallback}from"#channel/session-callback.js";import{resumeHook}from"#internal/workflow/runtime.js";import{deserializeContext}from"#context/serialize.js";import{HookNotFoundError}from"#compiled/@workflow/errors/index.js";import{SUBAGENT_EXECUTION_FAILED}from"#subagents/agent-handle-errors.js";import{postSessionCallbackRequest}from"#execution/session-callback-request.js";import{SUBAGENT_ADAPTER_KIND,isSubagentAdapterState}from"#subagents/adapter-state.js";import{readTaskIdFromInboxToken}from"#tasks/task-inbox-token.js";const log=createLogger(`execution.delegated-parent-notification`);async function notifyDelegatedParentStep(e){"use step";if(e.result===void 0)return;let t=(await deserializeContext(e.serializedContext)).get(ChannelKey);if(t?.kind!==SUBAGENT_ADAPTER_KIND)return;let n=String(t.state?.parentContinuationToken??``);n!==``&&await resumeHook(n,{kind:`runtime-action-result`,results:[e.usage===void 0?e.result:{...e.result,outcome:{...e.result.outcome,usageDelta:e.usage},usage:e.usage}]})}const ZERO_TOKEN_USAGE={cacheReadTokens:0,cacheWriteTokens:0,inputTokens:0,outputTokens:0};async function notifyTurnCallerStep(e){"use step";if(e.caller===void 0)return;let t=createSettledTurnResult({caller:e.caller,lifecycle:e.lifecycle,sessionId:e.sessionId,settled:e.settled});if(e.caller.replyTo.kind===`callback`){await postSettledTurnCallback({result:t,sessionId:e.sessionId,url:e.caller.replyTo.url});return}await resumeSettledTurnHook(e.caller.replyTo.token,t)}async function notifyCancelledTaskCallerStep(e){"use step";if(e.caller===void 0)return;let t=e.usage??ZERO_TOKEN_USAGE,n={code:SUBAGENT_EXECUTION_FAILED,message:`The agent invocation was cancelled.`},r={callId:e.caller.callId,isError:!0,kind:`subagent-result`,origin:`child`,outcome:{kind:`parked`,result:{kind:`cancelled`},usageDelta:t},output:n,subagentName:e.caller.subagentName},i=e.usage===void 0?r:{...r,usage:e.usage};if(e.caller.replyTo.kind===`callback`){await postSettledTurnCallback({result:i,sessionId:e.sessionId,url:e.caller.replyTo.url});return}await resumeSettledTurnHook(e.caller.replyTo.token,i)}function createSettledTurnResult(e){let t=e.settled.usage??ZERO_TOKEN_USAGE;if(e.settled.isError===!0){let n={code:SUBAGENT_EXECUTION_FAILED,message:toErrorMessage(e.settled.output)};return{callId:e.caller.callId,isError:!0,kind:`subagent-result`,origin:`child`,outcome:{kind:e.lifecycle,result:{error:n,kind:`failed`},usageDelta:t},output:n,subagentName:e.caller.subagentName}}let n=parseJsonValue(e.settled.output),a={callId:e.caller.callId,kind:`subagent-result`,origin:`child`,outcome:{kind:e.lifecycle,result:{kind:`succeeded`,output:n},usageDelta:t},output:n,subagentName:e.caller.subagentName};return e.settled.usage===void 0?a:{...a,usage:e.settled.usage}}async function resolveInitialTurnCallerStep(e){"use step";let t=e.serializedContext[SessionCallbackKey.name];if(t!==void 0){let e=parseSessionCallback(t);if(!e.ok)throw Error(`Serialized session callback is invalid.`,{cause:e.cause});return{callId:e.callback.callId,replyTo:{kind:`callback`,token:e.callback.token,url:e.callback.url},subagentName:e.callback.subagentName,taskId:e.callback.taskId??readTaskIdFromInboxToken(e.callback.token)}}let r=(await deserializeContext(e.serializedContext)).get(ChannelKey);if(!(r?.kind!==SUBAGENT_ADAPTER_KIND||!isSubagentAdapterState(r.state)))return{callId:r.state.callId,replyTo:{kind:`hook`,token:r.state.parentContinuationToken},subagentName:r.state.subagentName,taskId:r.state.taskId??readTaskIdFromInboxToken(r.state.parentContinuationToken)}}async function bindTurnCallerContextStep(e){"use step";let r=e.caller;if(r===void 0)return e.serializedContext;let i=r.activityObserver===void 0?e.serializedContext:{...e.serializedContext,[ActivityObserverKey.name]:r.activityObserver};if(r.replyTo.kind===`callback`){let e={callId:r.callId,subagentName:r.subagentName,token:r.replyTo.token,url:r.replyTo.url};return{...i,[SessionCallbackKey.name]:r.taskId===void 0?e:{...e,taskId:r.taskId}}}let o=i[ChannelKey.name];if(typeof o!=`object`||!o||Reflect.get(o,`kind`)!==SUBAGENT_ADAPTER_KIND||!isSubagentAdapterState(Reflect.get(o,`state`)))throw Error(`Delegated local turn is missing its subagent adapter binding.`);let{taskId:s,...c}=Reflect.get(o,`state`),l={...c,callId:r.callId,parentContinuationToken:r.replyTo.token,subagentName:r.subagentName};return r.taskId!==void 0&&(l.taskId=r.taskId),{...i,[ChannelKey.name]:{...o,state:l}}}async function postSettledTurnCallback(e){let{sessionId:t}=e;if(e.result.isError===!0){await postCallbackPayload({payload:{callId:e.result.callId,error:e.result.output,kind:`turn.failed`,outcome:e.result.outcome,sessionId:t,subagentName:e.result.subagentName},url:e.url});return}await postCallbackPayload({payload:{callId:e.result.callId,kind:`turn.completed`,outcome:e.result.outcome,output:e.result.output,sessionId:t,subagentName:e.result.subagentName},url:e.url})}async function postCallbackPayload(e){let t=await postSessionCallbackRequest({body:e.payload,url:e.url});if(!t.ok)throw Error(`Turn callback failed with HTTP ${t.status}.`)}async function resumeSettledTurnHook(e,t){try{await resumeHook(e,{kind:`runtime-action-result`,results:[t]})}catch(n){if(!HookNotFoundError.is(n))throw n;log.warn(`turn caller hook no longer exists`,{callId:t.callId,callerToken:e})}}export{bindTurnCallerContextStep,notifyCancelledTaskCallerStep,notifyDelegatedParentStep,notifyTurnCallerStep,resolveInitialTurnCallerStep};

package/dist/src/subagents/parent-result.js

@@ -0,0 +1 @@
+import{toErrorMessage}from"#shared/errors.js";import{CHANNEL_CONTEXT_KEY_NAME}from"#context/key-names.js";import{SUBAGENT_EXECUTION_FAILED}from"#subagents/agent-handle-errors.js";import{SUBAGENT_ADAPTER_KIND}from"#subagents/adapter-state.js";const ZERO_TOKEN_USAGE={cacheReadTokens:0,cacheWriteTokens:0,inputTokens:0,outputTokens:0};function createDelegatedSubagentSuccessResult(e,n){let i=e[CHANNEL_CONTEXT_KEY_NAME];if(i?.kind===SUBAGENT_ADAPTER_KIND)return{callId:String(i.state?.callId??``),kind:`subagent-result`,origin:`child`,outcome:{kind:`terminal`,result:{kind:`succeeded`,output:n},usageDelta:ZERO_TOKEN_USAGE},output:n,subagentName:String(i.state?.subagentName??``)}}function createDelegatedSubagentErrorResult(t,r){let i=createDelegatedSubagentSuccessResult(t,``);if(i===void 0)return;let a={code:SUBAGENT_EXECUTION_FAILED,message:toErrorMessage(r)};return{...i,isError:!0,outcome:{kind:`terminal`,result:{error:a,kind:`failed`},usageDelta:ZERO_TOKEN_USAGE},output:a}}export{createDelegatedSubagentErrorResult,createDelegatedSubagentSuccessResult};

package/dist/src/{execution/remote-agent-dispatch.d.ts → subagents/remote-dispatch.d.ts}

@@ -2,7 +2,7 @@ import { type ResetResponse } from "#protocol/reset-session.js";
 import type { ActivityObserverConfig, CancelTurnResult, SessionAuthContext, SessionTraceContext } from "#channel/types.js";
 import type { ChannelAudience } from "#shared/channel-audience.js";
 import type { HarnessSession } from "#harness/types.js";
-import type { RuntimeRemoteAgentCallActionRequest } from "#shared/action-types.js";
+import type { RuntimeRemoteAgentDispatchRequest } from "#shared/action-types.js";
 import type { RuntimeSubagentRegistry } from "#runtime/subagents/registry.js";
 import type { DynamicRemoteAgentConfig } from "#runtime/subagents/dynamic-remote-agent-config.js";
 import type { CompiledRuntimeAgentBundle } from "#runtime/sessions/compiled-agent-cache.js";
@@ -12,7 +12,7 @@ type RemoteAgentSessionCoordinates = {
     readonly sessionId: string;
 };
 export declare function startRemoteAgentSession(input: {
-    readonly action: RuntimeRemoteAgentCallActionRequest;
+    readonly action: RuntimeRemoteAgentDispatchRequest;
     /** The dispatching turn's session principal, forwarded when `remote.forwardPrincipal` is set. */
     readonly auth?: SessionAuthContext | null;
     readonly callbackBaseUrl: string | undefined;
@@ -30,6 +30,7 @@ export declare function startRemoteAgentSession(input: {
     readonly parentTraceContext?: SessionTraceContext;
     readonly remote: ResolvedRuntimeRemoteAgentNode;
     readonly session: HarnessSession;
+    readonly taskId?: string;
 }): Promise<RemoteAgentSessionCoordinates>;
 /** Continues one remote-agent session by its immutable session ID. */
 export declare function continueRemoteAgentSession(input: {

package/dist/src/subagents/remote-dispatch.js

@@ -0,0 +1 @@
+import{z}from"#compiled/zod/index.js";import{createEveCallbackRoutePath,createEveSessionCancelRoutePath,createEveSessionResetRoutePath,createEveSessionRoutePath}from"#protocol/routes.js";import{expectFunction,expectObjectRecord}from"#internal/authored-module.js";import{CancelTurnResponseSchema}from"#protocol/cancel-turn.js";import{ResetResponseSchema}from"#protocol/reset-session.js";import{formatTraceparent}from"#protocol/traceparent.js";import{writeForwardedAudienceBaggage}from"#protocol/baggage.js";import{decisionToTraceContentCeiling}from"#shared/forwarded-trace-policy.js";import{createWorkflowCallbackUrl}from"#execution/workflow-callback-url.js";import{readTaskIdFromInboxToken}from"#tasks/task-inbox-token.js";import{formatSubagentInput,normalizeRequestedOutputSchema}from"#subagents/invocation.js";import{AgentHandleError}from"#protocol/agent-handle-error.js";import{createRemoteAgentRouteUrl}from"#subagents/remote-route-url.js";const CreateSessionResponseSchema=z.object({ok:z.literal(!0),sessionId:z.string().min(1),status:z.literal(`accepted`)});var RemoteAgentCancelRequestError=class extends Error{retryable;constructor(e,t){super(e),this.name=`RemoteAgentCancelRequestError`,this.retryable=t.retryable}};async function startRemoteAgentSession(e){let n=e.callbackToken??e.session.continuationToken;if(!n)throw Error(`Cannot dispatch remote agent without a parent continuation token.`);if(!e.callbackBaseUrl)throw Error(`Cannot dispatch remote agent without a callback base URL.`);let r=buildForwardedPrincipalField(e),i={capabilities:{},callback:{callId:e.action.callId,subagentName:e.action.remoteAgentName,taskId:e.taskId??readTaskIdFromInboxToken(n),token:n,url:createWorkflowCallbackUrl(e.callbackBaseUrl,createEveCallbackRoutePath(n))},message:formatRemoteAgentCallInputMessage({action:e.action,remote:e.remote}),mode:`conversation`,outputSchema:normalizeRequestedOutputSchema(e.action.input.outputSchema)??e.remote.outputSchema};e.activityObserver!==void 0&&(i.activityObserver=e.activityObserver),r!==void 0&&(i.forwardedPrincipal=r),e.operationId!==void 0&&(i.operationId=e.operationId);let a=await resolveRemoteAgentRequestHeaders(e.remote),o=formatTraceparent(e.parentTraceContext);o!==void 0&&setHeader(a,`traceparent`,o),setHeader(a,`baggage`,writeForwardedAudienceBaggage(readHeader(a,`baggage`),buildForwardedTraceAssertion({forwardedPrincipal:r,originAudience:e.originAudience,parentTraceContext:e.parentTraceContext,traceparent:o})));let s=await fetch(createRemoteAgentSessionUrl(e.remote),{body:JSON.stringify(i),headers:{"content-type":`application/json`,...a},method:`POST`});if(!s.ok)throw Error(`Remote agent "${e.action.remoteAgentName}" create-session request failed with HTTP ${s.status}.`);let c;try{c=await s.json()}catch{throw Error(`Remote agent "${e.action.remoteAgentName}" create-session response was not valid JSON.`)}let l=CreateSessionResponseSchema.safeParse(c);if(!l.success)throw Error(`Remote agent "${e.action.remoteAgentName}" create-session response was invalid.`);return{sessionId:l.data.sessionId}}function buildForwardedTraceAssertion(e){let t=decisionToTraceContentCeiling(e.parentTraceContext?.decision);if(!(e.forwardedPrincipal===void 0||e.parentTraceContext===void 0||(e.parentTraceContext.traceFlags&1)!=1||e.traceparent===void 0||t===void 0))return{ceiling:t,originAudience:e.originAudience??`unknown`}}async function continueRemoteAgentSession(e){let t=buildForwardedPrincipalField(e),n={activityObserver:e.activityObserver,callback:e.callback,message:e.message,outputSchema:e.outputSchema};t!==void 0&&(n.forwardedPrincipal=t);let r=await fetch(createRemoteAgentContinueUrl(e.remote,e.sessionId),{body:JSON.stringify(n),headers:{"content-type":`application/json`,...await resolveRemoteAgentRequestHeaders(e.remote)},method:`POST`});if(!r.ok){let n=await readRemoteAgentErrorCode(r),i=r.status===404||n===AgentHandleError.SessionNotResumable.code,a=r.status===400&&t!==void 0?` The receiver may support forwarded principals only on session creation; upgrade it before retrying.`:``;throw new RemoteAgentContinueRequestError(`Remote agent "${e.remote.name}" continue-session request failed${i?` permanently`:``} with HTTP ${r.status}.${a}`,{deliveryAmbiguous:isAmbiguousRemoteContinueStatus(r.status),retryable:!i})}}var RemoteAgentContinueRequestError=class extends Error{deliveryAmbiguous;retryable;constructor(e,t){super(e),this.name=`RemoteAgentContinueRequestError`,this.deliveryAmbiguous=t.deliveryAmbiguous,this.retryable=t.retryable}};function isRetryableRemoteAgentContinueError(e){return!(e instanceof RemoteAgentContinueRequestError)||e.retryable}function isAmbiguousRemoteAgentContinueError(e){return!(e instanceof RemoteAgentContinueRequestError)||e.deliveryAmbiguous}function isAmbiguousRemoteContinueStatus(e){return e===408||e===425||e>=500}async function readRemoteAgentErrorCode(e){let t;try{t=await e.json()}catch{return}if(typeof t!=`object`||!t)return;let n=Reflect.get(t,`code`);return typeof n==`string`?n:void 0}function buildForwardedPrincipalField(e){if(e.remote.forwardPrincipal!==!0||e.auth===null||e.auth===void 0)return;let t={current:e.auth};return e.initiatorAuth!==null&&e.initiatorAuth!==void 0&&(t.initiator=e.initiatorAuth),t}async function cancelRemoteAgentTurn(e){let t=e.headers??await resolveRemoteAgentRequestHeaders(e.remote),n=await fetch(createRemoteAgentCancelTurnUrl(e.remote,e.sessionId),{body:e.turnId===void 0&&e.taskId===void 0?void 0:JSON.stringify({taskId:e.taskId,turnId:e.turnId}),headers:t,method:`POST`});if(!n.ok)throw new RemoteAgentCancelRequestError(`Remote agent "${e.remote.name}" cancel-turn request failed with HTTP ${n.status}.`,{retryable:isRetryableRemoteCancelStatus(n.status)});let r;try{r=await n.json()}catch{throw new RemoteAgentCancelRequestError(`Remote agent "${e.remote.name}" cancel-turn response was not valid JSON.`,{retryable:!1})}let i=CancelTurnResponseSchema.safeParse(r);if(!i.success||i.data.status===`accepted`&&i.data.sessionId!==e.sessionId)throw new RemoteAgentCancelRequestError(`Remote agent "${e.remote.name}" cancel-turn response was invalid.`,{retryable:!1});return i.data.status===`accepted`?{sessionId:i.data.sessionId,status:`accepted`}:{status:`no_active_turn`}}function readHeader(e,t){let n=Object.keys(e).find(e=>e.toLowerCase()===t);return n===void 0?void 0:e[n]}function setHeader(e,t,n){for(let n of Object.keys(e))n.toLowerCase()===t&&delete e[n];n!==void 0&&(e[t]=n)}async function resetRemoteAgentSession(e){let t=e.headers??await resolveRemoteAgentRequestHeaders(e.remote),n=await fetch(createRemoteAgentRouteUrl(e.remote.url,createEveSessionResetRoutePath(e.sessionId)),{body:JSON.stringify({reason:`Parent session ended`}),headers:{"content-type":`application/json`,...t},method:`POST`});if(!n.ok)throw Error(`Remote agent "${e.remote.name}" reset-session request failed with HTTP ${n.status}.`);let i=ResetResponseSchema.safeParse(await n.json());if(!i.success||i.data.status===`reset`&&i.data.previousSessionId!==e.sessionId)throw Error(`Remote agent "${e.remote.name}" reset-session response was invalid.`);return i.data}function isRetryableRemoteAgentCancelError(e){return!(e instanceof RemoteAgentCancelRequestError)||e.retryable}function resolveRemoteAgentForAction(e){let t=e.registry.get(e.nodeId)?.definition;if(e.dynamicRemoteAgent!==void 0){if(t===void 0)throw Error(`Missing remote agent "${e.remoteAgentName}" in runtime registry.`);let n=resolveDynamicRemoteAgentCredentials(e.dynamicRemoteAgent),r=e.dynamicRemoteAgent,i={description:r.description,kind:`remote`,logicalPath:t.logicalPath,name:e.remoteAgentName,nodeId:e.nodeId,outputSchema:r.outputSchema,path:r.path,sourceId:t.sourceId,sourceKind:`module`,url:r.url};return r.forwardPrincipal!==void 0&&(i.forwardPrincipal=r.forwardPrincipal),n.auth!==void 0&&(i.auth=n.auth),n.headers!==void 0&&(i.headers=n.headers),i}if(t?.kind!==`remote`)throw Error(`Missing remote agent "${e.remoteAgentName}" in runtime registry.`);return t}async function resolveRemoteAgentStreamHeaders(e){if(e.resolverId===void 0)return{};let t=new Set([e.bundle.graph.root,...e.bundle.graph.nodesByNodeId.values()]);for(let n of t){let t=n.subagentRegistry.subagentsByNodeId.get(e.resolverId)?.definition;if(t!==void 0){if(t.kind!==`remote`||t.name!==e.name||t.url!==e.url)throw Error(`Remote child stream resolver does not match the authored remote agent.`);return await resolveRemoteAgentRequestHeaders(t)}}return await resolveRemoteAgentRequestHeaders(resolveDynamicRemoteAgentCredentials({credentialsStepId:e.resolverId,description:``,path:``,url:e.url}))}function resolveDynamicRemoteAgentCredentials(e){if(e.credentialsStepId===void 0)return{};let t=getStepRegistry().get(e.credentialsStepId);if(t===void 0)throw Error(`Dynamic remote subagent credentials function "${e.credentialsStepId}" is not registered.`);let n=expectObjectRecord(t(),`Dynamic remote subagent credentials are invalid.`),r={};return n.auth!==void 0&&(r.auth=expectFunction(n.auth,`Dynamic remote subagent auth is invalid.`)),n.headers!==void 0&&(r.headers=resolveDynamicRemoteAgentHeaders(n.headers)),r}function resolveDynamicRemoteAgentHeaders(e){if(typeof e==`function`)return e;let t=expectObjectRecord(e,`Dynamic remote subagent headers are invalid.`);for(let e of Object.values(t))if(typeof e!=`string`)throw Error(`Dynamic remote subagent headers are invalid.`);return t}function getStepRegistry(){let e=Symbol.for(`@workflow/core//registeredSteps`),t=globalThis,n=t[e];return n===void 0&&(n=new Map,t[e]=n),n}function createRemoteAgentSessionUrl(e){return createRemoteAgentRouteUrl(e.url,e.path)}function createRemoteAgentCancelTurnUrl(e,t){return createRemoteAgentRouteUrl(e.url,createEveSessionCancelRoutePath(t))}function createRemoteAgentContinueUrl(e,t){return createRemoteAgentRouteUrl(e.url,createEveSessionRoutePath(t))}function isRetryableRemoteCancelStatus(e){return e===408||e===425||e===429||e>=500}async function resolveRemoteAgentRequestHeaders(e){let t={};return e.headers!==void 0&&Object.assign(t,typeof e.headers==`function`?await e.headers():e.headers),e.auth!==void 0&&Object.assign(t,(await e.auth()).headers),t}function formatRemoteAgentCallInputMessage(e){let t=typeof e.action.input.message==`string`?e.action.input.message:``;return formatSubagentInput({description:e.remote.description,message:t,name:e.action.remoteAgentName,type:`remote`}).message}export{RemoteAgentContinueRequestError,cancelRemoteAgentTurn,continueRemoteAgentSession,isAmbiguousRemoteAgentContinueError,isRetryableRemoteAgentCancelError,isRetryableRemoteAgentContinueError,resetRemoteAgentSession,resolveRemoteAgentForAction,resolveRemoteAgentStreamHeaders,startRemoteAgentSession};

package/dist/src/{execution/subagent-start-local.d.ts → subagents/start-local.d.ts}

@@ -1,13 +1,13 @@
-import type { DispatchOutcome, RuntimeSession } from "#execution/agent-handle-dispatch.js";
+import type { DispatchOutcome, RuntimeSession } from "#subagents/handle-dispatch.js";
 import type { LocalDevRequestProvenance } from "#context/keys.js";
-import { buildSubagentRunInput, type SubagentInputSource } from "#execution/subagent-tool.js";
+import { buildSubagentRunInput, type SubagentInputSource } from "#subagents/tool.js";
 import { createWorkflowRuntime } from "#execution/workflow-runtime.js";
-import type { RuntimeSubagentCallActionRequest } from "#shared/action-types.js";
+import type { RuntimeSubagentDispatchRequest } from "#shared/action-types.js";
 import type { CompiledBundle } from "#runtime/sessions/runtime-context-keys.js";
 type DynamicSubagentAgentConfig = Parameters<typeof createWorkflowRuntime>[0]["dynamicSubagentAgentConfig"];
 /** Starts one local subagent after dispatch planning has selected its target. */
 export declare function startLocalSubagent(input: {
-    readonly action: RuntimeSubagentCallActionRequest;
+    readonly action: RuntimeSubagentDispatchRequest;
     readonly auth: Parameters<typeof buildSubagentRunInput>[0]["auth"];
     readonly batchEvent: {
         readonly sequence: number;
@@ -25,9 +25,8 @@ export declare function startLocalSubagent(input: {
     readonly parentTraceContext: Parameters<typeof buildSubagentRunInput>[0]["parentTraceContext"];
     readonly activityObserver?: Parameters<typeof buildSubagentRunInput>[0]["activityObserver"];
     readonly sandboxSessionId: string;
-    readonly selfAgent: boolean;
     readonly session: RuntimeSession;
     readonly source: SubagentInputSource;
-    readonly taskOwned: boolean;
+    readonly taskId?: string;
 }): Promise<DispatchOutcome>;
 export {};

package/dist/src/subagents/start-local.js

@@ -0,0 +1 @@
+import{createLogger,logError}from"#internal/logging.js";import{ContextContainer,contextStorage}from"#context/container.js";import{toErrorMessage}from"#shared/errors.js";import{createWorkflowRuntime,waitForCommandHookOwner}from"#execution/workflow-runtime.js";import{buildSubagentRunInput}from"#subagents/tool.js";import{SUBAGENT_START_FAILED}from"#subagents/agent-handle-errors.js";const log=createLogger(`execution.subagent-start-local`);async function startLocalSubagent(e){let{action:n,source:r}=e,i=createWorkflowRuntime({compiledArtifactsSource:e.bundle.compiledArtifactsSource,dynamicSubagentAgentConfig:e.dynamicSubagentAgentConfig,nodeId:n.nodeId}),{childContinuationToken:a,runInput:o}=buildSubagentRunInput({action:n,auth:e.auth,batchEvent:e.batchEvent,capabilities:e.capabilities,channelMetadata:e.channelMetadata,fanoutSize:e.fanoutSize,initiatorAuth:e.initiatorAuth,graph:e.bundle.graph,parentContinuationToken:e.parentContinuationToken,parentTraceContext:e.parentTraceContext,activityObserver:e.activityObserver,sandboxSessionId:e.sandboxSessionId,session:e.session,selfAgent:r.type===`runtime`,source:r,taskId:e.taskId}),s=r.type===`runtime`?`agent/self`:`agent/local`,c;try{await contextStorage.run(new ContextContainer({localDevRequest:e.localDevRequest}),()=>i.createSession(o)),c=(await waitForCommandHookOwner(a)).runId}catch(t){return logError(log,`local subagent start failed`,t,{callId:n.callId,nodeId:n.nodeId,subagentName:n.subagentName}),{kind:`error`,result:{callId:n.callId,isError:!0,kind:`subagent-result`,origin:`dispatch`,output:{code:SUBAGENT_START_FAILED,message:toErrorMessage(t)},subagentName:n.subagentName},session:e.currentSession}}return{address:{continuationToken:a,kind:s,sessionId:c},callId:n.callId,kind:`called`,name:n.name,session:e.currentSession,toolName:n.subagentName}}export{startLocalSubagent};

package/dist/src/{execution/subagent-start-remote.d.ts → subagents/start-remote.d.ts}

@@ -1,11 +1,11 @@
-import type { DispatchOutcome, RuntimeSession } from "#execution/agent-handle-dispatch.js";
-import { resolveRemoteAgentForAction, startRemoteAgentSession } from "#execution/remote-agent-dispatch.js";
-import type { RuntimeRemoteAgentCallActionRequest } from "#shared/action-types.js";
+import type { DispatchOutcome, RuntimeSession } from "#subagents/handle-dispatch.js";
+import { resolveRemoteAgentForAction, startRemoteAgentSession } from "#subagents/remote-dispatch.js";
+import type { RuntimeRemoteAgentDispatchRequest } from "#shared/action-types.js";
 import type { CompiledBundle } from "#runtime/sessions/runtime-context-keys.js";
 import type { ChannelAudience } from "#shared/channel-audience.js";
 /** Starts one remote subagent after dispatch planning has selected its target. */
 export declare function startRemoteSubagent(input: {
-    readonly action: RuntimeRemoteAgentCallActionRequest;
+    readonly action: RuntimeRemoteAgentDispatchRequest;
     readonly auth: Parameters<typeof startRemoteAgentSession>[0]["auth"];
     readonly batchEvent: {
         readonly sequence: number;
@@ -21,5 +21,5 @@ export declare function startRemoteSubagent(input: {
     readonly parentTraceContext: Parameters<typeof startRemoteAgentSession>[0]["parentTraceContext"];
     readonly activityObserver?: Parameters<typeof startRemoteAgentSession>[0]["activityObserver"];
     readonly session: RuntimeSession;
-    readonly taskOwned: boolean;
+    readonly taskId?: string;
 }): Promise<DispatchOutcome>;

package/dist/src/subagents/start-remote.js

@@ -0,0 +1 @@
+import{createLogger,logError}from"#internal/logging.js";import{resolveRemoteAgentForAction,startRemoteAgentSession}from"#subagents/remote-dispatch.js";import{createRemoteAgentStartFailureResult}from"#execution/dispatch-action-failures.js";import{mintStartOperation}from"#execution/dispatch-start-operation.js";import{deriveChildActivityObserverConfig}from"#execution/activity-work.js";const log=createLogger(`execution.subagent-start-remote`);async function startRemoteSubagent(e){let{action:r}=e,i=deriveChildActivityObserverConfig({activityObserver:e.activityObserver,callId:r.callId,kind:`remote-agent`,name:r.remoteAgentName,parentSessionId:e.session.sessionId,parentTurnId:e.batchEvent.turnId}),a,o;try{if(e.callbackBaseUrl===void 0)throw Error(`Cannot dispatch remote agent without a callback base URL.`);a=e.callbackBaseUrl,o=resolveRemoteAgentForAction({dynamicRemoteAgent:e.dynamicRemoteAgent,nodeId:r.nodeId,remoteAgentName:r.remoteAgentName,registry:e.bundle.subagentRegistry.subagentsByNodeId})}catch(n){return logError(log,`remote agent start failed`,n,{remoteAgentName:r.remoteAgentName,nodeId:r.nodeId,callId:r.callId}),{kind:`error`,result:createRemoteAgentStartFailureResult({action:r,error:n}),session:e.currentSession}}let{operation:s}=mintStartOperation({callId:r.callId,name:r.remoteAgentName,nodeId:r.nodeId,parentSessionId:e.session.sessionId,parentTurnId:e.batchEvent.turnId}),c={resolverId:e.dynamicRemoteAgent===void 0?r.nodeId:e.dynamicRemoteAgent.credentialsStepId};try{let t=await startRemoteAgentSession({action:r,auth:e.auth,callbackBaseUrl:a,callbackToken:e.parentContinuationToken,originAudience:e.originAudience,initiatorAuth:e.initiatorAuth,operationId:s.id,parentTraceContext:e.parentTraceContext,activityObserver:i,remote:o,session:e.session,taskId:e.taskId});return{address:{callbackBaseUrl:a,credentialResolver:c,kind:`agent/remote`,sessionId:t.sessionId,url:o.url},callId:r.callId,kind:`called`,name:r.name,session:e.currentSession,toolName:r.remoteAgentName}}catch(n){return logError(log,`remote agent start failed`,n,{remoteAgentName:r.remoteAgentName,nodeId:r.nodeId,callId:r.callId}),{kind:`error`,result:createRemoteAgentStartFailureResult({action:r,error:n}),session:e.currentSession}}}export{startRemoteSubagent};

package/dist/src/{execution/subagent-tool.d.ts → subagents/tool.d.ts}

@@ -1,9 +1,9 @@
 import type { ActivityObserverConfig, ChannelInstrumentationProjection, RunInput, SessionAuthContext, SessionCapabilities, SessionTraceContext } from "#channel/types.js";
 import type { HarnessSession } from "#harness/types.js";
-import type { RuntimeSubagentCallActionRequest } from "#shared/action-types.js";
+import type { RuntimeSubagentDispatchRequest } from "#shared/action-types.js";
 import type { JsonObject } from "#shared/json.js";
 /**
- * Pending runtime-action batch event metadata needed for child run lineage.
+ * Pending task batch event metadata needed for child run lineage.
  */
 interface BatchEventMetadata {
     readonly sequence: number;
@@ -47,7 +47,7 @@ export interface SubagentSandboxGraph {
  * Builds the {@link RunInput} for one delegated subagent child run.
  */
 export declare function buildSubagentRunInput(input: {
-    readonly action: RuntimeSubagentCallActionRequest;
+    readonly action: RuntimeSubagentDispatchRequest;
     readonly auth: SessionAuthContext | null;
     readonly batchEvent: BatchEventMetadata;
     /**
@@ -79,5 +79,7 @@ export declare function buildSubagentRunInput(input: {
     readonly activityObserver?: ActivityObserverConfig;
     readonly session: HarnessSession;
     readonly source: SubagentInputSource;
+    /** Owning task when this child starts from a background workflow tool. */
+    readonly taskId?: string;
 }): SubagentRunInputBuild;
 export {};

package/dist/src/subagents/tool.js

@@ -0,0 +1 @@
+import{mintSubagentContinuationToken}from"#execution/session.js";import{SUBAGENT_ADAPTER_KIND}from"#subagents/adapter-state.js";import{formatSubagentInput,normalizeRequestedOutputSchema}from"#subagents/invocation.js";import{resolveRemainingSessionTokenLimits}from"#subagents/token-budget.js";function buildSubagentRunInput(n){let{action:r,auth:i,batchEvent:a,capabilities:o,channelMetadata:s,initiatorAuth:c,session:l,source:u}=n,d=mintSubagentContinuationToken(`${l.sessionId}:${r.callId}`),f=l.rootSessionId??l.sessionId,p=resolveRemainingSessionTokenLimits(l,n.fanoutSize),m=normalizeRequestedOutputSchema(r.input.outputSchema),h={callId:r.callId,parentContinuationToken:n.parentContinuationToken??l.continuationToken,parentSessionId:l.sessionId,subagentName:r.subagentName};n.taskId!==void 0&&(h.taskId=n.taskId),(n.graph?.nodesByNodeId.get(r.nodeId)?.sandboxRegistry.sandbox?.definition.inheritsParent===!0||n.selfAgent)&&(l.sandboxState!==void 0&&(h.parentSandboxState=l.sandboxState),h.sandboxSessionId=n.sandboxSessionId??l.sessionId);let g={adapter:{kind:SUBAGENT_ADAPTER_KIND,state:h},auth:i,capabilities:o,channelMetadata:s,continuationToken:d,initiatorAuth:c,input:{message:formatSubagentCallInputMessage({action:r,source:u}),outputSchema:m??u.outputSchema},limits:p,mode:`conversation`,parent:{callId:r.callId,rootSessionId:f,sessionId:l.sessionId,turn:{id:a.turnId,sequence:a.sequence}},parentTraceContext:n.parentTraceContext,activityObserver:n.activityObserver};return n.taskId!==void 0&&(g.taskId=n.taskId),{childContinuationToken:d,runInput:g}}function formatSubagentCallInputMessage(e){let{message:t}=e.action.input;switch(e.source.type){case`local`:return formatSubagentInput({description:e.source.description,message:t,name:e.action.subagentName,type:`local`}).message;case`runtime`:return formatSubagentInput({message:t,name:e.action.subagentName,type:`runtime`}).message;default:return e.source}}export{buildSubagentRunInput};

package/dist/src/svelte/index.js

@@ -1,3 +1,3 @@
-import { n as defaultMessageReducer, t as useEveAgent } from "../chunks/use-eve-agent-B5I-k6Ek.js";
+import { n as defaultMessageReducer, t as useEveAgent } from "../chunks/use-eve-agent-C3vUG5g2.js";
 
 export { defaultMessageReducer, useEveAgent };

package/dist/src/svelte/use-eve-agent.js

@@ -1,3 +1,3 @@
-import { t as useEveAgent } from "../chunks/use-eve-agent-B5I-k6Ek.js";
+import { t as useEveAgent } from "../chunks/use-eve-agent-C3vUG5g2.js";
 
 export { useEveAgent };

package/dist/src/tasks/json.js

@@ -1 +1 @@
-import{readSubagentTaskMetadata}from"#tasks/types.js";import{TASK_VIEW_JSON_SCHEMA}from"#tools/framework/task-contract.js";function taskViewToJson(t){let n=readSubagentTaskMetadata(t),r=n===void 0?t.metadata:{agentId:n.agentId,kind:n.kind,mode:n.mode,name:n.name};return TASK_VIEW_JSON_SCHEMA.parse({...t,metadata:r})}function taskViewsToJson(e){return{tasks:e.map(e=>taskViewToJson(e))}}export{taskViewToJson,taskViewsToJson};
+import{TASK_VIEW_JSON_SCHEMA}from"#tools/framework/task-contract.js";function taskViewToJson(t){return TASK_VIEW_JSON_SCHEMA.parse(t)}function taskViewsToJson(e){return{tasks:e.map(e=>taskViewToJson(e))}}export{taskViewToJson,taskViewsToJson};

package/dist/src/tasks/session-index.d.ts

@@ -1,6 +1,6 @@
 import type { HarnessSession, SessionStateMap } from "#harness/types.js";
 import type { TaskExecutorBinding } from "#tools/task.js";
-import { type DurableTaskMetadata, type TaskView } from "#tasks/types.js";
+import { type TaskMetadata, type TaskView } from "#tasks/types.js";
 /**
  * Session-state key for the parent's live-task index.
  *
@@ -29,8 +29,7 @@ export interface SessionTaskIndexEntry {
     readonly createdByStepIndex?: number;
     readonly createdByTurnId: string;
     readonly executor?: TaskExecutorBinding;
-    readonly metadata: DurableTaskMetadata;
-    readonly operationId?: string;
+    readonly metadata: TaskMetadata;
 }
 /**
  * Reads and validates the task index from session state.

package/dist/src/tasks/session-index.js

@@ -1 +1 @@
-import{z}from"#compiled/zod/index.js";import{sameTaskMetadata}from"#tasks/types.js";const SESSION_TASKS_STATE_KEY=`eve.tasks`,taskMetadataSchema=z.union([z.strictObject({agentId:z.string().min(1),kind:z.literal(`subagent`),mode:z.enum([`local`,`remote`]),name:z.string().min(1)}),z.strictObject({kind:z.string().min(1),name:z.string().min(1)})]),taskViewBaseShape={executor:z.strictObject({binding:z.strictObject({data:z.record(z.string(),z.custom()),kind:z.string().min(1)}).optional(),childSessionId:z.string().min(1).optional(),childTurnId:z.string().min(1).optional(),lifecycle:z.enum([`parked`,`terminal`]).optional()}).optional(),metadata:taskMetadataSchema,taskId:z.string().min(1),usage:z.strictObject({cacheReadTokens:z.number().nonnegative(),cacheWriteTokens:z.number().nonnegative(),inputTokens:z.number().nonnegative(),outputTokens:z.number().nonnegative()}).optional()},taskViewSchema=z.discriminatedUnion(`status`,[z.strictObject({...taskViewBaseShape,lastOutput:z.strictObject({data:z.custom(),type:z.literal(`result`)}),status:z.literal(`completed`)}),z.strictObject({...taskViewBaseShape,lastOutput:z.strictObject({data:z.custom(),type:z.literal(`error`)}),status:z.literal(`failed`)}),z.strictObject({...taskViewBaseShape,status:z.literal(`cancelled`)})]),sessionTaskIndexEntrySchema=z.strictObject({taskInboxToken:z.string().min(1),createdByStepIndex:z.number().int().nonnegative().optional(),createdByTurnId:z.string().min(1),executor:z.strictObject({data:z.record(z.string(),z.custom()),kind:z.string().min(1)}).optional(),metadata:taskMetadataSchema,operationId:z.string().min(1).optional(),taskId:z.string().min(1),taskRunId:z.string().min(1),terminalView:taskViewSchema.optional()}),sessionTaskIndexSchema=z.strictObject({tasks:z.array(sessionTaskIndexEntrySchema)}).refine(e=>new Set(e.tasks.map(e=>e.taskId)).size===e.tasks.length,{message:`Task ids must be unique.`}).refine(e=>e.tasks.every(e=>e.terminalView===void 0||e.terminalView.taskId===e.taskId&&sameTaskMetadata(e.terminalView.metadata,e.metadata)),{message:`Cached terminal views must match their task index entry.`});function getSessionTaskIndex(e){let t=e?.[SESSION_TASKS_STATE_KEY];if(t===void 0)return[];let n=sessionTaskIndexSchema.safeParse(t);if(!n.success)throw Error(`Corrupt task index under session state key "${SESSION_TASKS_STATE_KEY}": ${n.error.message}`);return n.data.tasks}function cacheTerminalTaskView(e,n){if(!isValidTerminalView(n))throw Error(`Cannot cache invalid terminal task "${n.taskId}".`);let r=getSessionTaskIndex(e),i=r.findIndex(e=>e.taskId===n.taskId);if(i<0)return e;if(!sameTaskMetadata(r[i].metadata,n.metadata))throw Error(`Task view metadata does not match index entry "${n.taskId}".`);let a=[...r];return a[i]={...a[i],terminalView:n},{...e,[SESSION_TASKS_STATE_KEY]:{tasks:a}}}function isValidTerminalView(e){if(e.inputRequests!==void 0)return!1;switch(e.status){case`completed`:return e.lastOutput?.type===`result`;case`failed`:return e.lastOutput?.type===`error`;case`cancelled`:return e.lastOutput===void 0;case`working`:return!1}}function findSessionTaskEntry(e,t){return getSessionTaskIndex(e).find(e=>e.taskId===t)}function recordSessionTask(e,t){let n=[...getSessionTaskIndex(e.state).filter(e=>e.taskId!==t.taskId),t];return{...e,state:{...e.state,[SESSION_TASKS_STATE_KEY]:{tasks:n}}}}export{SESSION_TASKS_STATE_KEY,cacheTerminalTaskView,findSessionTaskEntry,getSessionTaskIndex,recordSessionTask};
+import{z}from"#compiled/zod/index.js";import{sameTaskMetadata}from"#tasks/types.js";const SESSION_TASKS_STATE_KEY=`eve.tasks`,taskMetadataSchema=z.looseObject({kind:z.string().min(1),name:z.string().min(1)}),taskViewBaseShape={executor:z.strictObject({binding:z.strictObject({data:z.record(z.string(),z.custom()),kind:z.string().min(1)}).optional()}).optional(),metadata:taskMetadataSchema,taskId:z.string().min(1),usage:z.strictObject({cacheReadTokens:z.number().nonnegative(),cacheWriteTokens:z.number().nonnegative(),inputTokens:z.number().nonnegative(),outputTokens:z.number().nonnegative()}).optional()},taskViewSchema=z.discriminatedUnion(`status`,[z.strictObject({...taskViewBaseShape,lastOutput:z.strictObject({data:z.custom(),type:z.literal(`result`)}),status:z.literal(`completed`)}),z.strictObject({...taskViewBaseShape,lastOutput:z.strictObject({data:z.custom(),type:z.literal(`error`)}),status:z.literal(`failed`)}),z.strictObject({...taskViewBaseShape,status:z.literal(`cancelled`)})]),sessionTaskIndexEntrySchema=z.strictObject({taskInboxToken:z.string().min(1),createdByStepIndex:z.number().int().nonnegative().optional(),createdByTurnId:z.string().min(1),executor:z.strictObject({data:z.record(z.string(),z.custom()),kind:z.string().min(1)}).optional(),metadata:taskMetadataSchema,taskId:z.string().min(1),taskRunId:z.string().min(1),terminalView:taskViewSchema.optional()}),sessionTaskIndexSchema=z.strictObject({tasks:z.array(sessionTaskIndexEntrySchema),version:z.literal(2)}).refine(e=>new Set(e.tasks.map(e=>e.taskId)).size===e.tasks.length,{message:`Task ids must be unique.`}).refine(e=>e.tasks.every(e=>e.terminalView===void 0||e.terminalView.taskId===e.taskId&&sameTaskMetadata(e.terminalView.metadata,e.metadata)),{message:`Cached terminal views must match their task index entry.`});function getSessionTaskIndex(e){let t=e?.[SESSION_TASKS_STATE_KEY];if(t===void 0)return[];let n=typeof t==`object`&&t?Reflect.get(t,`version`):void 0;if(n!==2)throw Error(`Unsupported task index version ${JSON.stringify(n)} under session state key "${SESSION_TASKS_STATE_KEY}"; expected version 2.`);let r=sessionTaskIndexSchema.safeParse(t);if(!r.success)throw Error(`Corrupt task index under session state key "${SESSION_TASKS_STATE_KEY}": ${r.error.message}`);return r.data.tasks}function cacheTerminalTaskView(e,n){if(!isValidTerminalView(n))throw Error(`Cannot cache invalid terminal task "${n.taskId}".`);let r=getSessionTaskIndex(e),i=r.findIndex(e=>e.taskId===n.taskId);if(i<0)return e;if(!sameTaskMetadata(r[i].metadata,n.metadata))throw Error(`Task view metadata does not match index entry "${n.taskId}".`);let a=[...r];return a[i]={...a[i],terminalView:n},{...e,[SESSION_TASKS_STATE_KEY]:{tasks:a,version:2}}}function isValidTerminalView(e){if(e.inputRequests!==void 0)return!1;switch(e.status){case`completed`:return e.lastOutput?.type===`result`;case`failed`:return e.lastOutput?.type===`error`;case`cancelled`:return e.lastOutput===void 0;case`working`:return!1}}function findSessionTaskEntry(e,t){return getSessionTaskIndex(e).find(e=>e.taskId===t)}function recordSessionTask(e,t){let n=[...getSessionTaskIndex(e.state).filter(e=>e.taskId!==t.taskId),t];return{...e,state:{...e.state,[SESSION_TASKS_STATE_KEY]:{tasks:n,version:2}}}}export{SESSION_TASKS_STATE_KEY,cacheTerminalTaskView,findSessionTaskEntry,getSessionTaskIndex,recordSessionTask};

package/dist/src/tasks/task-id.d.ts

@@ -1,9 +1,8 @@
 /**
- * Derives the stable task id for one originating subagent call.
+ * Derives the stable task id for one originating background call.
  *
- * Reuses the agent-handle operation-id derivation —
- * `hash(parentSessionId, parentTurnId, callId)` — so replayed creation
- * for the same call yields the same task without new machinery, and a
+ * Uses `hash(parentSessionId, parentTurnId, callId)` so replayed creation
+ * for the same call yields the same task, and a
  * task can never be confused with a child session id or continuation
  * token.
  *

package/dist/src/tasks/task-id.js

@@ -1 +1 @@
-import{createHash}from"node:crypto";import{deriveAgentOperationId}from"#harness/handles/operation-id.js";function deriveTaskId(e){return`task_${deriveAgentOperationId(e).slice(0,24)}`}function deriveTaskInboxToken(t){return`task:${t.taskId}:${createHash(`sha256`).update(`${t.taskId}\0${t.parentContinuationToken}`).digest(`hex`).slice(0,32)}`}export{deriveTaskId,deriveTaskInboxToken};
+import{createHash}from"node:crypto";function deriveTaskId(e){return`task_${createHash(`sha256`).update(`${e.parentSessionId}\0${e.parentTurnId}\0${e.callId}`).digest(`hex`).slice(0,24)}`}function deriveTaskInboxToken(e){return`task:${e.taskId}:${createHash(`sha256`).update(`${e.taskId}\0${e.parentContinuationToken}`).digest(`hex`).slice(0,32)}`}export{deriveTaskId,deriveTaskInboxToken};

package/dist/src/tasks/transitions.d.ts

@@ -1,14 +1,5 @@
-import type { TaskCommand, TaskView } from "#tasks/types.js";
-/**
- * Action taken on one command applied to a task view.
- *
- * - `accepted`: the view changed; the new view must be appended.
- * - `noop`: the command is recognized and benign (idempotent cancel,
- *   stale answer); nothing changed and nothing is appended.
- * - `rejected`: the command is invalid for the current status; the
- *   reason is diagnostic only.
- */
-type TaskTransitionResult = {
+import { type TaskCommand, type TaskView } from "#tasks/types.js";
+export type TaskTransitionResult = {
     readonly action: "accepted";
     readonly view: TaskView;
 } | {
@@ -19,40 +10,5 @@ type TaskTransitionResult = {
     readonly view: TaskView;
     readonly reason: string;
 };
-/**
- * Pure transition function for the task lifecycle:
- *
- * ```text
- * working <-> input_required
- *    |             |
- *    +-----> completed
- *    +-----> failed
- *    +-----> cancelled
- * ```
- *
- * Terminal states are final: a late child result can never revive a
- * cancelled task, and repeated cancellation is idempotent. The durable
- * task run is the only caller that persists accepted views, which is
- * what serializes competing completion, cancellation, and input
- * transitions.
- *
- * Orthogonal to the status, the view carries private executor state
- * (`TaskExecutorState`) with its own lifecycle. These commands move
- * executor fields, never the status above:
- *
- * ```text
- * binding:  unset --bind-------> bound            (replay noop, conflict rejected)
- * address:  unset --start-turn-> session pinned   (turn id updated per delivery)
- * verdict:  unset --complete/fail/cancel/settle-executor-> parked | terminal
- * ```
- *
- * - `bind` writes the executor binding exactly once: replaying the
- *   same binding is a noop, a different one is rejected.
- * - `start-turn` records the child session/turn ids used to address
- *   the executor, rejecting a child-session mismatch.
- * - Terminal commands and a late `settle-executor` record the child's
- *   lifecycle verdict: `parked` means the child session survived and
- *   can take another delivery, `terminal` means it ended with the turn.
- */
+/** Pure, executor-neutral transition function for one durable task. */
 export declare function applyTaskTransition(view: TaskView, command: TaskCommand): TaskTransitionResult;
-export {};

package/dist/src/tasks/transitions.js

@@ -1 +1 @@
-import{jsonValuesEqual}from"#shared/json.js";import{isTerminalTaskStatus,readTaskInputRequestId}from"#tasks/types.js";function terminalView(e,t,n){let r={executor:t.lifecycle===void 0?e.executor:{...e.executor,lifecycle:t.lifecycle},metadata:e.metadata,taskId:e.taskId};switch(t.usage!==void 0&&(r.usage=t.usage),n.status){case`completed`:return{...r,lastOutput:n.lastOutput,status:`completed`};case`failed`:return{...r,lastOutput:n.lastOutput,status:`failed`};case`cancelled`:return{...r,status:`cancelled`}}}function applyTaskTransition(r,i){if(i.kind===`bind`){let t=r.executor?.binding;return t!==void 0&&t.kind===i.executor.kind&&jsonValuesEqual(t.data,i.executor.data)?{action:`noop`,view:r}:t===void 0?{action:`accepted`,view:{...r,executor:{...r.executor,binding:i.executor}}}:{action:`rejected`,reason:`Task "${r.taskId}" already has an executor binding.`,view:r}}if(isTerminalTaskStatus(r.status)){if(i.kind===`settle-executor`){let e={...r.executor,lifecycle:`terminal`};if(sameUsage(r.usage,i.usage)&&r.executor?.lifecycle===`terminal`)return{action:`noop`,view:r};let t={...r,executor:e};return{action:`accepted`,view:i.usage===void 0?t:{...t,usage:i.usage}}}return i.kind===`cancel`&&r.status===`cancelled`?{action:`noop`,view:r}:{action:`rejected`,reason:`Task "${r.taskId}" is already ${r.status}; "${i.kind}" cannot change a terminal task.`,view:r}}switch(i.kind){case`complete`:return{action:`accepted`,view:terminalView(r,i,{lastOutput:{data:i.data,type:`result`},status:`completed`})};case`fail`:case`reject-dispatch`:return{action:`accepted`,view:terminalView(r,i,{lastOutput:{data:i.data,type:`error`},status:`failed`})};case`cancel`:return{action:`accepted`,view:terminalView(r,i,{status:`cancelled`})};case`settle-executor`:return{action:`rejected`,reason:`Task "${r.taskId}" is not terminal; usage settles with its terminal command.`,view:r};case`require-authorization`:{let e={blockedOn:`authorization`,requestId:i.requestId};return r.status===`input_required`?r.inputRequests.some(e=>readTaskInputRequestId(e)===i.requestId)?{action:`noop`,view:r}:{action:`accepted`,view:{...r,inputRequests:[...r.inputRequests,e]}}:{action:`accepted`,view:{inputRequests:[e],executor:r.executor,metadata:r.metadata,status:`input_required`,taskId:r.taskId}}}case`require-input`:return isValidInputRequestBatch(i.inputRequests)?{action:`accepted`,view:{inputRequests:i.inputRequests,executor:r.executor,metadata:r.metadata,status:`input_required`,taskId:r.taskId}}:{action:`rejected`,reason:`Task "${r.taskId}" received an invalid input request batch.`,view:r};case`ready`:return{action:`accepted`,view:r};case`answered`:{if(r.status!==`input_required`)return{action:`noop`,view:r};let e=new Set(i.requestIds),t=r.inputRequests,a=t.filter(t=>{let r=readTaskInputRequestId(t);return r===void 0||!e.has(r)});return a.length===t.length?{action:`noop`,view:r}:a.length>0?{action:`accepted`,view:{inputRequests:a,executor:r.executor,metadata:r.metadata,status:`input_required`,taskId:r.taskId}}:{action:`accepted`,view:{executor:r.executor,metadata:r.metadata,status:`working`,taskId:r.taskId}}}case`start-turn`:return i.taskId===r.taskId?r.executor?.childSessionId!==void 0&&r.executor.childSessionId!==i.childSessionId?{action:`rejected`,reason:`Task child session "${i.childSessionId}" does not match "${r.executor.childSessionId}".`,view:r}:r.executor?.childSessionId===i.childSessionId&&r.executor.childTurnId===i.childTurnId?{action:`noop`,view:r}:{action:`accepted`,view:{...r,executor:{...r.executor,childSessionId:i.childSessionId,childTurnId:i.childTurnId}}}:{action:`rejected`,reason:`Task turn identity "${i.taskId}" does not match "${r.taskId}".`,view:r}}}function isValidInputRequestBatch(e){if(e.length===0)return!1;let t=e.map(readTaskInputRequestId);return t.every(e=>e!==void 0&&e.length>0)&&new Set(t).size===t.length}function sameUsage(e,t){return e===void 0||t===void 0?e===t:e?.cacheReadTokens===t.cacheReadTokens&&e.cacheWriteTokens===t.cacheWriteTokens&&e.inputTokens===t.inputTokens&&e.outputTokens===t.outputTokens}export{applyTaskTransition};
+import{jsonValuesEqual}from"#shared/json.js";import{isTerminalTaskStatus,readTaskInputRequestId}from"#tasks/types.js";function terminalView(e,t,n){let r=`usage`in t?t.usage:void 0,i={executor:e.executor,metadata:e.metadata,taskId:e.taskId};switch(r!==void 0&&(i.usage=r),n.status){case`completed`:return{...i,lastOutput:n.lastOutput,status:`completed`};case`failed`:return{...i,lastOutput:n.lastOutput,status:`failed`};case`cancelled`:return{...i,status:`cancelled`}}}function applyTaskTransition(r,i){if(i.kind===`bind`){let t=r.executor?.binding;return t!==void 0&&t.kind===i.executor.kind&&jsonValuesEqual(t.data,i.executor.data)?{action:`noop`,view:r}:t===void 0?{action:`accepted`,view:{...r,executor:{...r.executor,binding:i.executor}}}:{action:`rejected`,reason:`Task "${r.taskId}" already has an executor binding.`,view:r}}if(isTerminalTaskStatus(r.status))return i.kind===`cancel`&&r.status===`cancelled`?{action:`noop`,view:r}:{action:`rejected`,reason:`Task "${r.taskId}" is already ${r.status}; "${i.kind}" cannot change a terminal task.`,view:r};switch(i.kind){case`complete`:return{action:`accepted`,view:terminalView(r,i,{lastOutput:{data:i.data,type:`result`},status:`completed`})};case`fail`:case`reject-dispatch`:return{action:`accepted`,view:terminalView(r,i,{lastOutput:{data:i.data,type:`error`},status:`failed`})};case`cancel`:return{action:`accepted`,view:terminalView(r,i,{status:`cancelled`})};case`require-input`:return isValidInputRequestBatch(i.inputRequests)?{action:`accepted`,view:{inputRequests:i.inputRequests,executor:r.executor,metadata:r.metadata,status:`input_required`,taskId:r.taskId}}:{action:`rejected`,reason:`Task "${r.taskId}" received an invalid input request batch.`,view:r};case`ready`:return{action:`accepted`,view:r};case`answered`:{if(r.status!==`input_required`)return{action:`noop`,view:r};let e=new Set(i.requestIds),t=r.inputRequests.filter(t=>{let r=readTaskInputRequestId(t);return r===void 0||!e.has(r)});return t.length===r.inputRequests.length?{action:`noop`,view:r}:t.length>0?{action:`accepted`,view:{...r,inputRequests:t}}:{action:`accepted`,view:{executor:r.executor,metadata:r.metadata,status:`working`,taskId:r.taskId}}}}}function isValidInputRequestBatch(e){if(e.length===0)return!1;let t=e.map(readTaskInputRequestId);return t.every(e=>e!==void 0&&e.length>0)&&new Set(t).size===t.length}export{applyTaskTransition};