eve 0.50.0 → 0.51.0

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

@@ -1 +0,0 @@
-const WORKFLOW_TOOL_EXECUTOR_KIND=`workflow-tool`;export{WORKFLOW_TOOL_EXECUTOR_KIND};

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

@@ -1,9 +0,0 @@
-import type { ToolRunWorkflowInput } from "#execution/tool-run/types.js";
-/**
- * Runs one authored workflow tool call. The run's own hook is its identity
- * claim and its control inbox: a duplicate start loses the claim and exits; a
- * `cancel` message aborts `ctx.abortSignal`, and the run waits up to
- * {@link CANCEL_GRACE} for the body to unwind before ending as cancelled, so a
- * body parked on a hook or sleep cannot keep a cancelled run alive.
- */
-export declare function toolRunWorkflow(input: ToolRunWorkflowInput): Promise<void>;

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

@@ -1 +0,0 @@
-import{getWorkflowMetadata,sleep}from"#compiled/@workflow/core/index.js";import{claimHookOwnership,disposeHook,isHookConflictError}from"#execution/hook-ownership.js";import{attachRunContext}from"#execution/tool-run/messages.js";import{resumeHookStep}from"#execution/tool-run/resume-hook-step.js";import{openRunControlInbox}from"#execution/tool-run/run-control.js";import{normalizeSerializableError}from"#execution/workflow-errors.js";import{readRegisteredWorkflow}from"#execution/workflow-registry.js";function noop(){}async function toolRunWorkflow(e){"use workflow";let s=openRunControlInbox(e.hookToken),c=!1;try{try{await claimHookOwnership(s.hook),c=!0}catch(e){if(isHookConflictError(e))return;throw e}let r=readRunId(),o={callId:e.callId,input:e.input,runId:r,sequence:e.session.turn.sequence,stepIndex:e.stepIndex,toolName:e.toolName,turnId:e.session.turn.id},l=createWorkflowToolContext(e,s.signal);attachRunContext(l,{from:o,owner:e.owner});let u=runBody(e,l,o),d=u.catch(noop),f;try{f={output:await Promise.race([u,s.cancelled]),status:`completed`}}catch(e){s.signal.aborted?(await Promise.race([d,sleep(`30s`)]),f={reason:s.reason(),status:`cancelled`}):f={error:normalizeSerializableError(e),status:`failed`}}let p={from:o,result:f};await resumeHookStep(e.owner.outcome,p,{ifPresent:f.status===`cancelled`})}finally{c&&await disposeHook(s.hook)}}async function runBody(e,t,n){let r=resolveWorkflowToolExecute(e)(e.input,t);if(!isAsyncIterable(r))return await r;let i=r[Symbol.asyncIterator](),a,o=await i.next();for(;o.done!==!0;){a=o.value;let t={from:n,update:o.value};await resumeHookStep(e.owner.report,t),o=await i.next()}return o.value??a??null}function isAsyncIterable(e){return typeof e==`object`&&!!e&&typeof e[Symbol.asyncIterator]==`function`}function readRunId(){let t=getWorkflowMetadata().workflowRunId;if(typeof t!=`string`)throw Error(`The tool run has no workflow run id.`);return t}function resolveWorkflowToolExecute(e){let t=readRegisteredWorkflow(e.workflowId);if(typeof t!=`function`)throw Error(`Tool "${e.toolName}" is not registered as a workflow in this deployment (${e.workflowId}). The tool was renamed or removed after this run started.`);return t}function createWorkflowToolContext(e,t){let{callId:n,session:r,toolName:i}=e,unavailable=(e,t)=>{throw Error(`ctx.${e} is not available inside a workflow tool; ${t}. Tool "${i}" runs as a durable workflow body, which only replays deterministic code.`)};return{abortSignal:t,callId:n,getSandbox:()=>unavailable(`getSandbox()`,`the session sandbox belongs to the turn`),getSkill:()=>unavailable(`getSkill()`,`skills are read through the session sandbox`),getToken:()=>unavailable(`getToken()`,`read credentials from the environment inside a "use step" helper`),requireAuth:()=>unavailable(`requireAuth()`,`a workflow body cannot park on authorization`),session:r,toolName:i}}export{toolRunWorkflow};

package/dist/src/execution/tools/subagent/local.d.ts

@@ -1,40 +0,0 @@
-import { type TaskExec, type ToolContext } from "#tools/definition.js";
-import type { PendingAgentDispatchAction } from "#shared/dispatch-action.js";
-interface SubagentDefinitionInput {
-    readonly description: string;
-    readonly name: string;
-    readonly target: PendingAgentDispatchAction["target"];
-}
-export declare function defineSubagent(input: SubagentDefinitionInput): import("#tools/definition.js").BackgroundToolDefinition<{
-    agentId?: string | null | undefined;
-    message: string;
-    outputSchema?: {
-        [x: string]: unknown;
-    } | undefined;
-}, import("#tools/definition.js").TaskReceipt<{
-    agentId: string;
-}>> & {
-    execute(input: {
-        agentId?: string | null | undefined;
-        message: string;
-        outputSchema?: {
-            [x: string]: unknown;
-        } | undefined;
-    }, ctx: ToolContext, task: TaskExec): Promise<import("#tools/definition.js").TaskDelegated<{
-        agentId: string;
-    }>>;
-};
-export declare function countLocalSubagentCalls(calls: readonly {
-    readonly definition: {
-        readonly behavior?: import("#tools/behavior.js").PreparedToolBehavior;
-    };
-}[]): number;
-export declare function executeSubagentTool(input: {
-    readonly definition: SubagentDefinitionInput;
-    readonly task: TaskExec;
-    readonly toolContext: ToolContext;
-    readonly toolInput: unknown;
-}): Promise<import("#tools/definition.js").TaskDelegated<{
-    agentId: string;
-}>>;
-export {};

package/dist/src/execution/tools/subagent/local.js

