eve 0.50.0 → 0.51.0

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};

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

@@ -1,24 +0,0 @@
-import type { PreparedRuntimeActionDispatch } from "#execution/dispatch-runtime-actions-shared.js";
-import type { RuntimeSession } from "#execution/agent-handle-dispatch.js";
-import type { RuntimeToolResultActionResult } from "#shared/action-types.js";
-import type { PendingDispatchAction, PendingWorkflowToolAction } from "#shared/dispatch-action.js";
-export declare function isWorkflowToolAction(action: PendingDispatchAction): action is PendingWorkflowToolAction;
-/**
- * Starts the run and records it on the session so the turn can bind its
- * result, route its requests, and cancel it. A start failure settles the call
- * with an error and records nothing, so nothing is left to cancel.
- */
-export declare function startWorkflowTool(input: {
-    readonly action: PendingWorkflowToolAction;
-    readonly batchEvent: {
-        readonly sequence: number;
-        readonly stepIndex: number;
-        readonly turnId: string;
-    };
-    readonly ownerInboxToken: string | undefined;
-    readonly prepared: Pick<PreparedRuntimeActionDispatch, "auth" | "initiatorAuth" | "parentSession">;
-    readonly session: RuntimeSession;
-}): Promise<{
-    readonly result?: RuntimeToolResultActionResult;
-    readonly session: RuntimeSession;
-}>;

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

@@ -1 +0,0 @@
-import{createLogger,logError}from"#internal/logging.js";import{toError}from"#shared/errors.js";import{recordToolRun}from"#harness/tool-runs.js";import{deriveRunOwner}from"#execution/tool-run/messages.js";import{startToolRun}from"#execution/tool-run/start.js";import{createRuntimeToolResultFromValue}from"#harness/action-result-helpers.js";const log=createLogger(`execution.tool-run`);function isWorkflowToolAction(e){return e.target.kind===`workflow-tool-call`}async function startWorkflowTool(e){let{action:n,batchEvent:r,prepared:i,session:a}=e;if(e.ownerInboxToken===void 0)throw Error(`Workflow tool "${n.toolName}" was dispatched without the turn inbox its run reports to.`);try{let t=await startToolRun({callId:n.callId,input:n.input,owner:deriveRunOwner(e.ownerInboxToken),session:{auth:{current:i.auth,initiator:i.initiatorAuth},id:a.sessionId,parent:i.parentSession,turn:{id:r.turnId,sequence:r.sequence}},stepIndex:r.stepIndex,toolName:n.toolName,workflowId:n.target.workflowId});return{session:recordToolRun(a,{callId:n.callId,hookToken:t.hookToken,runId:t.runId,toolName:n.toolName})}}catch(e){return logError(log,`workflow tool run failed to start`,e,{callId:n.callId,toolName:n.toolName}),{result:createRuntimeToolResultFromValue({callId:n.callId,isError:!0,output:toError(e),toolName:n.toolName}),session:a}}}export{isWorkflowToolAction,startWorkflowTool};

package/dist/src/execution/tool-run/emit-run-report-step.d.ts

@@ -1,7 +0,0 @@
-import type { RunRef } from "#execution/tool-run/messages.js";
-import type { JsonValue } from "#shared/json.js";
-export declare function emitRunReportStep(input: {
-    readonly from: RunRef;
-    readonly parentWritable: WritableStream<Uint8Array>;
-    readonly update: JsonValue;
-}): Promise<void>;

package/dist/src/execution/tool-run/emit-run-report-step.js

@@ -1 +0,0 @@
-import{createActionPartialEvent,encodeMessageStreamEvent,stampMessageStreamEvent}from"#protocol/message.js";import{createRuntimeToolResultFromValue}from"#harness/action-result-helpers.js";async function emitRunReportStep(e){"use step";let t=createActionPartialEvent({result:createRuntimeToolResultFromValue({callId:e.from.callId,output:e.update,toolName:e.from.toolName}),sequence:e.from.sequence,stepIndex:e.from.stepIndex,turnId:e.from.turnId}),n=e.parentWritable.getWriter();try{await n.write(encodeMessageStreamEvent(stampMessageStreamEvent(t)))}finally{n.releaseLock()}}export{emitRunReportStep};

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

