eve 0.71.2 → 0.72.0

package/dist/src/harness/coordination.d.ts

@@ -1,76 +1,44 @@
 import type { ModelMessage } from "ai";
-import type { RuntimeActionRequest, RuntimeWorkflowTaskRequest, WorkflowToolCallEntry } from "#shared/action-types.js";
+import type { RuntimeActionRequest, RuntimeActionResult, RuntimeWorkflowTaskRequest, WorkflowToolCallEntry } from "#shared/action-types.js";
 import { type JsonObject } from "#shared/json.js";
-import type { HarnessEmitFn, HarnessSession, HarnessToolMap, SessionStateMap, StepInput } from "#harness/types.js";
-/**
- * Serializable event coordinates for one pending coordination batch.
- *
- * Runtime action results are projected back onto the parent stream using the
- * same turn and step identity as the originating `actions.requested` batch.
- */
-interface PendingCoordinationEventMetadata {
-    readonly sequence: number;
-    readonly stepIndex: number;
-    readonly turnId: string;
-}
-/** Serializable pending coordination batch stored on `session.state`. */
-export interface PendingCoordinationBatch {
-    /** Workflow tool runs pending coordination, including agent tools. */
-    readonly tasks: readonly RuntimeWorkflowTaskRequest[];
-    readonly event: PendingCoordinationEventMetadata;
-    readonly responseMessages: readonly ModelMessage[];
-}
-/**
- * Outcome of resolving a pending coordination batch.
- */
-interface ResolvePendingCoordinationResult {
-    readonly messages: ModelMessage[];
-    readonly outcome: "continue" | "resolved" | "unresolved";
-    readonly session: HarnessSession;
-}
-/** Returns the pending coordination batch stored on the session, if any. */
-export declare function getPendingCoordinationBatch(state: SessionStateMap | undefined): PendingCoordinationBatch | undefined;
-export declare function clearPendingCoordinationBatch(session: HarnessSession): HarnessSession;
-/** What the model reads for a call its turn's cancellation stopped before the call settled. */
-export declare const CANCELLED_CALL_RESULT = "The turn was cancelled before this call finished.";
-/**
- * Moves a cancelled turn's pending batch into history instead of dropping it.
- * The model keeps the calls it made, each answered as cancelled, so it sees
- * that the work started and stopped rather than a request left unanswered.
- */
-export declare function commitCancelledCoordinationBatch(session: HarnessSession): HarnessSession;
-/**
- * Stores one pending coordination batch on the session.
- */
-export declare function setPendingCoordinationBatch<T extends {
-    readonly state?: SessionStateMap;
-}>(input: {
-    readonly tasks: readonly RuntimeWorkflowTaskRequest[];
-    readonly event: PendingCoordinationEventMetadata;
-    readonly responseMessages: readonly ModelMessage[];
-    readonly session: T;
-}): T;
+import type { HarnessSession, HarnessToolMap } from "#harness/types.js";
+type ToolResponsePart = Extract<ModelMessage, {
+    role: "tool";
+}>["content"][number];
+type ToolResultPart = Extract<ToolResponsePart, {
+    type: "tool-result";
+}>;
 /** Rejects a batch before any result or side effect can bind ambiguously by call id. */
 export declare function assertUniqueCoordinationCallIds(requests: readonly {
     readonly callId: string;
 }[]): void;
-/** Every call a pending batch waits on: workflow runs and task tool calls. */
-export declare function pendingCoordinationCallIds(batch: PendingCoordinationBatch): readonly string[];
 /**
- * Resolves one pending coordination batch back into model history.
- *
- * When all expected runtime action results are present, this appends the
- * stored assistant tool-call messages plus synthesized tool-result messages to
- * history, clears the pending batch, and emits `action.result` events back
- * onto the parent stream.
+ * Forgets the workflow runs whose results arrived. Nobody can answer what a finished run asked,
+ * so its relayed requests are returned for the machine to withdraw.
+ */
+export declare function forgetFinishedRuns(session: HarnessSession, results: readonly RuntimeActionResult[], turnId: string): {
+    readonly requestIds: readonly string[];
+    readonly session: HarnessSession;
+};
+/** Each runtime result as the model reads it, beside the result the stream reports. */
+export declare function runtimeResultCalls(results: readonly RuntimeActionResult[], tools: HarnessToolMap | undefined): Promise<{
+    readonly part: ToolResultPart;
+    readonly result: RuntimeActionResult;
+}[]>;
+/**
+ * Turns a step's deferred calls into workflow runs, committing a task record
+ * for each call that starts a task. Task tool calls stay in the response
+ * alone: the session reads them from there.
  */
