eve 0.67.2 → 0.69.0

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

@@ -1 +0,0 @@
-import{createLogger}from"#internal/logging.js";import{resumeSessionInbox}from"#execution/session-inbox/resume.js";import{resumeWorkflowToolRunAnswers}from"#execution/tools/workflow/answer.js";import{formatTaskNotification,formatTaskOutput}from"#tasks/notification.js";import{submitActivity}from"#execution/submit-activity.js";import{workflowToolRunInputRequests}from"#execution/tools/workflow/owner-inbox.js";import{isTaskWorkflowTargetGone}from"#execution/tasks/workflow-target.js";import{isTerminalTaskStatus,taskAuthorizationRequestId}from"#tasks/types.js";const log=createLogger(`execution.tasks.run`);async function notifyTaskParent(e){"use step";let t=taskNotificationCommand(e);try{await resumeSessionInbox(e.token,t)}catch(e){if(!isTaskWorkflowTargetGone(e))throw e;log.warn(`task notification target is gone; the parent session already ended`,{taskDeliveryId:t.taskDeliveryId})}}function taskNotificationCommand(e){if(`view`in e){let{view:t,update:n}=e;if(n!==void 0)return{kind:`send`,payload:{message:`Background task ${t.taskId} (${t.metadata.name}) update: ${formatTaskOutput(n.report.update)}`},taskDeliveryId:`${t.taskId}:update:${t.taskId}:${n.index}:${n.report.from.callId}`};let r={message:formatTaskNotification(t)};return isTerminalTaskStatus(t.status)&&(r.task={views:[t]}),{kind:`send`,payload:r,taskDeliveryId:`${t.taskId}:ready:${t.status}`}}let{taskId:t,request:n}=e,{request:r}=n;if(r.kind===`authorization-request`)return taskAuthorizationCommand(r,t);if(r.kind===`agent-invoke`||r.kind===`agent-settled`){let e={replyTo:n.replyTo,request:r,taskId:t},i=r.kind===`agent-invoke`?r.invocationId:`${r.result.callId}:settled`;return{kind:`send`,payload:{task:{agentRequests:[e]}},taskDeliveryId:`${t}:agent:${n.from.runId}:${i}`}}let i=n.requestCoordinates??n.from;return{kind:`send`,payload:{task:{inputRequests:[{replyTo:n.replyTo,requests:workflowToolRunInputRequests(n),sequence:i.sequence,stepIndex:i.stepIndex,taskId:t,turnId:i.turnId}]}},taskDeliveryId:`${t}:input:${i.turnId}:${i.stepIndex}:${i.sequence}`}}function taskAuthorizationCommand(e,t){let{event:n}=e,r=n.event.data,i={task:{authorizationEvents:[{hookPayload:n,taskId:t}]}};return n.event.type===`authorization.required`&&(i.message=`Background task ${t} needs authorization.`),{kind:`send`,payload:i,taskDeliveryId:`${t}:authorization:${n.event.type}:${r.turnId}:${r.stepIndex}:${r.sequence}:${taskAuthorizationRequestId(n.event)}`}}async function emitTaskActivityStep(e){"use step";let t=projectTaskActivity({activityObserver:e.activityObserver,settledAt:new Date().toISOString(),view:e.view});await submitActivity({events:t,sink:e.activityObserver?.sink})}function projectTaskActivity(e){let t=e.activityObserver?.workIdentity;if(t===void 0)return[];let n=e.view.status;return n===`working`?[{eventId:`${t.id}:started`,kind:`work.started`,startedAt:e.settledAt,work:t}]:n!==`completed`&&n!==`failed`&&n!==`cancelled`?[]:[{eventId:`${t.id}:settled:${n}`,kind:`work.settled`,outcome:n,settledAt:e.settledAt,workId:t.id}]}async function deliverTaskInputResponsesStep(e){"use step";let t=new Set(e.requestIds),n={auth:e.answer.auth,kind:`send`,payload:{inputResponses:e.answer.inputResponses.filter(e=>t.has(e.requestId))},taskDeliveryId:`${e.answer.taskId}:${[...e.requestIds].sort().join(`,`)}`};try{if(e.answer.childResponseUrl!==void 0){let t=await fetch(e.answer.childResponseUrl,{body:JSON.stringify({inputResponses:n.payload.inputResponses}),headers:{"content-type":`application/json`},method:`POST`,redirect:`error`});if(t.status===404)return`unreachable`;if(!t.ok)throw Error(`Remote task input delivery failed with HTTP ${t.status}.`)}else e.answerHook===void 0?await resumeSessionInbox(e.answer.childSessionInbox??e.answer.childContinuationToken,n):await resumeWorkflowToolRunAnswers(e.answer.childContinuationToken,n.payload.inputResponses);return`delivered`}catch(t){if(isTaskWorkflowTargetGone(t))return log.warn(`task input answer target is gone; the child turn already ended`,{taskId:e.answer.taskId}),`unreachable`;throw t}}export{deliverTaskInputResponsesStep,emitTaskActivityStep,notifyTaskParent,projectTaskActivity};

package/dist/src/execution/tasks/parent/control-shared.d.ts

@@ -1,23 +0,0 @@
-import type { HarnessSession as RuntimeSession } from "#harness/types.js";
-import type { RuntimeActionResult, RuntimeToolCallActionRequest } from "#shared/action-types.js";
-import { type BackgroundWorkflowToolRun } from "#harness/workflow-tool-runs.js";
-import type { TaskView } from "#tasks/types.js";
-/**
- * Result and lookup helpers shared by the task-control executors
- * (`task_cancel` in the dispatch module,
- * task controls in their own).
- */
-/** Resolves owned index entries, or the ids this session does not own. */
-export declare function lookupTaskEntries(session: RuntimeSession, taskIds: readonly string[]): {
-    readonly entries: BackgroundWorkflowToolRun[];
-    readonly kind: "found";
-} | {
-    readonly kind: "unknown";
-    readonly unknown: string[];
-};
-/** One successful task-control result carrying full task views. */
-export declare function createTaskViewsResult(action: RuntimeToolCallActionRequest, views: readonly TaskView[]): RuntimeActionResult;
-/** One task-control error the model can act on. */
-export declare function createTaskControlError(action: RuntimeToolCallActionRequest, message: string): RuntimeActionResult;
-/** The ownership error for ids outside this session's task index. */
-export declare function createUnknownTasksError(action: RuntimeToolCallActionRequest, unknown: readonly string[]): RuntimeActionResult;

package/dist/src/execution/tasks/parent/control-shared.js

@@ -1 +0,0 @@
-import{getBackgroundTasks}from"#harness/workflow-tool-runs.js";import{taskViewsToJson}from"#tasks/json.js";function lookupTaskEntries(e,t){let n=[],r=[],i=getBackgroundTasks(e.state);for(let e of t){let t=i.get(e)?.run;t===void 0?r.push(e):n.push(t)}return r.length>0?{kind:`unknown`,unknown:r}:{entries:n,kind:`found`}}function createTaskViewsResult(e,t){return{callId:e.callId,kind:`tool-result`,output:taskViewsToJson(t),toolName:e.toolName}}function createTaskControlError(e,t){return{callId:e.callId,isError:!0,kind:`tool-result`,output:{message:t},toolName:e.toolName}}function createUnknownTasksError(e,t){return createTaskControlError(e,`Unknown task ids: ${t.join(`, `)}. Tasks belong to the session that created them.`)}export{createTaskControlError,createTaskViewsResult,createUnknownTasksError,lookupTaskEntries};

package/dist/src/execution/tasks/parent/delegate.d.ts

@@ -1,35 +0,0 @@
-import type { HarnessSession } from "#harness/types.js";
-import type { BackgroundWorkflowToolRun, TaskAgentDispatchContext } from "#harness/workflow-tool-runs.js";
-import type { JsonValue } from "#shared/json.js";
-import type { TaskMetadata } from "#tasks/types.js";
-import type { ContextReader } from "#context/key.js";
-import { type SessionAuth } from "#context/keys.js";
-export declare function createTaskAgentDispatchContext(ctx: ContextReader, auth: SessionAuth): TaskAgentDispatchContext;
-export type BackgroundTaskDraft = Omit<BackgroundWorkflowToolRun, "address"> & {
-    readonly address: {
-        readonly hookToken: string;
-    };
-};
-/** Derives the replay-stable task identity before its owning run is started. */
-export declare function prepareBackgroundTask(input: {
-    readonly callId: string;
-    readonly dispatchContext: TaskAgentDispatchContext;
-    readonly metadata: TaskMetadata;
-    readonly parentSessionId: string;
-    readonly parentStepIndex?: number;
-    readonly parentTurnId: string;
-    readonly session: HarnessSession;
-}): BackgroundTaskDraft;
-/** Releases task events only after the parent session index committed. */
-export declare function acknowledgeDelegatedTasksStep(input: {
-    readonly tasks: readonly {
-        readonly taskInboxToken: string;
-        readonly taskId: string;
-        readonly taskRunId: string;
-    }[];
-}): Promise<void>;
-/** Silently terminates a task whose child dispatch failed before parent indexing. */
-export declare function rejectDelegatedDispatch(input: {
-    readonly error: JsonValue;
-    readonly task: BackgroundWorkflowToolRun;
-}): Promise<void>;

package/dist/src/execution/tasks/parent/delegate.js

@@ -1 +0,0 @@
-import{SessionDynamicSubagentSelectionsKey,TurnDynamicSubagentSelectionsKey}from"#context/keys.js";import{getRun}from"#internal/workflow/runtime.js";import{sendTaskCommand,sendTaskCommandToOwner}from"#execution/tasks/parent/run-parent.js";import{deriveTaskId,deriveTaskInboxToken}from"#tasks/task-id.js";function createTaskAgentDispatchContext(e,t){return{auth:t,sessionDynamicSubagentSelections:e.get(SessionDynamicSubagentSelectionsKey),turnDynamicSubagentSelections:e.get(TurnDynamicSubagentSelectionsKey)}}function prepareBackgroundTask(e){let t=deriveTaskId({callId:e.callId,parentSessionId:e.parentSessionId,parentTurnId:e.parentTurnId});return{callId:e.callId,toolName:e.metadata.name,lifetime:`session`,origin:{turnId:e.parentTurnId,stepIndex:e.parentStepIndex??0},address:{hookToken:deriveTaskInboxToken({parentContinuationToken:e.session.continuationToken,taskId:t})},task:{dispatchContext:e.dispatchContext,metadata:e.metadata,taskId:t}}}async function acknowledgeDelegatedTasksStep(e){"use step";for(let t of e.tasks){if(await sendTaskCommandToOwner({command:{kind:`ready`},taskInboxToken:t.taskInboxToken,retryUnreachable:{attempts:20,delayMs:250}})!==void 0)continue;let e=await getRun(t.taskRunId).status;if(e!==`completed`&&e!==`cancelled`)throw Error(`Task run "${t.taskId}" did not accept its readiness command.`)}}async function rejectDelegatedDispatch(e){await sendTaskCommand({command:{data:e.error,kind:`reject-dispatch`},taskInboxToken:e.task.address.hookToken,retryUnreachable:{attempts:20,delayMs:250}})}export{acknowledgeDelegatedTasksStep,createTaskAgentDispatchContext,prepareBackgroundTask,rejectDelegatedDispatch};

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

