eve 0.50.0 → 0.51.1

package/dist/src/execution/delegated-parent-result.js

@@ -1 +0,0 @@
-import{toErrorMessage}from"#shared/errors.js";import{CHANNEL_CONTEXT_KEY_NAME}from"#context/key-names.js";import{SUBAGENT_EXECUTION_FAILED}from"#harness/agent-handle-errors.js";import{SUBAGENT_ADAPTER_KIND}from"#execution/subagent-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/delegation-tool.d.ts

@@ -1,10 +0,0 @@
-import type { HarnessToolDefinition } from "#harness/execute-tool.js";
-import type { PreparedRuntimeDelegationTool } from "#runtime/sessions/turn.js";
-import { type ToolSchemaSource } from "#tools/schema.js";
-type HarnessDelegationTool = Pick<PreparedRuntimeDelegationTool, "behavior" | "description" | "name"> & {
-    readonly inputSchema?: ToolSchemaSource | null;
-    readonly outputSchema?: ToolSchemaSource | null;
-};
-export declare function createHarnessDelegationToolDefinition(tool: HarnessDelegationTool): HarnessToolDefinition;
-export declare function createBackgroundSubagentHarnessDefinition(tool: HarnessDelegationTool): HarnessToolDefinition;
-export {};

package/dist/src/execution/delegation-tool.js

@@ -1 +0,0 @@
-import{UNSPECIFIED_INPUT_SCHEMA,toInputSchema,toOutputSchema}from"#tools/schema.js";import{createToolExecuteWithAuth}from"#execution/tool-auth.js";import{defineSubagent}from"#execution/tools/subagent/local.js";import{defineRemoteSubagent}from"#execution/tools/subagent/remote.js";function createHarnessDelegationToolDefinition(t){return{behavior:t.behavior,description:t.description??``,inputSchema:toInputSchema(t.inputSchema)??UNSPECIFIED_INPUT_SCHEMA,name:t.name,outputSchema:toOutputSchema(t.outputSchema)??void 0}}function createBackgroundSubagentHarnessDefinition(n){let r=n.behavior?.handling;if(r?.kind!==`dispatch`)throw Error(`Background subagent tool "${n.name}" has no prepared dispatch target.`);if(r.target.kind===`task-cancel`||r.target.kind===`task-update`||r.target.kind===`workflow-tool-call`)throw Error(`Background subagent tool "${n.name}" cannot dispatch ${r.target.kind}.`);let i=createBackgroundSubagentDefinition({description:n.description??``,name:n.name,target:r.target}),a=createToolExecuteWithAuth({execute:i.execute,execution:i.execution,scope:n.name});return{behavior:n.behavior,description:i.description,execute:a,execution:i.execution,inputSchema:toInputSchema(i.inputSchema)??UNSPECIFIED_INPUT_SCHEMA,name:n.name,outputSchema:toOutputSchema(i.outputSchema)??void 0}}function createBackgroundSubagentDefinition(e){switch(e.target.kind){case`remote-agent-call`:return defineRemoteSubagent({description:e.description,name:e.name,target:e.target});case`self-agent-call`:case`subagent-call`:return defineSubagent({description:e.description,name:e.name,target:e.target})}}export{createBackgroundSubagentHarnessDefinition,createHarnessDelegationToolDefinition};

package/dist/src/execution/dispatch-runtime-actions-shared.d.ts

@@ -1,165 +0,0 @@
-/**
- * Machinery shared by the two runtime-action dispatch steps:
- * `dispatchRuntimeActionsStep` (plain mode) and `dispatchTaskStep`
- * (task mode). Both run the same preflight → plan → dispatch → emit
- * skeleton over one pending batch and differ only in the per-entry
- * delegation lifecycle, so planning and the replay-safe
- * `subagent.called` emission tail live here.
- */
-import type { ActivityObserverConfig, SessionParent } from "#channel/types.js";
-import { type ChannelAdapter, type ChannelAdapterContext } from "#channel/adapter.js";
-import { type LocalDevRequestProvenance } from "#context/keys.js";
-import { type AlsContext } from "#context/container.js";
-import { type CompiledBundle } from "#runtime/sessions/runtime-context-keys.js";
-import { type DispatchOutcome, type RuntimeAgentHandleAction, type RuntimeSession } from "#execution/agent-handle-dispatch.js";
-import { getPendingRuntimeActionBatch } from "#harness/runtime-actions.js";
-import type { ActivityWorkIdentityV1 } from "#protocol/activity.js";
-import type { RuntimeActionResult, RuntimeRemoteAgentCallActionRequest, RuntimeSubagentCallActionRequest, RuntimeSubagentDispatchFailure } from "#shared/action-types.js";
-import type { PendingAgentDispatchAction, PendingTaskControlAction, PendingWorkflowToolAction } from "#shared/dispatch-action.js";
-import { type DurableSessionState } from "#execution/durable-session-store.js";
-import { buildSubagentRunInput, type SubagentInputSource } from "#execution/subagent-tool.js";
-import { getDynamicSubagentSelection } from "#context/dynamic-subagent-lifecycle.js";
-type DynamicSubagentAgentConfig = NonNullable<Extract<ReturnType<typeof getDynamicSubagentSelection>, {
-    readonly kind: "subagent";
-}>["agentConfig"]>;
-type DynamicRemoteAgentConfig = NonNullable<Extract<ReturnType<typeof getDynamicSubagentSelection>, {
-    readonly kind: "remote";
-}>["remoteAgent"]>;
-export type DispatchPlanEntry = {
-    readonly kind: "resume";
-    readonly action: RuntimeAgentHandleAction;
-    readonly agentId: string;
-    readonly dynamicRemoteAgent?: DynamicRemoteAgentConfig;
-} | {
-    readonly kind: "reject";
-    readonly result: RuntimeSubagentDispatchFailure;
-} | {
-    readonly kind: "start";
-    readonly target: DispatchStartTarget;
-} | {
-    readonly kind: "task-control";
-    readonly action: PendingTaskControlAction;
-} | {
-    readonly kind: "workflow-tool";
-    readonly action: PendingWorkflowToolAction;
-};
-export type DispatchStartTarget = {
-    readonly kind: "local";
-    readonly action: RuntimeSubagentCallActionRequest;
-    readonly dynamicSubagentAgentConfig?: DynamicSubagentAgentConfig;
-    readonly selfAgent: boolean;
-    readonly source: SubagentInputSource;
-} | {
-    readonly kind: "remote";
-    readonly action: RuntimeRemoteAgentCallActionRequest;
-    readonly dynamicRemoteAgent?: DynamicRemoteAgentConfig;
-};
-/** Input contract shared by both dispatch steps so the turn workflow can select either. */
-export interface RuntimeActionDispatchInput {
-    readonly callbackBaseUrl?: string;
-    /** Internal hook that receives child completion and HITL payloads. */
-    readonly parentContinuationToken?: string;
-    readonly parentWritable: WritableStream<Uint8Array>;
-    readonly serializedContext: Record<string, unknown>;
-    readonly sessionState: DurableSessionState;
-}
-/**
- * Result contract shared by both dispatch steps. `pendingTasks` is
- * always empty in plain mode; keeping it on both keeps the turn
- * workflow's acknowledgement call site uniform.
- */
-export interface RuntimeActionDispatchResult {
-    readonly results: readonly RuntimeActionResult[];
-    readonly sessionState: DurableSessionState;
-    readonly pendingTasks: readonly {
-        readonly taskInboxToken: string;
-        readonly taskId: string;
-        readonly taskRunId: string;
-    }[];
-}
-/** Everything preflight produces before either step's dispatch loop runs. */
-export interface PreparedRuntimeActionDispatch {
-    readonly adapter: ChannelAdapter;
-    readonly adapterCtx: ChannelAdapterContext;
-    readonly auth: Parameters<typeof buildSubagentRunInput>[0]["auth"];
-    readonly batch: NonNullable<ReturnType<typeof getPendingRuntimeActionBatch>>;
-    readonly bundle: CompiledBundle;
-    readonly capabilities: Parameters<typeof buildSubagentRunInput>[0]["capabilities"];
-    readonly channelMetadata: Parameters<typeof buildSubagentRunInput>[0]["channelMetadata"];
-    /**
-     * Number of freshly started local subagents in the plan. The parent's
-     * remaining token quota is split across these, the children that
-     * actually receive an enforced cap: continuations already run under
-     * their own budget, and remote agents run on their own deployment
-     * under their own limits, so neither dilutes the local shares.
-     */
-    readonly fanoutSize: number;
-    readonly initiatorAuth: Parameters<typeof buildSubagentRunInput>[0]["initiatorAuth"];
-    readonly localDevRequest?: LocalDevRequestProvenance;
-    /** Lineage of the session running this dispatch, when it is itself a delegated child. */
-    readonly parentSession: SessionParent | undefined;
-    readonly parentTraceContext: Parameters<typeof buildSubagentRunInput>[0]["parentTraceContext"];
-    readonly activityObserver?: ActivityObserverConfig & {
-        readonly workIdentity: ActivityWorkIdentityV1;
-    };
-    readonly sandboxSessionId: string;
-    readonly serializedContext: Record<string, unknown>;
-    readonly plan: readonly DispatchPlanEntry[];
-    readonly session: RuntimeSession;
-}
-interface PreparedPendingRuntimeActionDispatch extends PreparedRuntimeActionDispatch {
-    /** Returns the durable baseline corresponding to `session`. */
-    readonly getBaselineSessionState: () => DurableSessionState;
-}
-/**
- * Runs every dispatch precondition that may throw — durable reads, context
- * deserialization, handle-store validation, and batch planning — before
- * the caller acquires the parent stream writer, so a preflight failure
- * never leaks the writer lock. Returns undefined when no actions are
- * pending.
- */
-export declare function prepareRuntimeActionDispatch(input: {
-    readonly serializedContext: Record<string, unknown>;
-    readonly sessionState: DurableSessionState;
-    /**
-     * Classify task-control calls as
-     * task-control plan entries. Only task mode plans them; in plain mode
-     * those calls fail as unsupported batch actions.
-     */
-    readonly taskControls: boolean;
-}): Promise<PreparedPendingRuntimeActionDispatch | undefined>;
-export declare function prepareAgentActionDispatch(input: {
-    readonly action: PendingAgentDispatchAction;
-    readonly ctx: AlsContext;
-    readonly event: {
-        readonly sequence: number;
-        readonly stepIndex: number;
-        readonly turnId: string;
-    };
-    readonly localFanoutSize: number;
-    readonly serializedContext: Record<string, unknown>;
-    readonly sessionState: DurableSessionState;
-}): Promise<PreparedRuntimeActionDispatch>;
-/**
- * Emits the parent `subagent.called` control-plane event for one adopted
- * child. Emission is observability, not control flow: a failure is logged
- * and swallowed, because a throw escaping the dispatch loop would durably
- * replay the step and re-dispatch children that already started.
- */
-export declare function emitSubagentCalled(input: {
-    readonly adapter: ChannelAdapter;
-    readonly adapterCtx: ChannelAdapterContext;
-    readonly batchEvent: {
-        readonly sequence: number;
-        readonly turnId: string;
-    };
-    readonly entry: Extract<DispatchPlanEntry, {
-        readonly kind: "resume" | "start";
-    }>;
-    readonly outcome: Extract<DispatchOutcome, {
-        readonly kind: "called";
-    }>;
-    readonly sessionId: string;
-    readonly writer: WritableStreamDefaultWriter<Uint8Array>;
-}): Promise<void>;
-export {};