@@ -1 +0,0 @@
-import{createLogger,logError}from"#internal/logging.js";import{loadContext}from"#context/container.js";import{HandleEventKey}from"#context/keys.js";import{createSubagentCalledEvent}from"#protocol/message.js";import{defineTool}from"#tools/definition.js";import{parseJsonObject}from"#shared/json.js";import{getHarnessEmissionState}from"#harness/emission.js";import{workflowEntryReference}from"#execution/workflow-runtime.js";import{serializeContext}from"#context/serialize.js";import{createDurableSessionState}from"#execution/durable-session-store.js";import{dispatchToTaskAgentAddress}from"#execution/agent-handle-dispatch.js";import{activeTurnId}from"#harness/active-turn-id.js";import{resolvePreparedAgentAction}from"#execution/prepared-agent-action.js";import{createAgentContinuationBundle}from"#execution/agent-continuation-bundle.js";import{prepareAgentActionDispatch}from"#execution/dispatch-runtime-actions-shared.js";import{startSubagent}from"#execution/dispatch-runtime-actions-start.js";import{deriveChildActivityObserverConfig}from"#execution/activity-work.js";import{CallbackBaseUrlKey}from"#harness/authorization.js";import{createSubagentExecutorBinding}from"#tasks/types.js";import{findTaskAgentAddress}from"#execution/tasks/parent/control-shared.js";import{checkTaskContinuationAvailability,createTaskContinuationBusyResult,describeTaskDispatch}from"#execution/tasks/parent/continuation-dispatch.js";import{SUBAGENT_TASK_RECEIPT_OUTPUT_SCHEMA}from"#tools/framework/task-contract.js";import{SUBAGENT_TOOL_INPUT_SCHEMA}from"#tools/framework/agent-contract.js";const batchAgentClaims=new WeakMap,log=createLogger(`runtime.framework-tools.subagent`);function defineSubagent(e){return defineTool({description:e.description,execution:`background`,inputSchema:SUBAGENT_TOOL_INPUT_SCHEMA,outputSchema:SUBAGENT_TASK_RECEIPT_OUTPUT_SCHEMA,execute:(t,n,r)=>executeSubagentTool({definition:e,task:r,toolContext:n,toolInput:t})})}function countLocalSubagentCalls(e){return e.filter(e=>{let t=e.definition.behavior?.handling;return t?.kind===`dispatch`&&(t.target.kind===`self-agent-call`||t.target.kind===`subagent-call`)}).length}async function executeSubagentTool(e){let t=loadContext(),{batch:r,session:i,task:a}=e.task,o=getHarnessEmissionState(i.state),s={callId:e.toolContext.callId,description:e.definition.description,input:parseJsonObject(SUBAGENT_TOOL_INPUT_SCHEMA.parse(e.toolInput)),target:e.definition.target,toolName:e.definition.name},c=resolvePreparedAgentAction(s).action,l=await dispatchSubagent({action:c,batch:r,callbackBaseUrl:t.get(CallbackBaseUrlKey),ctx:t,dispatchAction:s,event:{...o,turnId:activeTurnId(o)},localFanoutSize:countLocalSubagentCalls(r),serializedContext:serializeContext(t),sessionState:createDurableSessionState({session:i}),task:a}),u=findTaskAgentAddress(l.session,l.agentId);if(u===void 0)throw Error(`Subagent dispatch for "${l.agentId}" recorded no task agent address.`);let d=createSubagentExecutorBinding({address:u.address,identity:u.identity});await emitSubagentCalled$1({callId:e.toolContext.callId,childSessionId:l.address.sessionId,event:{...o,turnId:activeTurnId(o)},name:l.name,remote:l.remote,sessionId:i.sessionId,toolName:e.definition.name});let f=e.task.delegated({executor:d,receipt:{agentId:l.agentId}});return await emitSubagentCompleted({callId:e.toolContext.callId,output:JSON.stringify(f.receipt),subagentName:l.name,taskId:f.receipt.taskId}),f}async function dispatchSubagent(e){let t=await prepareAgentActionDispatch({action:e.dispatchAction,ctx:e.ctx,event:e.event,localFanoutSize:e.localFanoutSize,serializedContext:e.serializedContext,sessionState:e.sessionState}),n=t.plan[0];if(n===void 0||n.kind===`task-control`||n.kind===`workflow-tool`)throw Error(`Subagent tool dispatch produced no executable plan entry.`);if(n.kind===`reject`)throw Error(JSON.stringify(n.result.output));if(n.kind===`resume`){let r=await checkTaskContinuationAvailability({action:n.action,agentId:n.agentId,parentStepIndex:e.event.stepIndex,parentTurnId:e.event.turnId,session:t.session});if(r!==void 0)throw Error(JSON.stringify(r.output));let i=claimBatchAgent(e.batch,n.agentId,e.task.taskId);if(i!==void 0){let e=createTaskContinuationBusyResult({action:n.action,agentId:n.agentId,status:`working`,taskId:i});throw Error(JSON.stringify(e.output))}}let r=n.kind===`resume`?await dispatchToTaskAgentAddress({action:n.action,activityObserver:t.activityObserver===void 0?void 0:deriveChildActivityObserverConfig({activityObserver:t.activityObserver,callId:n.action.callId,kind:`task`,name:n.action.name,parentSessionId:t.session.sessionId,parentTurnId:e.event.turnId}),agentId:n.agentId,auth:t.auth,bundle:createAgentContinuationBundle({action:n.action,bundle:t.bundle,dynamicRemoteAgent:n.dynamicRemoteAgent}),currentSession:t.session,parentToken:e.task.taskInboxToken}):await startSubagent({auth:t.auth,batchEvent:e.event,bundle:t.bundle,callbackBaseUrl:e.callbackBaseUrl,capabilities:t.capabilities,channelMetadata:t.channelMetadata,currentSession:t.session,fanoutSize:t.fanoutSize,initiatorAuth:t.initiatorAuth,localDevRequest:t.localDevRequest,parentContinuationToken:e.task.taskInboxToken,parentTraceContext:t.parentTraceContext,activityObserver:t.activityObserver,sandboxSessionId:t.sandboxSessionId,serializedContext:t.serializedContext,session:t.session,taskOwned:!0,target:n.target});if(r.kind===`error`)throw Error(JSON.stringify(r.result.output));let i=describeTaskDispatch({action:e.action,agentId:n.kind===`resume`?n.agentId:void 0,parentSessionId:t.session.sessionId,parentTurnId:e.event.turnId,session:r.session}),a=n.kind===`resume`?n.dynamicRemoteAgent:n.target.kind===`remote`?n.target.dynamicRemoteAgent:void 0;return{address:r.address,agentId:i.agentId,mode:i.mode,name:i.name,...r.address.kind===`agent/remote`?{remote:{resolverId:a?.credentialsStepId??e.action.nodeId,url:r.address.url}}:{},session:r.session}}function claimBatchAgent(e,t,n){let r=batchAgentClaims.get(e);r===void 0&&(r=new Map,batchAgentClaims.set(e,r));let i=r.get(t);if(i!==void 0)return i;r.set(t,n)}async function emitSubagentCalled$1(e){let a=loadContext().get(HandleEventKey);if(a!==void 0)try{await a(createSubagentCalledEvent({callId:e.callId,childSessionId:e.childSessionId,name:e.name,remote:e.remote,sequence:e.event.sequence,sessionId:e.sessionId,toolName:e.toolName,turnId:e.event.turnId,workflowId:workflowEntryReference.workflowId}))}catch(n){logError(log,`subagent.called emission failed`,n,{callId:e.callId,childSessionId:e.childSessionId,toolName:e.toolName})}}async function emitSubagentCompleted(e){let i=loadContext().get(HandleEventKey);if(i!==void 0)try{await i({data:{backgroundTask:{status:`working`,taskId:e.taskId},callId:e.callId,output:e.output,subagentName:e.subagentName},type:`subagent.completed`})}catch(n){logError(log,`subagent.completed emission failed`,n,{callId:e.callId,taskId:e.taskId})}}export{countLocalSubagentCalls,defineSubagent,executeSubagentTool};