@@ -1,70 +0,0 @@
-import { type Hook } from "#compiled/@workflow/core/index.js";
-import type { ToolContext, ToolInputRequest, ToolInputResponse } from "#tools/definition.js";
-import type { JsonObject, JsonValue } from "#shared/json.js";
-export interface ToolRunOwner {
-    readonly outcome: string;
-    readonly report: string;
-    readonly request: string;
-}
-/** Identifies the sending run to an owner that shares its channels across many runs. */
-export interface RunRef {
-    readonly callId: string;
-    /** The tool's parsed input, shown as the request's action when the run asks. */
-    readonly input: JsonObject;
-    readonly runId: string;
-    /** Stream coordinates of the model call that made the tool call. */
-    readonly sequence: number;
-    readonly stepIndex: number;
-    readonly toolName: string;
-    readonly turnId: string;
-}
-export type RunOutcome = {
-    readonly status: "completed";
-    readonly output: JsonValue;
-} | {
-    readonly status: "failed";
-    readonly error: unknown;
-} | {
-    readonly status: "cancelled";
-    readonly reason?: string;
-};
-/** Progress sent up from a run; the owner streams it as a turn partial or a task update. */
-export interface RunReport {
-    readonly from: RunRef;
-    readonly update: JsonValue;
-}
-/** A question sent up from a run; the owner puts it to the human and resumes `answerToken` with the reply. */
-export interface RunRequestMessage {
-    readonly answerToken: string;
-    readonly from: RunRef;
-    readonly request: ToolInputRequest;
-}
-/** The end of a run, sent up once; the owner settles the tool call or the task with it. */
-export interface RunOutcomeMessage {
-    readonly from: RunRef;
-    readonly result: RunOutcome;
-}
-export declare const reportHook: import("#compiled/@workflow/core/index.js").TypedHook<RunReport, RunReport>;
-export declare const requestHook: import("#compiled/@workflow/core/index.js").TypedHook<RunRequestMessage, RunRequestMessage>;
-export declare const outcomeHook: import("#compiled/@workflow/core/index.js").TypedHook<RunOutcomeMessage, RunOutcomeMessage>;
-/** Derived from the owner's inbox token so owner and run agree without exchanging tokens. */
-export declare function deriveRunOwner(inboxToken: string): ToolRunOwner;
-export type RunControlMessage = {
-    readonly kind: "cancel";
-    readonly reason: string;
-};
-export declare function isRunControlMessage(value: unknown): value is RunControlMessage;
-interface RunContext {
-    answerSeq: number;
-    readonly from: RunRef;
-    readonly owner: ToolRunOwner;
-}
-export declare function attachRunContext(ctx: ToolContext, context: Omit<RunContext, "answerSeq">): void;
-/**
- * Asks the human on the session's channel and returns the hook the answer
- * resumes, as `createHook` would: await it for the answer, or race it against
- * a `sleep` for a deadline. Synchronous because a `Hook` is thenable: an async
- * `ask` would resolve to the answer, never the hook.
- */
-export declare function ask(ctx: ToolContext, request: ToolInputRequest): Hook<ToolInputResponse>;
-export {};

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

@@ -1 +0,0 @@
-import{createHook,defineHook}from"#compiled/@workflow/core/index.js";import{toolRunAnswerToken}from"#harness/tool-runs.js";import{resumeHookStep}from"#execution/tool-run/resume-hook-step.js";const reportHook=defineHook(),requestHook=defineHook(),outcomeHook=defineHook();function deriveRunOwner(e){return{outcome:`${e}:outcome`,report:`${e}:report`,request:`${e}:request`}}function isRunControlMessage(e){if(typeof e!=`object`||!e)return!1;let{kind:t,reason:n}=e;return t===`cancel`&&typeof n==`string`}const RUN_CONTEXT=Symbol.for(`eve.tool-run.context`);function attachRunContext(e,t){Object.defineProperty(e,RUN_CONTEXT,{enumerable:!1,value:{...t,answerSeq:0}})}function readRunContext(e){let t=e[RUN_CONTEXT];if(t===void 0)throw Error(`ask() must be called with the context of a workflow tool body ("use workflow").`);return t}function ask(t,r){let i=readRunContext(t),a=createHook({token:toolRunAnswerToken(i.from.runId,i.answerSeq++)}),o={answerToken:a.token,from:i.from,request:r};return resumeHookStep(i.owner.request,o),a}export{ask,attachRunContext,deriveRunOwner,isRunControlMessage,outcomeHook,reportHook,requestHook};

package/dist/src/execution/tool-run/owner-inbox.d.ts