@@ -1,22 +0,0 @@
-import type { HarnessSession as RuntimeSession } from "#harness/types.js";
-import { type BackgroundWorkflowToolRun } from "#harness/workflow-tool-runs.js";
-import { type TaskExecutorCancel } from "#execution/tasks/parent/task-cancel.js";
-import type { RuntimeActionResult, RuntimeToolCallActionRequest } from "#shared/action-types.js";
-import { type TaskView } from "#tasks/types.js";
-export declare function isTaskControlAction(action: RuntimeToolCallActionRequest): boolean;
-export declare function executeTaskControlAction(input: {
-    readonly action: RuntimeToolCallActionRequest;
-    readonly cancelOwnedWork?: TaskExecutorCancel;
-    readonly serializedContext?: Record<string, unknown>;
-    readonly session: RuntimeSession;
-}): Promise<{
-    readonly result: RuntimeActionResult;
-    readonly session: RuntimeSession;
-}>;
-/** Cancels task-owned work; the caller records the outcome in the parent session. */
-export declare function cancelOwnedTask(input: {
-    readonly cancelOwnedWork?: TaskExecutorCancel;
-    readonly entry: BackgroundWorkflowToolRun;
-    readonly serializedContext?: Record<string, unknown>;
-    readonly session?: RuntimeSession;
-}): Promise<TaskView>;

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

@@ -1 +0,0 @@
-import{sessionCommandHookToken}from"#execution/session-inbox/address.js";import{readWorkflowTaskView,recordWorkflowTaskView}from"#harness/workflow-tool-runs.js";import{sendTaskCommand}from"#execution/tasks/parent/run-parent.js";import"#tasks/types.js";import{createTaskControlError,createTaskViewsResult,createUnknownTasksError,lookupTaskEntries}from"#execution/tasks/parent/control-shared.js";import{notifyTaskParent}from"#execution/tasks/child/notify.js";import{cancelTaskOwnedWork}from"#execution/tasks/parent/task-cancel.js";import{TASK_CANCEL_TOOL_NAME,TASK_TOOL_NAMES}from"#tools/framework/task-contract.js";function isTaskControlAction(e){return e.kind===`tool-call`&&TASK_TOOL_NAMES.has(e.toolName)}async function executeTaskControlAction(e){let{action:t}=e,n=e.session,r=readTaskIds(t.input);if(r===void 0||r.length===0)return{result:createTaskControlError(t,"Provide a non-empty `taskIds` array."),session:n};let i=lookupTaskEntries(n,r);if(i.kind===`unknown`)return{result:createUnknownTasksError(t,i.unknown),session:n};if(t.toolName!==TASK_CANCEL_TOOL_NAME)return{result:createTaskControlError(t,`Unsupported task control "${t.toolName}".`),session:n};let a=[];for(let t of i.entries){let r=await cancelOwnedTask({cancelOwnedWork:e.cancelOwnedWork,entry:t,serializedContext:e.serializedContext,session:n});n={...n,state:recordWorkflowTaskView(n.state,r).state},a.push(r)}return{result:createTaskViewsResult(t,a),session:n}}async function cancelOwnedTask(e){let t=readWorkflowTaskView(e.entry.task);if(t!==void 0&&t.status!==`cancelled`)return t;let n=t??{metadata:e.entry.task.metadata,status:`cancelled`,taskId:e.entry.task.taskId};return await sendTaskCommand({command:{kind:`cancel`},taskInboxToken:e.entry.address.hookToken}),await cancelTaskOwnedWork({cancelOwnedWork:e.cancelOwnedWork,entry:e.entry,serializedContext:e.serializedContext,session:e.session}),e.session!==void 0&&await notifyTaskParent({token:sessionCommandHookToken(e.session.sessionId),view:n}),n}function readTaskIds(e){let t=e.taskIds;if(Array.isArray(t))return t.filter(e=>typeof e==`string`&&e.trim()!==``)}export{cancelOwnedTask,executeTaskControlAction,isTaskControlAction};

package/dist/src/execution/tasks/parent/hitl-proxy-steps.d.ts

@@ -1,27 +0,0 @@
-import type { SubagentCompletedStreamEvent } from "#protocol/message.js";
-import { type DurableSessionState } from "#execution/durable-session-store.js";
-import type { TaskInputRequestDelivery, TaskView } from "#tasks/types.js";
-/** Validates and records a generic task-owned workflow request. */
-export declare function recordTaskInputRequestStep(input: {
-    readonly request: TaskInputRequestDelivery;
-    readonly sessionState: DurableSessionState;
-}): Promise<{
-    readonly accepted: false;
-    readonly sessionState: DurableSessionState;
-} | {
-    readonly accepted: true;
-    readonly request: TaskInputRequestDelivery;
-    readonly sessionState: DurableSessionState;
-}>;
-/** Records child outcomes in the parent; its first terminal decision wins. */
-export declare function recordTerminalTaskViewsStep(input: {
-    readonly serializedContext: Record<string, unknown>;
-    readonly sessionState: DurableSessionState;
-    readonly views: readonly TaskView[];
-}): Promise<{
-    readonly serializedContext: Record<string, unknown>;
-    readonly sessionState: DurableSessionState;
-    /** Newly recorded terminal outcomes eligible for model notification. */
-    readonly views: readonly TaskView[];
-    readonly subagentCompletions: readonly SubagentCompletedStreamEvent[];
-}>;

package/dist/src/execution/tasks/parent/hitl-proxy-steps.js

@@ -1 +0,0 @@
-import{createEveTaskInputRoutePath}from"#protocol/routes.js";import{createLogger}from"#internal/logging.js";import{isInputRequest}from"#shared/input.js";import{contextStorage}from"#context/container.js";import{ActivityObserverKey}from"#context/keys.js";import{BundleKey}from"#runtime/sessions/runtime-context-keys.js";import{deserializeContext,serializeContext}from"#context/serialize.js";import{readDurableSession,replaceDurableSessionSnapshot}from"#execution/durable-session-store.js";import{getBackgroundTasks,recordWorkflowTaskView}from"#harness/workflow-tool-runs.js";import{getAgentHandleStore}from"#subagents/handles/store.js";import{clearProxyInputRequestsForTask,createTaskInputRequestId,upsertProxyInputRequestState}from"#harness/proxy-input-requests.js";import{bindSessionInstrumentation}from"#instrumentation/runtime.js";import{createRemoteTaskInputCallbackUrl}from"#execution/workflow-callback-url.js";import{submitActivity}from"#execution/submit-activity.js";import{applyTaskAgentHandleCommand}from"#subagents/handles/transitions.js";import{createTaskInputCapabilityToken}from"#execution/task-input-capability.js";import{projectTaskActivity}from"#execution/tasks/child/notify.js";const log=createLogger(`execution.tasks.parent`);async function recordTaskInputRequestStep(e){"use step";let t=readDurableSession(e.sessionState),n=getBackgroundTasks(t.state).get(e.request.taskId),r=e.request.requests??[e.request.request];if(n?.status!==`working`||r.length===0||!r.every(isInputRequest))return{accepted:!1,sessionState:e.sessionState};let i=r.map(t=>({...t,requestId:createTaskInputRequestId(e.request.taskId,t.requestId)})),a=getAgentHandleStore(t.state)?.handles.find(t=>t.phase===`claimed`&&t.ownerId===e.request.taskId),o=a?.phase===`claimed`&&a.address.kind===`agent/remote`?createRemoteTaskInputCallbackUrl(a.address.url,createEveTaskInputRoutePath(createTaskInputCapabilityToken(e.request.replyTo))):void 0,s=r.map((t,n)=>{let r=i[n],a={childContinuationToken:e.request.replyTo,childRequestId:t.requestId,kind:t.kind,taskId:e.request.taskId};return t.kind===`question`&&(a.question={...t.allowFreeform!==void 0&&{allowFreeform:t.allowFreeform},...t.options!==void 0&&{options:[...t.options]}}),o!==void 0&&(a.childResponseUrl=o),[r.requestId,a]}),c=upsertProxyInputRequestState({entries:s,forChildContinuationToken:e.request.replyTo,state:t.state});return{accepted:!0,request:e.request.requests===void 0?{...e.request,request:i[0]}:{...e.request,request:void 0,requests:i},sessionState:replaceDurableSessionSnapshot({session:{...t,state:c},state:e.sessionState})}}async function recordTerminalTaskViewsStep(e){"use step";let t=readDurableSession(e.sessionState),n=t,r=[],i=[],a=[];for(let t of e.views){let e=getBackgroundTasks(n.state).get(t.taskId)?.run;if(e===void 0)continue;let o=recordWorkflowTaskView(n.state,t);n={...n,state:o.state},o.firstOutcome&&o.view.metadata.kind===`subagent`&&o.view.status===`completed`&&a.push({type:`subagent.completed`,data:{callId:e.callId,subagentName:e.toolName,output:typeof o.view.lastOutput.data==`string`?o.view.lastOutput.data:JSON.stringify(o.view.lastOutput.data)}}),r.push(o.view),o.firstOutcome&&i.push(o.view),n=clearProxyInputRequestsForTask(n,t.taskId),n=applyTaskAgentHandleCommand(n,{kind:`release-owner`,ownerId:t.taskId}).session}return{serializedContext:await settleBackgroundTaskActions({serializedContext:e.serializedContext,session:n,views:r}),sessionState:n===t?e.sessionState:replaceDurableSessionSnapshot({session:n,state:e.sessionState}),views:i,subagentCompletions:a}}async function settleBackgroundTaskActions(e){if(e.views.length===0)return e.serializedContext;try{let t=await deserializeContext(e.serializedContext),n=t.get(ActivityObserverKey),r=new Date().toISOString(),i=getBackgroundTasks(e.session.state),a=e.views.flatMap(e=>{let t=i.get(e.taskId)?.run;return projectTaskActivity({activityObserver:n===void 0?void 0:{sink:n.sink,workIdentity:t?.task.activityWorkIdentity},settledAt:r,view:e})});await submitActivity({events:a,sink:n?.sink});let o=t.get(BundleKey);if(o===void 0)return e.serializedContext;let s=bindSessionInstrumentation({agentName:o.turnAgent.id,ctx:t,rootSessionId:e.session.rootSessionId??e.session.sessionId,sessionId:e.session.sessionId});if(s===void 0)return e.serializedContext;try{await contextStorage.run(t,()=>s.publishBackgroundTaskSettlements({acceptedAtMs:Date.now(),views:e.views}))}finally{await s.flush()}return serializeContext(t)}catch(t){return log.warn(`failed to settle background task instrumentation`,{error:t,sessionId:e.session.sessionId,taskIds:e.views.map(e=>e.taskId)}),e.serializedContext}}export{recordTaskInputRequestStep,recordTerminalTaskViewsStep};

