eve 0.68.0 → 0.70.0

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{displayTitle}from"#shared/display-name.js";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?displayTitle(e):e===AGENT_TOOL_NAME?r:`${displayTitle(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.d.ts

@@ -1,5 +1,7 @@
+import type { TokenUsage } from "#shared/token-usage.js";
 /** Emits a terminal `session.completed` outside a turn. */
 export declare function emitTerminalSessionCompletionStep(input: {
     readonly sessionWritable: WritableStream<Uint8Array>;
     readonly serializedContext: Record<string, unknown>;
+    readonly usage: TokenUsage | undefined;
 }): Promise<void>;

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({sessionWritable:e.sessionWritable,serializedContext:e.serializedContext,event:createSessionCompletedEvent(e.usage)})}export{emitTerminalSessionCompletionStep};

package/dist/src/execution/terminal-session-failure-step.d.ts

@@ -1,7 +1,9 @@
+import type { TokenUsage } from "#shared/token-usage.js";
 /** Emits a terminal `session.failed` to the adapter and durable stream. */
 export declare function emitTerminalSessionFailureStep(input: {
     readonly error: unknown;
     readonly sessionWritable: WritableStream<Uint8Array>;
     readonly serializedContext: Record<string, unknown>;
     readonly turnId?: string;
+    readonly usage: TokenUsage | undefined;
 }): Promise<void>;

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{publishTerminalSessionEvent}from"#execution/publish-session-events.js";import{summarizeKnownError}from"#harness/semantic-errors/index.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,usage:e.usage}),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.68.0//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.70.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,18 @@
+/** 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;
+/**
+ * How a tool call reads to a person: `Linear: List issues` for a
+ * `connection_execute` call, otherwise the tool's display title.
+ */
+export declare function toolCallDisplayName(toolName: string, input: unknown): 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";import{displayProperName,displayTitle}from"#shared/display-name.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 toolCallDisplayName(e,t){let n=e===`connection_execute`?readExecuteTarget(t):void 0;return n===void 0?displayTitle(e):`${displayProperName(n.connection)}: ${displayTitle(n.tool)}`}function findConnection(e,t){return e.getConnections().find(e=>e.connectionName===t)}export{CONNECTION_EXECUTE_TOOL_NAME,findConnection,qualifiedToolName,readExecuteTarget,toolCallDisplayName};

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,toolCallDisplayName}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{displayProperName}from"#shared/display-name.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}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.","Connections the user has not signed in to are listed under `unavailable` with `requiresSignIn`;","when the request needs one, search it again with `connection` and `signIn: true` to ask the user to sign in.",`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.`},signIn:{type:`boolean`,description:"Ask the user to sign in to `connection` first, then search it. Requires `connection`. Use only for a connection listed with `requiresSignIn` that the request needs."},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:{}}),label:{start:defineDurableCallback({callback:connectionSearchLabel,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){return toolCallDisplayName(CONNECTION_EXECUTE_TOOL_NAME,t)}function connectionSearchLabel(e,t){let n=isObject(t)?t.connection:void 0;return typeof n!=`string`||n===``?`Search connected tools`:isObject(t)&&t.signIn===!0?`Connect ${displayProperName(n)}`:`Search ${displayProperName(n)} tools`}async function searchConnectionTools(e,t){let n=isObject(t)?t:{},r=requireRegistry(),i=n.connection===void 0||n.connection===``?void 0:n.connection;if(n.signIn===!0&&i===void 0)throw Error("connection_search with signIn: true requires `connection`. Ask the user to sign in to one connection at a time.");let a=i===void 0?r.getConnections():[requireConnection(r,i)],o=createAuthorizationExecution();await completePendingAuthorizations(r,a,o);let s=[],c=[];for(let e of a){let t=await listConnectionTools(r,e,o,n.signIn===!0);if(`signIn`in t)return t.signIn;if(`unavailable`in t)s.push(t.unavailable);else for(let n of t.tools)c.push({connection:e,tool:n})}let l=s.filter(e=>e.terminal);if(a.length>0&&l.length===a.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(({terminal:e,...t})=>t)),p}async function listConnectionTools(e,t,n,r){let i=t.connectionName;try{return{tools:await e.getClient(i).getToolMetadata()}}catch(t){if(isConnectionAuthorizationRequiredError(t)){let a=await resolveInteractiveAuthorization(e,i);if(a!==void 0&&n.isJustAuthorized(a))return{unavailable:{connection:i,error:`Authorization failed for "${i}": the service rejected the token immediately after authorization.`,terminal:!0}};if(a===void 0){let e=`"${i}" requires authorization and cannot start interactive sign-in.`;if(r)throw Error(e);return{unavailable:{connection:i,error:e,terminal:!1}}}return r?{signIn:await n.handleError(t,a)}:{unavailable:{connection:i,error:`Sign-in required: the user has not signed in to "${i}", so its tools cannot be listed. If the request needs "${i}", call connection_search with connection "${i}" and signIn: true to ask the user to sign in.`,requiresSignIn:!0,terminal:!1}}}return log.warn(`failed to load connection tools`,{connection:i,error:t}),{unavailable:{connection:i,error:isConnectionAuthorizationFailedError(t)?`Authorization failed for "${i}": ${t.message}`:`Failed to load tools for "${i}": ${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,8 +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";
 import type { ToolInputResponseResponder } from "#tools/definition.js";
 export declare function toToolInputResponseResponder(auth: SessionAuthContext | null | undefined): ToolInputResponseResponder | undefined;
-/** 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, responder?: ToolInputResponseResponder): Promise<void>;
-/** Resolves a dismissible `ctx.ask()` request the user moved past without answering. */
-export declare function resumeWorkflowToolRunDismissal(answerToken: string): Promise<void>;
+/**
+ * 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";function toToolInputResponseResponder(e){return e==null?void 0:{authenticator:e.authenticator,principalId:e.principalId,principalType:e.principalType}}async function resumeWorkflowToolRunAnswers(e,t,n){for(let r of t??[]){let t={optionId:r.optionId,status:`answered`,text:r.text,...n===void 0?{}:{responder:n}};await resumeHook(e,t)}}async function resumeWorkflowToolRunDismissal(e){await resumeHook(e,{status:`dismissed`})}export{resumeWorkflowToolRunAnswers,resumeWorkflowToolRunDismissal,toToolInputResponseResponder};
+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};

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

@@ -1,16 +1,19 @@
 import type { SessionContext } from "#context/session-context.js";
-import type { WorkflowToolContext } from "#tools/workflow-definition.js";
-import { type WorkflowToolRunOutcome, type WorkflowToolRunOwner, type WorkflowToolRunRef } from "#execution/tools/workflow/messages.js";
+import type { AgentSessionContext } from "#execution/agent-sessions/context.js";
+import { type RunUsageTally } from "#execution/agent-sessions/usage.js";
+import type { AgentSession, WorkflowSharedContext } from "#tools/workflow-definition.js";
+import { WorkflowToolRunAsks } from "#execution/tools/workflow/ask.js";
+import type { WorkflowBodyCommand, WorkflowToolRunOutcome, WorkflowToolRunRef } from "#execution/tools/workflow/messages.js";
+import type { WorkflowToolRunInbox } from "#execution/tools/workflow/owner.js";
+import type { WorkflowToolRunEntry } from "#shared/action-types.js";
 import type { JsonObject, JsonValue } from "#shared/json.js";
+import type { ToolContext } from "#tools/definition.js";
 export interface WorkflowBodyDefinition {
-    /** Snapshot added for new runs; absent only when resuming an older durable payload. */
-    readonly agents?: WorkflowToolContext["agents"];
+    /** Everything the run needs to open `ctx.agent` sessions for its caller, and `ctx.agents`. */
+    readonly agentContext: AgentSessionContext;
     readonly callId: string;
-    /**
-     * Whether the owning session can reach a human. `false` makes `ctx.ask()`
-     * resolve as `unavailable` instead of waiting for an answer no one can give.
-     */
-    readonly canRequestInput?: boolean;
+    /** The entry point the run invokes, which decides the body's context. */
+    readonly entry: WorkflowToolRunEntry;
     readonly executeInput?: JsonValue;
     readonly input: JsonObject;
     readonly session: SessionContext["session"];
@@ -19,18 +22,56 @@ export interface WorkflowBodyDefinition {
     readonly workflowId: string;
 }
 export interface WorkflowBodyInput extends WorkflowBodyDefinition {
-    readonly owner: WorkflowToolRunOwner;
+    /** The run's control hook, which the session answers the body's questions on. */
+    readonly hookToken: string;
+    readonly owner: WorkflowToolRunInbox;
+    readonly runId?: string;
 }
-export interface WorkflowBodyResult {
-    readonly outcome: WorkflowToolRunOutcome;
-    readonly reportCount: number;
+/**
+ * How the session's commands reach a running body. What a command means
+ * depends on the entry point: a cancel ends an `execute` or `task` call, but
+ * only the current stretch of work of a `serve` task.
+ */
+export interface WorkflowBodyControl {
+    /** Aborts when the run stops for good; the run then settles as cancelled. */
+    readonly runSignal: AbortSignal;
+    /** The body is winding down cancelled work, which the run bounds with its cleanup deadline. */
+    readonly unwinding: boolean;
+    apply(command: WorkflowBodyCommand): void;
 }
-/** Executes one registered workflow body and reports progress to its owner. */
-export declare function executeWorkflowBody(input: WorkflowBodyInput & {
-    readonly execution: "background" | "blocking";
-    readonly runId?: string;
-}, signal: AbortSignal): Promise<WorkflowBodyResult>;
+/** A body the run started and how its commands reach it. */
+export interface StartedWorkflowBody {
+    /** The body's pending questions, which the session's decisions settle. */
+    readonly asks: WorkflowToolRunAsks;
+    /** Releases what the body opened, such as its `ctx.agent` sessions, once the run ends. */
+    close(): Promise<void>;
+    readonly control: WorkflowBodyControl;
+    readonly outcome: Promise<WorkflowToolRunOutcome>;
+    /** What the body's `ctx.agent` sessions spent, which the run's outcome carries. */
+    readonly usage: RunUsageTally;
+}
+/** Starts the body of an `execute` or `task` call, which serves the call the run started with. */
+export declare function startCallBody(input: WorkflowBodyInput): StartedWorkflowBody;
+/** A body's failure, or its cancellation when the run stopped. */
+export declare function toFailedOutcome(error: unknown, runSignal: AbortSignal): WorkflowToolRunOutcome;
 export declare function createWorkflowBodyRef(input: WorkflowBodyDefinition & {
-    readonly execution: "background" | "blocking";
     readonly runId?: string;
 }): WorkflowToolRunRef;
+export declare function resolveWorkflowEntryPoint<TEntryPoint>(input: WorkflowBodyInput): TEntryPoint;
+/**
+ * The members every entry point's context shares, bound to the run. `ask`
+ * is the entry point's own, since what it may ask for depends on its calls.
+ * The members that describe a call, `abortSignal`, `agents`, `callId`, and
+ * `session` (whose turn is the call's), come from the entry point, which
+ * knows its calls.
+ */
+export declare function createSharedContext(input: WorkflowBodyInput, agent: (name: string) => AgentSession, askPerson: WorkflowSharedContext["ask"]): Omit<ToolContext & WorkflowSharedContext, "abortSignal" | "agents" | "callId" | "messages" | "session">;
+/** `ctx.agents` for a call: the agents its context lists, frozen. */
+export declare function createAgentsView(context: AgentSessionContext): WorkflowSharedContext["agents"];
+export declare class WorkflowToolRunCancelledError extends Error {
+    constructor(reason: string);
+}
+/** Why an `execute` call's `abortSignal` aborted when a steering message arrived. */
+export declare class WorkflowToolRunInterruptedError extends Error {
+    constructor();
+}

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

@@ -1 +1 @@
-import{getWorkflowMetadata}from"#compiled/@workflow/core/index.js";import{normalizeSerializableError}from"#execution/workflow-errors.js";import{resumeHookStep}from"#execution/tools/workflow/resume-hook-step.js";import{ask,attachWorkflowToolRunContext}from"#execution/tools/workflow/ask.js";import{agent}from"#execution/tools/subagent/invoke-agent.js";import"#execution/tools/workflow/messages.js";import{readRegisteredWorkflow}from"#execution/workflow-registry.js";async function executeWorkflowBody(e,t){let n=createWorkflowBodyRef(e),r=createWorkflowBodyContext(e,t);attachWorkflowToolRunContext(r,{canRequestInput:e.canRequestInput,from:n,owner:e.owner});let i=0;try{let t=resolveWorkflowToolExecute(e)(e.executeInput??e.input,r),a;if(!isAsyncIterable(t))a=await t;else{let r=t[Symbol.asyncIterator](),o,s=await r.next();for(;s.done!==!0;){o=s.value;let t={from:n,update:s.value};await resumeHookStep(e.owner.inbox,{kind:`report`,...t}),i+=1,s=await r.next()}a=s.value??(e.execution===`blocking`?o:void 0)??null}return{outcome:{output:a,status:`completed`},reportCount:i}}catch(e){return t.aborted?{outcome:{reason:t.reason instanceof Error?t.reason.message:String(t.reason??``),status:`cancelled`},reportCount:i}:{outcome:{error:normalizeSerializableError(e),status:`failed`},reportCount:i}}}function createWorkflowBodyRef(e){return{callId:e.callId,execution:e.execution,input:e.input,runId:e.runId??getWorkflowMetadata().workflowRunId,sequence:e.session.turn.sequence,stepIndex:e.stepIndex,toolName:e.toolName,turnId:e.session.turn.id}}function resolveWorkflowToolExecute(e){let t=readRegisteredWorkflow(e.workflowId);if(typeof t!=`function`)throw Error(`Tool "${e.toolName}" is not registered as a workflow in this deployment (${e.workflowId}). The tool was renamed or removed after this run started.`);return t}function createWorkflowBodyContext(e,t){let unavailable=(t,n)=>{throw Error(`ctx.${t} is not available inside a workflow tool; ${n}. Tool "${e.toolName}" runs as a durable workflow body, which only replays deterministic code.`)},n={agent:((e,t)=>agent(n,e,t)),agents:Object.freeze(Object.fromEntries(Object.entries(e.agents??{}).map(([e,t])=>[e,Object.freeze({...t})]))),ask:e=>ask(n,e),abortSignal:t,callId:e.callId,getSandbox:()=>unavailable(`getSandbox()`,`the session sandbox belongs to the turn`),getToken:()=>unavailable(`getToken()`,`pass ctx directly to a "use step" helper to resolve credentials`),requireAuth:()=>unavailable(`requireAuth()`,`pass ctx directly to a "use step" helper to request authorization`),session:e.session,toolName:e.toolName};return n}function isAsyncIterable(e){return typeof e==`object`&&!!e&&typeof e[Symbol.asyncIterator]==`function`}export{createWorkflowBodyRef,executeWorkflowBody};
+import{getWorkflowMetadata}from"#compiled/@workflow/core/index.js";import{normalizeSerializableError}from"#execution/workflow-errors.js";import{createRunUsageTally}from"#execution/agent-sessions/usage.js";import{createAgentSessions}from"#execution/agent-sessions/session.js";import{WorkflowToolRunAsks,ask,attachWorkflowToolRunContext}from"#execution/tools/workflow/ask.js";import{readRegisteredWorkflow}from"#execution/workflow-registry.js";const INTERRUPTED_OUTPUT={interrupted:!0};var WorkflowCallSignals=class{body=new AbortController;run=new AbortController;asks;constructor(e){this.asks=e}get abortSignal(){return this.body.signal}get runSignal(){return this.run.signal}get interrupted(){return this.body.signal.aborted&&!this.run.signal.aborted}get unwinding(){return this.run.signal.aborted}apply(e){switch(e.kind){case`cancel`:case`end`:this.asks.cancelAll(),this.run.abort(new WorkflowToolRunCancelledError(e.reason)),this.body.abort(this.run.signal.reason);return;case`interrupt`:this.body.abort(new WorkflowToolRunInterruptedError);return;case`call`:return}}};function startCallBody(e){let t=createWorkflowBodyRef(e),n=new WorkflowToolRunAsks(t.runId),r=new WorkflowCallSignals(n),i={agentContext:e.agentContext,asks:n,auth:e.session.auth,control:e.hookToken,from:t,owner:e.owner},a=createRunUsageTally(),o=createAgentSessions(i,a),s=createCallContext(e,r,o.open);return attachWorkflowToolRunContext(s,i),{asks:n,close:o.close,control:r,outcome:executeCallBody(e,s,r,t),usage:a}}async function executeCallBody(e,t,n,r){try{let n=resolveWorkflowEntryPoint(e)(e.executeInput??e.input,t),i;if(!isAsyncIterable(n))i=await n;else{let t=n[Symbol.asyncIterator](),a,o=await t.next();for(;o.done!==!0;)a=o.value,await e.owner.send({from:r,kind:`report`,update:o.value}),o=await t.next();i=o.value??a??null}return{output:i,status:`completed`}}catch(e){return n.interrupted?{output:INTERRUPTED_OUTPUT,status:`completed`}:toFailedOutcome(e,n.runSignal)}}function toFailedOutcome(e,t){if(t.aborted){let{reason:e}=t;return{reason:e instanceof Error?e.message:String(e??``),status:`cancelled`}}return{error:normalizeSerializableError(e),status:`failed`}}function createWorkflowBodyRef(e){let t={callId:e.callId,input:e.input,runId:e.runId??getWorkflowMetadata().workflowRunId,sequence:e.session.turn.sequence,stepIndex:e.stepIndex,toolName:e.toolName,turnId:e.session.turn.id};return e.entry.entryPoint===`execute`?t:{...t,taskId:e.entry.taskId}}function resolveWorkflowEntryPoint(e){let t=readRegisteredWorkflow(e.workflowId);if(typeof t!=`function`)throw Error(`Tool "${e.toolName}" is not registered as a workflow in this deployment (${e.workflowId}). The tool was renamed or removed after this run started.`);return t}function createSharedContext(e,t,n){let unavailable=(t,n)=>{throw Error(`ctx.${t} is not available inside a workflow tool; ${n}. Tool "${e.toolName}" runs as a durable workflow body, which only replays deterministic code.`)};return{agent:t,ask:n,getSandbox:()=>unavailable(`getSandbox()`,`the session sandbox belongs to the turn`),getToken:()=>unavailable(`getToken()`,`pass ctx directly to a "use step" helper to resolve credentials`),requireAuth:()=>unavailable(`requireAuth()`,`pass ctx directly to a "use step" helper to request authorization`),toolName:e.toolName}}function createAgentsView(e){return Object.freeze(Object.fromEntries(Object.entries(e.agents).map(([e,t])=>[e,Object.freeze({...t})])))}function createCallContext(e,t,n){let r={...createSharedContext(e,n,(e,t)=>ask(r,e,t)),abortSignal:t.abortSignal,agents:createAgentsView(e.agentContext),callId:e.callId,session:e.session};return r}function isAsyncIterable(e){return typeof e==`object`&&!!e&&typeof e[Symbol.asyncIterator]==`function`}var WorkflowToolRunCancelledError=class extends Error{constructor(e){super(e),this.name=`WorkflowToolRunCancelledError`}},WorkflowToolRunInterruptedError=class extends Error{constructor(){super(`A new message arrived while the turn waited on this call.`),this.name=`WorkflowToolRunInterruptedError`}};export{WorkflowToolRunCancelledError,WorkflowToolRunInterruptedError,createAgentsView,createSharedContext,createWorkflowBodyRef,resolveWorkflowEntryPoint,startCallBody,toFailedOutcome};

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

@@ -1,8 +1,13 @@
+import type { WorkflowToolRunControlMessage } from "#execution/tools/workflow/messages.js";
 import type { WorkflowToolRunAddress } from "#execution/tools/workflow/types.js";
+/** How a run is told to stop: `end` also finishes a `serve` task's run, which a cancel keeps. */
+export type WorkflowToolRunStop = Extract<WorkflowToolRunControlMessage, {
+    readonly kind: "cancel" | "end";
+}>;
 /**
- * Asks the run to cancel itself, then bounds cooperative cleanup. Failures are
+ * Asks the run to stop itself, then bounds cooperative cleanup. Failures are
  * logged: the caller has already committed cancellation of the calling turn.
  */
-export declare function cancelWorkflowToolRun(run: WorkflowToolRunAddress, reason: string): Promise<void>;
+export declare function cancelWorkflowToolRun(run: WorkflowToolRunAddress, stop: WorkflowToolRunStop): Promise<void>;
 /** Allows cooperative cleanup, then forcibly stops a still-live run. */
 export declare function settleWorkflowToolRunCancellation(runId: string, reason: string, cooperative?: boolean): Promise<void>;

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

@@ -1 +1 @@
-import{createLogger,logError}from"#internal/logging.js";import{cancelRun,getRun,getWorld,resumeHook}from"#internal/workflow/runtime.js";import{isTaskWorkflowTargetGone}from"#execution/tasks/workflow-target.js";import{WORKFLOW_CANCELLATION_SETTLE_MS}from"#execution/tools/workflow/cancellation-policy.js";const log=createLogger(`execution.workflow-tool-run`);async function cancelWorkflowToolRun(e,t){let n={kind:`cancel`,reason:t},r=!1;try{await resumeHook(e.hookToken,n),r=!0}catch(t){isTaskWorkflowTargetGone(t)||logError(log,`failed to signal a workflow tool run to cancel; cancelling it outright`,t,{runId:e.runId})}try{await settleWorkflowToolRunCancellation(e.runId,t,r)}catch(t){if(isTaskWorkflowTargetGone(t))return;logError(log,`failed to cancel workflow tool run; it may run to completion`,t,{runId:e.runId})}}async function settleWorkflowToolRunCancellation(e,t,n=!0){if(n){let t=Date.now()+WORKFLOW_CANCELLATION_SETTLE_MS;for(;Date.now()<t;){try{let t=await getRun(e).status;if(t!==`pending`&&t!==`running`)return}catch(e){if(isTaskWorkflowTargetGone(e))return;throw e}await new Promise(e=>setTimeout(e,250))}}try{await cancelRun(await getWorld(),e,{cancelReason:t})}catch(e){if(isTaskWorkflowTargetGone(e))return;throw e}}export{cancelWorkflowToolRun,settleWorkflowToolRunCancellation};
+import{createLogger,logError}from"#internal/logging.js";import{cancelRun,getRun,getWorld,resumeHook}from"#internal/workflow/runtime.js";import{isTaskWorkflowTargetGone}from"#execution/tasks/workflow-target.js";import{WORKFLOW_CANCELLATION_SETTLE_MS}from"#execution/tools/workflow/cancellation-policy.js";const log=createLogger(`execution.workflow-tool-run`);async function cancelWorkflowToolRun(e,t){let{reason:n}=t,r=!1;try{await resumeHook(e.hookToken,t),r=!0}catch(t){isTaskWorkflowTargetGone(t)||logError(log,`failed to signal a workflow tool run to cancel; cancelling it outright`,t,{runId:e.runId})}try{await settleWorkflowToolRunCancellation(e.runId,n,r)}catch(t){if(isTaskWorkflowTargetGone(t))return;logError(log,`failed to cancel workflow tool run; it may run to completion`,t,{runId:e.runId})}}async function settleWorkflowToolRunCancellation(e,t,n=!0){if(n){let t=Date.now()+WORKFLOW_CANCELLATION_SETTLE_MS;for(;Date.now()<t;){try{let t=await getRun(e).status;if(t!==`pending`&&t!==`running`)return}catch(e){if(isTaskWorkflowTargetGone(e))return;throw e}await new Promise(e=>setTimeout(e,250))}}try{await cancelRun(await getWorld(),e,{cancelReason:t})}catch(e){if(isTaskWorkflowTargetGone(e))return;throw e}}export{cancelWorkflowToolRun,settleWorkflowToolRunCancellation};

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

@@ -1,7 +1,13 @@
-import type { WorkflowToolRunRef } from "#execution/tools/workflow/messages.js";
+import { type SessionStepState } from "#execution/publish-session-events.js";
+import { type SessionStateTransition } from "#execution/session/state-delta.js";
+import type { WorkflowToolRunAgentStartedMessage, WorkflowToolRunRef } from "#execution/tools/workflow/messages.js";
 import type { JsonValue } from "#shared/json.js";
-export declare function emitWorkflowToolRunReportStep(input: {
+/** Publishes a workflow tool run's `ctx.report()` update as `action.partial`. */
+export declare function emitWorkflowToolRunReportStep(input: SessionStepState & {
     readonly from: WorkflowToolRunRef;
-    readonly sessionWritable: WritableStream<Uint8Array>;
     readonly update: JsonValue;
-}): Promise<void>;
+}): Promise<SessionStateTransition>;
+/** Publishes `agent.started`, in order, for sessions workflow tool runs opened. */
+export declare function emitAgentStartedStep(input: SessionStepState & {
+    readonly messages: readonly WorkflowToolRunAgentStartedMessage[];
+}): Promise<SessionStateTransition>;