package/dist/src/execution/tools/subagent/remote.d.ts

@@ -1,26 +0,0 @@
-import type { PendingAgentDispatchAction } from "#shared/dispatch-action.js";
-export declare function defineRemoteSubagent(input: {
-    readonly description: string;
-    readonly name: string;
-    readonly target: Extract<PendingAgentDispatchAction["target"], {
-        readonly kind: "remote-agent-call";
-    }>;
-}): import("#tools/definition.js").BackgroundToolDefinition<{
-    agentId?: string | null | undefined;
-    message: string;
-    outputSchema?: {
-        [x: string]: unknown;
-    } | undefined;
-}, import("#tools/definition.js").TaskReceipt<{
-    agentId: string;
-}>> & {
-    execute(input: {
-        agentId?: string | null | undefined;
-        message: string;
-        outputSchema?: {
-            [x: string]: unknown;
-        } | undefined;
-    }, ctx: import("#tools/definition.js").ToolContext, task: import("#tools/definition.js").TaskExec): Promise<import("#tools/definition.js").TaskDelegated<{
-        agentId: string;
-    }>>;
-};

package/dist/src/execution/tools/subagent/remote.js

@@ -1 +0,0 @@
-import{defineTool}from"#tools/definition.js";import{executeSubagentTool}from"#execution/tools/subagent/local.js";import{SUBAGENT_TASK_RECEIPT_OUTPUT_SCHEMA}from"#tools/framework/task-contract.js";import{SUBAGENT_TOOL_INPUT_SCHEMA}from"#tools/framework/agent-contract.js";function defineRemoteSubagent(r){return defineTool({description:r.description,execution:`background`,inputSchema:SUBAGENT_TOOL_INPUT_SCHEMA,outputSchema:SUBAGENT_TASK_RECEIPT_OUTPUT_SCHEMA,execute:(e,t,n)=>executeSubagentTool({definition:r,task:n,toolContext:t,toolInput:e})})}export{defineRemoteSubagent};

package/dist/src/harness/agent-handle-errors.js

@@ -1 +0,0 @@
-const AGENT_MISMATCH=`AGENT_MISMATCH`,AGENT_UNREACHABLE=`AGENT_UNREACHABLE`,AGENT_BUSY=`AGENT_BUSY`,SUBAGENT_START_FAILED=`SUBAGENT_START_FAILED`,SUBAGENT_EXECUTION_FAILED=`SUBAGENT_EXECUTION_FAILED`,REMOTE_AGENT_START_FAILED=`REMOTE_AGENT_START_FAILED`,REMOTE_AGENT_FAILED=`REMOTE_AGENT_FAILED`,SESSION_FAILED=`SESSION_FAILED`;export{AGENT_BUSY,AGENT_MISMATCH,AGENT_UNREACHABLE,REMOTE_AGENT_FAILED,REMOTE_AGENT_START_FAILED,SESSION_FAILED,SUBAGENT_EXECUTION_FAILED,SUBAGENT_START_FAILED};

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

@@ -1 +0,0 @@
-import{AGENT_HANDLES_STATE_KEY}from"#harness/handles/state-key.js";function readAgentHandles(t){let n=t?.[AGENT_HANDLES_STATE_KEY];if(n===void 0)return[];let r=n.handles;return Array.isArray(r)?r:[]}function findRunningAgentHandle(e,t){return readAgentHandles(e).find(e=>e.phase===`running`&&e.operation.callId===t.callId)}function isResultBoundToRunningHandle(e,t){return t.kind!==`subagent-result`||t.origin===`dispatch`||t.backgroundTask!==void 0||findRunningAgentHandle(e,{callId:t.callId})!==void 0}function isInboxSubagentResultFromRunningHandle(e,t){return findRunningAgentHandle(e,{callId:t.callId})!==void 0}export{findRunningAgentHandle,isInboxSubagentResultFromRunningHandle,isResultBoundToRunningHandle};

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

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

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

