eve 0.50.0 → 0.51.1

package/dist/src/{execution/subagent-event-proxy-step.d.ts → subagents/event-proxy-step.d.ts}

@@ -2,6 +2,7 @@ import type { SubagentAuthorizationEventHookPayload, SubagentInputRequestHookPay
 import type { ContextContainer } from "#context/container.js";
 import { type DurableSession, type DurableSessionState } from "#execution/durable-session-store.js";
 import type { AnswerHookRoute } from "#harness/proxy-input-requests.js";
+import type { TaskInputRequestDelivery } from "#tasks/types.js";
 type SubagentEventHookPayload = SubagentAuthorizationEventHookPayload | SubagentInputRequestHookPayload;
 interface ProxySubagentEventResult {
     readonly serializedContext: Record<string, unknown>;
@@ -17,14 +18,7 @@ export declare function runProxySubagentEventStep(input: {
 }): Promise<ProxySubagentEventResult>;
 /** Emits a task request whose proxy routes were committed by a prior step. */
 export declare function emitRecordedTaskInputRequestStep(input: {
-    readonly hookPayload: SubagentInputRequestHookPayload;
-    readonly parentWritable: WritableStream<Uint8Array>;
-    readonly serializedContext: Record<string, unknown>;
-    readonly sessionState: DurableSessionState;
-}): Promise<ProxySubagentEventResult>;
-/** Emits a task authorization event after its ownership was validated. */
-export declare function emitRecordedTaskAuthorizationEventStep(input: {
-    readonly hookPayload: SubagentAuthorizationEventHookPayload;
+    readonly request: TaskInputRequestDelivery;
     readonly parentWritable: WritableStream<Uint8Array>;
     readonly serializedContext: Record<string, unknown>;
     readonly sessionState: DurableSessionState;

package/dist/src/subagents/event-proxy-step.js

@@ -0,0 +1 @@
+import{callAdapterEventHandler}from"#channel/adapter.js";import{ModeKey}from"#context/keys.js";import{encodeMessageStreamEvent,stampMessageStreamEvent}from"#protocol/message.js";import{BundleKey,ChannelKey}from"#runtime/sessions/runtime-context-keys.js";import{emitTurnEpilogue,getHarnessEmissionState,setHarnessEmissionState}from"#harness/emission.js";import{deserializeContext,serializeContext}from"#context/serialize.js";import{createDurableSessionState,readDurableSession}from"#execution/durable-session-store.js";import{resolveEffectiveAgentRuntime}from"#execution/effective-agent-config.js";import{hydrateDurableSession}from"#execution/session.js";import{buildAdapterContext}from"#channel/adapter-context.js";import{withContextScope}from"#context/run-step.js";import{upsertProxyInputRequests}from"#harness/proxy-input-requests.js";import{emitProxiedInputRequest}from"#subagents/hitl-proxy.js";import{setChannelContext}from"#execution/channel-context.js";import{reconcileSessionContinuationToken}from"#execution/reconcile-session-continuation-token.js";async function runProxySubagentEventStep(e){"use step";let t=await readDurableSession(e.sessionState),n=await deserializeContext(e.serializedContext);return emitProxiedSubagentEvent({answerHook:e.answerHook,ctx:n,durableSession:t,hookPayload:e.hookPayload,parentWritable:e.parentWritable})}async function emitRecordedTaskInputRequestStep(e){"use step";let t=await readDurableSession(e.sessionState);return await emitProxiedSubagentEvent({ctx:await deserializeContext(e.serializedContext),durableSession:t,hookPayload:{callId:e.request.taskId,childContinuationToken:e.request.replyTo,childSessionId:e.request.taskId,event:{requests:e.request.requests??[e.request.request],sequence:e.request.sequence,stepIndex:e.request.stepIndex,turnId:e.request.turnId},kind:`subagent-input-request`,subagentName:e.request.taskId},parentWritable:e.parentWritable,recordProxyInputRequests:!1})}async function emitProxiedSubagentEvent(i){let{ctx:a}=i,o=a.require(ChannelKey),s=resolveEffectiveAgentRuntime(a.require(BundleKey),a),c=hydrateDurableSession({compactionOverrides:{thresholdPercent:s.thresholdPercent},durable:i.durableSession,turnAgent:s.turnAgent}),l=buildAdapterContext(o,a),u=i.parentWritable.getWriter(),d,f;try{let emit=async t=>{let r=await callAdapterEventHandler(o,t,l);await u.write(encodeMessageStreamEvent(stampMessageStreamEvent(r)))},r=await withContextScope(a,c,async e=>{if(i.hookPayload.kind===`subagent-authorization-event`)return await emit(i.hookPayload.event),{result:void 0,session:await closeStandaloneAuthorizationEvent({emit,eventType:i.hookPayload.event.type,mode:a.require(ModeKey),session:e})};let n=await emitProxiedInputRequest({emit,hookPayload:i.hookPayload,mode:a.require(ModeKey),session:e});return{result:n.entries,session:n.session}});d=r.result,f=r.session}finally{u.releaseLock()}if(setChannelContext(a,{...o,state:{...l.state}}),i.recordProxyInputRequests!==!1&&d!==void 0&&i.hookPayload.kind===`subagent-input-request`){let e=i.answerHook;f=upsertProxyInputRequests({entries:e===void 0?d:d.map(([t,n])=>[t,{...n,answerHook:e}]),forChildContinuationToken:i.hookPayload.childContinuationToken,session:f})}let p=reconcileSessionContinuationToken(a,f);return{serializedContext:serializeContext(a),sessionState:createDurableSessionState({session:p})}}async function closeStandaloneAuthorizationEvent(e){if(e.mode!==`conversation`||e.eventType!==`authorization.required`&&e.eventType!==`authorization.completed`)return e.session;let t=getHarnessEmissionState(e.session.state),n=await emitTurnEpilogue(e.emit,t,e.mode);return setHarnessEmissionState(e.session,n)}export{emitProxiedSubagentEvent,emitRecordedTaskInputRequestStep,runProxySubagentEventStep};

package/dist/src/subagents/handle-dispatch.d.ts

@@ -0,0 +1,54 @@
+/** Continuation delivery for task-owned agent sessions. */
+import type { SessionAuthContext } from "#channel/types.js";
+import type { AgentAddress } from "#subagents/handles/store.js";
+import type { RuntimeAgentDispatchRequest, RuntimeRemoteAgentDispatchRequest, RuntimeSubagentDispatchRequest, RuntimeSubagentDispatchFailure } from "#shared/action-types.js";
+import type { CompiledBundle } from "#runtime/sessions/runtime-context-keys.js";
+import type { hydrateDurableSession } from "#execution/session.js";
+import type { TaskOwnedAgentHandle } from "#subagents/handles/store.js";
+/** Agent-task requests that may address an agent handle via `agentId`. */
+export type RuntimeAgentHandleAction = RuntimeRemoteAgentDispatchRequest | RuntimeSubagentDispatchRequest;
+/** Narrows an action to the kinds that may carry an `agentId` continuation. */
+export declare function isAgentHandleAction(action: RuntimeAgentDispatchRequest): action is RuntimeAgentHandleAction;
+/** Hydrated parent session snapshot threaded through dispatch. */
+export type RuntimeSession = ReturnType<typeof hydrateDurableSession>;
+/**
+ * Outcome of dispatching one planned agent task: an adopted child ready for
+ * the `subagent.called` emission tail, or a per-task error result.
+ * Either way the (possibly updated) session snapshot rides along.
+ *
+ * `address` is the same confirmed {@link AgentAddress} recorded on the
+ * child's running handle; consumers project it into wire shapes (e.g. the
+ * flat `childSessionId` / `remote` fields of `subagent.called`) at the
+ * emission site instead of this type re-encoding them.
+ */
+export type DispatchOutcome = {
+    readonly address: AgentAddress;
+    readonly callId: string;
+    readonly kind: "called";
+    readonly name: string;
+    readonly session: RuntimeSession;
+    readonly toolName: string;
+} | {
+    readonly deliveryAmbiguous?: boolean;
+    readonly deliveryPermanent?: boolean;
+    readonly kind: "error";
+    readonly result: RuntimeSubagentDispatchFailure;
+    readonly session: RuntimeSession;
+};
+/** Delivers a continuation after the session handle store atomically claimed it for one owner. */
+export declare function dispatchToClaimedAgentAddress(input: {
+    readonly action: RuntimeAgentHandleAction;
+    readonly auth: SessionAuthContext | null;
+    readonly bundle: CompiledBundle;
+    readonly currentSession: RuntimeSession;
+    readonly parentToken: string;
+    readonly handle: Extract<TaskOwnedAgentHandle, {
+        phase: "claimed";
+    }>;
+    readonly taskId?: string;
+}): Promise<DispatchOutcome>;
+export declare function createAgentErrorResult(input: {
+    readonly action: RuntimeAgentHandleAction;
+    readonly code: string;
+    readonly message: string;
+}): RuntimeSubagentDispatchFailure;

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

@@ -0,0 +1 @@
+import{createEveCallbackRoutePath}from"#protocol/routes.js";import{createLogger,logError}from"#internal/logging.js";import{createWorkflowRuntime}from"#execution/workflow-runtime.js";import{continueRemoteAgentSession,isAmbiguousRemoteAgentContinueError,isRetryableRemoteAgentContinueError,resolveRemoteAgentForAction}from"#subagents/remote-dispatch.js";import{AGENT_UNREACHABLE}from"#subagents/agent-handle-errors.js";import{createWorkflowCallbackUrl}from"#execution/workflow-callback-url.js";import{readTaskIdFromInboxToken}from"#tasks/task-inbox-token.js";import{isRuntimeNoActiveSessionError}from"#execution/runtime-errors.js";import{normalizeRequestedOutputSchema}from"#subagents/invocation.js";import{err,ok}from"#shared/result.js";const log=createLogger(`execution.agent-handle-dispatch`);function isAgentHandleAction(e){return e.kind===`subagent-call`||e.kind===`remote-agent-call`}async function dispatchToClaimedAgentAddress(e){return await dispatchToAgentAddress(e)}async function dispatchToAgentAddress(e){let{action:t,handle:r}=e,i=r.identity.id,a=await deliverToAgentAddress({action:t,address:r.address,auth:e.auth,bundle:e.bundle,identity:r.identity,parentToken:e.parentToken,taskId:e.taskId});if(!a.ok){let{cause:o,permanent:s}=a.error;return logError(log,`task agent delivery failed`,o,{agentId:i,callId:t.callId,nodeId:r.identity.nodeId,permanent:s,subagentName:r.identity.name}),{deliveryAmbiguous:a.error.deliveryAmbiguous,deliveryPermanent:s,kind:`error`,result:createAgentErrorResult({action:t,code:AGENT_UNREACHABLE,message:s?`Agent "${r.identity.name}" with id "${i}" is no longer reachable.`:`Agent "${r.identity.name}" with id "${i}" is temporarily unreachable. Try again.`}),session:e.currentSession}}return{address:r.address,callId:t.callId,kind:`called`,name:t.name,session:e.currentSession,toolName:r.identity.name}}async function deliverToAgentAddress(t){let{action:n,address:c,bundle:l,identity:u}=t;if(c.kind===`agent/remote`){let r;try{r=resolveRemoteAgentForAction({nodeId:u.nodeId,remoteAgentName:u.name,registry:l.subagentRegistry.subagentsByNodeId})}catch(e){return err({cause:e,deliveryAmbiguous:!1,permanent:!0})}try{await continueRemoteAgentSession({auth:t.auth,callback:{callId:n.callId,subagentName:u.name,taskId:t.taskId??readTaskIdFromInboxToken(t.parentToken),token:t.parentToken,url:createWorkflowCallbackUrl(c.callbackBaseUrl,createEveCallbackRoutePath(t.parentToken))},message:readSubagentMessage(n),outputSchema:normalizeRequestedOutputSchema(n.input.outputSchema),remote:{...r,url:c.url},sessionId:c.sessionId})}catch(e){return err({cause:e,deliveryAmbiguous:isAmbiguousRemoteAgentContinueError(e),permanent:!isRetryableRemoteAgentContinueError(e)})}return ok(void 0)}let d=createWorkflowRuntime({compiledArtifactsSource:l.compiledArtifactsSource,nodeId:u.nodeId});try{if((await d.dispatchSession({command:{auth:t.auth,caller:{callId:n.callId,replyTo:{kind:`hook`,token:t.parentToken},subagentName:u.name,taskId:t.taskId??readTaskIdFromInboxToken(t.parentToken)},kind:`send`,payload:{message:readSubagentMessage(n),outputSchema:normalizeRequestedOutputSchema(n.input.outputSchema)}},sessionId:c.sessionId})).status===`session_not_active`)return err({cause:Error(`Agent session "${c.sessionId}" is no longer active.`),deliveryAmbiguous:!1,permanent:!0})}catch(e){let t=isRuntimeNoActiveSessionError(e);return err({cause:e,deliveryAmbiguous:!t,permanent:t})}return ok(void 0)}function createAgentErrorResult(e){return{callId:e.action.callId,isError:!0,kind:`subagent-result`,origin:`dispatch`,output:{code:e.code,message:e.message},subagentName:e.action.kind===`remote-agent-call`?e.action.remoteAgentName:e.action.subagentName}}function readSubagentMessage(e){return typeof e.input.message==`string`?e.input.message:``}export{createAgentErrorResult,dispatchToClaimedAgentAddress,isAgentHandleAction};

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

@@ -1,5 +1,5 @@
 import type { ModelMessage } from "ai";
-import type { AgentHandle, AgentHandleStore } from "#harness/handles/store.js";
+import type { AgentHandle, AgentHandleStore } from "#subagents/handles/store.js";
 /**
  * Label prefixing every framework-injected agents announcement. Mock model
  * adapters use it to treat announcements as transparent scaffolding rather
@@ -15,12 +15,12 @@ export interface AgentView {
     readonly taskId?: string;
     readonly taskStatus?: "working" | "input_required";
 }
-/** Returns the resumable handles: the only phase the model may continue. */
+/** Returns the resumable handles: the only phases the model may continue. */
 export declare function projectParkedAgentHandles(store: AgentHandleStore): readonly Extract<AgentHandle, {
-    phase: "parked";
+    phase: "available" | "parked";
 }>[];
 /**
- * Renders the model-visible agent listing. Only parked handles appear:
+ * Renders the model-visible agent listing. Only idle handles appear:
  * starting and running children cannot accept a continuation, and private
  * delivery coordinates never render.
  */

package/dist/src/{harness → subagents}/handles/prompt.js

@@ -1,3 +1,3 @@
-const AGENTS_SNIPPET_LABEL=`[Agents]`;function projectParkedAgentHandles(e){return e.handles.filter(e=>e.phase===`parked`)}function renderAgentsSnippet(t){let n=projectParkedAgentHandles(t).map(e=>`<agent id="${escapeXml(e.identity.id)}" name="${escapeXml(e.identity.name)}">${escapeXml(e.lastStatus===``?`(no status)`:e.lastStatus)}</agent>`);return[AGENTS_SNIPPET_LABEL,`<agents>`,...n,`</agents>`].join(`
+const AGENTS_SNIPPET_LABEL=`[Agents]`;function projectParkedAgentHandles(e){return e.handles.filter(e=>e.phase===`available`||e.phase===`parked`)}function renderAgentsSnippet(t){let n=projectParkedAgentHandles(t).map(e=>{let t=e.phase===`parked`?e.lastStatus:`(available)`;return`<agent id="${escapeXml(e.identity.id)}" name="${escapeXml(e.identity.name)}">${escapeXml(t===``?`(no status)`:t)}</agent>`});return[AGENTS_SNIPPET_LABEL,`<agents>`,...n,`</agents>`].join(`
 `)}function renderAgentViewsSnippet(t){let n=t.map(e=>{let t=e.taskId===void 0||e.taskStatus===void 0?``:` taskId="${escapeXml(e.taskId)}" taskStatus="${e.taskStatus}"`,n=e.statusLine??(e.availability===`busy`?`(busy)`:`(available)`);return`<agent id="${escapeXml(e.id)}" name="${escapeXml(e.name)}" availability="${e.availability}"${t}>${escapeXml(n)}</agent>`});return[AGENTS_SNIPPET_LABEL,`<agents>`,...n,`</agents>`].join(`
 `)}function resolveAgentsAnnouncement(e){let t=e.messages.findLast(e=>e.role===`user`&&typeof e.content==`string`&&e.content.startsWith(`[Agents]`)),n=e.store??{handles:[]},r=e.agentViews?.length??projectParkedAgentHandles(n).length;if(t===void 0&&r===0)return;let i=e.agentViews===void 0?renderAgentsSnippet(n):renderAgentViewsSnippet(e.agentViews);return t?.content===i?void 0:i}function escapeXml(e){return e.replaceAll(`&`,`&amp;`).replaceAll(`"`,`&quot;`).replaceAll(`<`,`&lt;`).replaceAll(`>`,`&gt;`)}export{AGENTS_SNIPPET_LABEL,projectParkedAgentHandles,renderAgentViewsSnippet,renderAgentsSnippet,resolveAgentsAnnouncement};

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

@@ -1,10 +1,16 @@
 import type { RuntimeActionResult, RuntimeSubagentChildResult } from "#shared/action-types.js";
-import type { AgentHandle } from "#harness/handles/store.js";
+import type { TurnOwnedAgentHandle } from "#subagents/handles/store.js";
 import type { SessionStateMap } from "#harness/types.js";
 /** A handle with one outstanding operation and a confirmed child address. */
-export type RunningAgentHandle = Extract<AgentHandle, {
+export type RunningAgentHandle = Extract<TurnOwnedAgentHandle, {
     phase: "running";
 }>;
+/** Preserves driver-owned task leases when a concurrent turn returns an older snapshot. */
+export declare function mergeTaskOwnedAgentHandlesIntoTurnState(input: {
+    readonly baseState: SessionStateMap | undefined;
+    readonly driverState: SessionStateMap | undefined;
+    readonly turnState: SessionStateMap | undefined;
+}): SessionStateMap | undefined;
 /**
  * Finds the running agent handle a child-produced result must settle: the
  * handle whose recorded operation carries the result's callId.

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

@@ -0,0 +1 @@
+import{AGENT_HANDLES_STATE_KEY}from"#subagents/handles/state-key.js";function readAgentHandles(t){let n=t?.[AGENT_HANDLES_STATE_KEY];if(n===void 0)return[];let r=n.handles;return Array.isArray(r)?r:[]}function mergeTaskOwnedAgentHandlesIntoTurnState(t){let n=new Map(readAgentHandles(t.baseState).map(e=>[e.identity.id,e])),r=new Map(readAgentHandles(t.driverState).map(e=>[e.identity.id,e])),i=new Set([...n.keys(),...r.keys()]);for(let e of i)handlesEqual(n.get(e),r.get(e))&&i.delete(e);if(i.size===0)return t.turnState;let a=[];for(let e of readAgentHandles(t.turnState)){if(!i.has(e.identity.id)){a.push(e);continue}let t=r.get(e.identity.id);if(!handlesEqual(e,n.get(e.identity.id))&&!handlesEqual(e,t))throw Error(`Agent handle "${e.identity.id}" changed ownership while its turn was running.`);t!==void 0&&a.push(t),i.delete(e.identity.id)}for(let e of i){let t=r.get(e);t!==void 0&&a.push(t)}return{...t.turnState,[AGENT_HANDLES_STATE_KEY]:{handles:a}}}function handlesEqual(e,t){if(e===t)return!0;if(e===void 0||t===void 0)return!1;let n=Object.keys(e),r=Object.keys(t);return n.length===r.length&&n.every(n=>valuesEqual(Reflect.get(e,n),Reflect.get(t,n)))}function valuesEqual(e,t){if(e===t)return!0;if(typeof e!=`object`||!e||typeof t!=`object`||!t)return!1;let n=Object.keys(e),r=Object.keys(t);return n.length===r.length&&n.every(n=>valuesEqual(Reflect.get(e,n),Reflect.get(t,n)))}function findRunningAgentHandle(e,t){return readAgentHandles(e).find(e=>e.phase===`running`&&e.operation.callId===t.callId)}function isResultBoundToRunningHandle(e,t){return t.kind!==`subagent-result`||t.origin===`dispatch`||t.backgroundTask!==void 0||findRunningAgentHandle(e,{callId:t.callId})!==void 0}function isInboxSubagentResultFromRunningHandle(e,t){return findRunningAgentHandle(e,{callId:t.callId})!==void 0}export{findRunningAgentHandle,isInboxSubagentResultFromRunningHandle,isResultBoundToRunningHandle,mergeTaskOwnedAgentHandlesIntoTurnState};

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

@@ -0,0 +1,4 @@
+import type { DurableSessionState } from "#execution/durable-session-store.js";
+import type { TurnDriverAction } from "#execution/turn-control-receiver.js";
+/** Preserves handle leases accepted by the driver against a turn's older snapshot. */
+export declare function rebaseTaskAgentHandleMutations(action: TurnDriverAction, driverState: DurableSessionState, baseState: DurableSessionState): TurnDriverAction;

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

@@ -0,0 +1 @@
+import{mergeTaskOwnedAgentHandlesIntoTurnState}from"#subagents/handles/query.js";function rebaseTaskAgentHandleMutations(e,t,n){let r=e.sessionState.snapshot;if(r===void 0)throw Error(`Cannot merge task-owned agent handles into a session state without a snapshot.`);return{...e,sessionState:{...e.sessionState,snapshot:{...r,session:{...r.session,state:mergeTaskOwnedAgentHandlesIntoTurnState({baseState:n.snapshot?.session.state,driverState:t.snapshot?.session.state,turnState:r.session.state})}}}}}export{rebaseTaskAgentHandleMutations};

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{deriveChildActivityObserverConfig}from"#execution/activity-work.js";import{createRemoteAgentStartFailureResult}from"#execution/dispatch-action-failures.js";import{mintStartOperation}from"#execution/dispatch-start-operation.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/subagents/token-budget.js

@@ -0,0 +1 @@
+import{getSessionRemainingUsageQuota}from"#harness/turn-tag-state.js";function resolveRemainingSessionTokenLimits(t,n=1){let r=Math.max(1,Math.floor(n)),i=getSessionRemainingUsageQuota(t),a={maxInputTokensPerSession:grantTokenShare(i.inputTokens,r),maxOutputTokensPerSession:grantTokenShare(i.outputTokens,r)},o=grantCostShare(i.costUsd,r);return o!==!1&&(a.maxTokenCostUsdPerSession=o),a}function grantTokenShare(e,t){return e!==!1&&Math.floor(e/t)}function grantCostShare(e,t){return e!==!1&&e/t}export{resolveRemainingSessionTokenLimits};