package/dist/src/execution/tasks/parent/run-parent.d.ts

@@ -1,58 +0,0 @@
-import type { BackgroundWorkflowToolRunInput } from "#execution/tools/workflow/types.js";
-import { type TaskCommand, type TaskRunInboundPayload } from "#tasks/types.js";
-/**
- * Node-side admission and cancellation for session-owned workflow invocations.
- *
- * Every export must be called from inside a `"use step"` body; none of
- * these are steps themselves so dispatch and tool steps can compose them
- * inside one durable boundary.
- */
-/** Starts a session-owned invocation through the common workflow entry. */
-export declare function startTaskRun(input: BackgroundWorkflowToolRunInput): Promise<void>;
-/** Resolves the task run that won ownership of one replay-stable command token. */
-export declare function waitForTaskCommandOwner(input: {
-    readonly taskInboxToken: string;
-}): Promise<{
-    readonly runId: string;
-}>;
-/**
- * Submits one command to a task run.
- *
- * `unreachable` means the hook is not resumable — either the run
- * already finished and disposed it (the task is terminal; read the
- * final view) or, right after creation, the freshly started run has
- * not registered it yet. Senders racing that startup window pass
- * `retryUnreachable`; senders addressing an established task treat
- * `unreachable` as the terminal signal.
- */
-export declare function sendTaskCommand(input: {
-    readonly command: TaskCommand;
-    readonly taskInboxToken: string;
-    readonly retryUnreachable?: {
-        readonly attempts: number;
-        readonly delayMs: number;
-    };
-}): Promise<"delivered" | "unreachable">;
-/** Delivers one command and returns the accepting task workflow's run id. */
-export declare function sendTaskCommandToOwner(input: {
-    readonly command: TaskCommand;
-    readonly taskInboxToken: string;
-    readonly retryUnreachable?: {
-        readonly attempts: number;
-        readonly delayMs: number;
-    };
-}): Promise<{
-    readonly runId: string;
-} | undefined>;
-/**
- * Hands one non-command inbound payload to a task run.
- *
- * Used for payloads the run must act on before it may record them —
- * today only answered input batches, which it forwards to the child
- * first. `unreachable` means the task already finished and disposed its
- * hook, so the payload is stale by definition.
- */
-export declare function sendTaskInboundPayload(input: {
-    readonly taskInboxToken: string;
-    readonly payload: TaskRunInboundPayload;
-}): Promise<"delivered" | "unreachable">;

package/dist/src/execution/tasks/parent/run-parent.js

@@ -1 +0,0 @@
-import{startWorkflowOnCurrentDeployment,waitForCommandHookOwner,workflowToolRunWorkflowReference}from"#execution/workflow-runtime.js";import{resumeHook}from"#internal/workflow/runtime.js";import{isTaskWorkflowTargetGone}from"#execution/tasks/workflow-target.js";import"#tasks/types.js";async function startTaskRun(e){await startWorkflowOnCurrentDeployment(workflowToolRunWorkflowReference,[e])}async function waitForTaskCommandOwner(e){return await waitForCommandHookOwner(e.taskInboxToken)}async function sendTaskCommand(e){return await sendTaskCommandToOwner(e)===void 0?`unreachable`:`delivered`}async function sendTaskCommandToOwner(e){let t={command:e.command,kind:`task-command`},n=Math.max(1,e.retryUnreachable?.attempts??1);for(let r=0;;r+=1)try{let n=await resumeHook(e.taskInboxToken,t);if(typeof n!=`object`||!n||!(`runId`in n)||typeof n.runId!=`string`)throw Error(`Task inbox hook "${e.taskInboxToken}" returned no owner run id.`);return{runId:n.runId}}catch(t){if(!isTaskWorkflowTargetGone(t))throw t;if(r+1>=n)return;await new Promise(t=>setTimeout(t,e.retryUnreachable?.delayMs??250))}}async function sendTaskInboundPayload(e){try{return await resumeHook(e.taskInboxToken,e.payload),`delivered`}catch(e){if(!isTaskWorkflowTargetGone(e))throw e;return`unreachable`}}export{sendTaskCommand,sendTaskCommandToOwner,sendTaskInboundPayload,startTaskRun,waitForTaskCommandOwner};

package/dist/src/execution/tasks/parent/subagent-task-projection.d.ts

@@ -1,26 +0,0 @@
-import type { loadContext } from "#context/container.js";
-import { createSubagentReceiptIdentity } from "#execution/tools/subagent/receipt-identity.js";
-import type { JsonObject } from "#shared/json.js";
-export interface SubagentTaskProjection {
-    readonly identity?: ReturnType<typeof createSubagentReceiptIdentity>;
-    readonly metadata: {
-        readonly agentId: string;
-        readonly kind: "subagent";
-        readonly mode: "local" | "remote";
-        readonly name: string;
-    };
-    readonly receipt: {
-        readonly agentId: string;
-    };
-}
-export declare function projectSubagentTask(input: {
-    readonly ctx: ReturnType<typeof loadContext>;
-    readonly input: JsonObject;
-    readonly name: string;
-    readonly nodeId: string;
-    readonly taskInput: {
-        readonly callId: string;
-        readonly parentSessionId: string;
-        readonly parentTurnId: string;
-    };
-}): SubagentTaskProjection;

package/dist/src/execution/tasks/parent/subagent-task-projection.js

@@ -1 +0,0 @@
-import{BundleKey}from"#runtime/sessions/runtime-context-keys.js";import{getDynamicSubagentSelection}from"#context/dynamic-subagent-lifecycle.js";import{createSubagentReceiptIdentity}from"#execution/tools/subagent/receipt-identity.js";function projectSubagentTask(e){let t=e.input.agentId;if(typeof t==`string`&&t.trim()!==``)return{metadata:{agentId:t,kind:`subagent`,mode:readSubagentTaskMode(e.ctx,e.nodeId),name:e.name},receipt:{agentId:t}};let n=createSubagentReceiptIdentity({callId:e.taskInput.callId,nodeId:e.nodeId,parentSessionId:e.taskInput.parentSessionId,parentTurnId:e.taskInput.parentTurnId,subagentName:e.name});return{identity:n,metadata:{agentId:n.identity.id,kind:`subagent`,mode:readSubagentTaskMode(e.ctx,e.nodeId),name:e.name},receipt:{agentId:n.identity.id}}}function readSubagentTaskMode(e,t){let n=getDynamicSubagentSelection(e,t);return n===void 0?(e.get(BundleKey)?.subagentRegistry.subagentsByNodeId.get(t))?.definition.kind===`remote`?`remote`:`local`:n.kind===`remote`?`remote`:`local`}export{projectSubagentTask};

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

@@ -1,12 +0,0 @@
-import type { HarnessSession } from "#harness/types.js";
-import type { BackgroundWorkflowToolRun } from "#harness/workflow-tool-runs.js";
-export interface TaskExecutorCancelContext {
-    readonly entry: BackgroundWorkflowToolRun;
-    readonly serializedContext?: Record<string, unknown>;
-    readonly session?: Pick<HarnessSession, "state">;
-}
-export type TaskExecutorCancel = (input: TaskExecutorCancelContext) => Promise<void>;
-/** Cancels task-owned work and waits for the invocation cleanup boundary. */
-export declare function cancelTaskOwnedWork(input: TaskExecutorCancelContext & {
-    readonly cancelOwnedWork?: TaskExecutorCancel;
-}): Promise<void>;

package/dist/src/execution/tasks/parent/task-cancel.js

@@ -1 +0,0 @@
-import{settleWorkflowToolRunCancellation}from"#execution/tools/workflow/cancel.js";async function cancelTaskOwnedWork(e){await e.cancelOwnedWork?.(e),await settleWorkflowToolRunCancellation(e.entry.address.runId,`Task ${e.entry.task.taskId} was cancelled.`)}export{cancelTaskOwnedWork};

package/dist/src/execution/tasks/parent/tool-execution.d.ts

@@ -1,45 +0,0 @@
-import type { ContextContainer } from "#context/container.js";
-import type { FrameworkContextProvider } from "#context/provider.js";
-import type { HarnessSession, StepResult } from "#harness/types.js";
-import { type BackgroundToolExecutor } from "#harness/background-tools.js";
-interface BackgroundToolStepResult {
-    readonly backgroundTaskSession: HarnessSession;
-    readonly backgroundTasks: NonNullable<StepResult["backgroundTasks"]>;
-}
-export declare function runBackgroundStep(ctx: ContextContainer, session: HarnessSession, callback: (session: HarnessSession) => Promise<StepResult>): Promise<StepResult>;
-/**
- * Makes background tool work transactional with the harness step.
- *
- * Concretely: when the model calls a background tool,
- * the tool does real external work mid-step — it creates a task run and
- * delivers commands to its inbox — while the step itself can still fail. This
- * provider scopes that work to the step so it either lands with the step or
- * is compensated with it.
- *
- * Lifetime: one {@link BackgroundToolExecutionScope} per step. `create` runs
- * before the authored callback; exactly one of `commit` or `rollback` settles
- * the scope afterwards; `decorateStepResult` runs last, only after a
- * successful commit. Nothing survives the step except retained tasks (below).
- *
- * - `commit` — step succeeded. Compensates executions that never settled
- *   (the tool neither delegated nor completed its task), then records the
- *   task entries onto the session being persisted.
- * - `rollback` — step failed. Compensates incomplete executions, and settled
- *   ones too — unless the cause is turn cancellation: those tasks are already
- *   running, so they are retained for {@link readRetainedBackgroundToolResult}
- *   instead of killed.
- * - `decorateStepResult` — attaches `backgroundTasks` and
- *   `backgroundTaskSession` to the {@link StepResult} so the turn loop keeps
- *   tracking the spawned tasks after the step returns.
- */
-export declare const backgroundToolExecutionProvider: FrameworkContextProvider<BackgroundToolExecutor>;
-/**
- * Returns what a successful commit would have produced (session with task
- * entries and executor session writes applied) when turn cancellation raced
- * a successfully delegated task. `rollback` deliberately does not compensate
- * settled records on cancellation — that would kill already-running tasks —
- * so the cancellation epilogue reads this instead to keep those tasks tracked
- * in durable state rather than orphaned. `undefined` when nothing was retained.
- */
-export declare function readRetainedBackgroundToolResult(ctx: ContextContainer): BackgroundToolStepResult | undefined;
-export {};