package/dist/src/execution/dispatch-runtime-actions-shared.js

@@ -1 +0,0 @@
-import{createLogger,logError}from"#internal/logging.js";import{callAdapterEventHandler}from"#channel/adapter.js";import{ContextContainer}from"#context/container.js";import{ActivityObserverKey,AuthKey,CapabilitiesKey,ChannelInstrumentationKey,InitiatorAuthKey,ParentSessionKey,SandboxKey}from"#context/keys.js";import{createSubagentCalledEvent,encodeMessageStreamEvent,stampMessageStreamEvent}from"#protocol/message.js";import{BundleKey,ChannelKey}from"#runtime/sessions/runtime-context-keys.js";import{workflowEntryReference}from"#execution/workflow-runtime.js";import{deriveRootTurnActivityWorkId}from"#execution/activity-work-id.js";import{getAgentHandleStore}from"#harness/handles/store.js";import{deserializeContext}from"#context/serialize.js";import{createDurableSessionState,readDurableSession}from"#execution/durable-session-store.js";import{getDynamicSubagentSelection}from"#context/dynamic-subagent-lifecycle.js";import{hydrateDurableSession}from"#execution/session.js";import{resolveEffectiveAgentRuntime}from"#execution/effective-agent-config.js";import{buildAdapterContext}from"#channel/adapter-context.js";import{withContextScope}from"#context/run-step.js";import"#execution/agent-handle-dispatch.js";import{assertUniqueRuntimeActionCallIds,getPendingRuntimeActionBatch,setPendingRuntimeActionBatch}from"#harness/runtime-actions.js";import{activeTurnId}from"#harness/active-turn-id.js";import{createRecursiveAgentRootOnlyResult,createUnavailableDynamicSubagentResult,getSubagentName}from"#execution/dispatch-action-failures.js";import"#execution/subagent-tool.js";import{readSessionTraceContext}from"#tracing/agent-trace-context-store.js";import{isSubagentDelegationAction,resolveSubagentDepth}from"#harness/subagent-depth.js";import{isTaskControlAction}from"#execution/tasks/parent/dispatch.js";import{isWorkflowToolAction}from"#execution/tool-run/dispatch.js";import{resolvePreparedAgentAction}from"#execution/prepared-agent-action.js";const log=createLogger(`execution.dispatch-runtime-actions`);async function prepareRuntimeActionDispatch(e){let t=await readDurableSession(e.sessionState),n=getPendingRuntimeActionBatch(t.state);if(n===void 0||n.actions.length===0)return;let r=n.event.turnId||activeTurnId(e.sessionState.emissionState),i=n.event.turnId!==r,a=i?{...n,event:{...n.event,turnId:r}}:n,o=await prepareActionDispatch({batch:a,ctx:await deserializeContext(e.serializedContext),durableSession:t,serializedContext:e.serializedContext,taskControls:e.taskControls});if(!i)return{...o,getBaselineSessionState:()=>e.sessionState};let s=setPendingRuntimeActionBatch({...a,session:o.session});return{...o,getBaselineSessionState:()=>createDurableSessionState({session:s}),session:s}}async function prepareAgentActionDispatch(e){let t=await readDurableSession(e.sessionState);return await prepareActionDispatch({batch:{actions:[e.action],event:e.event,responseMessages:[]},ctx:copyDurableContext(e.ctx),durableSession:t,fanoutSize:e.localFanoutSize,serializedContext:e.serializedContext,taskControls:!1})}function copyDurableContext(e){let t=new ContextContainer;for(let[n,r]of e.entries())t.set(n,r);return t}async function prepareActionDispatch(e){let{batch:t,durableSession:n}=e;assertUniqueRuntimeActionCallIds(t.actions);let r=e.ctx,c=r.require(BundleKey),l=resolveEffectiveAgentRuntime(c,r),u=hydrateDurableSession({compactionOverrides:{thresholdPercent:l.thresholdPercent},durable:n,turnAgent:l.turnAgent}),d=r.require(ChannelKey);getAgentHandleStore(n.state);let f=planDispatch({actions:t.actions,bundle:c,ctx:r,session:u,taskControls:e.taskControls}),p=resolveActiveSandboxSessionId(d.state,u.sessionId);if(planSharesSandbox({bundle:c,plan:f}))try{u=(await withContextScope(r,u,async e=>(await r.require(SandboxKey).get(),{result:void 0,session:e}))).session}finally{r.clearVirtualContext()}return{adapter:d,adapterCtx:buildAdapterContext(d,r),auth:r.get(AuthKey)??null,batch:t,bundle:c,capabilities:r.get(CapabilitiesKey),channelMetadata:r.get(ChannelInstrumentationKey),fanoutSize:e.fanoutSize??f.filter(e=>e.kind===`start`&&e.target.kind===`local`).length,initiatorAuth:r.get(InitiatorAuthKey)??null,localDevRequest:r.localDevRequest,parentSession:r.get(ParentSessionKey),parentTraceContext:readSessionTraceContext(e.serializedContext,u.sessionId),plan:f,activityObserver:resolvePreparedActivity(r.get(ActivityObserverKey),u,t.event.turnId),sandboxSessionId:p,serializedContext:e.serializedContext,session:u}}function resolvePreparedActivity(e,t,n){if(e!==void 0)return{sink:e.sink,workIdentity:e.workIdentity??{id:deriveRootTurnActivityWorkId({sessionId:t.sessionId,turnId:n}),kind:`root-turn`,rootSessionId:t.rootSessionId??t.sessionId,rootTurnId:n,sessionId:t.sessionId,turnId:n}}}function planSharesSandbox(e){let t=e.bundle.graph;return e.plan.some(e=>e.kind!==`start`||e.target.kind!==`local`?!1:e.target.selfAgent||t?.nodesByNodeId.get(e.target.action.nodeId)?.sandboxRegistry.sandbox.definition.inheritsParent===!0)}function resolveActiveSandboxSessionId(e,t){if(typeof e!=`object`||!e)return t;let n=e.sandboxSessionId;return typeof n==`string`&&n.length>0?n:t}async function emitSubagentCalled(e){let{entry:r,outcome:i}=e;try{let t=r.kind===`resume`?r.action:r.target.action,a=r.kind===`resume`?r.dynamicRemoteAgent:r.target.kind===`remote`?r.target.dynamicRemoteAgent:void 0,o=await callAdapterEventHandler(e.adapter,createSubagentCalledEvent({callId:i.callId,childSessionId:i.address.sessionId,name:i.name,remote:i.address.kind===`agent/remote`?{resolverId:a===void 0?t.nodeId:a.credentialsStepId,url:i.address.url}:void 0,sequence:e.batchEvent.sequence,sessionId:e.sessionId,toolName:i.toolName,turnId:e.batchEvent.turnId,workflowId:workflowEntryReference.workflowId}),e.adapterCtx);await e.writer.write(encodeMessageStreamEvent(stampMessageStreamEvent(o)))}catch(e){logError(log,`subagent.called emission failed`,e,{callId:i.callId,childSessionId:i.address.sessionId,toolName:i.toolName})}}function planDispatch(e){let t=getAgentHandleStore(e.session.state)?.handles??[];return e.actions.map(n=>{if(e.taskControls&&isTaskControlAction(n))return{action:n,kind:`task-control`};if(isWorkflowToolAction(n))return{action:n,kind:`workflow-tool`};if(!isSubagentDelegationAction(n))throw Error(`Unsupported prepared dispatch target "${n.target.kind}" in workflow runtime.`);let r=resolvePreparedAgentAction(n),i=n.input.agentId,a=typeof i==`string`&&i.trim()!==``?i:void 0;if(a!==void 0){if(t.some(e=>e.identity.id===a)){let t=e.bundle.subagentRegistry.dynamicNodeIds?.has(r.action.nodeId)===!0?getDynamicSubagentSelection(e.ctx,r.action.nodeId):void 0;return{action:r.action,agentId:a,dynamicRemoteAgent:r.action.kind===`remote-agent-call`&&t?.kind===`remote`?t.remoteAgent:void 0,kind:`resume`}}log.warn(`unknown agentId on subagent call; starting a new agent`,{agentId:a,callId:n.callId})}return classifyFreshStart({action:r.action,bundle:e.bundle,ctx:e.ctx,selfAgent:r.selfAgent,session:e.session})})}function classifyFreshStart(e){let{action:t}=e,n=e.bundle.subagentRegistry.subagentsByNodeId,r=resolveSubagentDepth(e.session),i=e.session.rootSessionId!==void 0||r.currentDepth>0,a=(t.kind===`subagent-call`||t.kind===`remote-agent-call`)&&e.bundle.subagentRegistry.dynamicNodeIds?.has(t.nodeId)===!0,o=a?getDynamicSubagentSelection(e.ctx,t.nodeId):void 0;if(a&&(o===void 0||t.kind===`subagent-call`&&o.kind!==`subagent`||t.kind===`remote-agent-call`&&o.kind!==`remote`)){let e=getSubagentName(t);return log.warn(`dynamic subagent call blocked after availability changed`,{callId:t.callId,nodeId:t.nodeId,subagentName:e}),{kind:`reject`,result:createUnavailableDynamicSubagentResult(t)}}if(e.selfAgent&&t.kind!==`subagent-call`)throw Error(`A self-agent dispatch target must resolve to a local subagent action.`);if(e.selfAgent&&i&&t.kind===`subagent-call`)return log.warn(`recursive agent call blocked outside the root session`,{callId:t.callId,currentDepth:r.currentDepth,nodeId:t.nodeId,subagentName:t.subagentName}),{kind:`reject`,result:createRecursiveAgentRootOnlyResult(t)};switch(t.kind){case`subagent-call`:{let r=o?.kind===`subagent`?o.agentConfig:void 0,i=n.get(t.nodeId),a=r?.description??(i?.definition.kind===`subagent`?i.definition.description:void 0),s=a===void 0?{outputSchema:e.bundle.turnAgent.outputSchema,type:`runtime`}:{description:a,outputSchema:r?.outputSchema??e.bundle.graph?.nodesByNodeId.get(t.nodeId)?.turnAgent?.outputSchema,type:`local`};return{kind:`start`,target:{action:t,dynamicSubagentAgentConfig:r,kind:`local`,selfAgent:e.selfAgent,source:s}}}case`remote-agent-call`:return{kind:`start`,target:{action:t,dynamicRemoteAgent:o?.kind===`remote`?o.remoteAgent:void 0,kind:`remote`}};default:return t}}export{emitSubagentCalled,prepareAgentActionDispatch,prepareRuntimeActionDispatch};