@@ -1,11 +0,0 @@
-import type { SubagentInputRequestHookPayload } from "#channel/types.js";
-import type { RunOutcomeMessage, RunReport, RunRequestMessage } from "#execution/tool-run/messages.js";
-import type { RuntimeToolResultActionResult } from "#shared/action-types.js";
-import type { TaskCommand, TaskInboundUpdate } from "#tasks/types.js";
-/** A cancelled run settles the call as an error so the owner never waits on it. */
-export declare function runOutcomeToToolResult(message: RunOutcomeMessage): RuntimeToolResultActionResult;
-/** The answer hook token is both the request id and the route, so one resume reaches the body. */
-export declare function runRequestToInputRequestPayload(message: RunRequestMessage): SubagentInputRequestHookPayload;
-export declare function runReportToTaskUpdate(message: RunReport, taskId: string, updateIndex: number): TaskInboundUpdate;
-/** A cancelled run only settles the executor: the task itself was already cancelled. */
-export declare function runOutcomeToTaskCommand(message: RunOutcomeMessage): TaskCommand;

package/dist/src/execution/tool-run/owner-inbox.js

@@ -1 +0,0 @@
-function runOutcomeToToolResult(e){let{from:t,result:n}=e;if(n.status===`completed`)return{callId:t.callId,kind:`tool-result`,output:n.output,toolName:t.toolName};let r=n.status===`failed`?errorMessage(n.error):n.reason??`The tool run was cancelled.`;return{callId:t.callId,isError:!0,kind:`tool-result`,output:r,toolName:t.toolName}}function errorMessage(e){if(typeof e==`object`&&e&&`message`in e){let t=e.message;if(typeof t==`string`)return t}return String(e)}function runRequestToInputRequestPayload(e){let{answerToken:t,from:n,request:r}=e;return{callId:n.callId,childContinuationToken:t,childSessionId:n.runId,event:{requests:[toInputRequest(r,n,t)],sequence:n.sequence,stepIndex:n.stepIndex,turnId:n.turnId},kind:`subagent-input-request`,subagentName:n.toolName}}function toInputRequest(e,t,n){if(typeof e.prompt!=`string`||e.prompt.length===0)throw TypeError("A tool run request needs a non-empty `prompt`.");let r={action:{callId:t.callId,input:t.input,kind:`tool-call`,toolName:t.toolName},kind:`question`,prompt:e.prompt,requestId:n};return e.allowFreeform!==void 0&&(r.allowFreeform=e.allowFreeform),e.display!==void 0&&(r.display=e.display),e.options!==void 0&&(r.options=[...e.options]),r}function runReportToTaskUpdate(e,t,n){return{callId:e.from.callId,kind:`task-update`,message:typeof e.update==`string`?e.update:JSON.stringify(e.update),updateEpoch:t,updateIndex:n}}function runOutcomeToTaskCommand(e){let{result:t}=e;return t.status===`completed`?{data:t.output,kind:`complete`,lifecycle:`terminal`}:t.status===`failed`?{data:errorMessage(t.error),kind:`fail`,lifecycle:`terminal`}:{kind:`settle-executor`}}export{runOutcomeToTaskCommand,runOutcomeToToolResult,runReportToTaskUpdate,runRequestToInputRequestPayload};

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

@@ -1,13 +0,0 @@
-import { type RunOutcomeMessage, type RunReport, type RunRequestMessage } from "#execution/tool-run/messages.js";
-import { type ChannelReader } from "#execution/tool-run/owner-channels.js";
-/** In read priority: what a run said before its outcome lands first. */
-export type RunOwnerReaders = readonly [
-    ChannelReader<"report", RunReport>,
-    ChannelReader<"request", RunRequestMessage>,
-    ChannelReader<"outcome", RunOutcomeMessage>
-];
-export interface RunOwnerChannels {
-    readonly readers: RunOwnerReaders;
-    dispose(): Promise<void>;
-}
-export declare function openRunOwnerChannels(inboxToken: string): RunOwnerChannels;

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

@@ -1 +0,0 @@
-import{disposeHook}from"#execution/hook-ownership.js";import{createChannelReader}from"#execution/tool-run/owner-channels.js";import{deriveRunOwner,outcomeHook,reportHook,requestHook}from"#execution/tool-run/messages.js";function openRunOwnerChannels(e){let t=deriveRunOwner(e),n=reportHook.create({token:t.report}),r=requestHook.create({token:t.request}),i=outcomeHook.create({token:t.outcome});return{readers:[createChannelReader(`report`,n),createChannelReader(`request`,r),createChannelReader(`outcome`,i)],async dispose(){await Promise.all([disposeHook(n),disposeHook(r),disposeHook(i)])}}}export{openRunOwnerChannels};

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

