eve 0.67.2 → 0.69.0

package/dist/src/execution/tasks/table.d.ts

@@ -0,0 +1,192 @@
+import type { TaskCancelResult, TaskWaitResult } from "#execution/tasks/calls.js";
+import type { WorkflowToolRunCall } from "#execution/tools/workflow/messages.js";
+import type { SessionStateMap } from "#harness/types.js";
+import type { JsonValue } from "#shared/json.js";
+import type { TokenUsage } from "#shared/token-usage.js";
+import type { TaskCancelReason, TaskStartedStreamEvent } from "#protocol/message.js";
+/** At most this many tasks work at once in one session: a backstop normal use shouldn't reach. */
+export declare const MAX_WORKING_TASKS = 32;
+export interface TaskRunAddress {
+    readonly hookToken: string;
+    readonly runId: string;
+}
+/** The workflow run doing a task's work. `started` once its control hook can take commands. */
+export interface TaskRun extends TaskRunAddress {
+    readonly started: boolean;
+    /** The run's delegated spend the session counted so far, which later totals count from. */
+    readonly usage?: TokenUsage;
+}
+/** A call the task admitted and hasn't settled, with the turn that made it. */
+export interface TaskCall {
+    readonly callId: string;
+    readonly turnId: string;
+}
+/**
+ * A command for a task's run. Commands go over the run's one control hook, so
+ * the run sees calls and cancels in the order the session issued them.
+ */
+export type TaskRunCommand = {
+    readonly kind: "cancel";
+} | {
+    readonly call: WorkflowToolRunCall;
+    readonly kind: "call";
+};
+/** Commands for one run, to send in order. */
+export interface TaskRunCommands {
+    readonly commands: readonly TaskRunCommand[];
+    readonly run: TaskRunAddress;
+}
+/** How a task call ended, as `task.settled` reports it. */
+export type TaskOutcome = {
+    readonly output: JsonValue;
+    readonly status: "completed";
+} | {
+    readonly error: string;
+    readonly status: "failed";
+} | {
+    readonly reason?: TaskCancelReason;
+    readonly status: "cancelled";
+};
+/**
+ * An outcome the model receives, one per reply or run end, however many calls
+ * it settled. Cancelled work never reports back.
+ */
+export type TaskResult = Exclude<TaskOutcome, {
+    readonly status: "cancelled";
+}>;
+export interface TaskRecord {
+    readonly id: string;
+    /** Whether the tool is an agent's, as `task.started` reports it. */
+    readonly kind: TaskStartedStreamEvent["data"]["kind"];
+    /** The tool whose call started the task. */
+    readonly name: string;
+    /** A `serve` tool's task: it takes more calls by its id, and is idle between results. */
+    readonly resumable: boolean;
+    /** Calls without a result. The task is working while any remain. */
+    readonly calls: readonly TaskCall[];
+    /** Results not yet delivered to the model. */
+    readonly results: readonly TaskResult[];
+    /** The task's run, from its start until it finishes. */
+    readonly run?: TaskRun;
+    /** Commands issued before the run could take them, sent in order once it reports started. */
+    readonly held?: readonly TaskRunCommand[];
+}
+export interface TaskTable {
+    readonly tasks: readonly TaskRecord[];
+}
+export declare function readTaskTable(state: SessionStateMap | undefined): TaskTable;
+export declare function writeTaskTable<T extends {
+    readonly state?: SessionStateMap;
+}>(session: T, table: TaskTable): T;
+export declare function findTask(table: TaskTable, taskId: string): TaskRecord | undefined;
+export declare function isTaskWorking(record: TaskRecord): boolean;
+export declare function workingTasks(table: TaskTable): readonly TaskRecord[];
+/**
+ * The most recently used idle resumable tasks, oldest first. The table keeps
+ * records in order of use, so the last ones are the most recent.
+ */
+export declare function idleTasks(table: TaskTable): readonly TaskRecord[];
+/**
+ * Whether a call may reach the task by its id: the task is resumable and
+ * unfinished, and was started by this tool.
+ */
+export declare function isTaskAvailable(record: TaskRecord | undefined, toolName: string): record is TaskRecord & {
+    readonly run: TaskRun;
+};
+/** Tasks whose results the model has not received yet. */
+export declare function tasksWithResults(table: TaskTable): readonly TaskRecord[];
+/**
+ * What a wait on the turn's tasks returns now, or `undefined` to keep
+ * waiting. A waiting result, or nothing left working, ends it first;
+ * cancelled work never does.
+ */
+export declare function taskWaitResult(table: TaskTable, wake: {
+    readonly interrupted: boolean;
+    readonly timedOut: boolean;
+}): TaskWaitResult | undefined;
+/**
+ * What `task_cancel` answers, or `undefined` for a task that doesn't exist.
+ * `cancelled` means the caller cancels the working task.
+ */
+export declare function taskCancelResult(table: TaskTable, taskId: string): TaskCancelResult | undefined;
+/** Runs that may still be doing work, including cancelled runs that haven't confirmed yet. */
+export declare function liveTaskRuns(table: TaskTable): readonly TaskRunAddress[];
+/** Records a task for a call the model just made, with a new id. */
+export declare function createTask(table: TaskTable, input: {
+    readonly callId: string;
+    readonly kind: TaskRecord["kind"];
+    readonly name: string;
+    readonly resumable: boolean;
+    readonly turnId: string;
+}): {
+    readonly table: TaskTable;
+    readonly taskId: string;
+};
+/** Drops a task that never started, such as one past the cap. */
+export declare function removeTask(table: TaskTable, taskId: string): TaskTable;
+export declare function recordTaskRun(table: TaskTable, taskId: string, run: TaskRunAddress): TaskTable;
+/**
+ * The run can take commands now. Commands issued before this were held on the
+ * record; they are returned, in order, so the caller sends them.
+ */
+export declare function markTaskRunStarted(table: TaskTable, taskId: string, runId: string): {
+    readonly held?: TaskRunCommands;
+    readonly table: TaskTable;
+};
+/**
+ * Records a call that reaches an available task by its id: the task is
+ * working until the call has a result. The call goes to a started run now, or
+ * is held until the run reports started. The record moves to the end of the
+ * table, which keeps records in order of use.
+ */
+export declare function recordTaskCall(table: TaskTable, taskId: string, call: WorkflowToolRunCall): {
+    readonly send?: TaskRunCommands;
+    readonly table: TaskTable;
+};
+/**
+ * Settles calls that share one outcome, as one reply does, in one step. Each
+ * call settles once, with its own `task.settled`; the first outcome wins, so a
+ * call already settled, including one its owner cancelled, is dropped. The
+ * model receives the outcome once, since every call it settles would repeat it.
+ */
+export declare function settleTaskCalls(table: TaskTable, input: {
+    readonly callIds: readonly string[];
+    readonly outcome: TaskOutcome;
+    readonly taskId: string;
+}): {
+    readonly settled: readonly TaskCall[];
+    readonly table: TaskTable;
+};
+/**
+ * Settles every call still without a result with one outcome, as a run's
+ * return or failure does: a task's one call, or every call a resumable task
+ * received, or never received, since its last reply.
+ */
+export declare function settleRemainingTaskCalls(table: TaskTable, taskId: string, outcome: TaskOutcome): {
+    readonly settled: readonly TaskCall[];
+    readonly table: TaskTable;
+};
+/** Records the run's delegated spend the session just counted. */
+export declare function recordTaskRunUsage(table: TaskTable, taskId: string, usage: TokenUsage): TaskTable;
+/** The task's run finished; nothing is left to cancel. */
+export declare function finishTaskRun(table: TaskTable, taskId: string, runId: string): TaskTable;
+/** What cancelling a task changed, and the command to send its run, if any. */
+export interface TaskCancellation {
+    readonly send?: TaskRunCommands;
+    readonly settled: readonly TaskCall[];
+    readonly table: TaskTable;
+}
+/**
+ * Cancels a task's current work: its calls settle as cancelled and never
+ * report back, and a live run is told to stop. A run that hasn't started
+ * holds the cancel. A resumable task stays available and becomes idle.
+ */
+export declare function cancelTask(table: TaskTable, taskId: string): TaskCancellation;
+/**
+ * Hands every undelivered result to the model, which receives each
+ * once: `taken` is each record with its results, before they were cleared.
+ */
+export declare function takeTaskResults(table: TaskTable): {
+    readonly taken: readonly TaskRecord[];
+    readonly table: TaskTable;
+};

package/dist/src/execution/tasks/table.js