package/dist/src/execution/dispatch-runtime-actions-start.js

@@ -1 +0,0 @@
-import{normalizeChannelAudience}from"#shared/channel-audience.js";import{applyLiveDeliveryAudienceCeiling,readForwardedTraceAssertion}from"#shared/forwarded-trace-policy.js";import"#execution/subagent-tool.js";import{readActionTraceContext}from"#tracing/agent-trace-context-store.js";import{startLocalSubagent}from"#execution/subagent-start-local.js";import{startRemoteSubagent}from"#execution/subagent-start-remote.js";async function startSubagent(e){let t=readActionTraceContext(e.serializedContext,e.session.sessionId,e.batchEvent.turnId,e.target.action.callId)??e.parentTraceContext,n=readForwardedTraceAssertion(t?.forwardedTracePolicy),r=normalizeChannelAudience(e.channelMetadata?.metadata.audience),i=t?.decision===void 0?t:{...t,decision:applyLiveDeliveryAudienceCeiling(t.decision,r,n)};switch(e.target.kind){case`local`:return startLocalSubagent({action:e.target.action,auth:e.auth,batchEvent:e.batchEvent,bundle:e.bundle,capabilities:e.capabilities,channelMetadata:e.channelMetadata,currentSession:e.currentSession,dynamicSubagentAgentConfig:e.target.dynamicSubagentAgentConfig,fanoutSize:e.fanoutSize,initiatorAuth:e.initiatorAuth,localDevRequest:e.localDevRequest,parentContinuationToken:e.parentContinuationToken,parentTraceContext:i,activityObserver:e.activityObserver,sandboxSessionId:e.sandboxSessionId,selfAgent:e.target.selfAgent,session:e.session,source:e.target.source,taskOwned:e.taskOwned});case`remote`:return startRemoteSubagent({action:e.target.action,auth:e.auth,batchEvent:e.batchEvent,bundle:e.bundle,callbackBaseUrl:e.callbackBaseUrl,originAudience:n?.originAudience??r,currentSession:e.currentSession,dynamicRemoteAgent:e.target.dynamicRemoteAgent,initiatorAuth:e.initiatorAuth,parentContinuationToken:e.parentContinuationToken,parentTraceContext:i,activityObserver:e.activityObserver,session:e.session,taskOwned:e.taskOwned});default:return e.target}}export{startSubagent};

package/dist/src/execution/dispatch-runtime-actions-step.d.ts

@@ -1,18 +0,0 @@
-/**
- * Starts or continues every pending runtime action for the parked parent
- * session, with children reporting straight back to the parent turn via
- * `parentContinuationToken`.
- *
- * The batch is classified into a dispatch plan first (reject / resume /
- * start), then each entry dispatches and emits one
- * parent `subagent.called` control-plane event through a single tail.
- * Every start commits an agent handle (`starting`) before its side effect
- * and confirms it (`running`) once the child reports coordinates, so the
- * returned snapshot-bearing state owns every child it may have created.
- *
- * Agents running `experimental.tasks` never reach this step: the turn
- * workflow selects `dispatchTaskStep`, the task-mode sibling that wraps
- * each dispatch in the delegated-task lifecycle.
- */
-import { type RuntimeActionDispatchInput, type RuntimeActionDispatchResult } from "#execution/dispatch-runtime-actions-shared.js";
-export declare function dispatchRuntimeActionsStep(input: RuntimeActionDispatchInput): Promise<RuntimeActionDispatchResult>;

package/dist/src/execution/dispatch-runtime-actions-step.js