package/dist/src/execution/tasks/parent/tool-execution.js

@@ -1 +0,0 @@
-import{sessionCommandHookToken}from"#execution/session-inbox/address.js";import{loadContext}from"#context/container.js";import{ActivityObserverKey,CapabilitiesKey}from"#context/keys.js";import{buildCallbackContext}from"#context/build-callback-context.js";import{parseWorkflowToolInput}from"#execution/tools/workflow/background.js";import{getHarnessEmissionState}from"#harness/emission.js";import{deriveAgentOperationId}from"#subagents/handles/operation-id.js";import{getBackgroundTasks,registerWorkflowToolRun}from"#harness/workflow-tool-runs.js";import{getAgentHandleStore,writeHandles}from"#subagents/handles/store.js";import{runStep}from"#context/run-step.js";import{activeTurnId}from"#harness/active-turn-id.js";import{resolveWorkflowAgentMetadata}from"#execution/tools/subagent/metadata.js";import{AGENT_BUSY,AGENT_MISMATCH,AGENT_UNREACHABLE,formatAgentBusyMessage}from"#subagents/agent-handle-errors.js";import{startTaskRun,waitForTaskCommandOwner}from"#execution/tasks/parent/run-parent.js";import{isTurnCancellation}from"#harness/turn-cancellation.js";import{createTaskAgentDispatchContext,prepareBackgroundTask,rejectDelegatedDispatch}from"#execution/tasks/parent/delegate.js";import{applyTaskAgentHandleCommand}from"#subagents/handles/transitions.js";import{BackgroundToolExecutorKey}from"#harness/background-tools.js";import{deriveBackgroundTaskActivityObserver}from"#execution/activity-work.js";import{projectToolStartLabel}from"#harness/action-presentation.js";import{projectSubagentTask}from"#execution/tasks/parent/subagent-task-projection.js";import{steerBackgroundAgent}from"#execution/tools/subagent/steer.js";function runBackgroundStep(e,t,n){return runStep(e,t,n,[backgroundToolExecutionProvider])}const backgroundToolExecutionProvider={key:BackgroundToolExecutorKey,create(e,t){return{value:new BackgroundToolExecutionScope(t)}},async commit(e,t){return await requireExecutionScope(e).commit(t)},async rollback(e,t){await requireExecutionScope(e).rollback(t)},decorateStepResult(e,t){return requireExecutionScope(e).decorate(t)}};function readRetainedBackgroundToolResult(e){let t=e.get(BackgroundToolExecutorKey);return t instanceof BackgroundToolExecutionScope?t.retainedResult():void 0}var BackgroundToolExecutionScope=class{executions=new Map;records=[];agentHandleSession;agentHandlesChanged=!1;retained=!1;initialSession;constructor(e){this.initialSession=e,this.agentHandleSession=e}execute(e){let t=this.executions.get(e.options.toolCallId);if(t!==void 0)return t;if(!e.batch.calls.some(t=>t.callId===e.options.toolCallId))throw Error(`Background tool call "${e.options.toolCallId}" was not registered before execution.`);let n=this.start(e);return this.executions.set(e.options.toolCallId,n),n}async readAgentViews(){return(getAgentHandleStore(this.agentHandleSession.state)?.handles??[]).flatMap(e=>e.phase===`reserved`?[]:e.phase===`available`?[{availability:`available`,id:e.identity.id,name:e.identity.name}]:e.phase===`claimed`?[{availability:`busy`,id:e.identity.id,name:e.identity.name,taskId:e.ownerId,taskStatus:`working`}]:[])}hasPendingTasks(){return getBackgroundTasks(this.initialSession.state).query({state:`working`}).length>0||this.records.some(e=>e.settled&&e.task!==void 0)}async commit(e){let t=this.records.filter(e=>!e.settled);return t.length>0&&await this.compensate(t,Error(`Background tool execution did not delegate or complete its task.`)),this.apply(e)}decorate(e){let t=this.resultFields();return t===void 0?e:{...e,...t}}async rollback(e){let t=this.records.filter(e=>e.settled),n=this.records.filter(e=>!e.settled);if(n.length>0&&await this.compensate(n,e),t.length===0){this.retained=this.agentHandlesChanged&&isTurnCancellation(e);return}if(isTurnCancellation(e)){this.retained=!0;return}await this.compensate(t,e)}retainedResult(){return this.retained?this.resultFields():void 0}apply(e){let t=e;for(let e of this.records)e.settled&&e.task!==void 0&&(t=registerWorkflowToolRun(t,e.task));return this.agentHandlesChanged&&(t=writeHandles(t,getAgentHandleStore(this.agentHandleSession.state)?.handles??[])),t}resultFields(){let e=this.records.flatMap(e=>e.settled&&e.task!==void 0?[{callId:e.callId,taskInboxToken:e.task.address.hookToken,taskId:e.task.task.taskId,taskRunId:e.task.address.runId}]:[]);if(e.length!==0||this.agentHandlesChanged)return{backgroundTaskSession:this.apply(this.initialSession),backgroundTasks:e}}async start(e){let t={callId:e.options.toolCallId,settled:!1};this.records.push(t);let n=getHarnessEmissionState(this.initialSession.state),r=loadContext(),i=await this.startTask({ctx:r,emission:n,input:e,record:t});if(i.kind===`steered`)return t.settled=!0,i.receipt;let a=i.task;return t.task=a,t.settled=!0,{...i.receipt,status:`working`,taskId:a.task.taskId}}async startTask(e){let t=e.input.definition,n=parseWorkflowToolInput(e.input.toolInput,e.input.definition.name),r=activeTurnId(e.emission),i=t.nodeId===void 0?void 0:projectSubagentTask({ctx:e.ctx,input:n,name:e.input.definition.name,nodeId:t.nodeId??e.input.definition.name,taskInput:{callId:e.input.options.toolCallId,parentSessionId:this.initialSession.sessionId,parentTurnId:r}});if(i!==void 0&&i.identity===void 0&&!hasAgentHandle(this.agentHandleSession,i.metadata.agentId)){let{agentId:a,...o}=n;n=o,i=projectSubagentTask({ctx:e.ctx,input:o,name:e.input.definition.name,nodeId:t.nodeId??e.input.definition.name,taskInput:{callId:e.input.options.toolCallId,parentSessionId:this.initialSession.sessionId,parentTurnId:r}})}let a=i?.metadata??{kind:`tool`,name:e.input.definition.name},o=projectToolStartLabel(e.input.definition,e.input.toolInput),s=buildCallbackContext().session,c={activityObserver:deriveBackgroundTaskActivityObserver({activityObserver:e.ctx.get(ActivityObserverKey),callId:e.input.options.toolCallId,label:o,name:a.name,parentSessionId:this.initialSession.sessionId,parentTurnId:r,rootSessionId:this.initialSession.rootSessionId??this.initialSession.sessionId}),callId:e.input.options.toolCallId,dispatchContext:createTaskAgentDispatchContext(e.ctx,s.auth),metadata:a,parentSessionId:this.initialSession.sessionId,parentStepIndex:e.emission.stepIndex,parentTurnId:r,session:this.initialSession},l=prepareBackgroundTask(c),u={...l,task:{...l.task,activityWorkIdentity:c.activityObserver?.workIdentity}};if(t.nodeId!==void 0&&i!==void 0&&i.identity!==void 0){let t=i.identity;if(this.applyAgentHandleCommand({identity:t.identity,callId:c.callId,kind:`reserve`,operationId:t.operation.id,ownerId:u.task.taskId}).kind!==`ready`)throw Error(`Agent handle store rejected start operation "${t.operation.id}".`);e.record.reservation={agentId:t.identity.id,operationId:t.operation.id}}if(t.nodeId!==void 0&&i!==void 0&&i.identity===void 0){let t=deriveAgentOperationId({callId:c.callId,parentSessionId:c.parentSessionId,parentTurnId:r}),a=this.applyAgentHandleCommand({agentId:i.metadata.agentId,callId:c.callId,expectedTarget:i.metadata.mode,invokedName:i.metadata.name,kind:`claim`,operationId:t,ownerId:u.task.taskId});if(a.kind===`busy`&&a.handle.phase===`claimed`){let t=a.handle,r=getBackgroundTasks(this.agentHandleSession.state).get(t.ownerId);if(r?.metadata.kind===`subagent`&&r.metadata.agentId===t.identity.id&&r.metadata.name===t.identity.name&&r.status===`working`)return await steerBackgroundAgent({ctx:e.ctx,handle:t,callId:c.callId,input:n,session:this.agentHandleSession}),{kind:`steered`,receipt:{agentId:t.identity.id,taskId:r.taskId,status:`working`}}}readClaimedHandle(a)?e.record.claim={operationId:t,taskId:u.task.taskId}:throwAgentClaimError(i.metadata.agentId,a)}await startTaskRun({activityObserver:c.activityObserver,initialView:{metadata:u.task.metadata,status:`working`,taskId:u.task.taskId},parentContinuationToken:sessionCommandHookToken(this.initialSession.sessionId),taskInboxToken:u.address.hookToken,workflow:{agents:resolveWorkflowAgentMetadata(e.ctx),callId:c.callId,canRequestInput:e.ctx.get(CapabilitiesKey)?.requestInput===!0,executeInput:t.executeInput?.(n),input:n,session:s,stepIndex:e.emission.stepIndex,toolName:e.input.definition.name,workflowId:t.workflowId}});let d=await waitForTaskCommandOwner({taskInboxToken:u.address.hookToken}),f={...u,address:{...u.address,runId:d.runId}};return e.record.task=f,t.nodeId===void 0||i===void 0?{kind:`started`,task:f}:{kind:`started`,receipt:i.receipt,task:f}}applyAgentHandleCommand(e){let t=applyTaskAgentHandleCommand(this.agentHandleSession,e);return t.session!==this.agentHandleSession&&(this.agentHandleSession=t.session,this.agentHandlesChanged=!0),t.result}async compensate(e,t){let n=[];for(let r of e.toReversed()){if(r.task!==void 0)try{await rejectDelegatedDispatch({error:{code:`PARENT_STEP_FAILED`,message:t instanceof Error?t.message:String(t)},task:r.task})}catch(e){n.push(e)}r.claim!==void 0&&this.applyAgentHandleCommand({kind:`release-owner`,ownerId:r.claim.taskId}),r.reservation!==void 0&&r.task!==void 0&&this.applyAgentHandleCommand({agentId:r.reservation.agentId,kind:`remove`,ownerId:r.task.task.taskId})}if(n.length>0)throw AggregateError([t,...n],`Background tool execution failed and its tasks could not all be rejected.`,{cause:t})}};function hasAgentHandle(e,t){return getAgentHandleStore(e.state)?.handles.some(e=>e.identity.id===t)===!0}function requireExecutionScope(e){if(!(e instanceof BackgroundToolExecutionScope))throw Error(`The background tool executor is not owned by the task runtime.`);return e}function readClaimedHandle(e){return e.kind===`ready`&&e.handle?.phase===`claimed`}function throwAgentClaimError(e,t){throw t.kind===`mismatch`?Error(JSON.stringify({code:AGENT_MISMATCH,message:`Agent "${e}" no longer matches this subagent definition. Start a new agent instead.`})):t.kind===`busy`?Error(JSON.stringify({code:AGENT_BUSY,message:formatAgentBusyMessage({agentId:e,agentName:t.handle.identity.name,ownerId:`ownerId`in t.handle?t.handle.ownerId:void 0})})):Error(JSON.stringify({code:AGENT_UNREACHABLE,message:`Agent with id "${e}" is no longer reachable.`}))}export{backgroundToolExecutionProvider,readRetainedBackgroundToolResult,runBackgroundStep};

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