@@ -0,0 +1 @@
+import{isNonEmptyString,isObject}from"#shared/guards.js";import{UNREADABLE_TASK_ERROR}from"#execution/tasks/render.js";const TASK_TABLE_STATE_KEY=`eve.taskTable`,MAX_WORKING_TASKS=32,EMPTY_TABLE={tasks:[]};function readTaskTable(e){let t=e?.[TASK_TABLE_STATE_KEY];return!isObject(t)||t.version!==1||!Array.isArray(t.tasks)?EMPTY_TABLE:{tasks:Array.from(t.tasks).flatMap(e=>{let t=decodeTaskRecord(e);return t===void 0?[]:[t]})}}function writeTaskTable(e,t){let n=pruneFinishedRecords(t.tasks);if(n.length===0){let t={...e.state};return delete t[TASK_TABLE_STATE_KEY],{...e,state:Object.keys(t).length===0?void 0:t}}let r={tasks:n,version:1};return{...e,state:{...e.state,[TASK_TABLE_STATE_KEY]:r}}}function findTask(e,t){return e.tasks.find(e=>e.id===t)}function isTaskWorking(e){return e.calls.length>0}function workingTasks(e){return e.tasks.filter(isTaskWorking)}function idleTasks(e){return e.tasks.filter(isResumableTaskIdle).slice(-10)}function isTaskAvailable(e,t){return e!==void 0&&e.resumable&&e.run!==void 0&&e.name===t}function tasksWithResults(e){return e.tasks.filter(e=>e.results.length>0)}function taskWaitResult(e,t){let n=tasksWithResults(e).map(e=>({id:e.id,status:e.results.at(-1).status})),r=workingTasks(e).map(e=>e.id);if(n.length>0||r.length===0)return{settled:n,status:`settled`,working:r};if(t.interrupted)return{status:`interrupt`,working:r};if(t.timedOut)return{status:`timeout`,working:r}}function taskCancelResult(e,t){let n=findTask(e,t);if(n!==void 0)return{resumable:n.resumable,status:isTaskWorking(n)?`cancelled`:`already_finished`,tool:n.name}}function liveTaskRuns(e){return e.tasks.flatMap(e=>e.run===void 0?[]:[toRunAddress(e.run)])}function createTask(e,t){let n=createTaskId(e,t.name),r={calls:[{callId:t.callId,turnId:t.turnId}],id:n,kind:t.kind,name:t.name,results:[],resumable:t.resumable};return{table:{...e,tasks:[...e.tasks,r]},taskId:n}}function removeTask(e,t){return{...e,tasks:e.tasks.filter(e=>e.id!==t)}}function recordTaskRun(e,t,n){return updateTask(e,t,e=>({...e,run:{...n,started:!1}}))}function markTaskRunStarted(e,t,n){let r=findTask(e,t);if(r?.run===void 0||r.run.runId!==n||r.run.started)return{table:e};let i={...r.run,started:!0},a=updateTask(e,t,e=>{let{held:t,...n}=e;return{...n,run:i}});return r.held===void 0?{table:a}:{held:{commands:r.held,run:toRunAddress(i)},table:a}}function recordTaskCall(e,t,n){let r=findTask(e,t);if(r?.run===void 0)return{table:e};let i={call:n,kind:`call`},a=r.run,o={callId:n.callId,turnId:n.turnId},s={...r,calls:[...r.calls,o]};a.started||(s={...s,held:[...r.held??[],i]});let c={...e,tasks:[...removeTask(e,t).tasks,s]};return a.started?{send:{commands:[i],run:toRunAddress(a)},table:c}:{table:c}}function settleTaskCalls(e,t){let n=new Set(t.callIds),r=(findTask(e,t.taskId)?.calls??[]).filter(e=>n.has(e.callId));if(r.length===0)return{settled:r,table:e};let{outcome:i}=t;return{settled:r,table:updateTask(e,t.taskId,e=>({...e,calls:e.calls.filter(e=>!n.has(e.callId)),results:i.status===`cancelled`?e.results:[...e.results,i]}))}}function settleRemainingTaskCalls(e,t,n){return settleTaskCalls(e,{callIds:findTask(e,t)?.calls.map(e=>e.callId)??[],outcome:n,taskId:t})}function recordTaskRunUsage(e,t,n){return updateTask(e,t,e=>e.run===void 0?e:{...e,run:{...e.run,usage:n}})}function finishTaskRun(e,t,n){return updateTask(e,t,e=>{if(e.run?.runId!==n)return e;let{held:t,run:r,...i}=e;return i})}function cancelTask(e,t){let n=findTask(e,t);if(n===void 0)return{settled:[],table:e};if(n.resumable)return cancelResumableTask(e,n);let r=cancelledCalls(n),i=n.run,a=updateTask(e,t,e=>{let t={...e,calls:[]};return i===void 0||i.started?t:{...t,held:[{kind:`cancel`}]}});return i===void 0||!i.started?{settled:r,table:a}:{send:cancelCommand(i),settled:r,table:a}}function cancelResumableTask(e,t){let n=t.run;if(n===void 0||!isTaskWorking(t))return{settled:[],table:e};let r=cancelledCalls(t),i=updateTask(e,t.id,e=>{let t={...e,calls:[]};return n.started?t:{...t,held:[{kind:`cancel`}]}});return n.started?{send:cancelCommand(n),settled:r,table:i}:{settled:r,table:i}}function cancelCommand(e){return{commands:[{kind:`cancel`}],run:toRunAddress(e)}}function takeTaskResults(e){let t=tasksWithResults(e),n=e.tasks.map(e=>t.includes(e)?{...e,results:[]}:e);return{table:{...e,tasks:n},taken:t}}function updateTask(e,t,n){return{...e,tasks:e.tasks.map(e=>e.id===t?n(e):e)}}function cancelledCalls(e){return e.run===void 0?[]:e.calls}function toRunAddress(e){return{hookToken:e.hookToken,runId:e.runId}}function createTaskId(e,t){for(;;){let n=crypto.getRandomValues(new Uint8Array(6)),r=`${t}-${Array.from(n,e=>`0123456789abcdefghjkmnpqrstvwxyz`[e%32]).join(``)}`;if(findTask(e,r)===void 0)return r}}function isResumableTaskIdle(e){return e.resumable&&e.run!==void 0&&!isTaskWorking(e)}function isFinishedRecord(e){return e.calls.length===0&&e.results.length===0&&e.run===void 0}function pruneFinishedRecords(e){let t=e.filter(isFinishedRecord),n=t.length-100;if(n<=0)return e;let r=new Set(t.slice(0,n));return e.filter(e=>!r.has(e))}function decodeTaskRecord(e){if(isTaskRecord(e))return e;if(isObject(e)&&isNonEmptyString(e.id)&&isNonEmptyString(e.name))return{calls:[],id:e.id,kind:e.kind===`agent`?`agent`:`tool`,name:e.name,results:[{error:UNREADABLE_TASK_ERROR,status:`failed`}],resumable:!1}}function isTaskRecord(e){return isObject(e)&&isNonEmptyString(e.id)&&isNonEmptyString(e.name)&&(e.kind===`agent`||e.kind===`tool`)&&typeof e.resumable==`boolean`&&Array.isArray(e.calls)&&Array.from(e.calls).every(isTaskCall)&&Array.isArray(e.results)&&Array.from(e.results).every(isTaskResult)&&(e.run===void 0||isTaskRun(e.run))&&(e.held===void 0||Array.isArray(e.held)&&Array.from(e.held).every(isTaskRunCommand))}function isTaskRunCommand(e){return isObject(e)?e.kind===`cancel`||e.kind===`call`&&isObject(e.call)&&isNonEmptyString(e.call.callId):!1}function isTaskResult(e){return isObject(e)?e.status===`completed`?`output`in e:e.status===`failed`&&typeof e.error==`string`:!1}function isTaskRun(e){return isObject(e)&&isNonEmptyString(e.runId)&&isNonEmptyString(e.hookToken)&&typeof e.started==`boolean`&&(e.usage===void 0||isObject(e.usage))}function isTaskCall(e){return isObject(e)&&isNonEmptyString(e.callId)&&typeof e.turnId==`string`}export{MAX_WORKING_TASKS,cancelTask,createTask,findTask,finishTaskRun,idleTasks,isTaskAvailable,isTaskWorking,liveTaskRuns,markTaskRunStarted,readTaskTable,recordTaskCall,recordTaskRun,recordTaskRunUsage,removeTask,settleRemainingTaskCalls,settleTaskCalls,takeTaskResults,taskCancelResult,taskWaitResult,tasksWithResults,workingTasks,writeTaskTable};

package/dist/src/execution/tasks/task-id-input.d.ts

@@ -0,0 +1,19 @@
+import type { HarnessToolDefinition } from "#harness/execute-tool.js";
+import type { JsonObject } from "#shared/json.js";
+import { type ToolSchema } from "#tools/schema.js";
+/** The model input property eve adds to every `serve` tool. */
+export declare const TASK_ID_INPUT = "taskId";
+/** A `serve` tool's input schema as the model sees it, with the optional `taskId`. */
+export declare function withTaskIdSchema(schema: ToolSchema): ToolSchema;
+/**
+ * The tool as the model sees it: its input gains `taskId`, and its description
+ * explains it. An agent tool also gets its activity label, the agent and the
+ * first sentence of its message: `researcher: Find the March incidents`.
+ */
+export declare function withTaskIdInput(definition: HarnessToolDefinition): HarnessToolDefinition;
+/** A `serve` tool call's model input, split into the task it names and the tool's own input. */
+export interface ServeCallInput {
+    readonly input: JsonObject;
+    readonly taskId?: string;
+}
+export declare function splitTaskIdInput(modelInput: JsonObject): ServeCallInput;

package/dist/src/execution/tasks/task-id-input.js

