eve 0.50.0 → 0.51.1

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

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/session-token-limits.d.ts

@@ -1,41 +0,0 @@
-export interface SessionTokenAmounts {
-    readonly inputTokens: number;
-    readonly outputTokens: number;
-}
-export interface SessionRuntimeTokenLimits {
-    readonly inputTokens?: number;
-    readonly outputTokens?: number;
-}
-export type SessionTokenLimitViolation = {
-    readonly kind: "input";
-    readonly limit: number;
-    readonly usedTokens: number;
-} | {
-    readonly kind: "output";
-    readonly limit: number;
-    readonly usedTokens: number;
-};
-/** Resolves per-axis lifetime ceilings, preferring a previously granted ceiling. */
-export declare function resolveRuntimeTokenLimits(input: {
-    readonly configured: SessionRuntimeTokenLimits;
-    readonly stored?: SessionRuntimeTokenLimits;
-}): SessionRuntimeTokenLimits;
-/** Grants one full configured window from the current lifetime usage. */
-export declare function grantRuntimeTokenLimits(input: {
-    readonly configured: SessionRuntimeTokenLimits;
-    readonly usage: SessionTokenAmounts;
-}): SessionRuntimeTokenLimits;
-/** Returns the unspent quota for each capped axis. */
-export declare function remainingRuntimeTokenQuota(input: {
-    readonly runtime: SessionRuntimeTokenLimits;
-    readonly usage: SessionTokenAmounts;
-}): {
-    readonly inputTokens: number | false;
-    readonly outputTokens: number | false;
-};
-/** Returns the first exhausted axis, with input taking precedence. */
-export declare function findRuntimeTokenLimitViolation(input: {
-    readonly configured: SessionRuntimeTokenLimits;
-    readonly runtime: SessionRuntimeTokenLimits;
-    readonly usage: SessionTokenAmounts;
-}): SessionTokenLimitViolation | null;

package/dist/src/harness/session-token-limits.js

@@ -1 +0,0 @@
-function resolveRuntimeTokenLimits(e){let t={},n=e.stored?.inputTokens??e.configured.inputTokens;n!==void 0&&(t.inputTokens=n);let r=e.stored?.outputTokens??e.configured.outputTokens;return r!==void 0&&(t.outputTokens=r),t}function grantRuntimeTokenLimits(e){let t={};return e.configured.inputTokens!==void 0&&(t.inputTokens=e.usage.inputTokens+e.configured.inputTokens),e.configured.outputTokens!==void 0&&(t.outputTokens=e.usage.outputTokens+e.configured.outputTokens),t}function remainingRuntimeTokenQuota(e){return{inputTokens:e.runtime.inputTokens!==void 0&&Math.max(0,e.runtime.inputTokens-e.usage.inputTokens),outputTokens:e.runtime.outputTokens!==void 0&&Math.max(0,e.runtime.outputTokens-e.usage.outputTokens)}}function findRuntimeTokenLimitViolation(e){return e.runtime.inputTokens!==void 0&&e.configured.inputTokens!==void 0&&e.usage.inputTokens>=e.runtime.inputTokens?{kind:`input`,limit:e.configured.inputTokens,usedTokens:e.usage.inputTokens}:e.runtime.outputTokens!==void 0&&e.configured.outputTokens!==void 0&&e.usage.outputTokens>=e.runtime.outputTokens?{kind:`output`,limit:e.configured.outputTokens,usedTokens:e.usage.outputTokens}:null}export{findRuntimeTokenLimitViolation,grantRuntimeTokenLimits,remainingRuntimeTokenQuota,resolveRuntimeTokenLimits};

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/subagent-token-budget.js

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