@@ -1,13 +0,0 @@
-import { type UnstampedMessageStreamEvent } from "#protocol/message.js";
-type TerminalSessionEvent = Extract<UnstampedMessageStreamEvent, {
-    type: "session.completed" | "session.failed";
-}>;
-/** Delivers one out-of-turn terminal event through the native instrumentation lifecycle. */
-export declare function emitTerminalSessionEvent(input: {
-    readonly errorId?: string;
-    readonly event: TerminalSessionEvent;
-    readonly sessionWritable: WritableStream<Uint8Array>;
-    readonly serializedContext: Record<string, unknown>;
-    readonly turnId?: string;
-}): Promise<void>;
-export {};

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

@@ -1 +0,0 @@
-import{createLogger}from"#internal/logging.js";import{callAdapterEventHandler}from"#channel/adapter.js";import{contextStorage}from"#context/container.js";import{ParentSessionKey}from"#context/keys.js";import{encodeMessageStreamEvent,stampMessageStreamEvent}from"#protocol/message.js";import{BundleKey,ChannelKey}from"#runtime/sessions/runtime-context-keys.js";import{deserializeContext}from"#context/serialize.js";import{buildAdapterContext}from"#channel/adapter-context.js";import{bindSessionInstrumentation}from"#instrumentation/runtime.js";const log=createLogger(`execution.workflow-entry`);async function emitTerminalSessionEvent(e){let t=e.serializedContext[`eve.sessionId`]??``,n;try{n=await deserializeContext(e.serializedContext)}catch(n){log.error(`failed to restore context for terminal ${e.event.type} event`,{error:n,errorId:e.errorId,sessionId:t})}let handleEvent=async r=>{if(n!==void 0){let i=n.get(ChannelKey);if(i!==void 0)try{await callAdapterEventHandler(i,r,buildAdapterContext(i,n))}catch(n){log.error(`adapter failed to handle terminal ${r.type} event`,{error:n,errorId:e.errorId,sessionId:t})}}try{let t=e.sessionWritable.getWriter();try{await t.write(encodeMessageStreamEvent(stampMessageStreamEvent(r)))}finally{t.releaseLock()}}catch(n){log.error(`failed to write terminal ${r.type} event to durable stream`,{error:n,errorId:e.errorId,sessionId:t})}},r;if(n!==void 0)try{let e=n.require(BundleKey);r=bindSessionInstrumentation({agentName:e.turnAgent.id,ctx:n,rootSessionId:n.get(ParentSessionKey)?.rootSessionId??t,sessionId:t})}catch(n){log.error(`failed to bind instrumentation for terminal ${e.event.type} event`,{error:n,errorId:e.errorId,sessionId:t})}let i=r?.createHandleEvent({handleEvent,turnId:e.turnId})??handleEvent;try{n===void 0?await i(e.event):await contextStorage.run(n,()=>i(e.event))}catch(n){log.error(`instrumentation failed to handle terminal ${e.event.type} event`,{error:n,errorId:e.errorId,sessionId:t})}finally{try{await r?.flush()}catch(n){log.error(`failed to flush instrumentation after terminal ${e.event.type} event`,{error:n,errorId:e.errorId,sessionId:t})}}}export{emitTerminalSessionEvent};

package/dist/src/execution/tools/ask-question-workflow.js

@@ -1 +0,0 @@
-async function executeAskQuestionTool(e,t){"use workflow";return toAskQuestionOutput(await t.ask(toAskQuestionRequest(e)))}function toAskQuestionRequest(e){let t=e.options?.map(e=>({description:e.description,id:e.label,label:e.label}));return{allowFreeform:!0,dismissible:!0,display:t===void 0?`text`:`select`,prompt:e.question,...t!==void 0&&{options:t}}}function toAskQuestionOutput(e){return e.status===`answered`?{answer:e.optionId??e.text??``,status:`answered`}:{status:e.status}}executeAskQuestionTool.workflowId=`workflow//eve@0.67.2//executeAskQuestionTool`;export{executeAskQuestionTool,toAskQuestionOutput,toAskQuestionRequest};

package/dist/src/execution/tools/ask-question.d.ts

@@ -1,19 +0,0 @@
-export { executeAskQuestionTool } from "#execution/tools/ask-question-workflow.js";
-export declare const ASK_QUESTION_TOOL_DESCRIPTION: string;
-export interface AskQuestionInput {
-    options?: {
-        description: string;
-        label: string;
-    }[];
-    question: string;
-}
-export type AskQuestionOutput = {
-    answer: string;
-    status: "answered";
-} | {
-    status: "dismissed";
-} | {
-    status: "unavailable";
-};
-export declare const ASK_QUESTION_INPUT_SCHEMA: import("#tools/schema.js").ToolSchema<AskQuestionInput, AskQuestionInput>;
-export declare const ASK_QUESTION_OUTPUT_SCHEMA: import("#tools/schema.js").ToolSchema<AskQuestionOutput, AskQuestionOutput>;

package/dist/src/execution/tools/ask-question.js

@@ -1,2 +0,0 @@
-import{defineJsonSchema}from"#tools/schema.js";import{executeAskQuestionTool}from"#execution/tools/ask-question-workflow.js";const ASK_QUESTION_TOOL_DESCRIPTION=[`Ask the user a question and wait for the answer. Use this only when you cannot make good progress without the user's input: to choose between materially different approaches, fill in a missing requirement, or confirm something risky or irreversible. Do not ask for information you can find with your other tools, and do not ask the user to confirm routine steps.`,``,`Usage:`,`- Ask one focused question that includes the context needed to answer it.`,`- For a decision, offer 2-3 mutually exclusive options. Put the option you recommend first and end its label with "(Recommended)".`,`- Do not add an "Other" option; the user can always type their own answer.`,"- The result's `answer` is the chosen option's label or the user's own words.",`- If the status is "dismissed", the user moved on without answering; respond to their next message instead.`,`- If the status is "unavailable", no one can answer in this session; continue with your best judgment and state the assumption you made.`].join(`
-`),ASK_QUESTION_INPUT_SCHEMA=defineJsonSchema({type:`object`,properties:{options:{type:`array`,minItems:2,maxItems:3,items:{type:`object`,properties:{description:{type:`string`,minLength:1,maxLength:200,description:`One short sentence on the impact or tradeoff of choosing this option.`},label:{type:`string`,minLength:1,maxLength:80,description:`User-facing label, 1-5 words.`}},required:[`description`,`label`],additionalProperties:!1},description:`Two or three mutually exclusive choices, recommended option first. Omit for an open-ended question. Never include an "Other" option.`},question:{type:`string`,minLength:1,maxLength:2e3,description:`The question to show the user, with the context needed to answer it.`}},required:[`question`],additionalProperties:!1},e=>e.options!==void 0&&new Set(e.options.map(e=>e.label)).size!==e.options.length?`Option labels must be unique.`:void 0),ASK_QUESTION_OUTPUT_SCHEMA=defineJsonSchema({oneOf:[{type:`object`,properties:{answer:{type:`string`,description:`The chosen option's label, or the user's own words.`},status:{type:`string`,const:`answered`}},required:[`answer`,`status`],additionalProperties:!1},{type:`object`,properties:{status:{type:`string`,const:`dismissed`}},required:[`status`],additionalProperties:!1},{type:`object`,properties:{status:{type:`string`,const:`unavailable`}},required:[`status`],additionalProperties:!1}]});export{ASK_QUESTION_INPUT_SCHEMA,ASK_QUESTION_OUTPUT_SCHEMA,ASK_QUESTION_TOOL_DESCRIPTION,executeAskQuestionTool};

package/dist/src/execution/tools/connection-search.d.ts

@@ -1,2 +0,0 @@
-export declare function connectionToolReplayIdentity(toolName: string): string | undefined;
-export declare function resolveConnectionSearchDynamicTools(): Promise<Record<string, object> | null>;

package/dist/src/execution/tools/connection-search.js