@@ -0,0 +1 @@
+import{firstSentence}from"#shared/presentation-text.js";import{isToolSchema,withOptionalStringProperty}from"#tools/schema.js";import{AGENT_SERVE_TOOL_DESCRIPTION,SERVE_TOOL_DESCRIPTION,TASK_ID_INPUT_DESCRIPTION}from"#execution/tasks/render.js";import{AGENT_TOOL_NAME}from"#tools/framework/agent-contract.js";import{isAgentTool}from"#execution/tasks/tool-entry-point.js";const TASK_ID_INPUT=`taskId`;function withTaskIdSchema(e){return withOptionalStringProperty(e,{description:TASK_ID_INPUT_DESCRIPTION,name:TASK_ID_INPUT})}function withTaskIdInput(e){let t=e.inputSchema;if(!isToolSchema(t))throw Error(`Tool "${e.name}" has no input schema eve can add taskId to.`);let n=isAgentTool(e),r={...e,description:appendSentence(e.description,n?AGENT_SERVE_TOOL_DESCRIPTION:SERVE_TOOL_DESCRIPTION),inputSchema:withTaskIdSchema(t)};return!n||e.label?.start!==void 0?r:{...r,label:{...e.label,start:t=>agentCallLabel(e.name,t)}}}function agentCallLabel(e,t){let n=typeof t==`object`&&t?t.message:void 0,r=typeof n==`string`?firstSentence(n):void 0;return r===void 0?e:e===AGENT_TOOL_NAME?r:`${e}: ${r}`}function splitTaskIdInput(e){let{[TASK_ID_INPUT]:t,...n}=e;return typeof t==`string`?{input:n,taskId:t}:{input:n}}function appendSentence(e,t){let n=e.trimEnd();return n===``?t:`${n} ${t}`}export{TASK_ID_INPUT,splitTaskIdInput,withTaskIdInput,withTaskIdSchema};

package/dist/src/execution/tasks/tool-entry-point.d.ts

@@ -0,0 +1,11 @@
+import type { HarnessToolDefinition } from "#harness/execute-tool.js";
+import type { WorkflowToolEntryPoint } from "#tools/workflow-entry-point.js";
+/**
+ * The entry point a deferred tool's calls run through. Every agent tool is a
+ * `serve` tool; tools that dispatch nowhere are called like `execute`.
+ */
+export declare function entryPointOf(definition: HarnessToolDefinition | undefined): WorkflowToolEntryPoint;
+/** Whether calls to the tool run as tasks: every call to an agent, `task`, or `serve` tool. */
+export declare function startsTasks(definition: HarnessToolDefinition | undefined): boolean;
+/** Whether the tool is an agent: a declared, remote, dynamic, or root-copy agent. */
+export declare function isAgentTool(definition: HarnessToolDefinition | undefined): boolean;

package/dist/src/execution/tasks/tool-entry-point.js

@@ -0,0 +1 @@
+function entryPointOf(e){let t=dispatchTargetOf(e);return t===void 0?`execute`:t.kind===`workflow-tool-call`?t.entryPoint:`serve`}function startsTasks(e){return entryPointOf(e)!==`execute`}function isAgentTool(e){let t=dispatchTargetOf(e);return t!==void 0&&t.kind!==`workflow-tool-call`}function dispatchTargetOf(e){let t=e?.behavior?.handling;if(t?.kind===`dispatch`)return t.target}export{entryPointOf,isAgentTool,startsTasks};

package/dist/src/execution/tasks/workflow-target.d.ts

@@ -1,2 +1,4 @@
 /** Whether a workflow hook or run can no longer accept task traffic. */
 export declare function isTaskWorkflowTargetGone(error: unknown): boolean;
+/** Awaits traffic to a workflow hook or run, which a target already gone makes moot. */
+export declare function ignoreGoneTarget(pending: Promise<unknown>): Promise<void>;

package/dist/src/execution/tasks/workflow-target.js

@@ -1 +1 @@
-import{walkCauseChain}from"#shared/errors.js";import{EntityConflictError,HookNotFoundError,RunExpiredError,WorkflowRunNotFoundError}from"#compiled/@workflow/errors/index.js";function isTaskWorkflowTargetGone(e){for(let t of walkCauseChain(e))if(HookNotFoundError.is(t)||WorkflowRunNotFoundError.is(t)||RunExpiredError.is(t)||EntityConflictError.is(t))return!0;return!1}export{isTaskWorkflowTargetGone};
+import{walkCauseChain}from"#shared/errors.js";import{EntityConflictError,HookNotFoundError,RunExpiredError,WorkflowRunNotFoundError}from"#compiled/@workflow/errors/index.js";function isTaskWorkflowTargetGone(e){for(let t of walkCauseChain(e))if(HookNotFoundError.is(t)||WorkflowRunNotFoundError.is(t)||RunExpiredError.is(t)||EntityConflictError.is(t))return!0;return!1}async function ignoreGoneTarget(e){try{await e}catch(e){if(!isTaskWorkflowTargetGone(e))throw e}}export{ignoreGoneTarget,isTaskWorkflowTargetGone};

package/dist/src/execution/terminal-session-completion-step.js

@@ -1 +1 @@
-import{createSessionCompletedEvent}from"#protocol/message.js";import{emitTerminalSessionEvent}from"#execution/terminal-session-event.js";async function emitTerminalSessionCompletionStep(e){"use step";await emitTerminalSessionEvent({...e,event:createSessionCompletedEvent()})}export{emitTerminalSessionCompletionStep};
+import{createSessionCompletedEvent}from"#protocol/message.js";import{publishTerminalSessionEvent}from"#execution/publish-session-events.js";async function emitTerminalSessionCompletionStep(e){"use step";await publishTerminalSessionEvent({...e,event:createSessionCompletedEvent()})}export{emitTerminalSessionCompletionStep};

package/dist/src/execution/terminal-session-failure-step.js

@@ -1 +1 @@
-import{createLogger,formatError}from"#internal/logging.js";import{createSessionFailedEvent}from"#protocol/message.js";import{summarizeKnownError}from"#harness/semantic-errors/index.js";import{emitTerminalSessionEvent}from"#execution/terminal-session-event.js";const log=createLogger(`execution.workflow-entry`);async function emitTerminalSessionFailureStep(e){"use step";let t=formatError(e.error),n=summarizeKnownError(e.error),r=t;if(n!==null){let e={...t,message:n.message,name:n.name,semanticErrorId:n.id};r=n.hint===void 0?e:{...e,hint:n.hint}}let i=typeof r.name==`string`?r.name:`WORKFLOW_EXECUTION_FAILED`,a=typeof r.message==`string`?r.message:String(e.error),o=e.serializedContext[`eve.sessionId`]??``;log.error(`workflow loop threw — emitting terminal session.failed`,{sessionId:o,errorId:typeof r.errorId==`string`?r.errorId:void 0,code:i}),await emitTerminalSessionEvent({errorId:typeof r.errorId==`string`?r.errorId:void 0,event:createSessionFailedEvent({code:i,details:r,message:a,sessionId:o}),sessionWritable:e.sessionWritable,serializedContext:e.serializedContext,turnId:e.turnId})}export{emitTerminalSessionFailureStep};
+import{createLogger,formatError}from"#internal/logging.js";import{createSessionFailedEvent}from"#protocol/message.js";import{summarizeKnownError}from"#harness/semantic-errors/index.js";import{publishTerminalSessionEvent}from"#execution/publish-session-events.js";const log=createLogger(`execution.workflow-entry`);async function emitTerminalSessionFailureStep(e){"use step";let t=formatError(e.error),n=summarizeKnownError(e.error),r=t;if(n!==null){let e={...t,message:n.message,name:n.name,semanticErrorId:n.id};r=n.hint===void 0?e:{...e,hint:n.hint}}let i=typeof r.name==`string`?r.name:`WORKFLOW_EXECUTION_FAILED`,a=typeof r.message==`string`?r.message:String(e.error),o=e.serializedContext[`eve.sessionId`]??``;log.error(`workflow loop threw — emitting terminal session.failed`,{sessionId:o,errorId:typeof r.errorId==`string`?r.errorId:void 0,code:i}),await publishTerminalSessionEvent({errorId:typeof r.errorId==`string`?r.errorId:void 0,event:createSessionFailedEvent({code:i,details:r,message:a,sessionId:o}),sessionWritable:e.sessionWritable,serializedContext:e.serializedContext,turnId:e.turnId})}export{emitTerminalSessionFailureStep};

package/dist/src/execution/terminate-child-sessions-step.d.ts

@@ -1,15 +1,8 @@
 import { type DurableSessionState } from "#execution/durable-session-store.js";
 /**
- * Terminates children the parent holds handles to when the parent session
- * ends.
- *
- * Every nonterminal `agent/local`/`agent/self` handle is covered: `running`
- * and `parked` handles carry a confirmed address; a `starting` handle has
- * no session id yet (the child may not exist), so it is skipped with a
- * debug log rather than guessed at. Remote handles are retired through the
- * authenticated session-reset route.
+ * Session end ends every task, including cancelled runs that haven't
+ * confirmed yet. Each run ends the agent sessions it opened.
  */
 export declare function terminateChildSessionsStep(input: {
-    readonly serializedContext?: Record<string, unknown>;
     readonly sessionState: DurableSessionState;
 }): Promise<void>;

package/dist/src/execution/terminate-child-sessions-step.js