@@ -1 +0,0 @@
-import{createDurableSessionState}from"#execution/durable-session-store.js";import{dispatchToAgentHandle}from"#execution/agent-handle-dispatch.js";import{startWorkflowTool}from"#execution/tool-run/dispatch.js";import{createAgentContinuationBundle}from"#execution/agent-continuation-bundle.js";import{emitSubagentCalled,prepareRuntimeActionDispatch}from"#execution/dispatch-runtime-actions-shared.js";import{startSubagent}from"#execution/dispatch-runtime-actions-start.js";import{deriveChildActivityObserverConfig}from"#execution/activity-work.js";async function dispatchRuntimeActionsStep(r){"use step";let i=await prepareRuntimeActionDispatch({serializedContext:r.serializedContext,sessionState:r.sessionState,taskControls:!1});if(i===void 0)return{results:[],sessionState:r.sessionState,pendingTasks:[]};let{batch:a,bundle:o,session:s}=i,c=r.parentWritable.getWriter(),l=s,u=[];try{for(let e of i.plan){if(e.kind===`reject`){u.push(e.result);continue}if(e.kind===`workflow-tool`){let t=await startWorkflowTool({action:e.action,batchEvent:a.event,ownerInboxToken:r.parentContinuationToken,prepared:i,session:l});l=t.session,t.result!==void 0&&u.push(t.result);continue}if(e.kind===`task-control`)throw Error(`Task-control actions require the task dispatch step.`);let n;switch(e.kind){case`resume`:n=await dispatchToAgentHandle({action:e.action,activityObserver:i.activityObserver===void 0?void 0:deriveChildActivityObserverConfig({activityObserver:i.activityObserver,callId:e.action.callId,kind:e.action.kind===`remote-agent-call`?`remote-agent`:`subagent`,name:e.action.kind===`remote-agent-call`?e.action.remoteAgentName:e.action.subagentName,parentSessionId:s.sessionId,parentTurnId:a.event.turnId}),agentId:e.agentId,auth:i.auth,bundle:createAgentContinuationBundle({action:e.action,bundle:o,dynamicRemoteAgent:e.dynamicRemoteAgent}),currentSession:l,parentToken:r.parentContinuationToken??s.continuationToken,parentTurnId:a.event.turnId});break;case`start`:n=await startSubagent({auth:i.auth,batchEvent:a.event,bundle:o,callbackBaseUrl:r.callbackBaseUrl,capabilities:i.capabilities,channelMetadata:i.channelMetadata,currentSession:l,fanoutSize:i.fanoutSize,initiatorAuth:i.initiatorAuth,localDevRequest:i.localDevRequest,parentContinuationToken:r.parentContinuationToken,parentTraceContext:i.parentTraceContext,activityObserver:i.activityObserver,sandboxSessionId:i.sandboxSessionId,serializedContext:i.serializedContext,session:s,taskOwned:!1,target:e.target});break}if(l=n.session,n.kind===`error`){u.push(n.result);continue}await emitSubagentCalled({adapter:i.adapter,adapterCtx:i.adapterCtx,batchEvent:a.event,entry:e,outcome:n,sessionId:s.sessionId,writer:c})}}finally{c.releaseLock()}return{results:u,sessionState:l===s?i.getBaselineSessionState():createDurableSessionState({session:l}),pendingTasks:[]}}export{dispatchRuntimeActionsStep};

package/dist/src/execution/dispatch-workflow-runtime-actions-step.d.ts

@@ -1,18 +0,0 @@
-import { type DurableSessionState } from "#execution/durable-session-store.js";
-import type { RuntimeActionResult } from "#shared/action-types.js";
-/** Dispatches the child-agent action currently blocking a dynamic workflow. */
-export declare function dispatchWorkflowRuntimeActionsStep(input: {
-    readonly callbackBaseUrl?: string;
-    readonly parentContinuationToken?: string;
-    readonly parentWritable: WritableStream<Uint8Array>;
-    readonly serializedContext: Record<string, unknown>;
-    readonly sessionState: DurableSessionState;
-}): Promise<{
-    readonly results: readonly RuntimeActionResult[];
-    readonly sessionState: DurableSessionState;
-    readonly pendingTasks: readonly {
-        readonly taskInboxToken: string;
-        readonly taskId: string;
-        readonly taskRunId: string;
-    }[];
-}>;

package/dist/src/execution/dispatch-workflow-runtime-actions-step.js

@@ -1 +0,0 @@
-import{createLogger}from"#internal/logging.js";import{BundleKey}from"#runtime/sessions/runtime-context-keys.js";import{deserializeContext}from"#context/serialize.js";import{createDurableSessionState,readDurableSession}from"#execution/durable-session-store.js";import{hydrateDurableSession}from"#execution/session.js";import{resolveEffectiveAgentRuntime}from"#execution/effective-agent-config.js";import{setPendingRuntimeActionBatch}from"#harness/runtime-actions.js";import{getSubagentDelegationName,isSubagentDelegationAction}from"#harness/subagent-depth.js";import{dispatchRuntimeActionsStep}from"#execution/dispatch-runtime-actions-step.js";import{dispatchTaskStep}from"#execution/tasks/parent/dispatch-task-step.js";import{getPendingWorkflowInterrupt,setPendingWorkflowUsedCalls}from"#harness/workflow-interrupt-state.js";import{buildRuntimeActionsFromWorkflowInterrupt}from"#harness/workflow-runtime-action-state.js";import{planWorkflowSubagentDispatch}from"#harness/workflow-subagent-limit.js";const log=createLogger(`execution.dispatch-workflow-runtime-actions`);async function dispatchWorkflowRuntimeActionsStep(e){"use step";let n=await readDurableSession(e.sessionState),r=getPendingWorkflowInterrupt(n.state);if(r===void 0)return{results:[],sessionState:e.sessionState,pendingTasks:[]};let i=buildRuntimeActionsFromWorkflowInterrupt(r.interrupt);if(i.length===0)return{results:[],sessionState:e.sessionState,pendingTasks:[]};let a=await deserializeContext(e.serializedContext),o=a.require(BundleKey),s=resolveEffectiveAgentRuntime(o,a),c=planWorkflowSubagentDispatch({actions:i,maxSubagents:n.workflowMaxSubagents,usedCalls:r.usedCalls}),l=c.blocked.map(e=>(log.warn(`workflow subagent limit reached; blocking delegated call`,{callId:e.callId,maxSubagents:c.maxSubagents,subagentName:isSubagentDelegationAction(e)?getSubagentDelegationName(e):e.target.kind,usedCalls:c.usedCalls}),createWorkflowSubagentLimitResult({action:e,plan:c})));if(c.allowed.length===0)return{results:l,sessionState:e.sessionState,pendingTasks:[]};let u=setPendingWorkflowUsedCalls({session:hydrateDurableSession({compactionOverrides:{thresholdPercent:s.thresholdPercent},durable:n,turnAgent:s.turnAgent}),usedCalls:r.usedCalls+c.allowed.length}),d=setPendingRuntimeActionBatch({actions:c.allowed,event:{sequence:0,stepIndex:0,turnId:`workflow-dispatch`},responseMessages:[],session:u}),f=await(o.resolvedAgent.config?.experimental?.tasks===!0?dispatchTaskStep:dispatchRuntimeActionsStep)({callbackBaseUrl:e.callbackBaseUrl,parentContinuationToken:e.parentContinuationToken,parentWritable:e.parentWritable,serializedContext:e.serializedContext,sessionState:createDurableSessionState({session:d})});return l.length===0?f:{results:[...f.results,...l],sessionState:f.sessionState,pendingTasks:f.pendingTasks}}function createWorkflowSubagentLimitResult(e){let t=isSubagentDelegationAction(e.action)?getSubagentDelegationName(e.action):e.action.target.kind;return{callId:e.action.callId,isError:!0,kind:`subagent-result`,origin:`dispatch`,output:{code:`WORKFLOW_SUBAGENT_LIMIT_REACHED`,maxSubagents:e.plan.maxSubagents,message:`Workflow subagent limit reached (${String(e.plan.maxSubagents)}); "${t}" was not called.`},subagentName:t}}export{dispatchWorkflowRuntimeActionsStep};

package/dist/src/execution/finalize-terminal-session.d.ts

@@ -1,17 +0,0 @@
-import type { TurnCaller } from "#channel/types.js";
-import type { DurableSessionState } from "#execution/durable-session-store.js";
-import type { RunMode } from "#shared/run-mode.js";
-/** Completes a session that terminates outside a turn. */
-export declare function finalizeTerminalSession(input: {
-    readonly caller: TurnCaller | undefined;
-    readonly driverWritable: WritableStream<Uint8Array>;
-    readonly mode: RunMode;
-    readonly notifyCaller: boolean;
-    readonly serializedContext: Record<string, unknown>;
-    readonly sessionState: DurableSessionState;
-    readonly terminalState: {
-        terminalEmitted: boolean;
-    };
-}): Promise<{
-    readonly output: unknown;
-}>;