@@ -1,2 +0,0 @@
-import{createLogger}from"#internal/logging.js";import{loadContext}from"#context/container.js";import{toError}from"#shared/errors.js";import{defineJsonSchema}from"#tools/schema.js";import{stampDurableDynamicToolCallbacks}from"#tools/durable-callbacks.js";import{ContextKey}from"#context/key.js";import{ConnectionRegistryKey}from"#context/providers/connection-key.js";import{resolveApprovalPolicy}from"#approval/definition.js";import{getAuthorizationResults,requestAuthorization}from"#harness/authorization.js";import{createAuthorizationExecution}from"#runtime/connections/scoped-authorization.js";import{isConnectionAuthorizationFailedError,isConnectionAuthorizationRequiredError}from"#connections/errors.js";import{defineTool}from"#tools/definition.js";import{resolveConnectionAuthorization}from"#runtime/connections/resolve-authorization.js";import{supportsInteractiveAuthorization}from"#shared/connection-types.js";const logger=createLogger(`framework.connection-search-dynamic`),CONNECTION_SEARCH_INPUT_SCHEMA=defineJsonSchema({type:`object`,properties:{connection:{type:`string`,description:`Optional: limit search to a specific connection name.`},keywords:{type:`string`,description:`Search keywords and expanded aliases. Distill intent into keywords; avoid stop words like 'a', 'the', 'in'.`},limit:{type:`number`,description:`Max results to return. Default 10.`}},required:[`keywords`],additionalProperties:!1}),CONNECTION_SEARCH_OUTPUT_SCHEMA=defineJsonSchema({type:`array`,items:{type:`object`,properties:{connection:{type:`string`},description:{type:`string`},error:{type:`string`},inputSchema:{type:`object`},needsAuthorization:{type:`boolean`},outputSchema:{type:`object`},qualifiedName:{type:`string`},tool:{type:`string`}},required:[`connection`,`description`],additionalProperties:!1}}),ConnectionSearchResultsKey=new ContextKey(`eve.connectionSearchResults`);function qualifiedConnectionToolName(e,t){return`${e}__${t}`}function tokenize(e){return e.toLowerCase().split(/[\s_\-./]+/).filter(e=>e.length>1)}function scoreMatch(e,t){let n=tokenize(t.name),r=tokenize(t.description),i=0;for(let t of e){for(let e of n)(e.includes(t)||t.includes(e))&&(i+=3);for(let e of r)(e.includes(t)||t.includes(e))&&(i+=1)}return i}async function resolveInteractiveAuth(e,t){let n=e.getConnections().find(e=>e.connectionName===t);if(n===void 0)return;let r=await resolveConnectionAuthorization(n);if(r!==void 0&&supportsInteractiveAuthorization(r))return{scope:n.connectionName,instanceId:n.instanceId,connection:{url:n.url??``},authorization:r}}async function completePendingAuthorizations(e,t,n){assertPendingConnectionAuthorizationInstances(e);for(let r of t){if(!getAuthorizationResults().some(e=>e.name===r.connectionName))continue;let t=await resolveInteractiveAuth(e,r.connectionName);t!==void 0&&await n.complete(t)}}async function executeConnectionSearch(e){let t=loadContext(),n=t.get(ConnectionRegistryKey);if(n===void 0)return[];let r=e.limit??10,i=tokenize(e.keywords),a=[],o=[],s=e.connection!==void 0&&e.connection!==``?n.getConnections().filter(t=>t.connectionName===e.connection):n.getConnections();if(e.connection&&s.length===0)throw Error(`Connection "${e.connection}" is not registered. Available connections: ${n.getConnectionNames().join(`, `)}.`);let c=createAuthorizationExecution();await completePendingAuthorizations(n,s,c);let l=[];for(let e of s){let t;try{t=await n.getClient(e.connectionName).getToolMetadata()}catch(t){if(isConnectionAuthorizationRequiredError(t)){let r=await resolveInteractiveAuth(n,e.connectionName);if(r!==void 0)try{let e=await c.handleError(t,r);l.push(...e.challenges)}catch(t){let n=toError(t);logger.warn(`connection authorization failed`,{connection:e.connectionName,error:n}),o.push({connection:e.connectionName,description:e.description,error:isConnectionAuthorizationFailedError(n)?n.message:`Failed to start authorization for "${e.connectionName}": ${n.message}`});continue}o.push({connection:e.connectionName,description:e.description,needsAuthorization:!0});continue}if(isConnectionAuthorizationFailedError(t)){logger.warn(`connection authorization failed`,{connection:e.connectionName,reason:t.reason,retryable:t.retryable,error:t}),o.push({connection:e.connectionName,description:e.description,error:`Authorization failed for ${e.connectionName}: ${t.message}`});continue}let r=toError(t);logger.warn(`failed to load connection tools`,{connection:e.connectionName,error:r}),o.push({connection:e.connectionName,description:e.description,error:`Failed to load tools for "${e.connectionName}": ${r.message}`});continue}for(let n of t){let t=scoreMatch(i,n);t>0&&a.push({item:{connection:e.connectionName,description:n.description,inputSchema:n.inputSchema,outputSchema:n.outputSchema,qualifiedName:qualifiedConnectionToolName(e.connectionName,n.name),tool:n.name},score:t})}}if(l.length>0)return requestAuthorization(l);let u=o.filter(e=>e.error!==void 0);if(s.length>0&&u.length===s.length)throw Error(u.map(e=>e.error).join(`
-`));a.sort((e,t)=>t.score-e.score);let d=a.slice(0,r).map(e=>e.item);if(d.length>0){let e=[...d,...o],n=t.get(ConnectionSearchResultsKey)??[],r=new Map(n.map(e=>[e.qualifiedName,e]));for(let e of d)e.qualifiedName&&r.set(e.qualifiedName,e);return t.set(ConnectionSearchResultsKey,[...r.values()]),e}return s.map(e=>o.find(t=>t.connection===e.connectionName)||{connection:e.connectionName,description:e.description})}function connectionToolReplayIdentity(e){let t=loadContext(),n=t.get(ConnectionSearchResultsKey)?.find(t=>t.qualifiedName===e);if(n!==void 0)return t.get(ConnectionRegistryKey)?.getConnections().find(e=>e.connectionName===n.connection)?.instanceId}function assertConnectionToolInstance(e){if(typeof e.instanceId!=`string`)return;let{connectionName:t}=readDiscoveredToolClosure(e);if(loadContext().get(ConnectionRegistryKey)?.getConnections().find(e=>e.connectionName===t)?.instanceId!==e.instanceId)throw Error(`The connection for this tool call changed or is unavailable. Request a new tool call and approval.`)}function readDiscoveredToolClosure(e){let t=e.connectionName,n=e.toolName;if(typeof t!=`string`||typeof n!=`string`)throw Error(`Discovered connection tool callback metadata is invalid.`);return{connectionName:t,toolName:n}}async function executeDiscoveredConnectionTool(e,t,n){let{connectionName:r,toolName:i}=readDiscoveredToolClosure(e),a=loadContext().get(ConnectionRegistryKey);if(a===void 0)throw Error(`Connection registry is unavailable while replaying a discovered tool.`);assertConnectionToolInstance(e),assertPendingConnectionAuthorizationInstances(a);let o=await resolveInteractiveAuth(a,r),s=createAuthorizationExecution();o!==void 0&&await s.complete(o);try{return await a.getClient(r).executeTool(i,t,{abortSignal:n.abortSignal,callId:n.callId})}catch(e){return await s.handleError(e,o)}}function assertPendingConnectionAuthorizationInstances(e){let t=new Map(e.getConnections().map(e=>[e.connectionName,e]));for(let e of getAuthorizationResults())if(e.instanceId!==void 0&&t.get(e.name)?.instanceId!==e.instanceId)throw Error(`Authorization for "${e.name}" cannot complete because its resolved connection changed while sign-in was pending. Start sign-in again.`)}async function requestDiscoveredConnectionToolApproval(e,t){let{connectionName:n}=readDiscoveredToolClosure(e);assertConnectionToolInstance(e);let r=loadContext().get(ConnectionRegistryKey)?.getConnectionApproval(n);return r===void 0?`not-applicable`:await resolveApprovalPolicy(r)(t)}async function authorizeDiscoveredConnectionToolApproval(e,t){let{connectionName:n}=readDiscoveredToolClosure(e);assertConnectionToolInstance(e);let r=loadContext().get(ConnectionRegistryKey)?.getConnectionApproval(n),i=r===void 0||typeof r==`function`?void 0:r.response;return i===void 0?{reason:`Approval response authorization is unavailable.`,status:`rejected`}:await i(t)}async function resolveConnectionSearchDynamicTools(){let e=loadContext().get(ConnectionRegistryKey);if(!e||e.getConnections().length===0)return null;let t=e.getConnections(),n=t.map(e=>e.connectionName),r=new Set(n),i=(loadContext().get(ConnectionSearchResultsKey)??[]).filter(e=>r.has(e.connection)),a={},o=defineTool({description:`Search for tools across your connections. Discovered tools become directly callable by their qualified name (e.g. \`linear__list_issues\`) in your next response. Available connections: ${n.join(`, `)}.`,inputSchema:CONNECTION_SEARCH_INPUT_SCHEMA,async execute(e){return executeConnectionSearch(e)},outputSchema:CONNECTION_SEARCH_OUTPUT_SCHEMA});stampDurableDynamicToolCallbacks(o,{inputSchema:{callback:()=>CONNECTION_SEARCH_INPUT_SCHEMA,closure:{}},outputSchema:{callback:()=>CONNECTION_SEARCH_OUTPUT_SCHEMA,closure:{}},execute:{callback:(e,t)=>executeConnectionSearch(t),closure:{}}}),a.connection_search=o;for(let n of i){let r=n.connection,i=n.tool,o=e.getConnectionApproval(r),s=t.find(e=>e.connectionName===r)?.instanceId,c={connectionName:r,toolName:i};s!==void 0&&(c.instanceId=s);let l=defineTool({description:n.description,inputSchema:n.inputSchema??{type:`object`},approval:o,outputSchema:n.outputSchema,async execute(e,t){return await executeDiscoveredConnectionTool(c,e,t)}});stampDurableDynamicToolCallbacks(l,{execute:{callback:executeDiscoveredConnectionTool,closure:c},...o===void 0?{}:{approvalRequest:{callback:requestDiscoveredConnectionToolApproval,closure:c}},...o===void 0||typeof o==`function`||o.response===void 0?{}:{approvalResponse:{callback:authorizeDiscoveredConnectionToolApproval,closure:c}}}),a[qualifiedConnectionToolName(r,i)]=l}return a}export{connectionToolReplayIdentity,resolveConnectionSearchDynamicTools};

package/dist/src/execution/tools/sleep-workflow.d.ts

@@ -1,3 +0,0 @@
-import type { SleepToolInput, SleepToolOutput } from "#execution/tools/sleep.js";
-/** Waits durably in a workflow dedicated to this tool call. */
-export declare function executeSleepTool(input: SleepToolInput): Promise<SleepToolOutput>;

package/dist/src/execution/tools/sleep-workflow.js

@@ -1 +0,0 @@
-import{sleep}from"#compiled/@workflow/core/index.js";async function executeSleepTool(e){"use workflow";return await sleep(Math.ceil(e.seconds*1e3)),{waitedSeconds:e.seconds}}executeSleepTool.workflowId=`workflow//eve@0.67.2//executeSleepTool`;export{executeSleepTool};

package/dist/src/execution/tools/sleep.d.ts