@@ -1,167 +0,0 @@
-import { type AgentAddress, type AgentHandle, type AgentIdentity, type ContinueOperation, type StartOperation } from "#harness/handles/store.js";
-import type { HarnessSession, SessionStateMap } from "#harness/types.js";
-import type { AgentTurnOutcome } from "#shared/agent-turn-outcome.js";
-/**
- * Records intent to start a fresh child. Must be applied to the step's
- * working snapshot before the start side effect runs, so the returned state
- * owns any child the step may have created.
- *
- * The guarantee is intra-step, not exactly-once: the prepared handle
- * durably commits only when the enclosing dispatch step's result commits.
- * A crash between an accepted start and that commit replays the step from
- * the pre-step snapshot and re-runs the side effect.
- *
- * Throws when the identity or operation already exists: fresh starts mint
- * a new identity, so a collision means corrupted derivation, not a replay.
- */
-export declare function prepareAgentStart(session: HarnessSession, input: {
-    readonly identity: AgentIdentity;
-    readonly operation: StartOperation;
-    readonly target: AgentStartTargetInput;
-}): HarnessSession;
-type AgentStartTargetInput = Extract<AgentHandle, {
-    phase: "starting";
-}>["target"];
-/** Result of preparing a continuation against an existing handle. */
-export type PrepareAgentContinuationResult = {
-    readonly kind: "ready";
-    readonly session: HarnessSession;
-    readonly handle: Extract<AgentHandle, {
-        phase: "running";
-    }>;
-} | {
-    readonly kind: "unknown";
-} | {
-    readonly kind: "mismatch";
-} | {
-    readonly kind: "busy";
-};
-/**
- * Records intent to deliver a follow-up turn to a parked child. Must be
- * applied to the step's working snapshot before the delivery side effect
- * runs.
- *
- * Delivery is at-least-once, not exactly-once: the `running` handle durably
- * commits only when the enclosing dispatch step's result commits. If the
- * step dies after a successful delivery, replay starts from `parked` and
- * delivers the same operation again — which is why replaying the operation
- * already recorded on a running handle returns `ready` with the unchanged
- * session instead of a busy conflict.
- *
- * `unknown`, `mismatch`, and `busy` do not change the session; the caller
- * maps them onto `AGENT_UNREACHABLE`, `AGENT_MISMATCH`, and `AGENT_BUSY`
- * results.
- */
-export declare function prepareAgentContinuation(session: HarnessSession, input: {
-    readonly agentId: string;
-    readonly invokedName: string;
-    readonly operation: ContinueOperation;
-}): PrepareAgentContinuationResult;
-/**
- * Confirms a started child: `starting` becomes `running` with the child's
- * confirmed address. Throws when no starting handle carries the operation,
- * because confirming an unprepared start means ownership was never
- * committed. Re-confirming an already-running handle with the same
- * operation and address is a replay no-op.
- */
-export declare function confirmAgentStarted(session: HarnessSession, input: {
-    readonly operationId: string;
-    readonly address: AgentAddress;
-}): HarnessSession;
-/** Confirms a task-mode child as a persistent identity/address record. */
-export declare function confirmTaskAgentAddress(session: HarnessSession, input: {
-    readonly operationId: string;
-    readonly address: AgentAddress;
-}): HarnessSession;
-/**
- * Records a task-mode child's persistent address from its durable executor
- * binding, applied when the parent step that delegated the task commits.
- *
- * Replay-idempotent: a record identical to the stored handle is a no-op
- * (a resumed child, or a replayed commit). A different record under the
- * same id throws — ids derive from unique operations, so a collision
- * means corrupted derivation, not a replay.
- */
-export declare function recordTaskAgentAddress(session: HarnessSession, input: {
-    readonly address: AgentAddress;
-    readonly identity: AgentIdentity;
-}): HarnessSession;
-/** Removes a task-mode address after permanent delivery failure. */
-export declare function removeTaskAgentAddress(session: HarnessSession, agentId: string): HarnessSession;
-/** State-only variant used while consuming a terminal task wake. */
-export declare function removeTaskAgentAddressFromState(state: SessionStateMap | undefined, agentId: string): SessionStateMap;
-/**
- * Resolves a dispatch that definitively failed.
- *
- * - A dead start or dead continuation deletes the handle: there is no
- *   child left to own.
- * - A retryable continuation failure restores `parked` with the status the
- *   handle showed before the delivery, so the model may retry the same
- *   `agentId` later.
- *
- * Unknown operations are a no-op: the failure raced a settlement that
- * already resolved the handle.
- */
-export declare function rejectAgentEffect(session: HarnessSession, input: {
-    readonly operationId: string;
-    readonly disposition: "dead" | "retryable";
-}): HarnessSession;
-/**
- * Parks every running child when the parent abandons a cancelled turn.
- *
- * Cancellation requests each running descendant's cancellation and then
- * tears down the turn inbox — the only hook a child settlement can
- * resume — so no later settlement can move these handles. Without this
- * transition they would stay `running` forever: invisible to the model,
- * unresumable, and retried by every future cancellation.
- *
- * A cancelled child settles its own turn as a park, so `parked` with
- * `"(cancelled)"` mirrors {@link settleAgentTurn}'s cancelled outcome. If
- * the child instead died, a later continuation attempt discovers the dead
- * session and {@link rejectAgentEffect} deletes the handle.
- */
-export declare function abandonRunningAgentTurns(session: HarnessSession): HarnessSession;
-/** Result of applying a settled child turn to the store. */
-export type SettleAgentTurnResult = {
-    readonly kind: "settled";
-    readonly session: HarnessSession;
-} | {
-    readonly kind: "ignored";
-    readonly reason: "unknown-operation";
-};
-/**
- * Applies one settled child turn: `running` becomes `parked` for a parked
- * outcome or is deleted for a terminal outcome.
- *
- * The settlement must carry the operation currently recorded on the
- * running handle; anything else is ignored so a stale delivery can never
- * move a newer turn.
- */
-export declare function settleAgentTurn(session: HarnessSession, input: {
-    readonly operationId: string;
-    readonly outcome: AgentTurnOutcome;
-}): SettleAgentTurnResult;
-/**
- * Rebases the handle delta one dispatch produced (`base` → `next`) onto a
- * working session that other concurrently staged effects may have advanced
- * past `base`.
- *
- * Per handle id:
- *
- * - deleted by the dispatch → deleted from the working session.
- * - added by the dispatch → appended. If the working session already holds
- *   the id with different content, throws: ids derive from unique
- *   operations, so a collision means corrupted derivation.
- * - changed in place by the dispatch → the dispatched copy replaces the
- *   working copy while that copy still matches `base`. A working copy that
- *   diverged from both throws instead of silently dropping either change.
- * - untouched by the dispatch → the working copy is kept.
- *
- * A delta the working session already contains is a no-op, so replaying an
- * effect is safe.
- */
-export declare function rebaseAgentHandles(session: HarnessSession, input: {
-    readonly base: SessionStateMap | undefined;
-    readonly next: SessionStateMap | undefined;
-}): HarnessSession;
-export {};

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