package/dist/src/execution/finalize-terminal-session.js

@@ -1 +0,0 @@
-import{notifyDelegatedParentStep,notifyTurnCallerStep}from"#execution/delegated-parent-notification.js";import{createDelegatedSubagentSuccessResult}from"#execution/delegated-parent-result.js";import{fireSessionCallbackStep}from"#execution/session-callback-step.js";import{emitTerminalSessionCompletionStep}from"#execution/terminal-session-completion-step.js";import{terminateChildSessionsStep}from"#execution/terminate-child-sessions-step.js";async function finalizeTerminalSession(e){return await terminateChildSessionsStep({serializedContext:e.serializedContext,sessionState:e.sessionState}),await emitTerminalSessionCompletionStep({parentWritable:e.driverWritable,serializedContext:e.serializedContext}),e.terminalState.terminalEmitted=!0,e.notifyCaller&&(e.mode===`task`?(await fireSessionCallbackStep({output:``,serializedContext:e.serializedContext,status:`completed`}),await notifyDelegatedParentStep({result:createDelegatedSubagentSuccessResult(e.serializedContext,``),serializedContext:e.serializedContext})):e.caller!==void 0&&await notifyTurnCallerStep({caller:e.caller,lifecycle:`terminal`,sessionId:e.sessionState.sessionId,settled:{output:``}})),{output:``}}export{finalizeTerminalSession};

package/dist/src/execution/prepared-agent-action.d.ts

@@ -1,7 +0,0 @@
-import type { RuntimeAgentHandleAction } from "#execution/agent-handle-dispatch.js";
-import type { PendingAgentDispatchAction } from "#shared/dispatch-action.js";
-/** Converts a prepared dispatch identity into the existing agent transport contract. */
-export declare function resolvePreparedAgentAction(action: PendingAgentDispatchAction): {
-    readonly action: RuntimeAgentHandleAction;
-    readonly selfAgent: boolean;
-};

package/dist/src/execution/prepared-agent-action.js

@@ -1 +0,0 @@
-function resolvePreparedAgentAction(e){let t={callId:e.callId,description:e.description,input:e.input,name:e.toolName,nodeId:e.target.nodeId};switch(e.target.kind){case`remote-agent-call`:return{action:{...t,kind:`remote-agent-call`,remoteAgentName:e.target.remoteAgentName},selfAgent:!1};case`self-agent-call`:return{action:{...t,kind:`subagent-call`,subagentName:e.target.subagentName},selfAgent:!0};case`subagent-call`:return{action:{...t,kind:`subagent-call`,subagentName:e.target.subagentName},selfAgent:!1}}}export{resolvePreparedAgentAction};

package/dist/src/execution/remote-agent-dispatch.js

@@ -1 +0,0 @@
-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{formatSubagentInput,normalizeRequestedOutputSchema}from"#execution/subagent-invocation.js";import{createWorkflowCallbackUrl}from"#execution/workflow-callback-url.js";import{readTaskIdFromInboxToken}from"#tasks/task-inbox-token.js";import{AgentHandleError}from"#protocol/agent-handle-error.js";import{createRemoteAgentRouteUrl}from"#execution/remote-agent-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: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/session-callback-route.js

@@ -1 +0,0 @@
-import{z}from"#compiled/zod/index.js";import{isInputRequest}from"#shared/input.js";import{jsonValueSchema}from"#shared/json-schemas.js";import{resumeHook}from"#internal/workflow/runtime.js";import{REMOTE_AGENT_FAILED}from"#harness/agent-handle-errors.js";import{readTaskIdFromInboxToken}from"#tasks/task-inbox-token.js";import{agentTurnOutcomeSchema}from"#shared/agent-turn-outcome.js";import{tokenUsageSchema}from"#shared/token-usage.js";const ZERO_TOKEN_USAGE={cacheReadTokens:0,cacheWriteTokens:0,inputTokens:0,outputTokens:0},eventCoordinateSchema=z.number().int().nonnegative(),authorizationChallengeSchema=z.looseObject({displayName:z.string().optional(),expiresAt:z.string().optional(),instructions:z.string().optional(),url:z.string().optional(),userCode:z.string().optional()}),taskInputEventSchema=z.looseObject({requests:z.array(jsonValueSchema.refine(isInputRequest)).min(1),sequence:eventCoordinateSchema,stepIndex:eventCoordinateSchema,turnId:z.string()}),taskAuthorizationEventSchema=z.discriminatedUnion(`type`,[z.looseObject({data:z.looseObject({attemptId:z.string().optional(),authorization:authorizationChallengeSchema.optional(),description:z.string(),name:z.string(),sequence:eventCoordinateSchema,stepIndex:eventCoordinateSchema,turnId:z.string(),webhookUrl:z.string().optional()}),type:z.literal(`authorization.required`)}),z.looseObject({data:z.looseObject({attemptId:z.string().optional(),authorization:authorizationChallengeSchema.optional(),name:z.string(),outcome:z.enum([`authorized`,`declined`,`failed`,`timed-out`]),reason:z.string().optional(),sequence:eventCoordinateSchema,stepIndex:eventCoordinateSchema,turnId:z.string()}),type:z.literal(`authorization.completed`)})]),taskEventCallbackSchema=z.discriminatedUnion(`kind`,[z.object({callId:z.string(),childContinuationToken:z.string(),childSessionId:z.string(),event:taskInputEventSchema,kind:z.literal(`task.input-requested`),subagentName:z.string(),taskId:z.string()}),z.object({callId:z.string(),childContinuationToken:z.string(),childSessionId:z.string(),event:taskAuthorizationEventSchema,kind:z.literal(`task.authorization`),subagentName:z.string(),taskId:z.string()})]),taskTurnStartedCallbackSchema=z.object({kind:z.literal(`turn.started`),sessionId:z.string().min(1),taskId:z.string().min(1),turnId:z.string().min(1)}),taskUpdateCallbackSchema=z.object({callId:z.string().min(1),kind:z.literal(`task.update`),message:z.string().min(1),taskId:z.string().min(1),updateEpoch:z.string().min(1),updateIndex:eventCoordinateSchema}),sessionResultCallbackSchema=z.discriminatedUnion(`kind`,[z.object({callId:z.string().min(1),kind:z.literal(`session.completed`),output:jsonValueSchema.optional(),subagentName:z.string().min(1),usage:z.unknown().optional()}),z.object({callId:z.string().min(1),error:jsonValueSchema.optional(),kind:z.literal(`session.failed`),subagentName:z.string().min(1),usage:z.unknown().optional()}),z.object({callId:z.string().min(1),kind:z.literal(`turn.completed`),outcome:agentTurnOutcomeSchema,output:jsonValueSchema.optional(),subagentName:z.string().min(1)}),z.object({callId:z.string().min(1),error:jsonValueSchema,kind:z.literal(`turn.failed`),outcome:agentTurnOutcomeSchema,subagentName:z.string().min(1)})]);async function handleSessionCallbackRequest(e,t){let n=t.params.token;if(typeof n!=`string`||n.length===0)return Response.json({error:`Missing callback token.`,ok:!1},{status:400});let i;try{i=await e.json()}catch{return Response.json({error:`Invalid JSON body.`,ok:!1},{status:400})}let a=projectTaskEvent(i,n);if(a instanceof Response)return a;if(a!==void 0){try{await resumeHook(n,a)}catch{return Response.json({error:`Session callback not pending.`,ok:!1},{status:404})}return Response.json({ok:!0},{status:202})}let o=projectTaskUpdate(i,n);if(o instanceof Response)return o;if(o!==void 0){try{await resumeHook(n,o)}catch{return Response.json({error:`Session callback not pending.`,ok:!1},{status:404})}return Response.json({ok:!0},{status:202})}let s=projectTaskTurnStarted(i,n);if(s instanceof Response)return s;if(s!==void 0){try{await resumeHook(n,s)}catch{return Response.json({error:`Session callback not pending.`,ok:!1},{status:404})}return Response.json({ok:!0},{status:202})}let c=projectSessionCallbackResult(i);if(c instanceof Response)return c;try{await resumeHook(n,{kind:`runtime-action-result`,results:[c]})}catch{return Response.json({error:`Session callback not pending.`,ok:!1},{status:404})}return Response.json({ok:!0},{status:202})}function callbackKind(e){if(!(typeof e!=`object`||!e))return Reflect.get(e,`kind`)}function projectTaskEvent(e,t){let n=callbackKind(e);if(n!==`task.input-requested`&&n!==`task.authorization`)return;let r=taskEventCallbackSchema.safeParse(e);if(!r.success)return Response.json({error:`Invalid task event callback.`,ok:!1},{status:400});let i=r.data,a=rejectMismatchedTaskToken(t,i.taskId);return a===void 0?i.kind===`task.input-requested`?{callId:i.callId,childContinuationToken:i.childContinuationToken,childSessionId:i.childSessionId,event:i.event,kind:`subagent-input-request`,subagentName:i.subagentName}:{callId:i.callId,childSessionId:i.childSessionId,event:i.event,kind:`authorization-event`,subagentName:i.subagentName}:a}function projectTaskTurnStarted(e,t){if(callbackKind(e)!==`turn.started`)return;let n=taskTurnStartedCallbackSchema.safeParse(e);if(!n.success)return Response.json({error:`Invalid task turn-start callback.`,ok:!1},{status:400});let r=rejectMismatchedTaskToken(t,n.data.taskId);return r===void 0?{childSessionId:n.data.sessionId,childTurnId:n.data.turnId,kind:`turn-started`,taskId:n.data.taskId}:r}function projectTaskUpdate(e,t){if(callbackKind(e)!==`task.update`)return;let n=taskUpdateCallbackSchema.safeParse(e);if(!n.success)return Response.json({error:`Invalid task update callback.`,ok:!1},{status:400});let r=rejectMismatchedTaskToken(t,n.data.taskId);return r===void 0?{callId:n.data.callId,kind:`task-update`,message:n.data.message,updateEpoch:n.data.updateEpoch,updateIndex:n.data.updateIndex}:r}function rejectMismatchedTaskToken(e,t){return readTaskIdFromInboxToken(e)===t?void 0:Response.json({error:`Task callback token mismatch.`,ok:!1},{status:403})}function projectSessionCallbackResult(e){if(typeof e!=`object`||!e)return Response.json({error:`Expected a JSON object.`,ok:!1},{status:400});let t=callbackKind(e);if(t!==`session.completed`&&t!==`session.failed`&&t!==`turn.completed`&&t!==`turn.failed`)return Response.json({error:`Unsupported callback kind.`,ok:!1},{status:400});let n=sessionResultCallbackSchema.safeParse(e);if(!n.success)return Response.json({error:`Invalid session result callback.`,ok:!1},{status:400});let r=n.data;if(r.kind===`session.completed`){let e=r.output??``,t=parseCallbackUsage(r.usage),n={callId:r.callId,kind:`subagent-result`,origin:`child`,outcome:{kind:`terminal`,result:{kind:`succeeded`,output:e},usageDelta:t??ZERO_TOKEN_USAGE},output:e,subagentName:r.subagentName};return t===void 0?n:{...n,usage:t}}if(r.kind===`session.failed`){let e=r.error===void 0?{code:REMOTE_AGENT_FAILED,message:`Remote agent failed.`}:r.error,t=parseCallbackUsage(r.usage);return{callId:r.callId,isError:!0,kind:`subagent-result`,origin:`child`,outcome:{kind:`terminal`,result:{error:e,kind:`failed`},usageDelta:t??ZERO_TOKEN_USAGE},output:e,subagentName:r.subagentName}}return r.kind===`turn.completed`?{callId:r.callId,kind:`subagent-result`,origin:`child`,outcome:r.outcome,output:r.output??``,subagentName:r.subagentName,usage:r.outcome.usageDelta}:{callId:r.callId,isError:!0,kind:`subagent-result`,origin:`child`,outcome:r.outcome,output:r.error,subagentName:r.subagentName}}function parseCallbackUsage(e){if(e===void 0)return;let t=tokenUsageSchema.safeParse(e);return t.success?t.data:void 0}export{handleSessionCallbackRequest};