@@ -1,10 +0,0 @@
-export { executeSleepTool } from "#execution/tools/sleep-workflow.js";
-export declare const SLEEP_TOOL_DESCRIPTION = "Wait for a specified amount of time before continuing. Use this when a process or condition needs time to change before it is useful to check its progress or status again.";
-export interface SleepToolInput {
-    seconds: number;
-}
-export interface SleepToolOutput {
-    waitedSeconds: number;
-}
-export declare const SLEEP_INPUT_SCHEMA: import("#tools/schema.js").ToolSchema<SleepToolInput, SleepToolInput>;
-export declare const SLEEP_OUTPUT_SCHEMA: import("#tools/schema.js").ToolSchema<SleepToolOutput, SleepToolOutput>;

package/dist/src/execution/tools/sleep.js

@@ -1 +0,0 @@
-import{defineJsonSchema}from"#tools/schema.js";import{executeSleepTool}from"#execution/tools/sleep-workflow.js";const MAX_SLEEP_SECONDS=Math.floor((2**53-1)/1e3),SLEEP_TOOL_DESCRIPTION=`Wait for a specified amount of time before continuing. Use this when a process or condition needs time to change before it is useful to check its progress or status again.`,SLEEP_INPUT_SCHEMA=defineJsonSchema({type:`object`,properties:{seconds:{type:`number`,exclusiveMinimum:0,maximum:MAX_SLEEP_SECONDS,description:`How long to wait, in seconds.`}},required:[`seconds`],additionalProperties:!1}),SLEEP_OUTPUT_SCHEMA=defineJsonSchema({type:`object`,properties:{waitedSeconds:{type:`number`,exclusiveMinimum:0}},required:[`waitedSeconds`],additionalProperties:!1});export{SLEEP_INPUT_SCHEMA,SLEEP_OUTPUT_SCHEMA,SLEEP_TOOL_DESCRIPTION,executeSleepTool};

package/dist/src/execution/tools/subagent/accept-event-step.d.ts

@@ -1,7 +0,0 @@
-import { type DurableSessionState } from "#execution/durable-session-store.js";
-import { type TaskAuthorizationEventDelivery } from "#tasks/types.js";
-/** Accepts authorization events from the workflow task itself or an agent it owns. */
-export declare function acceptTaskAuthorizationEventStep(input: {
-    readonly delivery: TaskAuthorizationEventDelivery;
-    readonly sessionState: DurableSessionState;
-}): Promise<boolean>;

package/dist/src/execution/tools/subagent/accept-event-step.js

@@ -1 +0,0 @@
-import{readDurableSession}from"#execution/durable-session-store.js";import{getBackgroundTasks}from"#harness/workflow-tool-runs.js";import{getAgentHandleStore}from"#subagents/handles/store.js";import"#tasks/types.js";async function acceptTaskAuthorizationEventStep(e){"use step";let{hookPayload:t,taskId:n}=e.delivery,r=readDurableSession(e.sessionState),i=getBackgroundTasks(r.state).get(n);if(i===void 0)return!1;if(i.metadata.kind===`tool`&&i.run.address.runId===t.childSessionId&&i.metadata.name===t.subagentName&&i.turnId===t.event.data.turnId)return t.event.type===`authorization.completed`||i.status===`working`;let a=getAgentHandleStore(r.state)?.handles??[],o=a.find(e=>e.phase===`claimed`&&e.ownerId===n&&e.identity.name===t.subagentName&&e.address.sessionId===t.childSessionId),s=a.filter(e=>e.phase===`reserved`&&e.ownerId===n&&e.identity.name===t.subagentName);return o===void 0&&s.length!==1?!1:i.status===`working`}export{acceptTaskAuthorizationEventStep};

package/dist/src/execution/tools/subagent/emit-event-step.d.ts

@@ -1,12 +0,0 @@
-import { type DurableSessionState } from "#execution/durable-session-store.js";
-import type { UnstampedMessageStreamEvent } from "#protocol/message.js";
-/** Publishes a subagent notification, then runs its hooks without model preparation. */
-export declare function emitSubagentEventStep(input: {
-    readonly event: UnstampedMessageStreamEvent;
-    readonly sessionWritable: WritableStream<Uint8Array>;
-    readonly serializedContext: Record<string, unknown>;
-    readonly sessionState: DurableSessionState;
-}): Promise<{
-    readonly serializedContext: Record<string, unknown>;
-    readonly sessionState: DurableSessionState;
-}>;

package/dist/src/execution/tools/subagent/emit-event-step.js

@@ -1 +0,0 @@
-import{contextStorage}from"#context/container.js";import{BundleKey,ChannelKey}from"#runtime/sessions/runtime-context-keys.js";import{deserializeContext,serializeContext}from"#context/serialize.js";import{createDurableSessionState,readDurableSession}from"#execution/durable-session-store.js";import{resolveEffectiveAgentRuntime}from"#execution/effective-agent-config.js";import{hydrateDurableSession}from"#execution/session.js";import{withContextScope}from"#context/run-step.js";import{dispatchStreamEventHooks}from"#context/hook-lifecycle.js";import{createSessionEventSink}from"#execution/session/event-sink.js";import{reconcileSessionContinuationToken}from"#execution/reconcile-session-continuation-token.js";async function emitSubagentEventStep(e){"use step";let t=await deserializeContext(e.serializedContext),n=t.require(BundleKey),publish=async()=>{let n=createSessionEventSink({adapter:t.require(ChannelKey),ctx:t,isFirstTurn:e.sessionState.emissionState.sequence===0,sessionWritable:e.sessionWritable,sessionId:e.sessionState.sessionId});try{return await contextStorage.run(t,()=>n.emit(e.event))}finally{n.release()}},r=n.hookRegistry;if((r.streamEventsByType.get(e.event.type)?.length??0)===0&&r.streamEventsWildcard.length===0)return await publish(),{serializedContext:serializeContext(t),sessionState:e.sessionState};let i=resolveEffectiveAgentRuntime(n,t),a=hydrateDurableSession({durable:readDurableSession(e.sessionState),turnAgent:i.turnAgent,compactionOverrides:{thresholdPercent:i.thresholdPercent}}),o=await withContextScope(t,a,async e=>{let n=await publish();return n.suppressed||await dispatchStreamEventHooks({ctx:t,registry:r,event:n.event}),{result:void 0,session:e}});return{serializedContext:serializeContext(t),sessionState:createDurableSessionState({session:reconcileSessionContinuationToken(t,o.session)})}}export{emitSubagentEventStep};

package/dist/src/execution/tools/subagent/invoke-agent.d.ts

@@ -1,42 +0,0 @@
-import type { RuntimeActionResultHookPayload, SubagentAuthorizationEventHookPayload, SubagentInputRequestHookPayload } from "#channel/types.js";
-import type { RuntimeSubagentChildResult } from "#shared/action-types.js";
-import type { JsonValue } from "#shared/json.js";
-import type { JsonObject } from "#shared/json.js";
-import type { AgentInput } from "#tools/workflow-definition.js";
-import type { ToolContext } from "#tools/definition.js";
-export type InternalAgentInput = {
-    readonly agentId?: string;
-    readonly message: string;
-    readonly outputSchema?: JsonObject;
-    readonly target: string;
-};
-/**
- * Asks the owning session to spawn an agent for a workflow tool run. Spawning
- * needs owner-held material (auth, capabilities, the agent handle
- * store) that a workflow tool body never has.
- */
-export interface AgentInvocationRequest {
-    readonly input: InternalAgentInput;
-    readonly invocationId: string;
-    readonly kind: "agent-invoke";
-}
-/**
- * Tells the owning session that an owner-spawned agent replied to the run, so
- * the owner can release the handle it reserved for `agent-invoke`.
- */
-export interface AgentSettlementRequest {
-    readonly kind: "agent-settled";
-    readonly result: RuntimeSubagentChildResult;
-}
-export type AgentInvocationEvent = SubagentAuthorizationEventHookPayload | SubagentInputRequestHookPayload;
-export type AgentInvocationReply = AgentInvocationEvent | RuntimeActionResultHookPayload | {
-    readonly kind: "agent-settled";
-    readonly callId: string;
-};
-/** Invokes an agent from a workflow tool. */
-export declare function agent(ctx: ToolContext, target: string, input: AgentInput): Promise<JsonValue>;
-/** Invokes an agent with a framework-selected replay-stable invocation id. */
-export declare function invokeAgent(ctx: ToolContext, input: InternalAgentInput, options?: {
-    readonly invocationId?: string;
-}): Promise<JsonValue>;
-export declare function validateAgentInput(input: InternalAgentInput): void;

package/dist/src/execution/tools/subagent/invoke-agent.js

@@ -1 +0,0 @@
-import{sessionCommandHookToken,sessionInboxHookToken}from"#execution/session-inbox/address.js";import{createHook}from"#compiled/@workflow/core/index.js";import{disposeHook}from"#execution/hook-ownership.js";import{resumeHookStep}from"#execution/tools/workflow/resume-hook-step.js";import{readWorkflowToolRunOwner,readWorkflowToolRunRef}from"#execution/tools/workflow/ask.js";async function agent(e,t,n){return readWorkflowToolRunRef(e),validateAgentInput({...n,target:t}),await invokeAgent(e,{agentId:n.agentId,message:n.message,outputSchema:n.outputSchema,target:t})}async function invokeAgent(e,t,n={}){validateAgentInput(t);let r=readWorkflowToolRunRef(e),i=readWorkflowToolRunOwner(e),a=createHook(),o=n.invocationId??`${e.callId}:${a.token}`;try{await resumeHookStep(i.inbox,{kind:`request`,from:r,replyTo:a.token,request:{input:t,invocationId:o,kind:`agent-invoke`}});let n=a[Symbol.asyncIterator]();for(;;){let s=await nextAgentReply(n,e.abortSignal);if(s.done)break;let c=s.value;if(c.kind===`runtime-action-result`){let s=c.results.find(e=>e.kind===`subagent-result`&&e.callId===o);if(s!==void 0){if(s.origin===`child`)for(await resumeHookStep(i.inbox,{kind:`request`,from:r,replyTo:a.token,request:{kind:`agent-settled`,result:s}});;){let r=await nextAgentReply(n,e.abortSignal);if(r.done)throw Error(`Agent "${t.target}" closed before settlement.`);if(r.value.kind===`agent-settled`&&r.value.callId===o)break}if(s.isError===!0)throw s.output;return s.output}continue}if(c.kind!==`agent-settled`){if(c.kind===`subagent-input-request`){await resumeHookStep(i.inbox,{kind:`request`,from:r,replyTo:c.childSessionInbox?.sessionId===c.childSessionId?sessionInboxHookToken(sessionCommandHookToken(c.childSessionInbox.sessionId)):c.childContinuationToken,request:{kind:`input-batch`,requests:c.event.requests},requestCoordinates:{sequence:c.event.sequence,stepIndex:c.event.stepIndex,turnId:c.event.turnId}});continue}await resumeHookStep(i.inbox,{kind:`request`,from:r,replyTo:a.token,request:{event:c,kind:`authorization-request`}})}}}finally{try{await disposeHook(a)}catch{}}throw Error(`Agent "${t.target}" closed without a result.`)}async function nextAgentReply(e,t){if(t===void 0)return await e.next();if(t.aborted)throw t.reason;let n,r=new Promise((e,t)=>{n=t}),abort=()=>n?.(t.reason);t.addEventListener(`abort`,abort,{once:!0});try{return await Promise.race([e.next(),r])}finally{t.removeEventListener(`abort`,abort)}}function validateAgentInput(e){if(typeof e.target!=`string`||e.target.trim()===``)throw TypeError(`agent() requires a non-empty agent name as its first argument.`);if(typeof e.message!=`string`||e.message.trim()===``)throw TypeError("agent() requires a non-empty `message`.");if(e.outputSchema!==void 0&&(typeof e.outputSchema!=`object`||e.outputSchema===null||Array.isArray(e.outputSchema)))throw TypeError("agent() `outputSchema` must be a JSON Schema object.")}export{agent,invokeAgent,validateAgentInput};