@@ -1 +0,0 @@
-import{jsonValuesEqual}from"#shared/json.js";import{AGENT_HANDLES_STATE_KEY,assertPersistableAgentHandleStore,formatAgentStatus,getAgentHandleStore}from"#harness/handles/store.js";function prepareAgentStart(e,t){let n=getAgentHandleStore(e.state)?.handles??[];if(n.some(e=>e.identity.id===t.identity.id))throw Error(`Agent handle "${t.identity.id}" already exists.`);return writeHandles(e,[...n,{identity:t.identity,operation:t.operation,phase:`starting`,target:t.target}])}function prepareAgentContinuation(e,t){let n=getAgentHandleStore(e.state)?.handles??[],r=n.find(e=>e.identity.id===t.agentId);if(r===void 0)return{kind:`unknown`};if(r.identity.name!==t.invokedName)return{kind:`mismatch`};if(r.phase===`running`&&r.operation.id===t.operation.id)return{handle:r,kind:`ready`,session:e};if(r.phase!==`parked`)return{kind:`busy`};let a={address:r.address,identity:r.identity,operation:{...t.operation,previousStatus:r.lastStatus},phase:`running`};return{handle:a,kind:`ready`,session:writeHandles(e,n.map(e=>e.identity.id===t.agentId?a:e))}}function findActiveHandle(e,t){return e.find(e=>(e.phase===`starting`||e.phase===`running`)&&e.operation.id===t)}function confirmAgentStarted(e,t){let n=getAgentHandleStore(e.state)?.handles??[],r=findActiveHandle(n,t.operationId);if(r===void 0)throw Error(`No prepared agent handle for operation "${t.operationId}".`);return r.phase===`running`?e:writeHandles(e,n.map(e=>e===r?{address:t.address,identity:r.identity,operation:r.operation,phase:`running`}:e))}function confirmTaskAgentAddress(e,t){let n=getAgentHandleStore(e.state)?.handles??[],r=findActiveHandle(n,t.operationId);if(r===void 0)throw Error(`No prepared agent handle for operation "${t.operationId}".`);if(r.phase===`running`)throw Error(`Task agent operation "${t.operationId}" was confirmed as a running handle.`);return writeHandles(e,n.map(e=>e===r?{address:t.address,identity:r.identity,phase:`addressed`}:e))}function recordTaskAgentAddress(t,n){let r=getAgentHandleStore(t.state)?.handles??[],a={address:n.address,identity:n.identity,phase:`addressed`},o=r.find(e=>e.identity.id===n.identity.id);if(o!==void 0){if(jsonValuesEqual(o,a))return t;throw Error(`Agent handle "${n.identity.id}" already exists with different content.`)}return writeHandles(t,[...r,a])}function removeTaskAgentAddress(e,t){return{...e,state:removeTaskAgentAddressFromState(e.state,t)}}function removeTaskAgentAddressFromState(e,r){let a=getAgentHandleStore(e)?.handles??[];return{...e,[AGENT_HANDLES_STATE_KEY]:assertPersistableAgentHandleStore({handles:a.filter(e=>!(e.phase===`addressed`&&e.identity.id===r))})}}function rejectAgentEffect(e,t){let n=getAgentHandleStore(e.state)?.handles??[],r=findActiveHandle(n,t.operationId);if(r===void 0)return e;if(t.disposition===`retryable`&&r.phase===`running`){let{operation:t}=r;if(t.kind===`continue`)return writeHandles(e,n.map(e=>e===r?{address:r.address,identity:r.identity,lastStatus:t.previousStatus,phase:`parked`}:e))}return writeHandles(e,n.filter(e=>e!==r))}function abandonRunningAgentTurns(e){let t=getAgentHandleStore(e.state)?.handles??[];return t.some(e=>e.phase===`running`)?writeHandles(e,t.map(e=>e.phase===`running`?{address:e.address,identity:e.identity,lastStatus:`(cancelled)`,phase:`parked`}:e)):e}function settleAgentTurn(e,t){let n=getAgentHandleStore(e.state)?.handles??[],a=n.find(e=>e.phase===`running`&&e.operation.id===t.operationId);if(a===void 0||a.phase!==`running`)return{kind:`ignored`,reason:`unknown-operation`};if(t.outcome.kind===`terminal`)return{kind:`settled`,session:writeHandles(e,n.filter(e=>e!==a))};let{result:o}=t.outcome,s=o.kind===`succeeded`?formatAgentStatus(o.output):o.kind===`failed`?formatAgentStatus(o.error):`(cancelled)`;return{kind:`settled`,session:writeHandles(e,n.map(e=>e===a?{address:a.address,identity:a.identity,lastStatus:s,phase:`parked`}:e))}}function rebaseAgentHandles(t,n){let r=handlesById(n.base),a=handlesById(n.next),o=getAgentHandleStore(t.state)?.handles??[],s=new Set(o.map(e=>e.identity.id)),c=!1,l=[];for(let t of o){let n=t.identity.id,i=r.get(n),o=a.get(n);if(i!==void 0&&o===void 0){c=!0;continue}if(i===void 0&&o!==void 0&&!jsonValuesEqual(t,o))throw Error(`Agent handle "${n}" added by a dispatch already exists with different content.`);if(i!==void 0&&o!==void 0&&!jsonValuesEqual(i,o)){if(jsonValuesEqual(t,i)){l.push(o),c=!0;continue}if(!jsonValuesEqual(t,o))throw Error(`Agent handle "${n}" was changed by a dispatch and concurrently by another effect.`)}l.push(t)}let u=[...a.values()].filter(e=>!r.has(e.identity.id)&&!s.has(e.identity.id));return!c&&u.length===0?t:writeHandles(t,[...l,...u])}function handlesById(e){let t=getAgentHandleStore(e)?.handles??[];return new Map(t.map(e=>[e.identity.id,e]))}function writeHandles(e,r){return{...e,state:{...e.state,[AGENT_HANDLES_STATE_KEY]:assertPersistableAgentHandleStore({handles:r})}}}export{abandonRunningAgentTurns,confirmAgentStarted,confirmTaskAgentAddress,prepareAgentContinuation,prepareAgentStart,rebaseAgentHandles,recordTaskAgentAddress,rejectAgentEffect,removeTaskAgentAddress,removeTaskAgentAddressFromState,settleAgentTurn};

package/dist/src/harness/runtime-actions.js