@@ -1,18 +0,0 @@
-import { type Hook } from "#compiled/@workflow/core/index.js";
-import { type RunControlMessage } from "#execution/tool-run/messages.js";
-/**
- * The run's control inbox. An unawaited hook read is not scheduled under
- * replay, so `cancelled` must be raced for a cancel to be observed at all.
- */
-export interface RunControlInbox {
-    readonly hook: Hook<RunControlMessage>;
-    readonly signal: AbortSignal;
-    /** Rejects with {@link RunCancelledError} when a cancel message arrives; never resolves. */
-    readonly cancelled: Promise<never>;
-    reason(): string | undefined;
-}
-/** Opens without claiming, so a losing duplicate start never trips the signal. */
-export declare function openRunControlInbox(hookToken: string): RunControlInbox;
-export declare class RunCancelledError extends Error {
-    constructor(reason: string);
-}

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

@@ -1 +0,0 @@
-import{createHook}from"#compiled/@workflow/core/index.js";import{isRunControlMessage}from"#execution/tool-run/messages.js";function openRunControlInbox(t){let n=createHook({token:t}),r=n[Symbol.asyncIterator](),i=new AbortController,a,o=consumeCancel(r,e=>{a=e,i.abort(new RunCancelledError(e))});return o.catch(()=>{}),{cancelled:o,hook:n,reason:()=>a,signal:i.signal}}async function consumeCancel(e,n){for(;;){let r;try{r=await e.next()}catch{return await new Promise(()=>{})}if(r.done===!0)return await new Promise(()=>{});if(isRunControlMessage(r.value))throw n(r.value.reason),new RunCancelledError(r.value.reason)}}var RunCancelledError=class extends Error{constructor(e){super(e),this.name=`RunCancelledError`}};export{RunCancelledError,openRunControlInbox};

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

@@ -1,11 +0,0 @@
-import type { ToolRunWorkflowInput } from "#execution/tool-run/types.js";
-export declare function deriveToolRunHookToken(input: {
-    readonly callId: string;
-    readonly parentSessionId: string;
-    readonly parentTurnId: string;
-}): string;
-/** Resolves once the run owns its hook. Call from inside a `"use step"` body. */
-export declare function startToolRun(input: Omit<ToolRunWorkflowInput, "hookToken">): Promise<{
-    readonly hookToken: string;
-    readonly runId: string;
-}>;

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

@@ -1 +0,0 @@
-import{startWorkflowOnCurrentDeployment,toolRunWorkflowReference,waitForCommandHookOwner}from"#execution/workflow-runtime.js";import{deriveAgentOperationId}from"#harness/handles/operation-id.js";function deriveToolRunHookToken(e){return`eve:tool-run:${deriveAgentOperationId(e)}`}async function startToolRun(t){let n=deriveToolRunHookToken({callId:t.callId,parentSessionId:t.session.id,parentTurnId:t.session.turn.id});return await startWorkflowOnCurrentDeployment(toolRunWorkflowReference,[{...t,hookToken:n}]),{hookToken:n,runId:(await waitForCommandHookOwner(n)).runId}}export{deriveToolRunHookToken,startToolRun};

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

@@ -1,21 +0,0 @@
-import type { SessionContext } from "#context/session-context.js";
-import type { ToolRunOwner } from "#execution/tool-run/messages.js";
-import type { JsonObject } from "#shared/json.js";
-export type ToolRunSessionContext = SessionContext["session"];
-export interface ToolRunWorkflowInput {
-    readonly callId: string;
-    /** Deterministic per call: a replayed start re-derives it, loses the claim, and exits. */
-    readonly hookToken: string;
-    readonly input: JsonObject;
-    readonly owner: ToolRunOwner;
-    readonly session: ToolRunSessionContext;
-    /** Harness step index of the model call that made this tool call. */
-    readonly stepIndex: number;
-    readonly toolName: string;
-    readonly workflowId: string;
-}
-export interface ToolRunAddress {
-    readonly hookToken: string;
-    readonly runId: string;
-}
-export declare const WORKFLOW_TOOL_EXECUTOR_KIND = "workflow-tool";