package/dist/src/execution/tools/subagent/invoke-preparation.d.ts

@@ -1,44 +0,0 @@
-import type { ContextReader } from "#context/key.js";
-import { type PreparedCoordinationDispatch } from "#execution/coordination-dispatch-shared.js";
-import { type DurableSessionState } from "#execution/durable-session-store.js";
-import type { RuntimeAgentDispatchRequest } from "#shared/action-types.js";
-import type { RuntimeSubagentDispatchFailure } from "#shared/action-types.js";
-import type { AgentInvocationRequest } from "#execution/tools/subagent/invoke-agent.js";
-import { type CompiledBundle } from "#runtime/sessions/runtime-context-keys.js";
-import type { DynamicRemoteAgentConfig } from "#runtime/subagents/dynamic-remote-agent-config.js";
-import { type RuntimeAgentHandleAction, type RuntimeSession } from "#subagents/handle-dispatch.js";
-import type { SubagentStartTarget } from "#execution/tools/subagent/start.js";
-type OwnerAgentDispatchPlanEntry = {
-    readonly kind: "resume";
-    readonly action: RuntimeAgentHandleAction;
-    readonly agentId: string;
-    readonly dynamicRemoteAgent?: DynamicRemoteAgentConfig;
-} | {
-    readonly kind: "reject";
-    readonly result: RuntimeSubagentDispatchFailure;
-} | {
-    readonly kind: "start";
-    readonly target: SubagentStartTarget;
-};
-/** Prepares one workflow-owner agent invocation from durable inputs. */
-export declare function prepareOwnerAgentInvocation(input: {
-    readonly invocation: AgentInvocationRequest["input"];
-    readonly invocationId: string;
-    readonly knownAgentIds?: readonly string[];
-    readonly serializedContext: Record<string, unknown>;
-    readonly sessionState: DurableSessionState;
-    readonly taskId?: string;
-}): Promise<Omit<PreparedCoordinationDispatch<OwnerAgentDispatchPlanEntry>, "sessionState">>;
-export declare function planAgentDispatch(input: {
-    readonly action: RuntimeAgentDispatchRequest;
-    readonly bundle: CompiledBundle;
-    readonly ctx: ContextReader;
-    readonly knownAgentIds?: readonly string[];
-    readonly session: RuntimeSession;
-}): OwnerAgentDispatchPlanEntry;
-export declare function resolveAgentInvocationAction(input: {
-    readonly ctx: ContextReader;
-    readonly input: AgentInvocationRequest["input"];
-    readonly invocationId: string;
-}): RuntimeAgentDispatchRequest;
-export {};

package/dist/src/execution/tools/subagent/invoke-preparation.js

@@ -1 +0,0 @@
-import{createLogger}from"#internal/logging.js";import{SessionDynamicSubagentSelectionsKey,TurnDynamicSubagentSelectionsKey}from"#context/keys.js";import{BundleKey}from"#runtime/sessions/runtime-context-keys.js";import{getHarnessEmissionState}from"#harness/emission.js";import{deserializeContext}from"#context/serialize.js";import{readDurableSession}from"#execution/durable-session-store.js";import{getBackgroundTasks}from"#harness/workflow-tool-runs.js";import{getAgentHandleStore}from"#subagents/handles/store.js";import{getDynamicSubagentSelection}from"#context/dynamic-subagent-lifecycle.js";import{activeTurnId}from"#harness/active-turn-id.js";import{prepareActionDispatch}from"#execution/coordination-dispatch-shared.js";import{ROOT_RUNTIME_AGENT_NODE_ID}from"#runtime/graph.js";import{AGENT_TOOL_DESCRIPTION,AGENT_TOOL_NAME}from"#tools/framework/agent-contract.js";import{isAgentHandleAction}from"#subagents/handle-dispatch.js";import{createRecursiveAgentRootOnlyResult,createUnavailableDynamicSubagentResult,getSubagentName}from"#execution/dispatch-action-failures.js";const log=createLogger(`execution.agent-invocation`);async function prepareOwnerAgentInvocation(e){let t=readDurableSession(e.sessionState),n=await deserializeContext(e.serializedContext),r=getHarnessEmissionState(t.state),i=e.taskId===void 0?void 0:getBackgroundTasks(t.state).get(e.taskId)?.run,a=resolveAgentInvocationAction({ctx:n,input:e.invocation,invocationId:e.invocationId});return await prepareActionDispatch({batch:{requests:[a],event:{...r,stepIndex:i?.origin.stepIndex??r.stepIndex,turnId:i?.origin.turnId??activeTurnId(r)}},ctx:n,durableSession:t,fanoutSize:1,plan:({bundle:t,ctx:n,session:r})=>[planAgentDispatch({action:a,bundle:t,ctx:n,knownAgentIds:e.knownAgentIds,session:r})],planReusesOwnerSandbox:({bundle:e,plan:t})=>ownerPlanReusesSandbox({bundle:e,plan:t}),serializedContext:e.serializedContext})}function planAgentDispatch(e){let t=new Set(e.knownAgentIds??(getAgentHandleStore(e.session.state)?.handles??[]).map(e=>e.identity.id)),n=e.action.input.agentId,r=typeof n==`string`&&n.trim()!==``?n:void 0;if(r!==void 0&&isAgentHandleAction(e.action)){if(t.has(r)){let t=e.bundle.subagentRegistry.dynamicNodeIds?.has(e.action.nodeId)===!0?getDynamicSubagentSelection(e.ctx,e.action.nodeId):void 0;return{action:e.action,agentId:r,dynamicRemoteAgent:e.action.kind===`remote-agent-call`&&t?.kind===`remote`?t.remoteAgent:void 0,kind:`resume`}}log.warn(`unknown agentId on subagent call; starting a new agent`,{agentId:r,callId:e.action.callId})}return classifyFreshStart(e)}function classifyFreshStart(e){let{action:t}=e,n=e.bundle.subagentRegistry.subagentsByNodeId,r=e.bundle.subagentRegistry.dynamicNodeIds?.has(t.nodeId)===!0,i=r?getDynamicSubagentSelection(e.ctx,t.nodeId):void 0;if(r&&(i===void 0||t.kind===`subagent-call`&&i.kind!==`subagent`||t.kind===`remote-agent-call`&&i.kind!==`remote`))return log.warn(`dynamic subagent call blocked after availability changed`,{callId:t.callId,nodeId:t.nodeId,subagentName:getSubagentName(t)}),{kind:`reject`,result:createUnavailableDynamicSubagentResult(t)};if(isRecursiveAgentAction(t,n)&&e.session.rootSessionId!==void 0)return log.warn(`recursive agent call blocked outside the root session`,{callId:t.callId,nodeId:t.nodeId,rootSessionId:e.session.rootSessionId,subagentName:t.subagentName}),{kind:`reject`,result:createRecursiveAgentRootOnlyResult(t)};if(t.kind===`remote-agent-call`)return{kind:`start`,target:{action:t,dynamicRemoteAgent:i?.kind===`remote`?i.remoteAgent:void 0,kind:`remote`}};let a=i?.kind===`subagent`?i.agentConfig:void 0,o=n.get(t.nodeId),s=a?.description??(o?.definition.kind===`subagent`?o.definition.description:void 0);return{kind:`start`,target:{action:t,dynamicSubagentAgentConfig:a,kind:`local`,source:s===void 0?{type:`runtime`}:{description:s,type:`local`}}}}function ownerPlanReusesSandbox(e){return e.plan.some(t=>{if(t.kind!==`start`||t.target.kind!==`local`)return!1;let n=t.target.action;return n.subagentName===`agent`&&!e.bundle.subagentRegistry.subagentsByNodeId.has(n.nodeId)||e.bundle.graph?.nodesByNodeId.get(n.nodeId)?.sandboxRegistry.sandbox.definition.kind===`parent`})}function isRecursiveAgentAction(e,t){return e.kind===`subagent-call`&&e.subagentName===`agent`&&!t.has(e.nodeId)}function resolveAgentInvocationAction(e){let t=e.ctx.require(BundleKey),n=t.subagentRegistry.subagentsByName.get(e.input.target),r=n===void 0?Object.values({...e.ctx.get(SessionDynamicSubagentSelectionsKey),...e.ctx.get(TurnDynamicSubagentSelectionsKey)}).find(t=>t!==null&&t.prepared?.name===e.input.target):void 0,i=n?.definition??r?.prepared??(e.input.target===AGENT_TOOL_NAME&&t.nodeId===void 0?{description:AGENT_TOOL_DESCRIPTION,kind:`subagent`,name:AGENT_TOOL_NAME,nodeId:ROOT_RUNTIME_AGENT_NODE_ID}:void 0);if(i===void 0)throw Error(`Agent target "${e.input.target}" is not available to this agent.`);let a={message:e.input.message};e.input.agentId!==void 0&&(a.agentId=e.input.agentId),e.input.outputSchema!==void 0&&(a.outputSchema=e.input.outputSchema);let o={callId:e.invocationId,description:i.description??``,input:a,name:i.name,nodeId:i.nodeId};return i.kind===`remote`?{...o,kind:`remote-agent-call`,remoteAgentName:i.name}:{...o,kind:`subagent-call`,subagentName:i.name}}export{planAgentDispatch,prepareOwnerAgentInvocation,resolveAgentInvocationAction};