@@ -1 +0,0 @@
-import{createActionResultEvent}from"#protocol/message.js";import{parseJsonObject}from"#shared/json.js";import{settleAgentTurn}from"#harness/handles/transitions.js";import{findToolRun,removeToolRun}from"#harness/tool-runs.js";import{clearProxyInputRequestsForChild,clearProxyInputRequestsWhere}from"#harness/proxy-input-requests.js";import{getPendingDispatchActionKey}from"#runtime/actions/keys.js";import{accumulateSessionUsage,getTurnUsageState,setTurnUsageState}from"#harness/turn-tag-state.js";import{findRunningAgentHandle,isResultBoundToRunningHandle}from"#harness/handles/query.js";import{resolveRuntimeActionResultsForKeys}from"#runtime/actions/results.js";import{normalizeToolModelOutput}from"#harness/tool-model-output.js";const PENDING_RUNTIME_ACTION_BATCH_KEY=`eve.runtime.pendingActionBatch`;function readSubagentResultOutcome(e){return e.origin===`child`?e.outcome:void 0}function getPendingRuntimeActionBatch(e){let t=e?.[PENDING_RUNTIME_ACTION_BATCH_KEY];if(typeof t!=`object`||!t)return;let n=t;if(!(!Array.isArray(n.actions)||!Array.isArray(n.responseMessages)||typeof n.event!=`object`||n.event===null))return n}function hasPendingRuntimeActionBatch(e){return getPendingRuntimeActionBatch(e)!==void 0}function clearPendingRuntimeActionBatch(e){if(e.state?.[PENDING_RUNTIME_ACTION_BATCH_KEY]===void 0)return e;let t={...e.state};return delete t[PENDING_RUNTIME_ACTION_BATCH_KEY],{...e,state:Object.keys(t).length>0?t:void 0}}function setPendingRuntimeActionBatch(e){assertUniqueRuntimeActionCallIds(e.actions);let t={...e.session.state};return t[PENDING_RUNTIME_ACTION_BATCH_KEY]={actions:[...e.actions],event:e.event,responseMessages:[...e.responseMessages]},{...e.session,state:t}}function assertUniqueRuntimeActionCallIds(e){let t=new Set;for(let n of e){if(t.has(n.callId))throw Error(`Runtime action batch contains duplicate callId "${n.callId}".`);t.add(n.callId)}}function resolveReadyRuntimeActionResults(e){let t=getPendingRuntimeActionBatch(e.session.state);if(t!==void 0)return resolveRuntimeActionResultsForBatch({batch:t,results:e.results,state:e.session.state})}function resolveRuntimeActionResultsForBatch(e){return resolveRuntimeActionResultsForKeys({pendingKeys:e.batch.actions.map(e=>getPendingDispatchActionKey(e)),results:e.results.filter(t=>isResultBoundToRunningHandle(e.state,t))})}async function resolvePendingRuntimeActions(t){let a=getPendingRuntimeActionBatch(t.session.state);if(a===void 0)return{messages:[...t.session.history],outcome:`continue`,session:t.session};let o=resolveReadyRuntimeActionResults({results:t.stepInput?.runtimeActionResults??[],session:t.session});if(o===void 0)return{messages:[...t.session.history],outcome:`unresolved`,session:t.session};if(t.emit!==void 0)for(let n of o){if(n.kind===`subagent-result`&&n.isError!==!0){let e=readBackgroundTaskReceipt(n),r={callId:n.callId,output:typeof n.output==`string`?n.output:JSON.stringify(n.output),subagentName:n.subagentName};await t.emit({data:e===void 0?r:{...r,backgroundTask:e},type:`subagent.completed`})}await t.emit(createActionResultEvent({result:n,sequence:a.event.sequence,stepIndex:a.event.stepIndex,turnId:a.event.turnId}))}let s=t.session;for(let e of o){if(e.kind!==`subagent-result`||e.origin!==`child`||readBackgroundTaskReceipt(e)!==void 0)continue;let t=findRunningAgentHandle(s.state,{callId:e.callId});if(t===void 0)continue;let r=readSubagentResultOutcome(e);if(r===void 0)continue;r.kind===`terminal`&&`continuationToken`in t.address&&(s=clearProxyInputRequestsForChild(s,t.address.continuationToken));let i=settleAgentTurn(s,{operationId:t.operation.id,outcome:r});i.kind===`settled`&&(s=i.session)}for(let e of o){if(e.kind!==`tool-result`)continue;let t=findToolRun(s.state,e.callId);t!==void 0&&(s=removeToolRun(clearProxyInputRequestsWhere(s,e=>e.answerHook?.runId===t.runId),t.callId))}let c={...s.state};delete c[PENDING_RUNTIME_ACTION_BATCH_KEY],s={...s,state:Object.keys(c).length>0?c:void 0};for(let e of o){if(e.kind!==`subagent-result`)continue;let t=readSubagentResultOutcome(e);t!==void 0&&(s=setTurnUsageState(s,accumulateSessionUsage({previous:getTurnUsageState(s.state),usage:t.usageDelta})))}let l=[];for(let e of o){switch(e.kind){case`load-skill-result`:l.push({output:toToolResultOutput(e),toolCallId:e.callId,toolName:`load_skill`,type:`tool-result`});continue;case`subagent-result`:l.push({output:toToolResultOutput(e),toolCallId:e.callId,toolName:e.subagentName,type:`tool-result`});continue;case`tool-result`:l.push({output:await projectToolResultOutput(e,t.tools?.get(e.toolName)),toolCallId:e.callId,toolName:e.toolName,type:`tool-result`});continue}throw Error(`Unsupported runtime action result kind "${String(e)}".`)}let u=[...s.history,...a.responseMessages];return l.length>0&&u.push({content:l,role:`tool`}),{messages:u,outcome:`resolved`,session:s}}function readBackgroundTaskReceipt(e){return`backgroundTask`in e?e.backgroundTask:void 0}function createRuntimeActionRequestFromToolCall(e){let t=e.tools.get(e.toolCall.toolName),n=resolveToolCallInputObject(e.toolCall.input,{callId:e.toolCall.toolCallId,toolName:e.toolCall.toolName});if(t?.behavior?.presentation===`load-skill`)return{callId:e.toolCall.toolCallId,input:n,kind:`load-skill`};let r=t?.execution===`background`||t?.behavior?.handling?.kind!==`dispatch`?void 0:t.behavior.handling.target;return t!==void 0&&(r?.kind===`self-agent-call`||r?.kind===`subagent-call`)?{callId:e.toolCall.toolCallId,description:t.description,input:n,kind:`subagent-call`,name:t.name,nodeId:r.nodeId,subagentName:r.subagentName}:t!==void 0&&r?.kind===`remote-agent-call`?{callId:e.toolCall.toolCallId,description:t.description,input:n,kind:`remote-agent-call`,name:t.name,nodeId:r.nodeId,remoteAgentName:r.remoteAgentName}:{callId:e.toolCall.toolCallId,input:n,kind:`tool-call`,toolName:e.toolCall.toolName}}function createPendingDispatchActionFromToolCall(e){let t=e.tools.get(e.toolCall.toolName);if(t===void 0)throw Error(`Unknown tool "${e.toolCall.toolName}" in dispatch projection.`);let n=t.behavior?.handling;if(n?.kind!==`dispatch`||t.execution===`background`)throw Error(`Tool "${e.toolCall.toolName}" is not a durable dispatch tool.`);return{callId:e.toolCall.toolCallId,description:t.description,input:resolveToolCallInputObject(e.toolCall.input,{callId:e.toolCall.toolCallId,toolName:e.toolCall.toolName}),target:n.target,toolName:t.name}}function resolveToolCallInputObject(e,n){if(e==null||typeof e==`string`&&e.trim()===``)return{};try{return parseJsonObject(typeof e==`string`?parseJsonStringInput(e):e)}catch(e){let t=e instanceof Error?e.message:String(e);throw TypeError(`Failed to parse tool-call arguments for "${n.toolName}" (${n.callId}): ${t}`,{cause:e})}}function parseJsonStringInput(e){return JSON.parse(e)}async function projectToolResultOutput(e,t){return e.isError===!0||t?.toModelOutput===void 0?toToolResultOutput(e):normalizeToolModelOutput({output:await t.toModelOutput(e.output),toolCallId:e.callId,toolName:e.toolName})}function toToolResultOutput(e){return typeof e.output==`string`?e.isError===!0?{type:`error-text`,value:e.output}:{type:`text`,value:e.output}:e.isError===!0?{type:`error-json`,value:toMutableJsonValue(e.output)}:{type:`json`,value:toMutableJsonValue(e.output)}}function toMutableJsonValue(e){if(e===null||typeof e==`string`||typeof e==`number`||typeof e==`boolean`)return e;if(Array.isArray(e))return e.map(e=>toMutableJsonValue(e));let t={};for(let[n,r]of Object.entries(e))t[n]=toMutableJsonValue(r);return t}export{assertUniqueRuntimeActionCallIds,clearPendingRuntimeActionBatch,createPendingDispatchActionFromToolCall,createRuntimeActionRequestFromToolCall,getPendingRuntimeActionBatch,hasPendingRuntimeActionBatch,resolvePendingRuntimeActions,resolveToolCallInputObject,setPendingRuntimeActionBatch};