package/dist/src/execution/session-callback-step.js

@@ -1 +0,0 @@
-import{createLogger}from"#internal/logging.js";import{SessionCallbackKey}from"#context/keys.js";import{toErrorMessage}from"#shared/errors.js";import{parseSessionCallback}from"#channel/session-callback.js";import{SESSION_FAILED}from"#harness/agent-handle-errors.js";import{postSessionCallbackRequest}from"#execution/session-callback-request.js";const log=createLogger(`execution.session-callback`);async function fireTaskEventCallbackStep(e){"use step";let t=parseSerializedSessionCallback(e.callback);if(t.taskId===void 0)return;let n=e.event.type===`input.requested`,r=n?`task.input-requested`:`task.authorization`,i=await postSessionCallbackRequest({body:{callId:t.callId,childContinuationToken:e.childContinuationToken,childSessionId:e.childSessionId,event:n?e.event.data:e.event,kind:r,subagentName:t.subagentName,taskId:t.taskId},url:t.url});if(!i.ok)throw Error(`Task event callback failed with HTTP ${i.status}.`)}async function fireTaskUpdateCallbackStep(e){"use step";let t=parseSerializedSessionCallback(e.callback);if(t.taskId===void 0)return;let n=await postSessionCallbackRequest({body:{callId:e.callId,updateIndex:e.updateIndex,updateEpoch:e.updateEpoch,kind:`task.update`,message:e.message,taskId:t.taskId},url:t.url});if(!n.ok)throw Error(`Task update callback failed with HTTP ${n.status}.`);return t.taskId}async function fireSessionCallbackStep(e){"use step";let r=e.serializedContext[`eve.sessionId`]??``,o=e.serializedContext[SessionCallbackKey.name];if(o!==void 0)try{let t=parseSerializedSessionCallback(o),a=await postSessionCallbackRequest({body:e.status===`completed`?buildCompletedCallbackBody({callback:t,output:e.output,sessionId:r,usage:e.usage}):{callId:t.callId,error:{code:SESSION_FAILED,message:toErrorMessage(e.error)},kind:`session.failed`,sessionId:r,subagentName:t.subagentName,usage:e.usage},url:t.url});if(!a.ok)throw Error(`Session callback failed with HTTP ${a.status}.`)}catch(e){throw log.error(`failed to post session callback`,{error:e,sessionId:r}),e}}function buildCompletedCallbackBody(e){let t={callId:e.callback.callId,kind:`session.completed`,output:e.output??``,sessionId:e.sessionId,subagentName:e.callback.subagentName};return e.usage===void 0?t:{...t,usage:e.usage}}function parseSerializedSessionCallback(e){let t=parseSessionCallback(e);if(!t.ok)throw Error(`Serialized session callback is invalid.`,{cause:t.cause});return t.callback}export{fireSessionCallbackStep,fireTaskEventCallbackStep,fireTaskUpdateCallbackStep};

package/dist/src/execution/subagent-adapter.js

@@ -1 +0,0 @@
-import{createErrorId,createLogger}from"#internal/logging.js";import{ContinuationTokenKey,SessionIdKey}from"#context/keys.js";import{resumeHook}from"#internal/workflow/runtime.js";import{SUBAGENT_ADAPTER_KIND,isSubagentAdapterState}from"#execution/subagent-adapter-state.js";const log=createLogger(`execution.subagent-adapter`),SUBAGENT_ADAPTER={kind:SUBAGENT_ADAPTER_KIND,async"approval.candidate"(e,t){await forwardSubagentAuthorizationEvent({data:e,type:`approval.candidate`},t)},async"approval.settled"(e,t){await forwardSubagentAuthorizationEvent({data:e,type:`approval.settled`},t)},async"authorization.required"(e,t){await forwardSubagentAuthorizationEvent({data:e,type:`authorization.required`},t)},async"authorization.completed"(e,t){await forwardSubagentAuthorizationEvent({data:e,type:`authorization.completed`},t)},async"input.requested"(e,t){let i=t.state;isSubagentAdapterState(i)&&await forwardSubagentInputRequestStep({hookPayload:{callId:i.callId,childContinuationToken:t.ctx.require(ContinuationTokenKey),childSessionId:t.ctx.require(SessionIdKey),event:{requests:e.requests,sequence:e.sequence,stepIndex:e.stepIndex,turnId:e.turnId},kind:`subagent-input-request`,subagentName:i.subagentName},parentContinuationToken:i.parentContinuationToken})}};async function forwardSubagentAuthorizationEvent(e,t){let n=t.state;isSubagentAdapterState(n)&&await forwardSubagentAuthorizationEventStep({hookPayload:{callId:n.callId,childSessionId:t.ctx.require(SessionIdKey),event:e,kind:`subagent-authorization-event`,subagentName:n.subagentName},parentContinuationToken:n.parentContinuationToken})}async function forwardSubagentAuthorizationEventStep(t){"use step";try{await resumeHook(t.parentContinuationToken,t.hookPayload)}catch(n){let r=createErrorId();throw log.warn(`failed to forward subagent authorization event to parent`,{callId:t.hookPayload.callId,childSessionId:t.hookPayload.childSessionId,errorId:r,eventType:t.hookPayload.event.type,parentContinuationToken:t.parentContinuationToken,subagentName:t.hookPayload.subagentName,error:n}),n}}async function forwardSubagentInputRequestStep(t){"use step";try{await resumeHook(t.parentContinuationToken,t.hookPayload)}catch(n){let r=createErrorId();throw log.warn(`failed to forward proxied HITL batch to parent`,{callId:t.hookPayload.callId,childContinuationToken:t.hookPayload.childContinuationToken,childSessionId:t.hookPayload.childSessionId,errorId:r,parentContinuationToken:t.parentContinuationToken,subagentName:t.hookPayload.subagentName,error:n}),n}}export{SUBAGENT_ADAPTER};