@@ -1 +1 @@
-import{createLogger,logError}from"#internal/logging.js";import{BundleKey}from"#runtime/sessions/runtime-context-keys.js";import{cancelRun,getWorld}from"#internal/workflow/runtime.js";import{deserializeContext}from"#context/serialize.js";import{readDurableSession}from"#execution/durable-session-store.js";import{resetRemoteAgentSession,resolveRemoteAgentForAction,resolveRemoteAgentStreamHeaders}from"#subagents/remote-dispatch.js";import{getAgentHandleStore}from"#subagents/handles/store.js";import{getDynamicSubagentSelection}from"#context/dynamic-subagent-lifecycle.js";import{cancelAllIndexedSessionTasksStep}from"#execution/cancel-indexed-session-tasks-step.js";const log=createLogger(`execution.terminate-child-sessions`);async function terminateChildSessionsStep(e){"use step";let t;try{t=readDurableSession(e.sessionState)}catch(t){logError(log,`failed to read child sessions for termination`,t,{parentSessionId:e.sessionState.sessionId});return}let n=getAgentHandleStore(t.state)?.handles??[],r=n.some(e=>`address`in e&&e.address.kind===`agent/remote`),i;if(await cancelAllIndexedSessionTasksStep({serializedContext:e.serializedContext,sessionState:e.sessionState}),r){if(e.serializedContext===void 0)throw Error(`Child finalization requires serialized runtime context.`);let t=await deserializeContext(e.serializedContext);i={bundle:t.require(BundleKey),ctx:t}}if(n.length!==0)for(let e of n){if(!(`address`in e)){log.debug(`skipping unaddressed child`,{agentId:e.identity.id,parentSessionId:t.sessionId});continue}try{if(e.address.kind===`agent/remote`){if(e.address.credentialResolver!==void 0){let t=e.address.credentialResolver.resolverId,n=t===void 0?{}:await resolveRemoteAgentStreamHeaders({bundle:i.bundle,name:e.identity.name,resolverId:t,url:e.address.url});await resetRemoteAgentSession({headers:n,remote:{name:e.identity.name,url:e.address.url},sessionId:e.address.sessionId})}else{let t=getDynamicSubagentSelection(i.ctx,e.identity.nodeId),n=resolveRemoteAgentForAction({dynamicRemoteAgent:t?.kind===`remote`?t.remoteAgent:void 0,nodeId:e.identity.nodeId,registry:i.bundle.subagentRegistry.subagentsByNodeId,remoteAgentName:e.identity.name});n.url===e.address.url?await resetRemoteAgentSession({remote:n,sessionId:e.address.sessionId}):await resetRemoteAgentSession({headers:{},remote:{name:e.identity.name,url:e.address.url},sessionId:e.address.sessionId})}}else await cancelRun(await getWorld(),e.address.sessionId,{cancelReason:`Parent session ended`})}catch(n){logError(log,`failed to terminate child session`,n,{agentId:e.identity.id,childSessionId:e.address.sessionId,kind:e.address.kind,parentSessionId:t.sessionId})}}}export{terminateChildSessionsStep};
+import{createLogger,logError}from"#internal/logging.js";import{liveTaskRuns,readTaskTable}from"#execution/tasks/table.js";import{readDurableSession}from"#execution/durable-session-store.js";import{cancelWorkflowToolRun}from"#execution/tools/workflow/cancel.js";const log=createLogger(`execution.terminate-child-sessions`);async function terminateChildSessionsStep(e){"use step";let t;try{t=readDurableSession(e.sessionState)}catch(t){logError(log,`failed to read child sessions for termination`,t,{parentSessionId:e.sessionState.sessionId});return}await stopTaskRuns(t)}async function stopTaskRuns(e){let t=liveTaskRuns(readTaskTable(e.state));await Promise.all(t.map(e=>cancelWorkflowToolRun(e,{kind:`end`,reason:`The session ended.`})))}export{terminateChildSessionsStep};

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

@@ -1 +1 @@
-import{buildBaseToolContext}from"#context/build-base-tool-context.js";import{createAuthorizationContext}from"#runtime/authorization-context.js";import{handleAuthorizationError}from"#runtime/connections/scoped-authorization.js";function createToolExecuteWithAuth(e){return(t,n)=>{let r=createAuthorizationContext({scope:e.scope}),i={...buildBaseToolContext({options:n,toolName:e.scope}),getToken:r.getToken,requireAuth:r.requireAuth};return r.run(()=>e.execute(t,i))}}function buildApprovalResponseAuth(e){let t=createAuthorizationContext({scope:e.scope,boundResponder:e.responder});return{getToken:(n,r)=>t.getToken(n,namespaceApprovalAuthOptions(e.scope,r)),requireAuth:(n,r)=>t.requireAuth(n,namespaceApprovalAuthOptions(e.scope,r))}}function namespaceApprovalAuthOptions(e,t){return t?.authKey===void 0?t:{...t,authKey:`${e}:${t.authKey}`}}async function handleApprovalResponsePolicyError(e){return await handleAuthorizationError(e)}export{buildApprovalResponseAuth,createToolExecuteWithAuth,handleApprovalResponsePolicyError};
+import{buildBaseToolContext}from"#context/build-base-tool-context.js";import{createAuthorizationContext}from"#runtime/authorization-context.js";import{handleAuthorizationError}from"#runtime/connections/scoped-authorization.js";function createToolExecuteWithAuth(e){return(t,n)=>{let r=createAuthorizationContext({scope:e.scope}),i={...buildBaseToolContext({options:n,toolName:e.scope}),messages:n.messages,getToken:r.getToken,requireAuth:r.requireAuth};return r.run(()=>e.execute(t,i))}}function buildApprovalResponseAuth(e){let t=createAuthorizationContext({scope:e.scope,boundResponder:e.responder});return{getToken:(n,r)=>t.getToken(n,namespaceApprovalAuthOptions(e.scope,r)),requireAuth:(n,r)=>t.requireAuth(n,namespaceApprovalAuthOptions(e.scope,r))}}function namespaceApprovalAuthOptions(e,t){return t?.authKey===void 0?t:{...t,authKey:`${e}:${t.authKey}`}}async function handleApprovalResponsePolicyError(e){return await handleAuthorizationError(e)}export{buildApprovalResponseAuth,createToolExecuteWithAuth,handleApprovalResponsePolicyError};

package/dist/src/execution/tools/agent-router-workflow.d.ts

@@ -2,4 +2,4 @@ import type { JsonValue } from "#shared/json.js";
 import type { WorkflowToolContext } from "#tools/workflow-definition.js";
 import type { AgentRouterInput } from "#execution/tools/agent-router.js";
 /** Routes one task through the complete workflow agent metadata snapshot. */
-export declare function executeAgentRouterTool(input: AgentRouterInput, ctx: WorkflowToolContext): Promise<JsonValue>;
+export declare function runAgentRouterTask(input: AgentRouterInput, ctx: WorkflowToolContext): Promise<JsonValue>;

package/dist/src/execution/tools/agent-router-workflow.js

@@ -1 +1 @@
-import{evaluate}from"#ai/evaluate.js";async function executeAgentRouterTool(e,t){"use workflow";let n=await chooseTarget(e.message,descriptions(t),t.abortSignal);return t.agent(n,{message:e.message})}async function chooseTarget(e,t,n){"use step";let r=Object.keys(t);if(r.length===0)throw Error(`agentRouter requires at least one available agent with a description.`);return r.length===1?r[0]:(await evaluate({abortSignal:n,state:{message:e},questions:{route:{type:`choice`,instructions:`Which subagent should handle this task?`,criteria:t}}})).answers.route.choice}function descriptions(e){return Object.fromEntries(Object.entries(e.agents).flatMap(([e,t])=>{let n=t.description.trim();return n.length===0?[]:[[e,n]]}))}executeAgentRouterTool.workflowId=`workflow//eve@0.67.2//executeAgentRouterTool`;export{executeAgentRouterTool};
+import{evaluate}from"#ai/evaluate.js";async function runAgentRouterTask(e,t){"use workflow";let n=await chooseTarget(e.message,descriptions(t),t.abortSignal),{message:r,status:i}=await(await t.agent(n).send(e.message,{signal:t.abortSignal})).result();if(i===`failed`)throw Error(`Agent "${n}" failed to handle the task.`);return r??null}async function chooseTarget(e,t,n){"use step";let r=Object.keys(t);if(r.length===0)throw Error(`agentRouter requires at least one available agent with a description.`);return r.length===1?r[0]:(await evaluate({abortSignal:n,state:{message:e},questions:{route:{type:`choice`,instructions:`Which subagent should handle this task?`,criteria:t}}})).answers.route.choice}function descriptions(e){return Object.fromEntries(Object.entries(e.agents).flatMap(([e,t])=>{let n=t.description.trim();return n.length===0?[]:[[e,n]]}))}runAgentRouterTask.workflowId=`workflow//eve@0.69.0//runAgentRouterTask`;export{runAgentRouterTask};

package/dist/src/execution/tools/agent-router.d.ts