-export declare function resolvePendingCoordination(input: {
-    readonly emit?: HarnessEmitFn;
+export declare function collectDeferredCalls(input: {
+    readonly session: HarnessSession;
+    readonly toolCalls: readonly CoordinationToolCall[];
+    readonly tools: HarnessToolMap;
+    readonly turnId: string;
+}): {
     readonly session: HarnessSession;
-    readonly stepInput?: StepInput;
-    /** Definitions whose `toModelOutput` projects a workflow tool's result for the model. */
-    readonly tools?: HarnessToolMap;
-}): Promise<ResolvePendingCoordinationResult>;
+    readonly workflowRequests: readonly RuntimeWorkflowTaskRequest[];
+};
 /** The parts of a model tool call that coordination turns into a runtime request. */
 export interface CoordinationToolCall {
     readonly input: unknown;

package/dist/src/harness/coordination.js

@@ -1 +1 @@
-import{createActionResultEvent}from"#protocol/message.js";import{parseJsonObject}from"#shared/json.js";import{validateHarnessModelMessages}from"#harness/messages.js";import{findBlockingWorkflowToolRun,removeBlockingWorkflowToolRuns}from"#harness/workflow-tool-runs.js";import{pendingTaskToolCalls}from"#execution/tasks/calls.js";import{resolveRuntimeActionResultsForCallIds}from"#runtime/actions/results.js";import{startsTasks}from"#execution/tasks/tool-entry-point.js";import{markRuntimeWorkflowToolAction}from"#shared/action-types.js";import{normalizeToolModelOutput}from"#harness/tool-model-output.js";import{extractHistoricalInputRequests}from"#harness/input-extraction.js";const PENDING_COORDINATION_BATCH_KEY=`eve.runtime.pendingCoordinationBatch`;function getPendingCoordinationBatch(e){let t=e?.[PENDING_COORDINATION_BATCH_KEY];if(typeof t!=`object`||!t)return;let n=t;if(Array.isArray(n.tasks)&&Array.isArray(n.responseMessages)&&typeof n.event==`object`&&n.event!==null)return n}function clearPendingCoordinationBatch(e){if(e.state?.[PENDING_COORDINATION_BATCH_KEY]===void 0)return e;let t={...e.state};return delete t[PENDING_COORDINATION_BATCH_KEY],{...e,state:Object.keys(t).length>0?t:void 0}}const CANCELLED_CALL_RESULT=`The turn was cancelled before this call finished.`;function commitCancelledCoordinationBatch(e){let t=getPendingCoordinationBatch(e.state);if(t===void 0)return e;let n=[...approvedSiblingCalls(e.history,t),...t.tasks.map(e=>({callId:e.callId,toolName:e.toolName})),...pendingTaskToolCalls(t.responseMessages).map(e=>({callId:e.callId,toolName:e.kind}))].map(({callId:e,toolName:t})=>({output:{type:`text`,value:CANCELLED_CALL_RESULT},toolCallId:e,toolName:t,type:`tool-result`})),r=validateHarnessModelMessages([...e.history,...t.responseMessages,...n.length===0?[]:[{content:n,role:`tool`}]]);return clearPendingCoordinationBatch({...e,history:r})}function approvedSiblingCalls(e,t){let n=t.responseMessages.at(-1);if(n?.role!==`tool`)return[];let r=new Set(n.content.flatMap(e=>e.type===`tool-approval-response`&&e.approved?[e.approvalId]:[])),i=new Set([...n.content.flatMap(e=>e.type===`tool-result`?[e.toolCallId]:[]),...t.tasks.map(e=>e.callId)]);return[...extractHistoricalInputRequests({history:[...e,...t.responseMessages],requestIds:r}).values()].map(({action:e})=>({callId:e.callId,toolName:e.toolName})).filter(({callId:e})=>!i.has(e))}function setPendingCoordinationBatch(e){assertUniqueCoordinationCallIds(e.tasks);let t={...e.session.state};return t[PENDING_COORDINATION_BATCH_KEY]={tasks:[...e.tasks],event:e.event,responseMessages:[...e.responseMessages]},{...e.session,state:t}}function assertUniqueCoordinationCallIds(e){let t=new Set;for(let n of e){if(t.has(n.callId))throw Error(`Coordination batch contains duplicate callId "${n.callId}".`);t.add(n.callId)}}function resolveReadyCoordinationResults(e){let t=getPendingCoordinationBatch(e.session.state);if(t!==void 0)return resolveRuntimeActionResultsForCallIds({pendingCallIds:pendingCoordinationCallIds(t),results:e.results})}function pendingCoordinationCallIds(e){let t=pendingTaskToolCalls(e.responseMessages).map(e=>e.callId);return[...e.tasks.map(e=>e.callId),...t]}async function resolvePendingCoordination(e){let t=getPendingCoordinationBatch(e.session.state);if(t===void 0)return{messages:[...e.session.history],outcome:`continue`,session:e.session};let n=resolveReadyCoordinationResults({results:e.stepInput?.runtimeActionResults??[],session:e.session});if(n===void 0)return{messages:[...e.session.history],outcome:`unresolved`,session:e.session};let r=e.session;for(let e of n){if(e.kind!==`tool-result`)continue;let n=findBlockingWorkflowToolRun(r.state,e.callId,t.event.turnId);n!==void 0&&(r=removeBlockingWorkflowToolRuns(r,t.event.turnId,n.callId))}let i={...r.state};if(delete i[PENDING_COORDINATION_BATCH_KEY],r={...r,state:Object.keys(i).length>0?i:void 0},e.emit!==void 0)for(let r of n)await e.emit(createActionResultEvent({result:r,sequence:t.event.sequence,stepIndex:t.event.stepIndex,turnId:t.event.turnId}));let a=[];for(let t of n){switch(t.kind){case`load-skill-result`:a.push({output:toToolResultOutput(t),toolCallId:t.callId,toolName:`load_skill`,type:`tool-result`});continue;case`subagent-result`:a.push({output:toToolResultOutput(t),toolCallId:t.callId,toolName:t.subagentName,type:`tool-result`});continue;case`tool-result`:a.push({output:await projectToolResultOutput(t,e.tools?.get(t.toolName)),toolCallId:t.callId,toolName:t.toolName,type:`tool-result`});continue}throw Error(`Unsupported runtime action result kind "${String(t)}".`)}let o=[...r.history,...t.responseMessages];if(a.length>0){let e=t.responseMessages.at(-1);e?.role===`tool`?o[o.length-1]={content:[...e.content,...a],role:`tool`}:o.push({content:a,role:`tool`})}return{messages:o,outcome:`resolved`,session:r}}function createRuntimeActionRequestFromToolCall(e){let t=e.tools.get(e.toolCall.toolName),n=resolveToolCallInputObject(e.toolCall.input,{callId:e.toolCall.toolCallId,toolName:e.toolCall.toolName});if(t?.frameworkAction===`load-skill`)return{callId:e.toolCall.toolCallId,input:n,kind:`load-skill`};let r={callId:e.toolCall.toolCallId,input:n,kind:`tool-call`,toolName:e.toolCall.toolName};return t?.workflowId===void 0?r:markRuntimeWorkflowToolAction(r)}function createCoordinationRequestFromToolCall(e){let t=e.tools.get(e.toolCall.toolName);if(t?.workflowId===void 0)throw Error(`Deferred tool "${e.toolCall.toolName}" has no workflow.`);return{callId:e.toolCall.toolCallId,entry:e.entry,executeInput:t.executeInput?.(e.input),input:e.input,kind:`workflow-task`,toolName:e.toolCall.toolName,workflowId:t.workflowId}}function resolveToolCallInputObject(e,t){if(e==null||typeof e==`string`&&e.trim()===``)return{};try{return parseJsonObject(typeof e==`string`?parseJsonStringInput(e):e)}catch(e){let n=e instanceof Error?e.message:String(e);throw TypeError(`Failed to parse tool-call arguments for "${t.toolName}" (${t.callId}): ${n}`,{cause:e})}}function parseJsonStringInput(e){return JSON.parse(e)}async function projectToolResultOutput(e,t){return e.isError===!0||t?.toModelOutput===void 0||startsTasks(t)?toToolResultOutput(e):normalizeToolModelOutput({output:await t.toModelOutput(e.output),toolCallId:e.callId,toolName:e.toolName})}function toToolResultOutput(e){return typeof e.output==`string`?e.isError===!0?{type:`error-text`,value:e.output}:{type:`text`,value:e.output}:e.isError===!0?{type:`error-json`,value:toMutableJsonValue(e.output)}:{type:`json`,value:toMutableJsonValue(e.output)}}function toMutableJsonValue(e){if(e===null||typeof e==`string`||typeof e==`number`||typeof e==`boolean`)return e;if(Array.isArray(e))return e.map(e=>toMutableJsonValue(e));let t={};for(let[n,r]of Object.entries(e))t[n]=toMutableJsonValue(r);return t}export{CANCELLED_CALL_RESULT,assertUniqueCoordinationCallIds,clearPendingCoordinationBatch,commitCancelledCoordinationBatch,createCoordinationRequestFromToolCall,createRuntimeActionRequestFromToolCall,getPendingCoordinationBatch,pendingCoordinationCallIds,resolvePendingCoordination,resolveToolCallInputObject,setPendingCoordinationBatch};
+import{parseJsonObject}from"#shared/json.js";import{findBlockingWorkflowToolRun,removeBlockingWorkflowToolRuns}from"#harness/workflow-tool-runs.js";import{getProxyInputRequests}from"#harness/proxy-input-requests.js";import{normalizeToolModelOutput}from"#harness/tool-model-output.js";import{startsTasks}from"#execution/tasks/tool-entry-point.js";import{markRuntimeWorkflowToolAction}from"#shared/action-types.js";import{commitCallEntry,isTaskTool}from"#execution/tasks/model-step.js";function assertUniqueCoordinationCallIds(e){let t=new Set;for(let n of e){if(t.has(n.callId))throw Error(`Coordination batch contains duplicate callId "${n.callId}".`);t.add(n.callId)}}function forgetFinishedRuns(e,t,n){let r=e,i=[];for(let e of t){if(e.kind!==`tool-result`)continue;let t=findBlockingWorkflowToolRun(r.state,e.callId,n);if(t!==void 0){for(let[e,n]of getProxyInputRequests(r.state))n.runId===t.address.runId&&i.push(e);r=removeBlockingWorkflowToolRuns(r,n,t.callId)}}return{requestIds:i,session:r}}async function runtimeResultCalls(e,t){let n=[];for(let r of e){switch(r.kind){case`load-skill-result`:n.push({part:toolResult(r,`load_skill`,toToolResultOutput(r)),result:r});continue;case`subagent-result`:n.push({part:toolResult(r,r.subagentName,toToolResultOutput(r)),result:r});continue;case`tool-result`:n.push({part:toolResult(r,r.toolName,await projectToolResultOutput(r,t?.get(r.toolName))),result:r});continue}throw Error(`Unsupported runtime action result kind "${String(r)}".`)}return n}function toolResult(e,t,n){return{output:n,toolCallId:e.callId,toolName:t,type:`tool-result`}}function collectDeferredCalls(e){let{session:t}=e,n=[];for(let r of e.toolCalls){let i=e.tools.get(r.toolName);if(isTaskTool(i))continue;let a=commitCallEntry(t,{callId:r.toolCallId,definition:i,input:resolveToolCallInputObject(r.input,{callId:r.toolCallId,toolName:r.toolName}),toolName:r.toolName,turnId:e.turnId});t=a.session,n.push(createCoordinationRequestFromToolCall({entry:a.entry,input:a.input,toolCall:r,tools:e.tools}))}return{session:t,workflowRequests:n}}function createRuntimeActionRequestFromToolCall(e){let t=e.tools.get(e.toolCall.toolName),n=resolveToolCallInputObject(e.toolCall.input,{callId:e.toolCall.toolCallId,toolName:e.toolCall.toolName});if(t?.frameworkAction===`load-skill`)return{callId:e.toolCall.toolCallId,input:n,kind:`load-skill`};let r=t?.behavior?.handling;if(t!==void 0&&r?.kind===`dispatch`&&r.target.kind!==`workflow-tool-call`){let i=r.target,a={callId:e.toolCall.toolCallId,description:t.description,input:n,name:e.toolCall.toolName,nodeId:i.nodeId};return i.kind===`remote-agent-call`?{...a,kind:`remote-agent-call`,remoteAgentName:i.remoteAgentName}:{...a,kind:`subagent-call`,subagentName:i.subagentName}}let i={callId:e.toolCall.toolCallId,input:n,kind:`tool-call`,toolName:e.toolCall.toolName};return t?.workflowId===void 0?i:markRuntimeWorkflowToolAction(i)}function createCoordinationRequestFromToolCall(e){let t=e.tools.get(e.toolCall.toolName);if(t?.workflowId===void 0)throw Error(`Deferred tool "${e.toolCall.toolName}" has no workflow.`);return{callId:e.toolCall.toolCallId,entry:e.entry,executeInput:t.executeInput?.(e.input),input:e.input,kind:`workflow-task`,toolName:e.toolCall.toolName,workflowId:t.workflowId}}function resolveToolCallInputObject(e,t){if(e==null||typeof e==`string`&&e.trim()===``)return{};try{return parseJsonObject(typeof e==`string`?parseJsonStringInput(e):e)}catch(e){let n=e instanceof Error?e.message:String(e);throw TypeError(`Failed to parse tool-call arguments for "${t.toolName}" (${t.callId}): ${n}`,{cause:e})}}function parseJsonStringInput(e){return JSON.parse(e)}async function projectToolResultOutput(e,t){return e.isError===!0||t?.toModelOutput===void 0||startsTasks(t)?toToolResultOutput(e):normalizeToolModelOutput({output:await t.toModelOutput(e.output),toolCallId:e.callId,toolName:e.toolName})}function toToolResultOutput(e){return typeof e.output==`string`?e.isError===!0?{type:`error-text`,value:e.output}:{type:`text`,value:e.output}:e.isError===!0?{type:`error-json`,value:toMutableJsonValue(e.output)}:{type:`json`,value:toMutableJsonValue(e.output)}}function toMutableJsonValue(e){if(e===null||typeof e==`string`||typeof e==`number`||typeof e==`boolean`)return e;if(Array.isArray(e))return e.map(e=>toMutableJsonValue(e));let t={};for(let[n,r]of Object.entries(e))t[n]=toMutableJsonValue(r);return t}export{assertUniqueCoordinationCallIds,collectDeferredCalls,createCoordinationRequestFromToolCall,createRuntimeActionRequestFromToolCall,forgetFinishedRuns,resolveToolCallInputObject,runtimeResultCalls};

package/dist/src/harness/current-messages.d.ts

@@ -1,4 +1,4 @@
-import type { ModelMessage, SystemModelMessage } from "ai";
+import type { SystemModelMessage } from "ai";
 import type { HistoryState } from "#context/keys.js";
 import type { Announcement } from "#harness/announcements.js";
 import { type FrameworkMessageKind, type HarnessModelMessage } from "#harness/messages.js";
@@ -24,6 +24,4 @@ export declare function createCurrentMessages(history: readonly HarnessModelMess
     addAnnouncements(announcements: CurrentAnnouncements): void;
     addSystem(messages: SystemModelMessage | readonly SystemModelMessage[]): void;
 };
-/** True when the history ends with a tool message carrying a tool-approval-response. */
-export declare function hasTailApprovalResponse(messages: readonly ModelMessage[]): boolean;
 export {};

package/dist/src/harness/current-messages.js

@@ -1 +1 @@
-import{createFrameworkUserMessage}from"#harness/messages.js";function createCurrentMessages(e,t={}){let n=[...e],r={...t.historyState},i=[],a=[],o=new Set(t.currentTurnMessages),s;for(let n of t.projectedMessages??e)s===void 0&&o.has(n)&&(s=a.length),n.role===`system`?i.push(n):a.push(n);let c=s??a.length,l=e.findIndex(e=>o.has(e)),u=l===-1?e.length:l,d=s!==void 0||!hasTailApprovalResponse(a);function appendUserMessage(e,t){let r=createFrameworkUserMessage(t,e);a.splice(c,0,r),n.splice(u,0,r),c+=1,u+=1}function add(e,t,{cacheFriendly:n=!0}={}){if(n&&d){appendUserMessage(e,t);return}i.push({role:`system`,content:e})}return{add,addAnnouncements(e){if(!d)return;let t=e.availableSkills;t!==void 0&&t.length>0&&r.availableSkills!==t&&(appendUserMessage(t,`context.state`),r.availableSkills=t);let n=e.keyed??{};for(let e of Object.keys(n).sort()){let t=n[e],i=r.announcements?.[e];if(i===t.value)continue;let a=t.render(i);a!==void 0&&appendUserMessage(a,`context.state`),r.announcements={...r.announcements,[e]:t.value}}},addSystem(e){i.push(...Array.isArray(e)?e:[e])},get nonSystemMessages(){return[...a]},get history(){return[...n]},get historyState(){return{...r}},get systemMessages(){return[...i]}}}function hasTailApprovalResponse(e){let t=e.at(-1);return t?.role===`tool`&&t.content.some(e=>e.type===`tool-approval-response`)}export{createCurrentMessages,hasTailApprovalResponse};
+import{createFrameworkUserMessage}from"#harness/messages.js";function createCurrentMessages(e,t={}){let n=[...e],r={...t.historyState},i=[],a=[],o=new Set(t.currentTurnMessages),s;for(let n of t.projectedMessages??e)s===void 0&&o.has(n)&&(s=a.length),n.role===`system`?i.push(n):a.push(n);let c=s??a.length,l=e.findIndex(e=>o.has(e)),u=l===-1?e.length:l;function appendUserMessage(e,t){let r=createFrameworkUserMessage(t,e);a.splice(c,0,r),n.splice(u,0,r),c+=1,u+=1}function add(e,t,{cacheFriendly:n=!0}={}){if(n){appendUserMessage(e,t);return}i.push({role:`system`,content:e})}return{add,addAnnouncements(e){let t=e.availableSkills;t!==void 0&&t.length>0&&r.availableSkills!==t&&(appendUserMessage(t,`context.state`),r.availableSkills=t);let n=e.keyed??{};for(let e of Object.keys(n).sort()){let t=n[e],i=r.announcements?.[e];if(i===t.value)continue;let a=t.render(i);a!==void 0&&appendUserMessage(a,`context.state`),r.announcements={...r.announcements,[e]:t.value}}},addSystem(e){i.push(...Array.isArray(e)?e:[e])},get nonSystemMessages(){return[...a]},get history(){return[...n]},get historyState(){return{...r}},get systemMessages(){return[...i]}}}export{createCurrentMessages};

package/dist/src/harness/emission.d.ts

@@ -5,57 +5,8 @@ type ToolResponsePart = Extract<ModelMessage, {
 type InlineToolResultPart = Extract<ToolResponsePart, {
     type: "tool-result";
 }>;
-import type { RuntimeIdentity, RuntimeTraceContext } from "#protocol/message.js";
-import type { JsonObject } from "#shared/json.js";
-import type { TokenUsage } from "#shared/token-usage.js";
-import type { HarnessEmissionState } from "#harness/emission-state.js";
-import type { HarnessEmitFn, HarnessToolMap, StepInput } from "#harness/types.js";
-export { getHarnessEmissionState, isHarnessBetweenTurns, setHarnessEmissionState, } from "#harness/emission-state.js";
-export type { HarnessEmissionState } from "#harness/emission-state.js";
-/**
- * Emits `session.started` (once), `turn.started`, and `message.received` at the
- * beginning of a new turn. Returns updated emission state.
- */
-export declare function emitTurnPreamble(emitFn: HarnessEmitFn, input: StepInput, state: HarnessEmissionState, messages: readonly ModelMessage[], runtimeIdentity?: RuntimeIdentity, traceContext?: RuntimeTraceContext): Promise<HarnessEmissionState>;
-/**
- * Emits `step.started` for one model call.
- */
-export declare function emitStepStarted(emitFn: HarnessEmitFn, state: HarnessEmissionState, modelId: string, messages?: readonly import("ai").ModelMessage[]): Promise<void>;
-interface FailedStepPayload {
-    readonly code: string;
-    readonly details?: JsonObject;
-    readonly message: string;
-}
-/**
- * Emits the full terminal failure cascade: `step.failed` →
- * `turn.failed` → `session.failed`.
- *
- * Use this when the session cannot be salvaged (structural config
- * error, auth misconfig, non-recoverable provider response). The
- * `session.failed` tail tells adapters the session is dead and no
- * further follow-up is possible on the same continuation token.
- */
-export declare function emitFailedStep(emitFn: HarnessEmitFn, state: HarnessEmissionState, input: FailedStepPayload & {
-    readonly sessionId: string;
-    readonly usage: TokenUsage;
-}): Promise<void>;
-/**
- * Emits the recoverable failure cascade: `step.failed` →
- * `turn.failed` → `session.waiting`.
- */
-export declare function emitRecoverableFailedTurn(emitFn: HarnessEmitFn, state: HarnessEmissionState, input: FailedStepPayload & {
-    readonly continuationToken: string;
-    readonly usage: TokenUsage;
-}): Promise<HarnessEmissionState>;
-/**
- * Returns updated emission state for the next step in the current turn.
- */
-export declare function advanceStep(state: HarnessEmissionState): HarnessEmissionState;
-/**
- * Emits `turn.completed` and `session.waiting` with the session's `usage`.
- * Returns updated emission state with an incremented sequence.
- */
-export declare function emitTurnEpilogue(emitFn: HarnessEmitFn, state: HarnessEmissionState, messages: readonly ModelMessage[], usage: TokenUsage): Promise<HarnessEmissionState>;
+import type { TurnPosition } from "#harness/session-machine/view.js";
+import type { HarnessEmitFn, HarnessToolMap } from "#harness/types.js";
 /**
  * Result of consuming one step's `fullStream`.
  *
@@ -87,4 +38,5 @@ interface StreamActionEmissionOptions {
  * stream batch into one request event before their first result. A result
  * without a streamed call resumes a call from an earlier step.
  */
-export declare function emitStreamContent(emitFn: HarnessEmitFn, state: HarnessEmissionState, fullStream: AsyncIterable<TextStreamPart<ToolSet>>, options?: StreamActionEmissionOptions): Promise<EmittedStreamContent>;
+export declare function emitStreamContent(emitFn: HarnessEmitFn, state: TurnPosition, fullStream: AsyncIterable<TextStreamPart<ToolSet>>, options?: StreamActionEmissionOptions): Promise<EmittedStreamContent>;
+export {};

package/dist/src/harness/emission.js

@@ -1 +1 @@
-import{createActionInputAppendedEvent,createActionPartialEvent,createActionResultEvent,createActionsRequestedEvent,createMessageAppendedEvent,createMessageCompletedEvent,createMessageReceivedEvent,createReasoningAppendedEvent,createReasoningCompletedEvent,createSessionFailedEvent,createSessionStartedEvent,createSessionWaitingEvent,createStepFailedEvent,createStepStartedEvent,createTurnCompletedEvent,createTurnFailedEvent,createTurnStartedEvent}from"#protocol/message.js";import{createRuntimeToolResultFromStepResult,createRuntimeToolResultFromToolError,createToolResultMessagePartFromToolError}from"#harness/action-result-helpers.js";import{emitNestedToolActions}from"#harness/nested-actions.js";import{createInvalidToolCallInputError,isInvalidToolCall,resolveProviderToolCallRequest}from"#harness/tool-call-input-errors.js";import{collectActionPresentation,createPresentedRuntimeActionRequestFromToolCall}from"#harness/action-presentation.js";import{projectDeltaPresentation,projectResultPresentation}from"#harness/tool-presentation.js";import{createProviderStreamActionBatch}from"#harness/stream-actions.js";import{normalizeModelStreamError}from"#harness/model-call-error.js";import{createOrderedStreamEmitter}from"#harness/ordered-stream-emitter.js";import{interruptStreamOnFailure}from"#harness/interruptible-stream.js";import{isInlineAuthorizationToolResult}from"#harness/inline-tool-authorization.js";import{normalizeAssistantStepFinishReason}from"#harness/finish-reason.js";import{getHarnessEmissionState,isHarnessBetweenTurns,setHarnessEmissionState}from"#harness/emission-state.js";async function emitTurnPreamble(e,t,n,r,i,a){let o=n.turnId!==``,s=o?n.turnId:`turn_${n.sequence}`;n.sessionStarted||await e(createSessionStartedEvent({runtime:i,trace:a})),o||await e(createTurnStartedEvent({sequence:n.sequence,trace:a,turnId:s}),r),t.message!==void 0&&await e(createMessageReceivedEvent({message:t.message,sequence:n.sequence,turnId:s}));let c={sessionStarted:!0,sequence:n.sequence,stepIndex:o?n.stepIndex:0,turnId:s};return o&&n.assistantOutputStarted?{...c,assistantOutputStarted:!0}:c}async function emitStepStarted(e,t,n,r){await e(createStepStartedEvent({modelId:n,sequence:t.sequence,stepIndex:t.stepIndex,turnId:t.turnId}),r)}async function emitStepAndTurnFailed(e,t,n){await e(createStepFailedEvent({...n,sequence:t.sequence,stepIndex:t.stepIndex,turnId:t.turnId})),await e(createTurnFailedEvent({...n,sequence:t.sequence,turnId:t.turnId}))}async function emitFailedStep(e,t,n){await emitStepAndTurnFailed(e,t,n),await e(createSessionFailedEvent(n))}async function emitRecoverableFailedTurn(e,t,n){return await emitStepAndTurnFailed(e,t,n),await e(createSessionWaitingEvent(n.usage)),{sessionStarted:t.sessionStarted,sequence:t.sequence+1,stepIndex:0,turnId:``}}function advanceStep(e){return{...e,stepIndex:e.stepIndex+1}}async function emitTurnEpilogue(e,t,n,r){return await e(createTurnCompletedEvent({sequence:t.sequence,turnId:t.turnId}),n),await e(createSessionWaitingEvent(r)),{sessionStarted:t.sessionStarted,sequence:t.sequence+1,stepIndex:0,turnId:``}}async function emitStreamContent(e,t,n,r){let i=createOrderedStreamEmitter(e),a=createProviderStreamActionBatch({emitFn:i.emit,state:t});try{return await consumeStreamContent(i.emit,t,interruptStreamOnFailure(n,i.failureSignal),a,r)}finally{try{await a.cancel()}finally{await i.closeAndDrain()}}}function reportedFinishReason(e,t){return t&&e===`stop`?`tool-calls`:e}async function consumeStreamContent(e,t,n,r,i){let a=``,o=``,s=`stop`,c,l=new Set,u=new Set,d=new Set,f=new Set,p=new Set,m=new Set,h=[],g=[],_=new Map,v=new Map,flushCurrentMessage=async()=>{o.length!==0&&(await e(createMessageCompletedEvent({finishReason:`tool-calls`,message:o,sequence:t.sequence,stepIndex:t.stepIndex,turnId:t.turnId})),o=``)},emitActionInput=async(n,r,i)=>e(createActionInputAppendedEvent({callId:n,inputTextDelta:i,sequence:t.sequence,stepIndex:t.stepIndex,toolName:r,turnId:t.turnId})),emitActionRequest=async n=>{let{action:r}=n;u.has(r.callId)||(o.trim().length>0&&await flushCurrentMessage(),u.add(r.callId),_.set(r.callId,r.input),await e(createActionsRequestedEvent({actions:[r],presentation:collectActionPresentation([n]),sequence:t.sequence,stepIndex:t.stepIndex,turnId:t.turnId})))},collectProviderToolCall=async e=>{if(f.has(e.toolCallId)||(f.add(e.toolCallId),u.has(e.toolCallId)))return;u.add(e.toolCallId),o.trim().length>0&&await flushCurrentMessage();let t=resolveProviderToolCallRequest(e,i?.tools??new Map);if(t.toolError!==void 0){m.add(e.toolCallId),await emitActionResult(createRuntimeToolResultFromToolError(t.toolError)),p.add(e.toolCallId),g.push(createToolResultMessagePartFromToolError(t.toolError));return}_.set(t.request.action.callId,t.request.action.input),r.observe(t.request)},emitActionResult=async n=>{if(d.has(n.callId))return;d.add(n.callId),await emitNestedToolActions(e,t,n.callId);let r=n.isError===!0?void 0:projectResultPresentation(i?.tools.get(n.toolName),n.callId,_.get(n.callId),n.output);await e(createActionResultEvent({presentation:r,result:n,sequence:t.sequence,stepIndex:t.stepIndex,turnId:t.turnId}))},emitActionPartial=async n=>{let r=projectDeltaPresentation(i?.tools.get(n.toolName),n.callId,_.get(n.callId),n.output);await e(createActionPartialEvent({presentation:r,result:n,sequence:t.sequence,stepIndex:t.stepIndex,turnId:t.turnId}))},emitToolCall=async e=>{if(isInvalidToolCall(e)){m.add(e.toolCallId);return}if(!(i===void 0||i.excludedActionToolNames.has(e.toolName)))try{await emitActionRequest(createPresentedRuntimeActionRequestFromToolCall({toolCall:e,tools:i.tools}))}catch(t){if(t instanceof TypeError){let n=createInvalidToolCallInputError({error:t,toolCall:e});m.add(e.toolCallId),o.trim().length>0&&await flushCurrentMessage(),await emitActionResult(createRuntimeToolResultFromToolError(n)),p.add(e.toolCallId),g.push(createToolResultMessagePartFromToolError(n));return}throw t}};for await(let d of n)if(c===void 0)switch(d.type){case`reasoning-delta`:await r.flush(),a+=d.text,await e(createReasoningAppendedEvent({reasoningDelta:d.text,sequence:t.sequence,stepIndex:t.stepIndex,turnId:t.turnId}));break;case`text-delta`:await r.flush(),a.trim().length>0&&(await e(createReasoningCompletedEvent({reasoning:a,sequence:t.sequence,stepIndex:t.stepIndex,turnId:t.turnId})),a=``),o+=d.text,await e(createMessageAppendedEvent({messageDelta:d.text,sequence:t.sequence,stepIndex:t.stepIndex,turnId:t.turnId}));break;case`tool-input-start`:if(i===void 0||d.providerExecuted===!0||i.excludedActionToolNames.has(d.toolName)){v.delete(d.id);break}await r.flush(),o.trim().length>0&&await flushCurrentMessage(),v.set(d.id,{toolName:d.toolName});break;case`tool-input-delta`:{let e=v.get(d.id);if(e===void 0)break;await r.flush(),await emitActionInput(d.id,e.toolName,d.delta);break}case`tool-input-end`:v.delete(d.id);break;case`tool-call`:{let e=d;v.delete(e.toolCallId),l.add(e.toolCallId),e.providerExecuted===!0?await collectProviderToolCall(e):(await r.flush(),await emitToolCall(e));break}case`tool-result`:{let e=d;if(e.preliminary===!0){e.providerExecuted!==!0&&await emitActionPartial(createRuntimeToolResultFromStepResult(e));break}if(e.providerExecuted===!0){await collectProviderToolCall({input:`input`in e?e.input:void 0,toolCallId:e.toolCallId,toolName:e.toolName}),await r.flush(),await emitActionResult(createRuntimeToolResultFromStepResult(e));break}if(l.has(d.toolCallId)){if(isInlineAuthorizationToolResult(e))break;u.has(d.toolCallId)&&(await emitActionResult(createRuntimeToolResultFromStepResult(e)),p.add(d.toolCallId));break}if(await r.flush(),await flushCurrentMessage(),isInlineAuthorizationToolResult(e)){p.add(d.toolCallId),h.push(e);break}await emitActionResult(createRuntimeToolResultFromStepResult(e)),p.add(d.toolCallId);break}case`tool-error`:{let e=d;e.providerExecuted===!0?(await collectProviderToolCall(e),await r.flush(),await emitActionResult(createRuntimeToolResultFromToolError(e))):u.has(e.toolCallId)?(await emitActionResult(createRuntimeToolResultFromToolError(e)),p.add(e.toolCallId),g.push(createToolResultMessagePartFromToolError(e))):l.has(e.toolCallId)||(await emitActionResult(createRuntimeToolResultFromToolError(e)),p.add(e.toolCallId));break}case`finish-step`:s=normalizeAssistantStepFinishReason(d.finishReason),await r.flush();break;case`error`:c=normalizeModelStreamError(d.error);break;case`abort`:throw new DOMException(d.reason??`The model stream was aborted.`,`AbortError`)}if(await r.flush(),c!==void 0)throw c;return a.trim().length>0&&await e(createReasoningCompletedEvent({reasoning:a,sequence:t.sequence,stepIndex:t.stepIndex,turnId:t.turnId})),s!==`content-filter`&&o.trim().length>0&&await e(createMessageCompletedEvent({finishReason:reportedFinishReason(s,i?.hidesHeldText===!0),message:o,sequence:t.sequence,stepIndex:t.stepIndex,turnId:t.turnId})),{emittedActionCallIds:u,handledInlineToolResultCallIds:p,invalidInputToolCallIds:m,inlineAuthorizationResults:h,trailingInlineToolResultParts:g}}export{advanceStep,emitFailedStep,emitRecoverableFailedTurn,emitStepStarted,emitStreamContent,emitTurnEpilogue,emitTurnPreamble,getHarnessEmissionState,isHarnessBetweenTurns,setHarnessEmissionState};
+import{createActionInputAppendedEvent,createActionPartialEvent,createActionResultEvent,createActionsRequestedEvent,createMessageAppendedEvent,createMessageCompletedEvent,createReasoningAppendedEvent,createReasoningCompletedEvent}from"#protocol/message.js";import{createRuntimeToolResultFromStepResult,createRuntimeToolResultFromToolError,createToolResultMessagePartFromToolError}from"#harness/action-result-helpers.js";import{emitNestedToolActions}from"#harness/nested-actions.js";import{createInvalidToolCallInputError,isInvalidToolCall,resolveProviderToolCallRequest}from"#harness/tool-call-input-errors.js";import{collectActionPresentation,createPresentedRuntimeActionRequestFromToolCall}from"#harness/action-presentation.js";import{projectDeltaPresentation,projectResultPresentation}from"#harness/tool-presentation.js";import{createProviderStreamActionBatch}from"#harness/stream-actions.js";import{normalizeModelStreamError}from"#harness/model-call/errors.js";import{createOrderedStreamEmitter}from"#harness/ordered-stream-emitter.js";import{interruptStreamOnFailure}from"#harness/interruptible-stream.js";import{isInlineAuthorizationToolResult}from"#harness/inline-tool-authorization.js";import{normalizeAssistantStepFinishReason}from"#harness/finish-reason.js";async function emitStreamContent(e,t,n,r){let i=createOrderedStreamEmitter(e),a=createProviderStreamActionBatch({emitFn:i.emit,state:t});try{return await consumeStreamContent(i.emit,t,interruptStreamOnFailure(n,i.failureSignal),a,r)}finally{try{await a.cancel()}finally{await i.closeAndDrain()}}}function reportedFinishReason(e,t){return t&&e===`stop`?`tool-calls`:e}async function consumeStreamContent(e,t,n,r,i){let a=``,o=``,s=`stop`,c,l=new Set,u=new Set,d=new Set,f=new Set,p=new Set,m=new Set,h=[],g=[],_=new Map,v=new Map,flushCurrentMessage=async()=>{o.length!==0&&(await e(createMessageCompletedEvent({finishReason:`tool-calls`,message:o,sequence:t.sequence,stepIndex:t.stepIndex,turnId:t.turnId})),o=``)},emitActionInput=async(n,r,i)=>e(createActionInputAppendedEvent({callId:n,inputTextDelta:i,sequence:t.sequence,stepIndex:t.stepIndex,toolName:r,turnId:t.turnId})),emitActionRequest=async n=>{let{action:r}=n;u.has(r.callId)||(o.trim().length>0&&await flushCurrentMessage(),u.add(r.callId),_.set(r.callId,r.input),await e(createActionsRequestedEvent({actions:[r],presentation:collectActionPresentation([n]),sequence:t.sequence,stepIndex:t.stepIndex,turnId:t.turnId})))},collectProviderToolCall=async e=>{if(f.has(e.toolCallId)||(f.add(e.toolCallId),u.has(e.toolCallId)))return;u.add(e.toolCallId),o.trim().length>0&&await flushCurrentMessage();let t=resolveProviderToolCallRequest(e,i?.tools??new Map);if(t.toolError!==void 0){m.add(e.toolCallId),await emitActionResult(createRuntimeToolResultFromToolError(t.toolError)),p.add(e.toolCallId),g.push(createToolResultMessagePartFromToolError(t.toolError));return}_.set(t.request.action.callId,t.request.action.input),r.observe(t.request)},emitActionResult=async n=>{if(d.has(n.callId))return;d.add(n.callId),await emitNestedToolActions(e,t,n.callId);let r=n.isError===!0?void 0:projectResultPresentation(i?.tools.get(n.toolName),n.callId,_.get(n.callId),n.output);await e(createActionResultEvent({presentation:r,result:n,sequence:t.sequence,stepIndex:t.stepIndex,turnId:t.turnId}))},emitActionPartial=async n=>{let r=projectDeltaPresentation(i?.tools.get(n.toolName),n.callId,_.get(n.callId),n.output);await e(createActionPartialEvent({presentation:r,result:n,sequence:t.sequence,stepIndex:t.stepIndex,turnId:t.turnId}))},emitToolCall=async e=>{if(isInvalidToolCall(e)){m.add(e.toolCallId);return}if(!(i===void 0||i.excludedActionToolNames.has(e.toolName)))try{await emitActionRequest(createPresentedRuntimeActionRequestFromToolCall({toolCall:e,tools:i.tools}))}catch(t){if(t instanceof TypeError){let n=createInvalidToolCallInputError({error:t,toolCall:e});m.add(e.toolCallId),o.trim().length>0&&await flushCurrentMessage(),await emitActionResult(createRuntimeToolResultFromToolError(n)),p.add(e.toolCallId),g.push(createToolResultMessagePartFromToolError(n));return}throw t}};for await(let d of n)if(c===void 0)switch(d.type){case`reasoning-delta`:await r.flush(),a+=d.text,await e(createReasoningAppendedEvent({reasoningDelta:d.text,sequence:t.sequence,stepIndex:t.stepIndex,turnId:t.turnId}));break;case`text-delta`:await r.flush(),a.trim().length>0&&(await e(createReasoningCompletedEvent({reasoning:a,sequence:t.sequence,stepIndex:t.stepIndex,turnId:t.turnId})),a=``),o+=d.text,await e(createMessageAppendedEvent({messageDelta:d.text,sequence:t.sequence,stepIndex:t.stepIndex,turnId:t.turnId}));break;case`tool-input-start`:if(i===void 0||d.providerExecuted===!0||i.excludedActionToolNames.has(d.toolName)){v.delete(d.id);break}await r.flush(),o.trim().length>0&&await flushCurrentMessage(),v.set(d.id,{toolName:d.toolName});break;case`tool-input-delta`:{let e=v.get(d.id);if(e===void 0)break;await r.flush(),await emitActionInput(d.id,e.toolName,d.delta);break}case`tool-input-end`:v.delete(d.id);break;case`tool-call`:{let e=d;v.delete(e.toolCallId),l.add(e.toolCallId),e.providerExecuted===!0?await collectProviderToolCall(e):(await r.flush(),await emitToolCall(e));break}case`tool-result`:{let e=d;if(e.preliminary===!0){e.providerExecuted!==!0&&await emitActionPartial(createRuntimeToolResultFromStepResult(e));break}if(e.providerExecuted===!0){await collectProviderToolCall({input:`input`in e?e.input:void 0,toolCallId:e.toolCallId,toolName:e.toolName}),await r.flush(),await emitActionResult(createRuntimeToolResultFromStepResult(e));break}if(l.has(d.toolCallId)){if(isInlineAuthorizationToolResult(e))break;u.has(d.toolCallId)&&(await emitActionResult(createRuntimeToolResultFromStepResult(e)),p.add(d.toolCallId));break}if(await r.flush(),await flushCurrentMessage(),isInlineAuthorizationToolResult(e)){p.add(d.toolCallId),h.push(e);break}await emitActionResult(createRuntimeToolResultFromStepResult(e)),p.add(d.toolCallId);break}case`tool-error`:{let e=d;e.providerExecuted===!0?(await collectProviderToolCall(e),await r.flush(),await emitActionResult(createRuntimeToolResultFromToolError(e))):u.has(e.toolCallId)&&(await emitActionResult(createRuntimeToolResultFromToolError(e)),p.add(e.toolCallId),g.push(createToolResultMessagePartFromToolError(e)));break}case`finish-step`:s=normalizeAssistantStepFinishReason(d.finishReason),await r.flush();break;case`error`:c=normalizeModelStreamError(d.error);break;case`abort`:throw new DOMException(d.reason??`The model stream was aborted.`,`AbortError`)}if(await r.flush(),c!==void 0)throw c;return a.trim().length>0&&await e(createReasoningCompletedEvent({reasoning:a,sequence:t.sequence,stepIndex:t.stepIndex,turnId:t.turnId})),s!==`content-filter`&&o.trim().length>0&&await e(createMessageCompletedEvent({finishReason:reportedFinishReason(s,i?.hidesHeldText===!0),message:o,sequence:t.sequence,stepIndex:t.stepIndex,turnId:t.turnId})),{emittedActionCallIds:u,handledInlineToolResultCallIds:p,invalidInputToolCallIds:m,inlineAuthorizationResults:h,trailingInlineToolResultParts:g}}export{emitStreamContent};

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

@@ -17,6 +17,7 @@ export interface HarnessToolDefinition {
     readonly execute?: (input: any, options: ToolExecuteOptions) => any;
     /** Optional JSON input substituted when this tool starts its workflow body. */
     readonly executeInput?: (input: unknown) => JsonValue;
+    readonly frameworkTool?: boolean;
     readonly frameworkAction?: "load-skill" | "task-cancel" | "task-wait";
     readonly inputSchema: FlexibleSchema;
     readonly name: string;

package/dist/src/harness/final-output.d.ts

@@ -4,6 +4,11 @@ import type { JsonObject } from "#shared/json.js";
  * Stable model-visible name for the kernel structured-output interception.
  */
 export declare const FINAL_OUTPUT_TOOL_NAME = "final_output";
+/**
+ * What the model reads when it gives its final output beside calls whose results it hasn't seen:
+ * the turn can't end on an answer written before them, so it answers again once they arrive.
+ */
+export declare const FINAL_OUTPUT_BESIDE_PENDING_CALLS = "Your final output wasn't delivered because other calls in this response were still running. Use their results, then call final_output again.";
 /**
  * Builds the model-facing `final_output` tool from a lowered output schema.
  *

package/dist/src/harness/final-output.js

@@ -1 +1 @@
-import{defineJsonSchema,toModelSchema}from"#tools/schema.js";const FINAL_OUTPUT_TOOL_NAME=`final_output`;function buildFinalOutputTool(e){let t=toModelSchema(defineJsonSchema(e),`input`);return{description:`Deliver your final answer in the required structure by calling this tool. Call it exactly once, when you are done; do not answer in prose.`,inputSchema:t,outputSchema:t}}export{FINAL_OUTPUT_TOOL_NAME,buildFinalOutputTool};
+import{defineJsonSchema,toModelSchema}from"#tools/schema.js";const FINAL_OUTPUT_TOOL_NAME=`final_output`,FINAL_OUTPUT_BESIDE_PENDING_CALLS=`Your final output wasn't delivered because other calls in this response were still running. Use their results, then call final_output again.`;function buildFinalOutputTool(e){let t=toModelSchema(defineJsonSchema(e),`input`);return{description:`Deliver your final answer in the required structure by calling this tool. Call it exactly once, when you are done; do not answer in prose.`,inputSchema:t,outputSchema:t}}export{FINAL_OUTPUT_BESIDE_PENDING_CALLS,FINAL_OUTPUT_TOOL_NAME,buildFinalOutputTool};

package/dist/src/harness/hitl/approvals.d.ts

@@ -0,0 +1,115 @@
+import type { SessionAuthContext } from "#channel/types.js";
+import type { ModelMessage } from "ai";
+import type { getApprovalAuditState } from "#harness/hitl/candidates.js";
+import { type AuthorizationChallenge } from "#harness/authorization.js";
+import { type ResolvedInputBatch } from "#harness/input-request-resolution.js";
+import type { StepInput } from "#harness/types.js";
+import type { RuntimeWorkflowTaskRequest } from "#shared/action-types.js";
+import type { InputRequest } from "#shared/input.js";
+import type { Transition } from "#harness/session-machine/commit.js";
+import { type ResolvedStepInput } from "./delivery.js";
+import type { StepCoordinates, SuspendedStep } from "#harness/session-machine/view.js";
+import { type SessionView } from "#harness/session-machine/view.js";
+/**
+ * A model response made calls that need a person's approval. The response waits in a suspended
+ * step, beside any runtime calls it made, and the turn holds until the answers arrive.
+ */
+export declare function parkOnApprovals(view: SessionView, input: {
+    readonly event: StepCoordinates;
+    readonly messages: readonly ModelMessage[];
+    readonly requests: readonly InputRequest[];
+    readonly tasks: readonly RuntimeWorkflowTaskRequest[];
+    readonly responseAuthRequiredRequestIds?: readonly string[];
+    readonly requester?: SuspendedStep["requester"];
+}): Transition;
+/** Approved workflow and agent calls join the runs their steps wait on, as their approvers. */
+export declare function dispatch(view: SessionView, input: {
+    readonly approvers: Readonly<Record<string, SessionAuthContext>>;
+    readonly tasks: readonly RuntimeWorkflowTaskRequest[];
+}): Transition;
+/**
+ * Approved calls run before the delivery's own input, as the AI SDK ran them: the model reads
+ * their results first. The input waits in the queue, unreceived, for the step after.
+ */
+export declare function deferInput(view: SessionView, input: StepInput): Transition;
+/** What the approval-response policies did with a delivery, before `answer` reads it. */
+export interface ResponsePolicyPass {
+    readonly kind: "continue" | "continue-coordination" | "authorization-required" | "responses-completed" | "park";
+    readonly challenges: readonly AuthorizationChallenge[];
+    readonly feedback: readonly string[];
+    /** The delivery minus the answers the policies took, plus the settlements they reached. */
+    readonly stepInput?: StepInput;
+    readonly audit: ReturnType<typeof getApprovalAuditState>;
+    /** Responder sign-ins pending when the pass began. */
+    readonly challengesAtStart: readonly AuthorizationChallenge[];
+}
+/** What `answer` concluded, beyond the events and state it changed. */
+export interface Answered extends Transition {
+    /**
+     * `continue`: the step goes on. `park`: nothing can run until more input arrives.
+     * `repeat`: a policy pass committed, so the next pass runs in a fresh step. `sign-in`: a
+     * responder must sign in first. `defer-message`: a message arrived while the session-limit
+     * prompt is open; it waits in its turn for the prompt.
+     */
+    readonly next: "continue" | "park" | "repeat" | "sign-in" | "defer-message";
+    /** The turn's input, without the answers `answer` consumed. */
+    readonly input?: StepInput;
+    /** Whether a plain-text answer consumed the message. */
+    readonly consumedMessage?: boolean;
+    /** The batches the delivery resolved, in order. */
+    readonly resolved: readonly ResolvedInputBatch[];
+    /** A decision on the session-limit prompt. */
+    readonly limit?: {
+        readonly granted: boolean;
+    };
+}
+/**
+ * A delivery answers what the session asked. An approval batch resolves once every request in it
+ * has a decision: approved calls become ready to run, denied ones get their denial as a result,
+ * and `once()` approvals grant their key. A message steers the held turn instead: the first
+ * pending batch resolves with the answers it has, and the rest are ignored. A session-limit
+ * answer grants or declines a fresh budget. A partial answer waits, queued, for the rest.
+ */
+export declare function answer(view: SessionView, input: {
+    readonly delivery: ResolvedStepInput | undefined;
+    readonly policy: ResponsePolicyPass;
+    /** The delivery merged the queue in, so the queue empties. */
+    readonly takeQueued: boolean;
+    readonly approvalKey: (request: InputRequest) => string | undefined;
+}): Answered;
+/** Queued input that can run now, rather than wait for more answers. */
+export declare function hasRunnableQueue(view: SessionView): boolean;
+/** Keys `once()` approvals granted, except those a pending approval still asks about. */
+export declare function grantedApprovalKeys(view: SessionView, approvalKey: (request: InputRequest) => string | undefined): ReadonlySet<string>;
+/**
+ * The steps a delivery approves calls of, whose tools the calls run with: those it answers in
+ * full, approving at least one call, or the only pending step a plain-text answer approves.
+ */
+export declare function approvingSteps(view: SessionView, stepInput: StepInput | undefined): readonly SuspendedStep[];
+/** The suspended step that holds `requestId`. */
+export declare function stepForRequest(view: SessionView, requestId: string): SuspendedStep | undefined;
+/**
+ * The held turn moves on, steered or cancelled: the sign-ins it waits on end, declined, including
+ * a responder's for one of its approvals.
+ */
+export declare function withdrawSignIns(view: SessionView, reason: string): Transition;
+/**
+ * The session spent its budget: it asks whether to continue instead of calling the model, and
+ * the turn ends. The prompt is the projection's open request; `answer` grants a
+ * fresh budget or declines it.
+ */
+export declare function requestLimit(view: SessionView, input: {
+    readonly request: InputRequest;
+}): Transition;
+/**
+ * Work needs a sign-in. The calls that need it stop, settling `cancelled` until it completes;
+ * an attempt it replaces fails; and each sign-in is asked for and recorded. The turn holds until
+ * every sign-in calls back. Input that waited on a responder's sign-in stays queued for it. An
+ * approved call that needs the sign-in leaves its step, so the model calls it again once the
+ * sign-in completes.
+ */
+export declare function requireSignIn(view: SessionView, input: {
+    readonly challenges: readonly AuthorizationChallenge[];
+    readonly callIdsByName?: ReadonlyMap<string, readonly string[]>;
+    readonly queued?: StepInput;
+}): Transition;

package/dist/src/harness/hitl/approvals.js

@@ -0,0 +1 @@
+import{canonicalize,compactInput,hasInput,isEmptyInput,resolveTextInput,withoutResponses,withoutTurnInput}from"./delivery.js";import{openInputs,turnCoordinates}from"#protocol/session-projection.js";import{readClientContext}from"#internal/client-context.js";import{createActionResultEvent,createApprovalCandidateEvent,createApprovalSettledEvent,createAuthorizationCompletedEvent,createAuthorizationRequiredEvent,createInputRequestedEvent,createInputResolvedEvent,createMessageCompletedEvent}from"#protocol/message.js";import{coalesceTurnInputs,createFrameworkUserMessage}from"#harness/messages.js";import{turnPosition}from"#harness/session-machine/view.js";import{renderPendingApprovalsSnippet}from"#harness/hitl/approval-prompt.js";import{finishTurn,hold,ownOpenRequestIds,settle,stepCallIds,suspend,withResult,withoutApproved}from"#harness/session-machine/transitions.js";import{supersededChallenges,withSignIns}from"#harness/authorization.js";import{withoutCalls}from"#harness/inline-tool-authorization.js";import{isApprovalRequest}from"#harness/input-request-class.js";import{authorizationEventFields}from"#harness/authorization-event-fields.js";import{TOOL_EXECUTION_DENIED_MESSAGE,resolveApprovalOutcome,resolveInputOutcome}from"#harness/input-request-resolution.js";import{resolveSessionLimitContinuation}from"#harness/hitl/budget-request.js";import{signInWithdrawn}from"#harness/session-machine/events.js";function parkOnApprovals(e,t){let n=t.requester?.principalType===`anonymous`?null:t.requester,r=t.messages.findIndex(e=>e.role!==`tool`),i=r===-1?t.messages:t.messages.slice(0,r),a=renderPendingApprovalsSnippet(t.requests),o=suspend(e.turn,{event:t.event,messages:t.messages.slice(i.length),requester:n,requests:t.requests,responseAuthRequiredRequestIds:t.responseAuthRequiredRequestIds,tasks:t.tasks});return{commit:[...i,...a===void 0?[]:[createFrameworkUserMessage(`context.state`,a)]],events:[createInputRequestedEvent({requests:t.requests,...t.event})],turn:o}}function dispatch(e,t){let n=e.turn.suspended.map(e=>{let n=stepCallIds(e),r=t.tasks.filter(e=>n.has(e.callId));if(r.length===0)return e;let i=withoutApproved(e,new Set(r.map(e=>e.callId))),a={...e.approvers};for(let{callId:e}of r){let n=t.approvers[e];n!==void 0&&(a[e]=n)}return{...i,tasks:[...e.tasks,...r],...Object.keys(a).length>0&&{approvers:a}}});return{events:[],turn:{...e.turn,suspended:n}}}function deferInput(e,t){return{events:[],turn:withQueued(e.turn,t)}}function withQueued(e,t){return t===void 0||isEmptyInput(t)?e:{...e,queued:e.queued===void 0?t:coalesceTurnInputs(e.queued,t)}}function answer(e,t){let{policy:n}=t,{projection:r}=e,i=turnPosition(r),a=[...n.feedback.map(e=>createMessageCompletedEvent({message:e,sequence:i.sequence,stepIndex:i.stepIndex,turnId:i.turnId})),...reportApprovalProgress(r,n.audit,n.challengesAtStart)],o=t.takeQueued?{...e.turn,queued:void 0}:e.turn,done=e=>({events:a,resolved:[],turn:o,...e}),queue=e=>{o=withQueued(o,e)};if(n.kind===`park`)return done({next:`park`});if(n.kind===`continue-coordination`)return queue(n.stepInput),done({next:`repeat`});if(n.challenges.length>0)return done({next:`sign-in`});let s=t.delivery,c=openInputs(r).find(t=>t.request.kind===`session-limit`&&ownOpenRequestIds(e).has(t.request.requestId)),l=o.suspended.filter(e=>e.requests.length>0);if(c===void 0&&l.length===0)return done({input:s,next:`continue`});let u=c===void 0?l.length===1?l[0]:void 0:{requests:[c.request]},d=u===void 0?s:resolveTextInput(u,s),f=canonicalize(d?.inputResponses??[]),p=new Map(f.map(e=>[e.requestId,e])),m=l.filter(e=>e.requests.every(e=>p.has(e.requestId))),leftoverFor=e=>f.filter(t=>e.some(e=>e.requests.some(e=>e.requestId===t.requestId))),park=()=>(queue(compactInput(d)),done({next:`park`}));if(f.length===0&&d?.message===void 0)return park();if(c!==void 0){let e=p.get(c.request.requestId);if(e===void 0)return hasInput(s)?(queue(withoutTurnInput(d)),done({input:d,next:`defer-message`})):(queue(compactInput(d)),done({next:`park`}));let t={event:{sequence:c.sequence,stepIndex:c.stepIndex,turnId:c.turnId},inputs:[{outcome:resolveInputOutcome(c.request.kind,e),request:c.request,response:e}]};a.push(resolvedEvent(t));let n=leftoverFor(l);return n.length>0&&queue({inputResponses:n}),done({consumedMessage:d?.messageConsumed,input:withoutResponses(d),limit:resolveSessionLimitContinuation({requests:[c.request],responses:f}),next:`continue`,resolved:[t]})}if(m.length===0&&d?.message===void 0)return park();m.length===0&&m.push(l[0]);let h=leftoverFor(l.filter(e=>!m.includes(e)));h.length>0&&queue({inputResponses:h});let g=new Set(o.grants),_=[],v=[],y=o.suspended.map(e=>{if(!m.includes(e))return e;let n=e.messages,r=[];for(let i of e.requests){let{approved:a,reason:o,status:s}=resolveApprovalOutcome(p.get(i.requestId));if(a){g.add(t.approvalKey(i)??i.action.toolName),r.push(i);continue}n=withResult(n,{output:{reason:o,type:`execution-denied`},toolCallId:i.action.callId,toolName:i.action.toolName,type:`tool-result`}),v.push(createActionResultEvent({rejected:!0,result:{callId:i.action.callId,isError:!0,kind:`tool-result`,output:{approval:{requestId:i.requestId,status:s},code:`TOOL_EXECUTION_DENIED`,message:o??TOOL_EXECUTION_DENIED_MESSAGE,tool:{result:`not_run`}},toolName:i.action.toolName},...e.event}))}_.push({event:e.event,inputs:e.requests.map(e=>{let t=p.get(e.requestId);return{outcome:resolveInputOutcome(e.kind,t),request:e,response:t}})});let i=[...e.approved??[],...r];return{...e,messages:n,requests:[],...i.length>0&&{approved:i}}});return a.push(..._.map(resolvedEvent),...v),o={...o,grants:[...g],suspended:y},done({consumedMessage:d?.messageConsumed,input:withoutResponses(d),next:`continue`,resolved:_})}function resolvedEvent(e){return createInputResolvedEvent({resolutions:e.inputs.map(e=>{let t={kind:e.request.kind,outcome:e.outcome,requestId:e.request.requestId};return e.response===void 0?t:{...t,response:e.response}}),...e.event})}function reportApprovalProgress(e,t,n){let r=turnCoordinates(e),isOpen=t=>{let n=e.inputs[t];return n!==void 0&&n.status!==`settled`},i=[];for(let a of n){let n=t.candidateHistory.some(e=>e.candidateId===a.candidateId&&e.status===`timed-out`),o=e.authorizations[a.attemptId??a.name];n&&o?.status===`required`&&i.push(createAuthorizationCompletedEvent({...authorizationEventFields(a),outcome:`failed`,reason:`The approval response expired. Please submit a new response.`,...r}))}for(let n of t.activeCandidates)e.candidates[n.candidateId]===void 0&&isOpen(n.requestId)&&i.push(createApprovalCandidateEvent({candidateId:n.candidateId,outcome:`pending`,requestId:n.requestId,responderPrincipalId:n.responder.principalId,...r}));for(let n of t.candidateHistory)n.status!==`allowed`&&n.status!==`authorization-required`&&e.inputs[n.requestId]!==void 0&&e.candidates[n.candidateId]?.outcome!==n.status&&i.push(createApprovalCandidateEvent({candidateId:n.candidateId,outcome:n.status,requestId:n.requestId,responderPrincipalId:n.responder.principalId,reason:n.reason,...r}));for(let e of t.settlements)isOpen(e.requestId)&&i.push(createApprovalSettledEvent({outcome:e.outcome===`allowed`?`approved`:`cancelled`,requestId:e.requestId,responderPrincipalId:e.actor.principalId,...r}));return i}function hasRunnableQueue(e){let t=e.turn.queued;if(t===void 0)return!1;if(t.message!==void 0||(t.context?.length??0)>0||readClientContext(t)!==void 0||t.outputSchema!==void 0||(t.runtimeActionResults?.length??0)>0)return!0;let n=[...t.inputResponses??[],...(t.attributedInputResponses??[]).map(({response:e})=>e)];if(n.length===0)return!1;let r=new Set(n.map(e=>e.requestId)),i=openInputs(e.projection).find(e=>e.request.kind===`session-limit`);return i===void 0?e.turn.suspended.some(e=>e.requests.length>0&&e.requests.every(e=>r.has(e.requestId))):r.has(i.request.requestId)}function grantedApprovalKeys(e,t){let n=new Set(e.turn.grants);for(let r of e.turn.suspended)for(let e of r.requests)isApprovalRequest(e)&&n.delete(t(e)??e.action.toolName);return n}function approvingSteps(e,t){let n=e.turn.suspended.filter(e=>e.requests.length>0),r=n.length===1?resolveTextInput(n[0],t):t,i=new Map((r?.inputResponses??[]).map(e=>[e.requestId,e.optionId]));return n.filter(e=>e.requests.every(e=>i.has(e.requestId))&&e.requests.some(e=>isApprovalRequest(e)&&i.get(e.requestId)===`approve`))}function stepForRequest(e,t){return e.turn.suspended.find(e=>e.requests.some(e=>e.requestId===t))}function withdrawSignIns(e,t){return{events:e.signIns.flatMap(n=>{let r=e.projection.authorizations[n.attemptId??n.name];return r?.status===`required`?[signInWithdrawn(r,t)]:[]}),signIns:[],turn:e.turn}}function requestLimit(e,t){let n=turnPosition(e.projection);return{events:[createInputRequestedEvent({requests:[t.request],sequence:n.sequence,stepIndex:n.stepIndex,turnId:n.turnId}),...finishTurn(e).events],turn:e.turn}}function requireSignIn(e,t){let n=turnPosition(e.projection),r={sequence:n.sequence,stepIndex:n.stepIndex,turnId:n.turnId},i=[...supersededChallenges(e.signIns,t.challenges).map(e=>createAuthorizationCompletedEvent({...authorizationEventFields(e),outcome:`failed`,reason:`Superseded by a newer authorization attempt.`,...r})),...t.challenges.map(e=>createAuthorizationRequiredEvent({...authorizationEventFields(e),description:e.challenge.instructions??`Authorization required for ${e.name}`,webhookUrl:e.hookUrl,...r}))];i.push(...hold(e,{on:`input`}).events);let a=t.queued===void 0?e.turn.queued:e.turn.queued===void 0?t.queued:coalesceTurnInputs(e.turn.queued,t.queued),o=withSignIns(e.signIns,t.challenges),s=new Set([...t.callIdsByName?.values()??[]].flat()),c=e.turn.suspended.map(e=>[...stepCallIds(e)].some(e=>s.has(e))?{...e,messages:withoutCalls(e.messages,s)}:e);if(c.every((t,n)=>t===e.turn.suspended[n]))return{events:i,signIns:o,turn:{...e.turn,queued:a}};let l=settle({...e,turn:{...e.turn,queued:a,suspended:c}},{results:[]});return{commit:l.commit,events:i,signIns:o,turn:l.turn}}export{answer,approvingSteps,deferInput,dispatch,grantedApprovalKeys,hasRunnableQueue,parkOnApprovals,requestLimit,requireSignIn,stepForRequest,withdrawSignIns};

package/dist/src/harness/hitl/approved-call-callers.d.ts

@@ -0,0 +1,14 @@
+import type { SessionAuthContext } from "#channel/types.js";
+import type { InputRequest } from "#shared/input.js";
+import type { SessionStateMap } from "#harness/types.js";
+/** Who approved each of the `approved` calls, by call id. */
+export declare function approversOf(approved: readonly InputRequest[], state: SessionStateMap | undefined): Readonly<Record<string, SessionAuthContext>>;
+/**
+ * Records who approved each of the `approved` calls, so each runs as its approver while the rest
+ * of the turn keeps the turn's own caller.
+ */
+export declare function setApprovedCallCallers(approved: readonly InputRequest[], state: SessionStateMap | undefined): void;
+/** Runs `fn` as the call's approver when `callId` is an approved call; otherwise as is. */
+export declare function runAsApprover<T>(callId: string | undefined, fn: () => T): T;
+/** A streaming call's body runs on each `next()`, so each one runs as the approver too. */
+export declare function iterateAsApprover<T>(callId: string | undefined, iterable: AsyncIterable<T>): AsyncIterable<T>;

package/dist/src/harness/hitl/approved-call-callers.js

@@ -0,0 +1 @@
+import{approverOfRequest}from"./candidates.js";import{contextStorage}from"#context/container.js";import{ContextKey}from"#context/key.js";import{runAsCaller}from"#context/caller-scope.js";const ApprovedCallCallersKey=new ContextKey(`eve.approvedCallCallers`);function approversOf(e,t){let n={};for(let r of e){if(r.action===void 0)continue;let e=approverOfRequest(t,r.requestId);e!==void 0&&(n[r.action.callId]=e)}return n}function setApprovedCallCallers(e,t){let n=contextStorage.getStore();n!==void 0&&n.setVirtualContext(ApprovedCallCallersKey,new Map(Object.entries(approversOf(e,t))))}function runAsApprover(e,t){let n=e===void 0?void 0:contextStorage.getStore()?.get(ApprovedCallCallersKey)?.get(e);return n===void 0?t():runAsCaller(n,t)}async function*iterateAsApprover(e,t){let n=t[Symbol.asyncIterator]();try{for(;;){let t=await runAsApprover(e,()=>n.next());if(t.done===!0)return;yield t.value}}finally{await n.return?.()}}export{approversOf,iterateAsApprover,runAsApprover,setApprovedCallCallers};

package/dist/src/harness/hitl/approved-calls.d.ts

@@ -0,0 +1,37 @@
+import { type ModelMessage, type TelemetryOptions, type ToolSet, type TypedToolResult } from "ai";
+import type { HarnessToolMap } from "#harness/types.js";
+import type { InputRequest } from "#shared/input.js";
+import type { HandleEventFn } from "#harness/types.js";
+type ToolResponsePart = Extract<ModelMessage, {
+    role: "tool";
+}>["content"][number];
+export interface ApprovedCallResult {
+    readonly part: Extract<ToolResponsePart, {
+        type: "tool-result";
+    }>;
+}
+/**
+ * Runs approved local calls before the model reads their results. Like the calls a model step
+ * runs inline, each streams its progress and result as it goes. The lifecycle owner places the
+ * results in the steps that made the calls.
+ */
+export declare function runApprovedCalls(input: {
+    readonly requests: readonly InputRequest[];
+    readonly tools: HarnessToolMap;
+    readonly approvedTools?: ReadonlySet<string>;
+    /** The conversation the tools read as `ctx.messages`. */
+    readonly messages: readonly ModelMessage[];
+    readonly position: {
+        readonly sequence: number;
+        readonly stepIndex: number;
+        readonly turnId: string;
+    };
+    readonly publish: HandleEventFn;
+    readonly abortSignal: AbortSignal | undefined;
+    /** The step attempt's telemetry, which hears each execution as the AI SDK reports it. */
+    readonly telemetry?: TelemetryOptions;
+}): Promise<{
+    readonly settled: readonly ApprovedCallResult[];
+    readonly toolResults: readonly TypedToolResult<ToolSet>[];
+}>;
+export {};

package/dist/src/harness/hitl/approved-calls.js

@@ -0,0 +1 @@
+import{asSchema}from"ai";import{createLogger,logError}from"#internal/logging.js";import{toError}from"#shared/errors.js";import{createActionPartialEvent,createActionResultEvent}from"#protocol/message.js";import{parseJsonObject}from"#shared/json.js";import{isAsyncIterable}from"#shared/async-iterable.js";import{throwIfTurnAborted}from"#harness/turn-cancellation.js";import{createRuntimeToolResultFromValue}from"#harness/action-result-helpers.js";import{emitNestedToolActions}from"#harness/nested-actions.js";import{projectDeltaPresentation,projectResultPresentation}from"#harness/tool-presentation.js";import{isInlineAuthorizationToolResult}from"#harness/inline-tool-authorization.js";import{TOOL_EXECUTION_DENIED_MESSAGE}from"#harness/input-request-resolution.js";import{buildToolSet,recheckApprovedCall}from"#harness/tools.js";const log=createLogger(`harness.tool-loop`);async function runApprovedCalls(e){let t=buildToolSet({tools:e.tools,approvedTools:e.approvedTools}),n=e.requests.map(n=>{let r=e.tools.get(n.action.toolName),i=t[n.action.toolName];if(r?.execute===void 0||i?.execute===void 0||i.toModelOutput===void 0)throw Error(`The approved tool is no longer available. Request a new tool call and approval.`);return{request:n,definition:r,tool:i}}),r={sequence:e.position.sequence,stepIndex:e.position.stepIndex,turnId:e.position.turnId},i=await Promise.allSettled(n.map(async({request:t,definition:n,tool:i})=>{let a=[],o=[],{callId:s,toolName:c,input:l}=t.action;try{if(throwIfTurnAborted(e.abortSignal),(await asSchema(i.inputSchema).validate?.(l))?.success===!1){let t=`The approved input is no longer valid for tool "${c}". Request a new tool call and approval.`;return await e.publish(createActionResultEvent({...r,result:createRuntimeToolResultFromValue({callId:s,isError:!0,output:t,toolName:c})})),{settled:[{part:{type:`tool-result`,toolCallId:s,toolName:c,output:{type:`error-text`,value:t}}}],toolResults:o}}let t=await recheckApprovedCall(n,{abortSignal:e.abortSignal,callId:s,input:l,approvedTools:e.approvedTools});if(t.denied)return await e.publish(createActionResultEvent({...r,rejected:!0,result:{callId:s,isError:!0,kind:`tool-result`,output:{code:`TOOL_EXECUTION_DENIED`,message:t.reason??TOOL_EXECUTION_DENIED_MESSAGE,tool:{result:`not_run`}},toolName:c}})),a.push({part:{output:{reason:t.reason,type:`execution-denied`},toolCallId:s,toolName:c,type:`tool-result`}}),{settled:a,toolResults:o};let u,d=!1,f=toolTelemetry(e.telemetry,{messages:[...e.messages],toolCall:{input:l,toolCallId:s,toolName:c,type:`tool-call`}});await f.started();let p=0;try{await f.execute(async()=>{let t=performance.now();try{let t=i.execute(l,{abortSignal:e.abortSignal,context:void 0,messages:[...e.messages],toolCallId:s});if(isAsyncIterable(t))for await(let i of t)u=i,await e.publish(createActionPartialEvent({...r,presentation:projectDeltaPresentation(n,s,parseJsonObject(l),i),result:createRuntimeToolResultFromValue({callId:s,output:i,toolName:c})}));else u=await t}finally{p=performance.now()-t}})}catch(t){await f.ended({error:t,input:l,toolCallId:s,toolName:c,type:`tool-error`},p),throwIfTurnAborted(e.abortSignal),logError(log,`tool execution failed`,t,{toolName:c,toolCallId:s}),d=!0,u=toError(t).message}d||await f.ended({input:l,output:u,toolCallId:s,toolName:c,type:`tool-result`},p);let m={input:l,output:u,toolCallId:s,toolName:c,type:`tool-result`};return o.push(m),isInlineAuthorizationToolResult(m)?{settled:a,toolResults:o}:(await emitNestedToolActions(e.publish,e.position,s),a.push({part:{output:d?{type:`error-text`,value:String(u)}:await i.toModelOutput({input:l,output:u,toolCallId:s}),toolCallId:s,toolName:c,type:`tool-result`}}),await e.publish(createActionResultEvent({...r,presentation:d?void 0:projectResultPresentation(n,s,parseJsonObject(l),u),result:createRuntimeToolResultFromValue({callId:s,isError:d,output:u,toolName:c})})),{settled:a,toolResults:o})}catch(t){throwIfTurnAborted(e.abortSignal);let n=toError(t).message;return logError(log,`approved tool failed`,t,{toolName:c,toolCallId:s}),await e.publish(createActionResultEvent({...r,result:createRuntimeToolResultFromValue({callId:s,isError:!0,output:n,toolName:c})})),{settled:[{part:{type:`tool-result`,toolCallId:s,toolName:c,output:{type:`error-text`,value:n}}}],toolResults:o}}})),a=i.find(e=>e.status===`rejected`);if(a?.status===`rejected`)throw a.reason;let o=i.flatMap(e=>e.status===`fulfilled`?[e.value]:[]);return{settled:o.flatMap(e=>e.settled),toolResults:o.flatMap(e=>e.toolResults)}}function toolTelemetry(e,t){let n=e===void 0||e.isEnabled===!1?[]:[e.integrations??[]].flat(),r={...t,callId:`approved:${t.toolCall.toolCallId}`,functionId:e?.functionId,recordInputs:e?.recordInputs,recordOutputs:e?.recordOutputs,toolContext:void 0},notify=async e=>{await Promise.allSettled(n.map(async t=>await e(t)))};return{started:()=>notify(e=>e.onToolExecutionStart?.(r)),execute:async e=>{let wrapped=e;for(let e of n){if(e.executeTool===void 0)continue;let n=wrapped;wrapped=()=>e.executeTool({...r,execute:n,toolCallId:t.toolCall.toolCallId})}await wrapped()},ended:(e,t)=>notify(n=>n.onToolExecutionEnd?.({...r,toolExecutionMs:t,toolOutput:e}))}}export{runApprovedCalls};

package/dist/src/harness/{session-limit-continuation.d.ts → hitl/budget-request.d.ts}

@@ -3,7 +3,7 @@
  *
  * When a durable session reaches its configured token or token-cost budget, the harness
  * parks on a harness-authored input request instead of failing the session.
- * The request is derived only from the session identity and violation, so
+ * The request is derived only from the session, turn, and violation, so
  * identical session state always produces an identical prompt — no model call
  * is involved.
  */
@@ -17,6 +17,8 @@ export declare const SESSION_LIMIT_STOP_OPTION_ID = "stop";
  */
 export declare function createSessionLimitContinuationRequest(input: {
     readonly sessionId: string;
+    /** The turn's `sequence`, which tells its prompt apart from another turn's at the same usage. */
+    readonly turnSequence: number;
     readonly violation: SessionUsageLimitViolation;
 }): InputRequest;
 /**

package/dist/src/harness/hitl/budget-request.js

@@ -0,0 +1 @@
+const SESSION_LIMIT_CONTINUE_OPTION_ID=`continue`,SESSION_LIMIT_STOP_OPTION_ID=`stop`;function createSessionLimitContinuationRequest(e){let{sessionId:t,turnSequence:n,violation:r}=e,i=r.kind===`token-cost`?r.usedCostUsd:r.usedTokens,a=`${t}:${String(n)}:limit:${r.kind}:${String(i)}`;return{action:{callId:a,input:r.kind===`token-cost`?{kind:r.kind,limitUsd:r.limitUsd,usedCostUsd:r.usedCostUsd}:{kind:r.kind,limit:r.limit,usedTokens:r.usedTokens},kind:`tool-call`,toolName:`session_limit_continuation`},allowFreeform:!1,display:`confirmation`,kind:`session-limit`,options:[{description:r.kind===`token-cost`?`Grant a fresh model token-cost budget`:`Grant a fresh token budget`,id:SESSION_LIMIT_CONTINUE_OPTION_ID,label:`Approve`,style:`primary`},{description:`Stop now`,id:SESSION_LIMIT_STOP_OPTION_ID,label:`Stop`,style:`danger`}],prompt:formatSessionLimitPrompt(r),requestId:a}}function formatCompactTokenCount(e){return e>=1e6?`${trimTrailingZero(e/1e6)}M`:e>=1e3?`${trimTrailingZero(e/1e3)}K`:String(e)}function trimTrailingZero(e){let t=e.toFixed(1);return t.endsWith(`.0`)?t.slice(0,-2):t}function formatSessionLimitPrompt(e){return`This session has hit the ${e.kind===`token-cost`?`${formatUsd(e.limitUsd)} model token-cost limit per session`:`${e.kind}-token limit (${formatCompactTokenCount(e.limit)}) per session`}. This is a guardrail against defective long-running sessions. If session activity looks fine, just approve to keep going.`}function formatUsd(e){return`$${(e<1e-6?String(e):e.toFixed(6)).replace(/0+$/u,``).replace(/\.$/u,``)}`}function isSessionLimitContinuationRequest(e){return e.kind===`session-limit`}function isSessionLimitContinuationRequestId(e){return/:limit:(?:input|output):\d+$/u.test(e)||/:limit:token-cost:\d+(?:\.\d+)?(?:e[+-]?\d+)?$/iu.test(e)}function resolveSessionLimitContinuation(e){let t=e.requests.find(isSessionLimitContinuationRequest);if(t===void 0)return;let n=e.responses.find(e=>e.requestId===t.requestId);if(n!==void 0){if(n.optionId===SESSION_LIMIT_CONTINUE_OPTION_ID)return{granted:!0};if(n.optionId===`stop`)return{granted:!1}}}export{SESSION_LIMIT_STOP_OPTION_ID,createSessionLimitContinuationRequest,isSessionLimitContinuationRequest,isSessionLimitContinuationRequestId,resolveSessionLimitContinuation};

package/dist/src/harness/hitl/budget.d.ts

@@ -0,0 +1,21 @@
+import type { HarnessSession } from "#harness/types.js";
+import type { InputRequest } from "#shared/input.js";
+import type { JsonObject } from "#shared/json.js";
+export { bumpSessionRuntimeUsageLimits } from "#harness/turn-tag-state.js";
+export type SessionUsageLimitCheck = {
+    readonly kind: "within";
+} | {
+    readonly kind: "ask";
+    readonly request: InputRequest;
+} | {
+    readonly kind: "fail";
+    readonly code: string;
+    readonly details: JsonObject;
+    readonly message: string;
+};
+/** Whether the session may call the model, may ask to continue, or must fail. */
+export declare function checkSessionUsageLimit(input: {
+    readonly canAsk: boolean;
+    readonly session: HarnessSession;
+    readonly turnSequence: number;
+}): SessionUsageLimitCheck;

package/dist/src/harness/hitl/budget.js

@@ -0,0 +1 @@
+import{bumpSessionRuntimeUsageLimits,getSessionTokenUsage,getSessionUsageLimitViolation}from"#harness/turn-tag-state.js";import{createSessionLimitContinuationRequest}from"#harness/hitl/budget-request.js";function checkSessionUsageLimit(e){let t=getSessionUsageLimitViolation(e.session);if(t===null)return{kind:`within`};if(violationWindow(t)>0&&e.canAsk)return{kind:`ask`,request:createSessionLimitContinuationRequest({sessionId:e.session.sessionId,turnSequence:e.turnSequence,violation:t})};let n=getSessionTokenUsage(e.session);return{code:t.kind===`token-cost`?`SESSION_TOKEN_COST_LIMIT_REACHED`:`SESSION_TOKEN_LIMIT_REACHED`,details:t.kind===`token-cost`?{costUsd:n.costUsd,kind:t.kind,limitUsd:t.limitUsd,usedCostUsd:t.usedCostUsd}:{inputTokens:n.inputTokens,kind:t.kind,limit:t.limit,outputTokens:n.outputTokens,usedTokens:t.usedTokens},kind:`fail`,message:formatSessionLimitMessage(t.kind)}}function violationWindow(e){return e.kind===`token-cost`?e.limitUsd:e.limit}function formatSessionLimitMessage(e){return e===`token-cost`?`The session reached its configured model token-cost limit.`:`The session reached its configured ${e} token limit.`}export{bumpSessionRuntimeUsageLimits,checkSessionUsageLimit};