package/dist/src/execution/subagent-event-proxy-step.js

@@ -1 +0,0 @@
-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{deserializeContext,serializeContext}from"#context/serialize.js";import{createDurableSessionState,readDurableSession}from"#execution/durable-session-store.js";import{hydrateDurableSession}from"#execution/session.js";import{resolveEffectiveAgentRuntime}from"#execution/effective-agent-config.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"#execution/subagent-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 emitProxiedSubagentEvent({ctx:await deserializeContext(e.serializedContext),durableSession:t,hookPayload:e.hookPayload,parentWritable:e.parentWritable,recordProxyInputRequests:!1})}async function emitRecordedTaskAuthorizationEventStep(e){"use step";let t=await readDurableSession(e.sessionState);return emitProxiedSubagentEvent({ctx:await deserializeContext(e.serializedContext),durableSession:t,hookPayload:e.hookPayload,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: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})}}export{emitProxiedSubagentEvent,emitRecordedTaskAuthorizationEventStep,emitRecordedTaskInputRequestStep,runProxySubagentEventStep};

package/dist/src/execution/subagent-start-local.js

@@ -1 +0,0 @@
-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{SUBAGENT_START_FAILED}from"#harness/agent-handle-errors.js";import{confirmAgentStarted,confirmTaskAgentAddress,prepareAgentStart,rejectAgentEffect}from"#harness/handles/transitions.js";import{buildSubagentRunInput}from"#execution/subagent-tool.js";import{deriveChildActivityObserverConfig}from"#execution/activity-work.js";import{mintStartOperation}from"#execution/dispatch-start-operation.js";const log=createLogger(`execution.subagent-start-local`);async function startLocalSubagent(e){let{action:t,source:n}=e,r=deriveChildActivityObserverConfig({activityObserver:e.activityObserver,callId:t.callId,kind:`subagent`,name:t.subagentName,parentSessionId:e.session.sessionId,parentTurnId:e.batchEvent.turnId}),i=createWorkflowRuntime({compiledArtifactsSource:e.bundle.compiledArtifactsSource,dynamicSubagentAgentConfig:e.dynamicSubagentAgentConfig,nodeId:t.nodeId}),{childContinuationToken:a,runInput:o}=buildSubagentRunInput({action:t,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:r,sandboxSessionId:e.sandboxSessionId,selfAgent:e.selfAgent,session:e.session,source:n}),s=n.type===`runtime`?`agent/self`:`agent/local`,{identity:c,operation:l}=mintStartOperation({callId:t.callId,name:t.subagentName,nodeId:t.nodeId,parentSessionId:e.session.sessionId,parentTurnId:e.batchEvent.turnId}),u=prepareAgentStart(e.currentSession,{identity:c,operation:l,target:{continuationToken:a,kind:s}}),d;try{await contextStorage.run(new ContextContainer({localDevRequest:e.localDevRequest}),()=>i.createSession(o)),d=(await waitForCommandHookOwner(a)).runId}catch(e){return logError(log,`local subagent start failed`,e,{callId:t.callId,nodeId:t.nodeId,subagentName:t.subagentName}),{kind:`error`,result:{callId:t.callId,isError:!0,kind:`subagent-result`,origin:`dispatch`,output:{code:SUBAGENT_START_FAILED,message:toErrorMessage(e)},subagentName:t.subagentName},session:rejectAgentEffect(u,{disposition:`dead`,operationId:l.id})}}let f={continuationToken:a,kind:s,sessionId:d};return{address:f,callId:t.callId,kind:`called`,name:t.name,session:e.taskOwned?confirmTaskAgentAddress(u,{address:f,operationId:l.id}):confirmAgentStarted(u,{address:f,operationId:l.id}),toolName:t.subagentName}}export{startLocalSubagent};

package/dist/src/execution/subagent-start-remote.js

@@ -1 +0,0 @@
-import{createLogger,logError}from"#internal/logging.js";import{resolveRemoteAgentForAction,startRemoteAgentSession}from"#execution/remote-agent-dispatch.js";import{confirmAgentStarted,confirmTaskAgentAddress,prepareAgentStart,rejectAgentEffect}from"#harness/handles/transitions.js";import{createRemoteAgentStartFailureResult}from"#execution/dispatch-action-failures.js";import{deriveChildActivityObserverConfig}from"#execution/activity-work.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{identity:s,operation:c}=mintStartOperation({callId:r.callId,name:r.remoteAgentName,nodeId:r.nodeId,parentSessionId:e.session.sessionId,parentTurnId:e.batchEvent.turnId}),l={resolverId:e.dynamicRemoteAgent===void 0?r.nodeId:e.dynamicRemoteAgent.credentialsStepId},u=prepareAgentStart(e.currentSession,{identity:s,operation:c,target:{callbackBaseUrl:a,credentialResolver:l,kind:`agent/remote`,url:o.url}});try{let t=await startRemoteAgentSession({action:r,auth:e.auth,callbackBaseUrl:a,callbackToken:e.parentContinuationToken,originAudience:e.originAudience,initiatorAuth:e.initiatorAuth,operationId:c.id,parentTraceContext:e.parentTraceContext,activityObserver:i,remote:o,session:e.session}),n={callbackBaseUrl:a,credentialResolver:l,kind:`agent/remote`,sessionId:t.sessionId,url:o.url};return{address:n,callId:r.callId,kind:`called`,name:r.name,session:e.taskOwned?confirmTaskAgentAddress(u,{address:n,operationId:c.id}):confirmAgentStarted(u,{address:n,operationId:c.id}),toolName:r.remoteAgentName}}catch(e){return logError(log,`remote agent start failed`,e,{remoteAgentName:r.remoteAgentName,nodeId:r.nodeId,callId:r.callId}),{kind:`error`,result:createRemoteAgentStartFailureResult({action:r,error:e}),session:rejectAgentEffect(u,{disposition:`dead`,operationId:c.id})}}}export{startRemoteSubagent};

package/dist/src/execution/subagent-tool.js

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

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

@@ -1,3 +0,0 @@
-export declare const TASK_UPDATE_SESSION_INSTRUCTION = "Background task updates\nYou are running as a background task. For multi-step work, use `task_update` at meaningful milestones to briefly state what you are currently doing. Keep updates terse and activity-focused; do not include preliminary findings or results. Do not wait for a response, and return your final result normally.";
-/** True when the serialized caller binding points at a durable task inbox. */
-export declare function isTaskOwnedSerializedContext(serializedContext: Record<string, unknown>): boolean;

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

@@ -1 +0,0 @@
-import{CHANNEL_CONTEXT_KEY_NAME,SESSION_CALLBACK_CONTEXT_KEY_NAME}from"#context/key-names.js";import{readTaskIdFromInboxToken}from"#tasks/task-inbox-token.js";const TASK_UPDATE_SESSION_INSTRUCTION="Background task updates\nYou are running as a background task. For multi-step work, use `task_update` at meaningful milestones to briefly state what you are currently doing. Keep updates terse and activity-focused; do not include preliminary findings or results. Do not wait for a response, and return your final result normally.";function isTaskOwnedSerializedContext(e){let t=e[SESSION_CALLBACK_CONTEXT_KEY_NAME];if(typeof t==`object`&&t&&typeof Reflect.get(t,`taskId`)==`string`)return!0;let n=e[CHANNEL_CONTEXT_KEY_NAME];if(typeof n!=`object`||!n)return!1;let r=Reflect.get(n,`state`);if(typeof r!=`object`||!r)return!1;let i=Reflect.get(r,`parentContinuationToken`);return typeof i==`string`&&readTaskIdFromInboxToken(i)!==void 0}export{TASK_UPDATE_SESSION_INSTRUCTION,isTaskOwnedSerializedContext};