package/dist/src/harness/subagent-depth.d.ts

@@ -1,10 +0,0 @@
-import type { HarnessSession } from "#harness/types.js";
-import type { PendingAgentDispatchAction, PendingDispatchAction } from "#shared/dispatch-action.js";
-export type ResolvedSubagentDepth = {
-    readonly currentDepth: number;
-    readonly nextChildDepth: number;
-};
-export declare function resolveSubagentDepth(session: Pick<HarnessSession, "subagentDepth">): ResolvedSubagentDepth;
-export declare function readSerializedSubagentDepth(serializedContext: Readonly<Record<string, unknown>>): number | undefined;
-export declare function isSubagentDelegationAction(action: PendingDispatchAction): action is PendingAgentDispatchAction;
-export declare function getSubagentDelegationName(action: PendingAgentDispatchAction): string;

package/dist/src/harness/subagent-depth.js

@@ -1 +0,0 @@
-import{SubagentDepthKey}from"#context/keys.js";function resolveSubagentDepth(e){let t=parseSubagentDepth(e.subagentDepth);return{currentDepth:t,nextChildDepth:t+1}}function readSerializedSubagentDepth(t){let n=parseSubagentDepth(t[SubagentDepthKey.name]);return n===0?void 0:n}function isSubagentDelegationAction(e){return e.target.kind===`self-agent-call`||e.target.kind===`subagent-call`||e.target.kind===`remote-agent-call`}function getSubagentDelegationName(e){switch(e.target.kind){case`remote-agent-call`:return e.target.remoteAgentName;case`self-agent-call`:case`subagent-call`:return e.target.subagentName;default:return e.target}}function parseSubagentDepth(e){return typeof e==`number`&&Number.isInteger(e)&&e>0?e:0}export{getSubagentDelegationName,isSubagentDelegationAction,readSerializedSubagentDepth,resolveSubagentDepth};

package/dist/src/harness/tool-runs.d.ts

@@ -1,21 +0,0 @@
-import type { HarnessSession, SessionStateMap } from "#harness/types.js";
-import type { RuntimeToolResultActionResult } from "#shared/action-types.js";
-export declare function toolRunAnswerToken(runId: string, seq: number): string;
-/** A workflow tool run the active turn waits on. Background runs live in the task index. */
-export interface ToolRunRecord {
-    readonly callId: string;
-    readonly hookToken: string;
-    readonly runId: string;
-    readonly toolName: string;
-}
-export declare function getToolRuns(state: SessionStateMap | undefined): readonly ToolRunRecord[];
-export declare function findToolRun(state: SessionStateMap | undefined, callId: string): ToolRunRecord | undefined;
-export declare function recordToolRun<T extends {
-    readonly state?: SessionStateMap;
-}>(session: T, record: ToolRunRecord): T;
-export declare function removeToolRun<T extends {
-    readonly state?: SessionStateMap;
-}>(session: T, callId: string): T;
-export declare function clearToolRuns(session: HarnessSession): HarnessSession;
-/** The turn inbox is shared; a result settles a call only if the turn recorded that run. */
-export declare function isInboxToolResultFromRecordedRun(state: SessionStateMap | undefined, result: RuntimeToolResultActionResult): boolean;

package/dist/src/harness/tool-runs.js

@@ -1 +0,0 @@
-const TOOL_RUNS_STATE_KEY=`eve.runtime.toolRuns`;function toolRunAnswerToken(e,t){return`eve:tool-run-answer:${e}:${t}`}function getToolRuns(t){let n=t?.[TOOL_RUNS_STATE_KEY];return Array.isArray(n)?n:[]}function findToolRun(e,t){return getToolRuns(e).find(e=>e.callId===t)}function recordToolRun(e,t){return writeToolRuns(e,[...getToolRuns(e.state).filter(e=>e.callId!==t.callId),t])}function removeToolRun(e,t){let n=getToolRuns(e.state),r=n.filter(e=>e.callId!==t);return r.length===n.length?e:writeToolRuns(e,r)}function clearToolRuns(e){return getToolRuns(e.state).length===0?e:writeToolRuns(e,[])}function isInboxToolResultFromRecordedRun(e,t){let n=findToolRun(e,t.callId);return n!==void 0&&n.toolName===t.toolName}function writeToolRuns(t,n){let r={...t.state};return n.length===0?delete r[TOOL_RUNS_STATE_KEY]:r[TOOL_RUNS_STATE_KEY]=n,{...t,state:Object.keys(r).length>0?r:void 0}}export{clearToolRuns,findToolRun,getToolRuns,isInboxToolResultFromRecordedRun,recordToolRun,removeToolRun,toolRunAnswerToken};

package/dist/src/harness/workflow-runtime-action-state.d.ts

@@ -1,9 +0,0 @@
-import type { PendingDispatchAction } from "#shared/dispatch-action.js";
-import { type WorkflowSandboxInterrupt } from "#shared/workflow-sandbox.js";
-export declare const WORKFLOW_RUNTIME_ACTION_INTERRUPT_KIND = "eve.workflow-runtime-action";
-export declare function isWorkflowRuntimeActionInterrupt(interrupt: unknown): boolean;
-export declare function buildRuntimeActionFromWorkflowInterrupt(interrupt: WorkflowSandboxInterrupt): PendingDispatchAction;
-/** Returns every pending runtime-action interrupt in deterministic request order. */
-export declare function getWorkflowRuntimeActionInterrupts(interrupt: WorkflowSandboxInterrupt): WorkflowSandboxInterrupt[];
-export declare function buildRuntimeActionsFromWorkflowInterrupt(interrupt: WorkflowSandboxInterrupt): PendingDispatchAction[];
-export declare function getRuntimeActionKeysFromWorkflowInterrupt(interrupt: WorkflowSandboxInterrupt): string[];

package/dist/src/harness/workflow-runtime-action-state.js