@@ -1,4 +1,4 @@
-export { executeAgentRouterTool } from "#execution/tools/agent-router-workflow.js";
+export { runAgentRouterTask } from "#execution/tools/agent-router-workflow.js";
 export declare const AGENT_ROUTER_TOOL_DESCRIPTION = "Route a task to the best available subagent based on each subagent's declared description.";
 export interface AgentRouterInput {
     readonly message: string;

package/dist/src/execution/tools/agent-router.js

@@ -1 +1 @@
-import{defineJsonSchema}from"#tools/schema.js";import{executeAgentRouterTool}from"#execution/tools/agent-router-workflow.js";const AGENT_ROUTER_TOOL_DESCRIPTION=`Route a task to the best available subagent based on each subagent's declared description.`,AGENT_ROUTER_INPUT_SCHEMA=defineJsonSchema({type:`object`,properties:{message:{type:`string`,minLength:1,description:`The complete task to send to the selected agent.`}},required:[`message`],additionalProperties:!1});export{AGENT_ROUTER_INPUT_SCHEMA,AGENT_ROUTER_TOOL_DESCRIPTION,executeAgentRouterTool};
+import{defineJsonSchema}from"#tools/schema.js";import{runAgentRouterTask}from"#execution/tools/agent-router-workflow.js";const AGENT_ROUTER_TOOL_DESCRIPTION=`Route a task to the best available subagent based on each subagent's declared description.`,AGENT_ROUTER_INPUT_SCHEMA=defineJsonSchema({type:`object`,properties:{message:{type:`string`,minLength:1,description:`The complete task to send to the selected agent.`}},required:[`message`],additionalProperties:!1});export{AGENT_ROUTER_INPUT_SCHEMA,AGENT_ROUTER_TOOL_DESCRIPTION,runAgentRouterTask};

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

@@ -0,0 +1,25 @@
+/**
+ * Approval for `connection_execute`: each call is approved under the called
+ * connection's own policy, keyed by connection and tool, and an approved call
+ * runs only against the connection instance it was approved for.
+ */
+import { type Approval, type ApprovalContext, type ApprovalResponseContext, type ApprovalResponseDecision, type ApprovalStatus } from "#approval/definition.js";
+import type { ResolvedConnectionDefinition } from "#runtime/types.js";
+/**
+ * Delegates approval to the called connection's policy. The request and
+ * response phases exist only when some registered connection defines them,
+ * so connections without a response policy keep the default response flow
+ * unless another connection in the same agent defines one.
+ */
+export declare function connectionExecuteApproval(approvals: readonly Approval[]): {
+    approvalKey?: undefined;
+    approval?: undefined;
+} | {
+    approvalKey: (input: unknown) => string;
+    approval: ((context: ApprovalContext<Record<string, unknown>>) => Promise<ApprovalStatus>) | {
+        request: (context: ApprovalContext<Record<string, unknown>>) => Promise<ApprovalStatus>;
+        response: (context: ApprovalResponseContext<Record<string, unknown>>) => Promise<ApprovalResponseDecision>;
+    };
+};
+/** Consumes the call's approval pin, rejecting the call if its connection changed. */
+export declare function releaseApprovalPin(callId: string, connection: ResolvedConnectionDefinition): void;

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

@@ -0,0 +1 @@
+import{CONNECTION_EXECUTE_TOOL_NAME,findConnection,qualifiedToolName,readExecuteTarget}from"./connection-target.js";import{loadContext}from"#context/container.js";import{defineDurableCallback}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{isApprovalRecheck}from"#harness/approval-recheck.js";const ConnectionApprovalPinsKey=new ContextKey(`eve.connectionApprovalPins`);function connectionExecuteApproval(e){if(e.length===0)return{};let t=defineDurableCallback({callback:requestConnectionApproval,closure:{}}),n=e.some(e=>typeof e!=`function`&&e.response!==void 0);return{approvalKey:defineDurableCallback({callback:connectionApprovalKey,closure:{}}),approval:n?{request:t,response:defineDurableCallback({callback:authorizeConnectionApprovalResponse,closure:{}})}:t}}function connectionApprovalKey(e,t){let n=readExecuteTarget(t);return n===void 0?CONNECTION_EXECUTE_TOOL_NAME:approvalKeyFor(n)}function approvalKeyFor(e){return JSON.stringify([e.connection,e.tool])}function policyApprovedTools(e,t){let n=qualifiedToolName(t),r=new Set([...e].filter(e=>e!==n));return e.has(approvalKeyFor(t))&&r.add(n),r}async function requestConnectionApproval(e,t){let n=readExecuteTarget(t.toolInput),r=loadContext().get(ConnectionRegistryKey);if(n===void 0||r===void 0)return`not-applicable`;let i=findConnection(r,n.connection),a=i===void 0?void 0:r.getConnectionApproval(i.connectionName);if(i===void 0||a===void 0)return`not-applicable`;isApprovalRecheck(t)&&!matchesApprovalPin(t.callId,i)&&markApprovalPinChanged(t.callId);let o=await resolveApprovalPolicy(a)({...t,approvedTools:policyApprovedTools(t.approvedTools,n),toolInput:n.input,toolName:qualifiedToolName(n)});return!isApprovalRecheck(t)&&parksForApproval(o)&&pinApprovedInstance(t.callId,i),o}function parksForApproval(e){return e===!0||e===`user-approval`||typeof e==`object`&&e.type===`user-approval`}async function authorizeConnectionApprovalResponse(e,t){let n=readExecuteTarget(t.request.toolInput),r=loadContext().get(ConnectionRegistryKey),i=n===void 0||r===void 0?void 0:findConnection(r,n.connection);if(n===void 0||r===void 0||i===void 0)return{reason:`The connection for this tool call is unavailable.`,status:`rejected`};if(!matchesApprovalPin(t.request.callId,i))return{reason:CONNECTION_CHANGED_MESSAGE,status:`rejected`};let a=r.getConnectionApproval(i.connectionName),o=a===void 0||typeof a==`function`?void 0:a.response;return o===void 0?{status:`allowed`}:await o({...t,request:{...t.request,toolInput:n.input,toolName:qualifiedToolName(n)}})}const CONNECTION_CHANGED_MESSAGE=`The connection for this tool call changed or is unavailable. Request a new tool call and approval.`;function pinApprovedInstance(e,t){let n=t.instanceId??``,r=loadContext();r.get(ConnectionApprovalPinsKey)?.[e]===void 0&&r.set(ConnectionApprovalPinsKey,(t={})=>Object.fromEntries([...Object.entries(t).slice(-49),[e,n]]))}function matchesApprovalPin(e,t){let n=loadContext().get(ConnectionApprovalPinsKey)?.[e];return n!==void 0&&n===(t.instanceId??``)}function markApprovalPinChanged(e){loadContext().set(ConnectionApprovalPinsKey,(t={})=>({...t,[e]:`\0changed`}))}function releaseApprovalPin(e,t){let n=loadContext(),r=n.get(ConnectionApprovalPinsKey);if(r?.[e]===void 0)return;let{[e]:i,...a}=r;if(n.set(ConnectionApprovalPinsKey,a),i!==(t.instanceId??``))throw Error(CONNECTION_CHANGED_MESSAGE)}export{connectionExecuteApproval,releaseApprovalPin};

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

@@ -0,0 +1,21 @@
+/**
+ * Keyword ranking for `connection_search` and for `connection_execute`'s
+ * suggestions when a tool name is unknown. Query and field text split into
+ * lowercase words (camelCase and punctuation are boundaries); a query word
+ * matches a field word when either is a prefix of the other, so `repo` finds
+ * `repositories` and `issues` finds `issue`. Each query word adds the weight of
+ * every field it matches, so broad fields rank below a tool's own name.
+ */
+import type { ResolvedConnectionDefinition } from "#runtime/types.js";
+import type { ConnectionToolMetadata } from "#shared/connection-types.js";
+export interface RankCandidate {
+    readonly connection: Pick<ResolvedConnectionDefinition, "connectionName" | "description">;
+    readonly tool: ConnectionToolMetadata;
+}
+/** Candidates matching `query`, best first. An empty query matches every candidate. */
+export declare function rankConnectionTools<T extends RankCandidate>(query: string, candidates: readonly T[]): T[];
+/**
+ * Names of one connection's tools closest to an unknown `name`. Only the tools'
+ * own fields count, since every candidate shares the connection.
+ */
+export declare function closestToolNames(name: string, tools: readonly ConnectionToolMetadata[], limit: number): string[];

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

@@ -0,0 +1 @@
+import{isObject}from"#shared/guards.js";function rankConnectionTools(e,t){let n=tokenize(e);return t.map(e=>({candidate:e,score:n.length===0?1:scoreFields(n,[...toolFields(e.tool),[tokenize(e.connection.connectionName),4],[tokenize(e.connection.description),1]])})).filter(e=>e.score>0).sort((e,t)=>t.score-e.score||e.candidate.connection.connectionName.localeCompare(t.candidate.connection.connectionName)||e.candidate.tool.name.localeCompare(t.candidate.tool.name)).map(e=>e.candidate)}function closestToolNames(e,t,n){let r=tokenize(e);return r.length===0?[]:t.map(e=>({name:e.name,score:scoreFields(r,toolFields(e))})).filter(e=>e.score>0).sort((e,t)=>t.score-e.score||e.name.localeCompare(t.name)).slice(0,n).map(e=>e.name)}function toolFields(e){let t=isObject(e.inputSchema.properties)?Object.entries(e.inputSchema.properties):[],n=t.flatMap(([,e])=>isObject(e)&&typeof e.description==`string`?[e.description]:[]);return[[tokenize(e.name),6],[t.flatMap(([e])=>tokenize(e)),3],[tokenize(e.description),2],[n.flatMap(tokenize),1]]}function scoreFields(e,t){let n=0;for(let r of e)for(let[e,i]of t)e.some(e=>matchesWord(e,r))&&(n+=i);return n}function matchesWord(e,t){return e.startsWith(t)||e.length>=3&&t.startsWith(e)}function tokenize(e){return e.replaceAll(/([a-z0-9])([A-Z])/gu,`$1 $2`).toLowerCase().split(/[^a-z0-9]+/u).filter(e=>e.length>1)}export{closestToolNames,rankConnectionTools};

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

@@ -0,0 +1,13 @@
+/** The `connection_execute` call target, shared by execution and approval. */
+import type { ConnectionRegistry } from "#runtime/connections/registry-types.js";
+import type { ResolvedConnectionDefinition } from "#runtime/types.js";
+import type { JsonObject } from "#shared/json.js";
+export declare const CONNECTION_EXECUTE_TOOL_NAME = "connection_execute";
+export interface ExecuteTarget {
+    readonly connection: string;
+    readonly input: JsonObject;
+    readonly tool: string;
+}
+export declare function readExecuteTarget(value: unknown): ExecuteTarget | undefined;
+export declare function qualifiedToolName(target: Pick<ExecuteTarget, "connection" | "tool">): string;
+export declare function findConnection(registry: ConnectionRegistry, name: string): ResolvedConnectionDefinition | undefined;

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

@@ -0,0 +1 @@
+import{isObject}from"#shared/guards.js";const CONNECTION_EXECUTE_TOOL_NAME=`connection_execute`;function readExecuteTarget(e){if(!isObject(e))return;let{connection:t,input:n,tool:r}=e;if(typeof t==`string`&&typeof r==`string`)return{connection:t,input:isObject(n)?n:{},tool:r}}function qualifiedToolName(e){return`${e.connection}__${e.tool}`}function findConnection(e,t){return e.getConnections().find(e=>e.connectionName===t)}export{CONNECTION_EXECUTE_TOOL_NAME,findConnection,qualifiedToolName,readExecuteTarget};

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

@@ -0,0 +1,10 @@
+/**
+ * `connection_search` and `connection_execute`: fixed tools that reach every
+ * connection tool without adding definitions to the model's tool list, so
+ * discovery never changes the cached prompt prefix. Both are rebuilt each
+ * step from the connection registry with identical model-facing definitions.
+ */
+import type { DynamicToolSet } from "#tools/dynamic.js";
+export declare const CONNECTION_SEARCH_TOOL_NAME = "connection_search";
+/** Builds both tools for the current step, or `null` when the agent has no connections. */
+export declare function resolveConnectionTools(): DynamicToolSet | null;

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

@@ -0,0 +1,2 @@
+import{CONNECTION_EXECUTE_TOOL_NAME,findConnection,qualifiedToolName,readExecuteTarget}from"./connection-target.js";import{connectionExecuteApproval,releaseApprovalPin}from"./connection-approval.js";import{closestToolNames,rankConnectionTools}from"./connection-search-rank.js";import{createLogger}from"#internal/logging.js";import{isObject}from"#shared/guards.js";import{loadContext}from"#context/container.js";import{toErrorMessage}from"#shared/errors.js";import{defineJsonSchema}from"#tools/schema.js";import{defineDurableCallback}from"#tools/durable-callbacks.js";import{ConnectionRegistryKey}from"#context/providers/connection-key.js";import{getAuthorizationResults,requestAuthorization}from"#harness/authorization.js";import{createAuthorizationExecution}from"#runtime/connections/scoped-authorization.js";import{isConnectionAuthorizationFailedError,isConnectionAuthorizationRequiredError}from"#connections/errors.js";import{reportNestedToolAction}from"#harness/nested-actions.js";import{resolveConnectionAuthorization}from"#runtime/connections/resolve-authorization.js";import{connectionToolModelOutput,toConnectionToolResult}from"#runtime/connections/tool-result.js";import{renderToolSignature}from"#runtime/connections/tool-signature.js";import{supportsInteractiveAuthorization}from"#shared/connection-types.js";import{defineTool}from"#tools/definition.js";const log=createLogger(`framework.connection-tools`),CONNECTION_SEARCH_TOOL_NAME=`connection_search`,CONNECTION_SEARCH_DESCRIPTION=[`Find tools in your connected services (MCP servers and OpenAPI APIs).`,`Returns each matching tool's connection, name, description, and TypeScript signature.`,"Omit `query` to list a connection's tools. Call a found tool with connection_execute.",`Prefer connected services over web search or general knowledge when a request relates to them.`].join(` `),CONNECTION_EXECUTE_DESCRIPTION=[`Call one tool from a connected service and return its result.`,"Use the exact `connection` and `tool` names returned by connection_search,","and pass `input` matching the tool's signature."].join(` `),CONNECTION_SEARCH_INPUT_SCHEMA={type:`object`,properties:{query:{type:`string`,description:`Words describing the capability, such as 'list open issues'. Omit to list every tool.`},connection:{type:`string`,description:`Only search this connection.`},limit:{type:`integer`,minimum:1,maximum:50,description:`Maximum results. Defaults to 10.`},offset:{type:`integer`,minimum:0,description:`Results to skip, for paging.`}},additionalProperties:!1},CONNECTION_EXECUTE_INPUT_SCHEMA={type:`object`,properties:{connection:{type:`string`,description:`Connection name from connection_search.`},tool:{type:`string`,description:`Tool name from connection_search.`},input:{type:`object`,description:`Arguments matching the tool's signature. Defaults to {}.`}},required:[`connection`,`tool`],additionalProperties:!1};function resolveConnectionTools(){let e=loadContext().get(ConnectionRegistryKey);if(e===void 0)return null;let t=e.getConnections().map(t=>e.getConnectionApproval(t.connectionName)).filter(e=>e!==void 0);return{[CONNECTION_SEARCH_TOOL_NAME]:defineTool({description:CONNECTION_SEARCH_DESCRIPTION,inputSchema:CONNECTION_SEARCH_INPUT_SCHEMA,execute:defineDurableCallback({callback:searchConnectionTools,closure:{}})}),[CONNECTION_EXECUTE_TOOL_NAME]:defineTool({description:CONNECTION_EXECUTE_DESCRIPTION,inputSchema:CONNECTION_EXECUTE_INPUT_SCHEMA,execute:defineDurableCallback({callback:executeConnectionTool,closure:{}}),label:{start:defineDurableCallback({callback:connectionToolLabel,closure:{}})},toModelOutput:defineDurableCallback({callback:(e,t)=>connectionToolModelOutput(t),closure:{}}),...connectionExecuteApproval(t)})}}function connectionToolLabel(e,t){let n=readExecuteTarget(t);return n===void 0?CONNECTION_EXECUTE_TOOL_NAME:qualifiedToolName(n)}async function searchConnectionTools(e,t){let n=isObject(t)?t:{},r=requireRegistry(),i=n.connection===void 0||n.connection===``?r.getConnections():[requireConnection(r,n.connection)],a=createAuthorizationExecution();await completePendingAuthorizations(r,i,a);let o=[],s=[],c=[];for(let e of i){let t=await listConnectionTools(r,e,a);if(`challenges`in t)o.push(...t.challenges);else if(`unavailable`in t)s.push(t.unavailable);else for(let n of t.tools)c.push({connection:e,tool:n})}if(o.length>0)return requestAuthorization(o);let l=s.filter(e=>e.terminal);if(i.length>0&&l.length===i.length)throw Error(l.map(e=>e.error).join(`
+`));let u=rankConnectionTools(n.query??``,c),d=clampInteger(n.limit,1,50,10),f=clampInteger(n.offset,0,2**53-1,0),p={tools:u.slice(f,f+d).map(({connection:e,tool:t})=>({connection:e.connectionName,description:t.description,signature:renderToolSignature({inputSchema:t.inputSchema,name:t.name,outputSchema:t.outputSchema}),tool:t.name})),total:u.length};return s.length>0&&(p.unavailable=s.map(({connection:e,error:t})=>({connection:e,error:t}))),p}async function listConnectionTools(e,t,n){let r=t.connectionName;try{return{tools:await e.getClient(r).getToolMetadata()}}catch(t){if(isConnectionAuthorizationRequiredError(t)){let i=await resolveInteractiveAuthorization(e,r);if(i===void 0)return{unavailable:{connection:r,error:`"${r}" requires authorization and cannot start interactive sign-in.`,terminal:!1}};try{return{challenges:(await n.handleError(t,i)).challenges}}catch(e){return log.warn(`connection authorization failed`,{connection:r,error:e}),{unavailable:{connection:r,error:isConnectionAuthorizationFailedError(e)?e.message:`Failed to start authorization for "${r}": ${toErrorMessage(e)}`,terminal:!0}}}}return log.warn(`failed to load connection tools`,{connection:r,error:t}),{unavailable:{connection:r,error:isConnectionAuthorizationFailedError(t)?`Authorization failed for "${r}": ${t.message}`:`Failed to load tools for "${r}": ${toErrorMessage(t)}`,terminal:!0}}}}function clampInteger(e,t,n,r){return typeof e!=`number`||!Number.isFinite(e)?r:Math.min(n,Math.max(t,Math.trunc(e)))}async function executeConnectionTool(e,t,n){let r=readExecuteTarget(t);if(r===void 0)throw Error("connection_execute requires string `connection` and `tool` values.");let i=requireRegistry(),a=requireConnection(i,r.connection);releaseApprovalPin(n.callId,a),assertPendingAuthorizationInstances(i,[a]);let o=await resolveInteractiveAuthorization(i,a.connectionName),s=createAuthorizationExecution();o!==void 0&&await s.complete(o);let c=i.getClient(a.connectionName),l;try{l=await c.getToolMetadata()}catch(e){return await s.handleError(e,o)}let u=l.find(e=>e.name===r.tool);if(u===void 0)throw Error(unknownToolMessage(a,r.tool,l));let d=await validToolInput(a,u,r.input),f=qualifiedToolName(r),p;try{p=await c.executeTool(u.name,d,{abortSignal:n.abortSignal,callId:n.callId})}catch(e){if(isConnectionAuthorizationRequiredError(e))return await s.handleError(e,o);throw reportNestedToolAction(n.callId,{input:d,isError:!0,output:toErrorMessage(e),toolName:f}),e}let m=toConnectionToolResult(a.protocol,u,p);if(!m.ok)throw reportNestedToolAction(n.callId,{input:d,isError:!0,output:m.error,toolName:f}),Error(m.error);return reportNestedToolAction(n.callId,{input:d,output:m.value,toolName:f}),m.value}async function validToolInput(e,t,n){let r=await defineJsonSchema(t.inputSchema)[`~standard`].validate(n);if(r.issues===void 0)return r.value;let i=r.issues.map(e=>{let t=(e.path??[]).map(e=>String(typeof e==`object`?e.key:e)).join(`.`);return t.length>0?`${t}: ${e.message}`:e.message}).join(`; `);throw Error(`Invalid input for "${t.name}" on connection "${e.connectionName}": ${i}. Signature: ${renderToolSignature({inputSchema:t.inputSchema,name:t.name,outputSchema:t.outputSchema})}`)}function unknownToolMessage(e,t,n){let r=closestToolNames(t,n,5),i=r.length>0?` Closest tools: ${r.join(`, `)}.`:` Use connection_search to find its tools.`;return`Connection "${e.connectionName}" has no tool named "${t}".${i}`}async function resolveInteractiveAuthorization(e,t){let n=findConnection(e,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){assertPendingAuthorizationInstances(e,t);let r=getAuthorizationResults();for(let i of t){if(!r.some(e=>e.name===i.connectionName))continue;let t=await resolveInteractiveAuthorization(e,i.connectionName);t!==void 0&&await n.complete(t)}}function assertPendingAuthorizationInstances(e,t){let n=new Set(t.map(e=>e.connectionName));for(let t of getAuthorizationResults())if(t.instanceId!==void 0&&n.has(t.name)&&findConnection(e,t.name)?.instanceId!==t.instanceId)throw Error(`Authorization for "${t.name}" cannot complete because its resolved connection changed while sign-in was pending. Start sign-in again.`)}function requireRegistry(){let e=loadContext().get(ConnectionRegistryKey);if(e===void 0)throw Error(`This agent has no connections.`);return e}function requireConnection(e,t){let n=findConnection(e,t);if(n!==void 0)return n;let r=e.getConnectionNames();throw Error(r.length===0?`Connection "${t}" is not available. No connections are available right now.`:`Connection "${t}" is not available. Available connections: ${r.join(`, `)}.`)}export{CONNECTION_SEARCH_TOOL_NAME,resolveConnectionTools};

package/dist/src/execution/tools/load-skill.js

@@ -1 +1 @@
-import{loadContext}from"#context/container.js";import{DynamicSkillManifestKey}from"#context/keys.js";import{defineJsonSchema}from"#tools/schema.js";import{stripSkillFrontmatter}from"#shared/skill-package.js";import{ConnectionRegistryKey}from"#context/providers/connection-key.js";import{BundleKey}from"#runtime/sessions/runtime-context-keys.js";async function executeLoadSkillTool(e){let t=loadContext(),{skill:n}=e,r=Object.values(t.get(DynamicSkillManifestKey)??{}).flat(),i=t.require(BundleKey).resolvedAgent.skills,a=r.find(e=>e.name===n);if(a!==void 0)return stripSkillFrontmatter(a.markdown);let o=i.find(e=>e.name===n);if(o!==void 0)return o.markdown;let s=formatSkillNotFoundError(n,[...new Set([...r,...i].map(e=>e.name))].sort()),c=t.get(ConnectionRegistryKey)?.getConnectionNames().find(e=>e.toLowerCase()===n.toLowerCase());throw Error(c===void 0?s:`${s} "${c}" is an installed connection, not a skill. Use connection_search with connection "${c}" to find its tools.`)}function formatSkillNotFoundError(e,t){return`No skill named "${e}".${t.length>0?` Available skills: ${t.join(`, `)}.`:``}`}const SKILL_INPUT_SCHEMA=defineJsonSchema({type:`object`,properties:{skill:{type:`string`,description:`Available skill name or id.`}},required:[`skill`],additionalProperties:!1}),SKILL_OUTPUT_SCHEMA=defineJsonSchema({type:`string`});async function executeLoadSkill(e){return await executeLoadSkillTool(e)}export{SKILL_INPUT_SCHEMA,SKILL_OUTPUT_SCHEMA,executeLoadSkill};
+import{loadContext}from"#context/container.js";import{DynamicSkillManifestKey}from"#context/keys.js";import{defineJsonSchema}from"#tools/schema.js";import{stripSkillFrontmatter}from"#shared/skill-package.js";import{ConnectionRegistryKey}from"#context/providers/connection-key.js";import{BundleKey}from"#runtime/sessions/runtime-context-keys.js";async function executeLoadSkillTool(e){let t=loadContext(),{skill:n}=e,r=Object.values(t.get(DynamicSkillManifestKey)??{}).flat(),i=t.require(BundleKey).resolvedAgent.skills,a=r.find(e=>e.name===n);if(a!==void 0)return stripSkillFrontmatter(a.markdown);let o=i.find(e=>e.name===n);if(o!==void 0)return o.markdown;let s=formatSkillNotFoundError(n,[...new Set([...r,...i].map(e=>e.name))].sort()),c=t.get(ConnectionRegistryKey)?.getConnectionNames().find(e=>e.toLowerCase()===n.toLowerCase());throw Error(c===void 0?s:`${s} "${c}" is a connection, not a skill. Find its tools with connection_search and connection "${c}", then call them with connection_execute.`)}function formatSkillNotFoundError(e,t){return`No skill named "${e}".${t.length>0?` Available skills: ${t.join(`, `)}.`:``}`}const SKILL_INPUT_SCHEMA=defineJsonSchema({type:`object`,properties:{skill:{type:`string`,description:`Available skill name or id.`}},required:[`skill`],additionalProperties:!1}),SKILL_OUTPUT_SCHEMA=defineJsonSchema({type:`string`});async function executeLoadSkill(e){return await executeLoadSkillTool(e)}export{SKILL_INPUT_SCHEMA,SKILL_OUTPUT_SCHEMA,executeLoadSkill};

package/dist/src/execution/tools/workflow/answer.d.ts

@@ -1,5 +1,11 @@
+import type { SessionAuthContext } from "#channel/types.js";
+import type { WorkflowAskRoute } from "#harness/proxy-input-requests.js";
 import type { InputResponse } from "#shared/input.js";
-/** Resumed with the bare response, not a session-inbox delivery, so the body can race the hook. */
-export declare function resumeWorkflowToolRunAnswers(answerToken: string, responses: readonly InputResponse[] | undefined): Promise<void>;
-/** Resolves a dismissible `ctx.ask()` request the user moved past without answering. */
-export declare function resumeWorkflowToolRunDismissal(answerToken: string): Promise<void>;
+import type { ToolInputResponseResponder } from "#tools/definition.js";
+export declare function toToolInputResponseResponder(auth: SessionAuthContext | null | undefined): ToolInputResponseResponder | undefined;
+/**
+ * Sends the answers the session accepted to the asking run's control hook,
+ * the same ordered inbox its commands use, so an answer the session accepted
+ * before an interrupt or cancel reaches the body before them.
+ */
+export declare function sendWorkflowAskAnswers(route: WorkflowAskRoute, responses: readonly InputResponse[] | undefined, responder?: ToolInputResponseResponder): Promise<void>;

package/dist/src/execution/tools/workflow/answer.js

@@ -1 +1 @@
-import{resumeHook}from"#internal/workflow/runtime.js";async function resumeWorkflowToolRunAnswers(e,t){for(let n of t??[]){let t={optionId:n.optionId,status:`answered`,text:n.text};await resumeHook(e,t)}}async function resumeWorkflowToolRunDismissal(e){await resumeHook(e,{status:`dismissed`})}export{resumeWorkflowToolRunAnswers,resumeWorkflowToolRunDismissal};
+import{resumeHook}from"#internal/workflow/runtime.js";function toToolInputResponseResponder(e){return e==null?void 0:{authenticator:e.authenticator,principalId:e.principalId,principalType:e.principalType}}async function sendWorkflowAskAnswers(e,t,n){for(let r of t??[]){let{optionId:t,text:i}=r,a=n===void 0?{optionId:t,status:`answered`,text:i}:{optionId:t,responder:n,status:`answered`,text:i},o={kind:`answer`,requestId:r.requestId,response:a};await resumeHook(e.control,o)}}export{sendWorkflowAskAnswers,toToolInputResponseResponder};

package/dist/src/execution/tools/workflow/ask.d.ts

@@ -1,14 +1,77 @@
-import { type Hook } from "#compiled/@workflow/core/index.js";
-import type { WorkflowToolRunOwner, WorkflowToolRunRef } from "#execution/tools/workflow/messages.js";
-import type { ToolContext, ToolInputRequest, ToolInputResponse } from "#tools/definition.js";
+import type { SessionAuth } from "#context/session-context.js";
+import type { AgentSessionContext } from "#execution/agent-sessions/context.js";
+import type { WorkflowToolRunAskDecision, WorkflowToolRunRef } from "#execution/tools/workflow/messages.js";
+import type { WorkflowToolRunInbox } from "#execution/tools/workflow/owner.js";
+import type { ToolContext, ToolInputRequest, ToolInputRequestOptions, ToolInputResponse } from "#tools/definition.js";
+/**
+ * The run a workflow body belongs to. Members that describe a call describe
+ * the one the run serves now, which a `serve` task changes with each call, so
+ * read them when they are used.
+ */
 export interface WorkflowToolRunContext {
-    readonly canRequestInput?: boolean;
+    /**
+     * What the call's caller lends it: the lineage a `ctx.agent` session opened
+     * now binds, and whether `ctx.ask()` can reach a person.
+     */
+    readonly agentContext: AgentSessionContext;
+    readonly asks: WorkflowToolRunAsks;
+    /** The auth of the call, which a message sent to a `ctx.agent` session now carries. */
+    readonly auth: SessionAuth;
+    /** The run's control hook, where the session sends its decisions on the run's questions. */
+    readonly control: string;
+    /**
+     * The ref of the call the run serves now, which questions and sign-ins come
+     * from. A `serve` task's changes with each call, so read it when sending.
+     */
     readonly from: WorkflowToolRunRef;
-    readonly owner: WorkflowToolRunOwner;
+    readonly owner: WorkflowToolRunInbox;
 }
-export declare function attachWorkflowToolRunContext(ctx: ToolContext, context: WorkflowToolRunContext): void;
+export declare function attachWorkflowToolRunContext(ctx: Pick<ToolContext, "abortSignal">, context: WorkflowToolRunContext): void;
 export declare function findWorkflowToolRunContext(value: unknown): WorkflowToolRunContext | undefined;
-export declare function readWorkflowToolRunRef(ctx: ToolContext): WorkflowToolRunRef;
-export declare function readWorkflowToolRunOwner(ctx: ToolContext): WorkflowToolRunOwner;
-/** Returns an answer which may be awaited or raced with another workflow operation. */
-export declare function ask(ctx: ToolContext, request: ToolInputRequest): Hook<ToolInputResponse> | Promise<ToolInputResponse>;
+/**
+ * The run's pending `ctx.ask()` questions. The run names each one, and each
+ * resolves only from what the session decided about it, delivered in order on
+ * the run's control hook, or as `cancelled` once the session stops the work.
+ */
+export declare class WorkflowToolRunAsks {
+    private opened;
+    private readonly pending;
+    /** Withdrawal requests on their way to the run's inbox. */
+    private readonly withdrawing;
+    private readonly runId;
+    constructor(runId: string);
+    /**
+     * Opens a question under a request ID that replays deterministically with
+     * the run. `send` sends the request and returns how to send its withdrawal.
+     */
+    open(send: (requestId: string) => () => Promise<void>): {
+        readonly answer: Promise<ToolInputResponse>;
+        readonly requestId: string;
+    };
+    /**
+     * Asks the session to withdraw a pending question, at most once. The
+     * question stays pending until the session decides it, so an answer the
+     * session accepted first still wins.
+     */
+    withdraw(requestId: string): void;
+    /** Asks the session to withdraw every pending question not already withdrawn. */
+    withdrawAll(): void;
+    /**
+     * Waits until every withdrawal asked for has reached the run's inbox, so the
+     * session decides each one before the run's outcome withdraws the rest.
+     */
+    flush(): Promise<void>;
+    /** Applies the session's decision. The first one wins; a repeated one is dropped. */
+    settle(decision: WorkflowToolRunAskDecision): void;
+    fail(requestId: string, error: unknown): void;
+    /** The session stopped the work, so it answers none of its questions anymore. */
+    cancelAll(): void;
+    private take;
+}
+/**
+ * Returns an answer which may be awaited or raced with another workflow
+ * operation. When the call's `abortSignal` or `options.signal` aborts, the run
+ * asks the session to withdraw the question. The answer is `cancelled` only if
+ * the session withdrew it before it accepted a person's answer.
+ */
+export declare function ask(ctx: Pick<ToolContext, "abortSignal">, request: ToolInputRequest, options?: ToolInputRequestOptions): Promise<ToolInputResponse>;

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

@@ -1 +1 @@
-import{workflowToolContextErrorMessage}from"#shared/workflow-tool-context.js";import{createHook}from"#compiled/@workflow/core/index.js";import{resumeHookStep}from"#execution/tools/workflow/resume-hook-step.js";const WORKFLOW_TOOL_RUN_CONTEXT=Symbol.for(`eve.workflow-tool-run.context`);function attachWorkflowToolRunContext(e,t){Object.defineProperty(e,WORKFLOW_TOOL_RUN_CONTEXT,{enumerable:!1,value:t})}function readWorkflowToolRunContext(e,t){let n=e?.[WORKFLOW_TOOL_RUN_CONTEXT];if(n===void 0)throw Error(workflowToolContextErrorMessage(t));return n}function findWorkflowToolRunContext(e){return typeof e==`object`&&e?e[WORKFLOW_TOOL_RUN_CONTEXT]:void 0}function readWorkflowToolRunRef(e){return readWorkflowToolRunContext(e,`agent`).from}function readWorkflowToolRunOwner(e){return readWorkflowToolRunContext(e,`agent`).owner}function ask(e,t){let n=readWorkflowToolRunContext(e,`ask`);if(n.canRequestInput===!1)return Promise.resolve({status:`unavailable`});let r=createHook();return resumeHookStep(n.owner.inbox,{kind:`request`,from:n.from,replyTo:r.token,request:{kind:`ask`,request:t}}),r}export{ask,attachWorkflowToolRunContext,findWorkflowToolRunContext,readWorkflowToolRunOwner,readWorkflowToolRunRef};
+import{workflowToolContextErrorMessage}from"#shared/workflow-tool-context.js";const WORKFLOW_TOOL_RUN_CONTEXT=Symbol.for(`eve.workflow-tool-run.context`);function attachWorkflowToolRunContext(e,t){Object.defineProperty(e,WORKFLOW_TOOL_RUN_CONTEXT,{enumerable:!1,value:t})}function readWorkflowToolRunContext(e,t){let n=e?.[WORKFLOW_TOOL_RUN_CONTEXT];if(n===void 0)throw Error(workflowToolContextErrorMessage(t));return n}function findWorkflowToolRunContext(e){return typeof e==`object`&&e?e[WORKFLOW_TOOL_RUN_CONTEXT]:void 0}const CANCELLED={status:`cancelled`},UNAVAILABLE={status:`unavailable`};var WorkflowToolRunAsks=class{opened=0;pending=new Map;withdrawing=new Set;runId;constructor(e){this.runId=e}open(e){this.opened+=1;let t=`${this.runId}-ask-${String(this.opened)}`,n,r=new Promise((e,t)=>{n={reject:t,resolve:e,withdraw:void 0}});return this.pending.set(t,n),n.withdraw=e(t),{answer:r,requestId:t}}withdraw(e){let t=this.pending.get(e),n=t?.withdraw;if(t===void 0||n===void 0)return;t.withdraw=void 0;let r=n().catch(t=>this.fail(e,t));this.withdrawing.add(r),r.then(()=>this.withdrawing.delete(r))}withdrawAll(){for(let e of this.pending.keys())this.withdraw(e)}async flush(){for(;this.withdrawing.size>0;)await Promise.all(this.withdrawing)}settle(e){let t=e.kind===`answer`?e.response:CANCELLED;this.take(e.requestId)?.resolve(t)}fail(e,t){this.take(e)?.reject(t)}cancelAll(){for(let e of this.pending.keys())this.take(e)?.resolve(CANCELLED)}take(e){let t=this.pending.get(e);return this.pending.delete(e),t}};function ask(e,t,n={}){let r=readWorkflowToolRunContext(e,`ask`);if(r.agentContext.capabilities?.requestInput!==!0)return Promise.resolve(UNAVAILABLE);let i=[e.abortSignal];if(n.signal!==void 0&&i.push(n.signal),i.some(e=>e.aborted))return Promise.resolve(CANCELLED);let{asks:a,control:o,owner:s}=r,c=r.from,{answer:l,requestId:u}=a.open(e=>{let n=s.send({kind:`request`,from:c,replyTo:e,request:{control:o,kind:`ask`,request:t}});return n.catch(t=>a.fail(e,t)),()=>n.then(()=>s.send({control:o,from:c,kind:`withdraw`,replyTo:e}))}),requestWithdrawal=()=>a.withdraw(u);for(let e of i)e.addEventListener(`abort`,requestWithdrawal,{once:!0});return l.finally(()=>{for(let e of i)e.removeEventListener(`abort`,requestWithdrawal)})}export{WorkflowToolRunAsks,ask,attachWorkflowToolRunContext,findWorkflowToolRunContext};