package/dist/src/execution/tasks/parent/agent-identity.d.ts

@@ -1,13 +0,0 @@
-import type { RuntimeAgentHandleAction } from "#execution/agent-handle-dispatch.js";
-/** Resolves the persistent agent identity attached to one delegated task. */
-export declare function describeTaskAgent(input: {
-    readonly action: RuntimeAgentHandleAction;
-    readonly agentId?: string;
-    readonly parentSessionId: string;
-    readonly parentTurnId: string;
-}): {
-    readonly agentId: string;
-    readonly callId: string;
-    readonly mode: "local" | "remote";
-    readonly name: string;
-};

package/dist/src/execution/tasks/parent/agent-identity.js

@@ -1 +0,0 @@
-import{mintStartOperation}from"#execution/dispatch-start-operation.js";function describeTaskAgent(e){let{action:t}=e,n=t.kind===`remote-agent-call`?t.remoteAgentName:t.subagentName;return{agentId:e.agentId??mintStartOperation({callId:t.callId,name:n,nodeId:t.nodeId,parentSessionId:e.parentSessionId,parentTurnId:e.parentTurnId}).identity.id,callId:t.callId,mode:t.kind===`remote-agent-call`?`remote`:`local`,name:n}}export{describeTaskAgent};

package/dist/src/execution/tasks/parent/agent-views.d.ts

@@ -1,7 +0,0 @@
-import type { ModelMessage } from "ai";
-import type { HarnessSession } from "#harness/types.js";
-import { type AgentView } from "#harness/handles/prompt.js";
-/** Derives model-visible task-agent availability from authoritative task views. */
-export declare function readTaskAgentViews(session: HarnessSession): Promise<readonly AgentView[]>;
-/** Appends the changed task-agent projection before the next model call. */
-export declare function appendTaskAgentAnnouncement(session: HarnessSession, messages?: readonly ModelMessage[]): Promise<HarnessSession>;

package/dist/src/execution/tasks/parent/agent-views.js

@@ -1 +0,0 @@
-import{resolveAgentsAnnouncement}from"#harness/handles/prompt.js";import{formatAgentStatus,getAgentHandleStore}from"#harness/handles/store.js";import{getSessionTaskIndex}from"#tasks/session-index.js";import{readSubagentTaskMetadata}from"#tasks/types.js";import{readTaskViews}from"#execution/tasks/parent/control-shared.js";async function readTaskAgentViews(e){let o=(getAgentHandleStore(e.state)?.handles??[]).filter(e=>e.phase===`addressed`);if(o.length===0)return[];let s=await readTaskViews(getSessionTaskIndex(e.state)),c=new Map;for(let e of s){let t=readSubagentTaskMetadata(e);if(t===void 0)continue;let n=c.get(t.agentId)??[];c.set(t.agentId,[...n,e])}return o.map(e=>{let n=c.get(e.identity.id)??[],r=n.filter(e=>e.status===`working`||e.status===`input_required`);if(r.length>1)throw Error(`Agent "${e.identity.id}" has more than one nonterminal task.`);let i=r[0];if(i!==void 0){let t=i.status===`input_required`?`input_required`:`working`;return{availability:`busy`,id:e.identity.id,name:e.identity.name,taskId:i.taskId,taskStatus:t}}let a=n.at(-1);return{availability:`available`,id:e.identity.id,name:e.identity.name,statusLine:a?.lastOutput===void 0?void 0:formatAgentStatus(a.lastOutput.data)}})}async function appendTaskAgentAnnouncement(t,r=t.history){let i=resolveAgentsAnnouncement({agentViews:await readTaskAgentViews(t),messages:r,store:getAgentHandleStore(t.state)});return i===void 0?t:{...t,history:[...t.history,{content:i,role:`user`}]}}export{appendTaskAgentAnnouncement,readTaskAgentViews};

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

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

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

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

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

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

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

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

package/dist/src/execution/tool-run/answer.js

@@ -1 +0,0 @@
-import{resumeHook}from"#internal/workflow/runtime.js";async function resumeToolRunAnswers(e,t){for(let n of t??[])await resumeHook(e,{optionId:n.optionId,text:n.text})}export{resumeToolRunAnswers};

package/dist/src/execution/tool-run/background.d.ts

@@ -1,14 +0,0 @@
-import { type ToolRunAddress } from "#execution/tool-run/types.js";
-import type { HarnessToolDefinition } from "#harness/execute-tool.js";
-import { type JsonObject } from "#shared/json.js";
-import type { TaskExecutorBinding } from "#tools/task.js";
-/** Harness `execute` for a background workflow tool: starts the run as the task's executor. */
-export declare function createWorkflowToolBackgroundExecute(input: {
-    readonly toolName: string;
-    readonly workflowId: string;
-}): NonNullable<HarnessToolDefinition["execute"]>;
-export declare function createWorkflowToolExecutorBinding(data: ToolRunAddress): TaskExecutorBinding;
-/** Reads the tool run recorded on a task's executor binding, if that is what runs it. */
-export declare function readWorkflowToolExecutor(binding: TaskExecutorBinding | undefined): ToolRunAddress | undefined;
-/** The input crosses the run's serialization boundary; a schema may emit a `Date`, which cannot. */
-export declare function parseWorkflowToolInput(toolInput: unknown, toolName: string): JsonObject;

package/dist/src/execution/tool-run/background.js

@@ -1 +0,0 @@
-import{parseJsonObject}from"#shared/json.js";import{buildCallbackContext}from"#context/build-callback-context.js";import{getHarnessEmissionState}from"#harness/emission.js";import{deriveRunOwner}from"#execution/tool-run/messages.js";import{startToolRun}from"#execution/tool-run/start.js";import{WORKFLOW_TOOL_EXECUTOR_KIND}from"#execution/tool-run/types.js";function createWorkflowToolBackgroundExecute(e){return async(r,i,a)=>{if(a===void 0)throw Error(`Background tool "${e.toolName}" requires a task runtime.`);let o=await startToolRun({callId:i.toolCallId,input:parseWorkflowToolInput(r,e.toolName),owner:deriveRunOwner(a.task.taskInboxToken),session:buildCallbackContext().session,stepIndex:getHarnessEmissionState(a.session.state).stepIndex,toolName:e.toolName,workflowId:e.workflowId});return a.delegated({executor:createWorkflowToolExecutorBinding(o),receipt:{}})}}function createWorkflowToolExecutorBinding(e){return{data:{hookToken:e.hookToken,runId:e.runId},kind:WORKFLOW_TOOL_EXECUTOR_KIND}}function readWorkflowToolExecutor(e){if(e?.kind!==WORKFLOW_TOOL_EXECUTOR_KIND)return;let{hookToken:t,runId:n}=e.data;return typeof t==`string`&&typeof n==`string`?{hookToken:t,runId:n}:void 0}function parseWorkflowToolInput(t,n){try{return parseJsonObject(t)}catch(e){throw TypeError(`Tool "${n}" is a workflow, so its parsed input must be a JSON object.`,{cause:e})}}export{createWorkflowToolBackgroundExecute,createWorkflowToolExecutorBinding,parseWorkflowToolInput,readWorkflowToolExecutor};

package/dist/src/execution/tool-run/cancel.d.ts

@@ -1,7 +0,0 @@
-import type { ToolRunAddress } from "#execution/tool-run/types.js";
-/**
- * Asks the run to cancel itself; cancels it outright only if the message cannot
- * be delivered. Failures are logged, not thrown: the caller has already
- * committed the cancellation the run was serving.
- */
-export declare function cancelToolRun(run: ToolRunAddress, reason: string): Promise<void>;

package/dist/src/execution/tool-run/cancel.js

@@ -1 +0,0 @@
-import{createLogger,logError}from"#internal/logging.js";import{cancelRun,getWorld,resumeHook}from"#internal/workflow/runtime.js";import{isTaskWorkflowTargetGone}from"#execution/tasks/workflow-target.js";const log=createLogger(`execution.tool-run`);async function cancelToolRun(e,n){let r={kind:`cancel`,reason:n};try{await resumeHook(e.hookToken,r);return}catch(t){if(isTaskWorkflowTargetGone(t))return;logError(log,`failed to signal a workflow tool run to cancel; cancelling it outright`,t,{runId:e.runId})}try{await cancelRun(await getWorld(),e.runId,{cancelReason:n})}catch(t){if(isTaskWorkflowTargetGone(t))return;logError(log,`failed to cancel workflow tool run; it may run to completion`,t,{runId:e.runId})}}export{cancelToolRun};