@@ -1 +0,0 @@
-import{getPendingDispatchActionKey}from"#runtime/actions/keys.js";import{getWorkflowSandboxPendingInterrupts}from"#shared/workflow-sandbox.js";const WORKFLOW_RUNTIME_ACTION_INTERRUPT_KIND=`eve.workflow-runtime-action`;function isWorkflowRuntimeActionInterrupt(e){return isRecord(e)&&isRecord(e.payload)&&e.payload.kind===`eve.workflow-runtime-action`}function buildRuntimeActionFromWorkflowInterrupt(e){let t=e.payload,n=t.dispatchTarget,r=t.toolInput,i=t.toolName,a=sanitizeCallId(`${i}_${`interruptId`in e?String(e.interruptId):``}`);if(n.kind===`self-agent-call`||n.kind===`subagent-call`||n.kind===`remote-agent-call`)return{callId:a,description:``,input:r,target:n,toolName:i};throw Error(`Workflow runtime actions cannot carry "${n.kind}" tools.`)}function getWorkflowRuntimeActionInterrupts(e){return getWorkflowSandboxPendingInterrupts(e).filter(isWorkflowRuntimeActionInterrupt)}function buildRuntimeActionsFromWorkflowInterrupt(e){return getWorkflowRuntimeActionInterrupts(e).map(e=>buildRuntimeActionFromWorkflowInterrupt(e))}function getRuntimeActionKeysFromWorkflowInterrupt(t){return buildRuntimeActionsFromWorkflowInterrupt(t).map(getPendingDispatchActionKey)}function sanitizeCallId(e){return e.replace(/[^a-zA-Z0-9_-]/g,`_`)}function isRecord(e){return typeof e==`object`&&!!e&&!Array.isArray(e)}export{WORKFLOW_RUNTIME_ACTION_INTERRUPT_KIND,buildRuntimeActionFromWorkflowInterrupt,buildRuntimeActionsFromWorkflowInterrupt,getRuntimeActionKeysFromWorkflowInterrupt,getWorkflowRuntimeActionInterrupts,isWorkflowRuntimeActionInterrupt};

package/dist/src/runtime/actions/keys.d.ts

@@ -1,14 +0,0 @@
-import type { RuntimeActionRequest, RuntimeActionResult } from "#shared/action-types.js";
-import type { PendingDispatchAction } from "#shared/dispatch-action.js";
-/**
- * Returns the stable match key used to pair one pending runtime action request
- * with its resume result.
- */
-export declare function getRuntimeActionRequestKey(action: RuntimeActionRequest): string;
-/** Returns the stable match key for one durable dispatch request. */
-export declare function getPendingDispatchActionKey(action: PendingDispatchAction): string;
-/**
- * Returns the stable match key used to pair one runtime action result with its
- * originating request.
- */
-export declare function getRuntimeActionResultKey(result: RuntimeActionResult): string;

package/dist/src/runtime/actions/keys.js

@@ -1 +0,0 @@
-function getRuntimeActionRequestKey(e){switch(e.kind){case`load-skill`:return`runtime-action:${e.kind}:${e.callId}`;case`remote-agent-call`:return`subagent-call:${e.remoteAgentName}:${e.callId}`;case`subagent-call`:return`subagent-call:${e.subagentName}:${e.callId}`;case`tool-call`:return`tool-call:${e.toolName}:${e.callId}`}}function getPendingDispatchActionKey(e){switch(e.target.kind){case`remote-agent-call`:return`subagent-call:${e.target.remoteAgentName}:${e.callId}`;case`self-agent-call`:case`subagent-call`:return`subagent-call:${e.target.subagentName}:${e.callId}`;case`task-cancel`:case`task-update`:case`workflow-tool-call`:return`tool-call:${e.toolName}:${e.callId}`;default:return e.target}}function getRuntimeActionResultKey(e){switch(e.kind){case`load-skill-result`:return`runtime-action:load-skill:${e.callId}`;case`subagent-result`:return`subagent-call:${e.subagentName}:${e.callId}`;case`tool-result`:return`tool-call:${e.toolName}:${e.callId}`}}export{getPendingDispatchActionKey,getRuntimeActionRequestKey,getRuntimeActionResultKey};

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

@@ -1,25 +0,0 @@
-import type { TaskCommand, TaskRunInboundPayload } from "#tasks/types.js";
-/**
- * Translates one inbound hook payload into a lifecycle command.
- *
- * Delegated dispatch hands children the task run's hook token, so the
- * payloads that used to resume the parent turn arrive here instead:
- *
- * - a settled child turn (local notification or remote callback)
- *   carries an explicit outcome — its result status decides
- *   `complete`, `fail`, or `cancel`;
- * - a forwarded HITL batch marks the task `input_required` with the
- *   outstanding requests;
- * - `authorization.required` also blocks the task (the child cannot
- *   proceed without the parent's user) under a reserved request id, and
- *   `authorization.completed` clears exactly that id. Authorization
- *   payloads never enter the view — only the fact that the child is
- *   blocked does.
- *
- * `input-response` is deliberately absent: the run must forward the
- * answers to the child before it may record them, so it builds that
- * command itself rather than translating one here.
- *
- * Returns `undefined` for unrecognized payloads, which the run ignores.
- */
-export declare function translateTaskInboundPayload(payload: TaskRunInboundPayload): TaskCommand | undefined;

package/dist/src/tasks/wire.js

@@ -1 +0,0 @@
-import{readTaskUsage,taskAuthorizationRequestId}from"#tasks/types.js";function translateTaskInboundPayload(n){switch(n.kind){case`task-command`:return n.command;case`runtime-action-result`:{let t=n.results[0];if(t===void 0)return;if(t.outcome!==void 0){let n=readTaskUsage(t.outcome.usageDelta);switch(t.outcome.result.kind){case`succeeded`:return withUsage({data:t.output,kind:`complete`,lifecycle:t.outcome.kind},n);case`failed`:return withUsage({data:t.output,kind:`fail`,lifecycle:t.outcome.kind},n);case`cancelled`:return withUsage({kind:`cancel`,lifecycle:t.outcome.kind},n)}}return}case`subagent-input-request`:return{inputRequests:n.event.requests,kind:`require-input`};case`turn-started`:return{childSessionId:n.childSessionId,childTurnId:n.childTurnId,kind:`start-turn`,taskId:n.taskId};case`authorization-event`:{let e=taskAuthorizationRequestId(n.event);return n.event.type===`authorization.required`?{kind:`require-authorization`,requestId:e}:{kind:`answered`,requestIds:[e]}}default:return}}function withUsage(e,t){return t===void 0?e:{...e,usage:t}}export{translateTaskInboundPayload};