eve 0.68.0 → 0.70.0

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

@@ -1,5 +1,5 @@
-import type { ModelMessage, ToolSet, TypedToolCall } from "ai";
-import type { RuntimeActionRequest, RuntimeToolCallActionRequest, RuntimeWorkflowTaskRequest } from "#shared/action-types.js";
+import type { ModelMessage } from "ai";
+import type { RuntimeActionRequest, 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";
 /**
@@ -13,20 +13,11 @@ interface PendingCoordinationEventMetadata {
     readonly stepIndex: number;
     readonly turnId: string;
 }
-/**
- * Serializable pending coordination batch stored on `session.state`.
- *
- * Child ownership does not live here: the agent handle store records every
- * dispatched child (from before its start side effect) and is the sole
- * authority for continuing, settling, and cancelling children.
- */
+/** Serializable pending coordination batch stored on `session.state`. */
 export interface PendingCoordinationBatch {
-    /** Framework task controls deferred to the turn owner. */
-    readonly runtimeActions: readonly RuntimeToolCallActionRequest[];
-    /** Authored-tool and subagent workflow tasks pending coordination. */
+    /** Workflow tool runs pending coordination, including agent tools. */
     readonly tasks: readonly RuntimeWorkflowTaskRequest[];
     readonly event: PendingCoordinationEventMetadata;
-    readonly localFanoutSize?: number;
     readonly responseMessages: readonly ModelMessage[];
 }
 /**
@@ -40,28 +31,38 @@ interface ResolvePendingCoordinationResult {
 /** 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(input: {
-    readonly runtimeActions: readonly RuntimeToolCallActionRequest[];
+export declare function setPendingCoordinationBatch<T extends {
+    readonly state?: SessionStateMap;
+}>(input: {
     readonly tasks: readonly RuntimeWorkflowTaskRequest[];
     readonly event: PendingCoordinationEventMetadata;
-    readonly localFanoutSize?: number;
     readonly responseMessages: readonly ModelMessage[];
-    readonly session: HarnessSession;
-}): HarnessSession;
+    readonly session: T;
+}): T;
 /** 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 `subagent.completed` and
- * `action.result` events back onto the parent stream.
+ * history, clears the pending batch, and emits `action.result` events back
+ * onto the parent stream.
  */
 export declare function resolvePendingCoordination(input: {
     readonly emit?: HarnessEmitFn;
@@ -70,24 +71,29 @@ export declare function resolvePendingCoordination(input: {
     /** Definitions whose `toModelOutput` projects a workflow tool's result for the model. */
     readonly tools?: HarnessToolMap;
 }): Promise<ResolvePendingCoordinationResult>;
+/** The parts of a model tool call that coordination turns into a runtime request. */
+export interface CoordinationToolCall {
+    readonly input: unknown;
+    readonly toolCallId: string;
+    readonly toolName: string;
+}
 /**
  * Projects one AI SDK tool call into the eve runtime-action contract.
  */
 export declare function createRuntimeActionRequestFromToolCall(input: {
-    readonly toolCall: TypedToolCall<ToolSet>;
+    readonly toolCall: CoordinationToolCall;
     readonly tools: HarnessToolMap;
 }): RuntimeActionRequest;
-/** Projects one deferred harness tool call into task/control coordination. */
+/**
+ * Projects one deferred harness tool call into a workflow run request. The
+ * input is the tool's own, without anything eve added to its model input.
+ */
 export declare function createCoordinationRequestFromToolCall(input: {
-    readonly toolCall: TypedToolCall<ToolSet>;
+    readonly entry: WorkflowToolCallEntry;
+    readonly input: JsonObject;
+    readonly toolCall: CoordinationToolCall;
     readonly tools: HarnessToolMap;
-}): {
-    readonly kind: "runtime-action";
-    readonly request: RuntimeToolCallActionRequest;
-} | {
-    readonly kind: "task";
-    readonly request: RuntimeWorkflowTaskRequest;
-};
+}): RuntimeWorkflowTaskRequest;
 /**
  * Coerces an AI SDK tool-call `input` into the runtime-action `JsonObject`
  * contract, throwing a `TypeError` (with the original as `cause`) that names

package/dist/src/harness/coordination.js

@@ -1 +1 @@
-import{parseJsonObject}from"#shared/json.js";import{createActionResultEvent}from"#protocol/message.js";import{findBlockingWorkflowToolRun,removeBlockingWorkflowToolRuns}from"#harness/workflow-tool-runs.js";import{clearProxyInputRequestsForChild,clearProxyInputRequestsWhere}from"#harness/proxy-input-requests.js";import{findRunningAgentHandle,isResultBoundToRunningHandle}from"#subagents/handles/query.js";import{accumulateSessionUsage,getTurnUsageState,setTurnUsageState}from"#harness/turn-tag-state.js";import{resolveRuntimeActionResultsForCallIds}from"#runtime/actions/results.js";import{settleAgentTurn}from"#subagents/handles/transitions.js";import{markRuntimeWorkflowToolAction}from"#shared/action-types.js";import{normalizeToolModelOutput}from"#harness/tool-model-output.js";const PENDING_COORDINATION_BATCH_KEY=`eve.runtime.pendingCoordinationBatch`;function readSubagentResultOutcome(e){return e.origin===`child`?e.outcome:void 0}function getPendingCoordinationBatch(e){let t=e?.[PENDING_COORDINATION_BATCH_KEY];if(typeof t!=`object`||!t)return;let n=t;if(Array.isArray(n.runtimeActions)&&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}}function setPendingCoordinationBatch(e){assertUniqueCoordinationCallIds([...e.runtimeActions,...e.tasks]);let t={...e.session.state};return t[PENDING_COORDINATION_BATCH_KEY]={runtimeActions:[...e.runtimeActions],tasks:[...e.tasks],event:e.event,localFanoutSize:e.localFanoutSize,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 resolveResultsForCoordinationBatch({batch:t,results:e.results,state:e.session.state})}function resolveResultsForCoordinationBatch(e){return resolveRuntimeActionResultsForCallIds({pendingCallIds:[...e.batch.runtimeActions,...e.batch.tasks].map(e=>e.callId),results:e.results.filter(t=>isResultBoundToRunningHandle(e.state,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!==`subagent-result`||e.origin!==`child`||readBackgroundTaskReceipt(e)!==void 0)continue;let t=findRunningAgentHandle(r.state,{callId:e.callId});if(t===void 0)continue;let n=readSubagentResultOutcome(e);if(n===void 0)continue;n.kind===`terminal`&&`continuationToken`in t.address&&(r=clearProxyInputRequestsForChild(r,t.address.continuationToken));let i=settleAgentTurn(r,{operationId:t.operation.id,outcome:n});i.kind===`settled`&&(r=i.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(clearProxyInputRequestsWhere(r,e=>e.answerHook?.runId===n.address.runId),t.event.turnId,n.callId))}let i={...r.state};delete i[PENDING_COORDINATION_BATCH_KEY],r={...r,state:Object.keys(i).length>0?i:void 0};for(let e of n){if(e.kind!==`subagent-result`)continue;let t=readSubagentResultOutcome(e);t!==void 0&&(r=setTurnUsageState(r,accumulateSessionUsage({previous:getTurnUsageState(r.state),usage:t.usageDelta})))}if(e.emit!==void 0)for(let r of n){if(r.kind===`subagent-result`&&r.origin===`child`&&r.outcome.result.kind===`succeeded`&&readBackgroundTaskReceipt(r)===void 0){let t={callId:r.callId,output:typeof r.output==`string`?r.output:JSON.stringify(r.output),subagentName:r.subagentName};await e.emit({data:t,type:`subagent.completed`})}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];return a.length>0&&o.push({content:a,role:`tool`}),{messages:o,outcome:`resolved`,session:r}}function readBackgroundTaskReceipt(e){return`backgroundTask`in e?e.backgroundTask:void 0}function createRuntimeActionRequestFromToolCall(e){let t=e.tools.get(e.toolCall.toolName),n=resolveToolCallInputObject(e.toolCall.input,{callId:e.toolCall.toolCallId,toolName:e.toolCall.toolName});if(t?.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),n=resolveToolCallInputObject(e.toolCall.input,{callId:e.toolCall.toolCallId,toolName:e.toolCall.toolName});if(t?.runtimeAction?.kind===`task-control`)return{kind:`runtime-action`,request:{callId:e.toolCall.toolCallId,input:n,kind:`tool-call`,toolName:e.toolCall.toolName}};if(t?.workflowId!==void 0)return{kind:`task`,request:{callId:e.toolCall.toolCallId,executeInput:t.executeInput?.(n),input:n,kind:`workflow-task`,toolName:e.toolCall.toolName,workflowId:t.workflowId}};throw Error(`Deferred tool "${e.toolCall.toolName}" has no task or runtime action.`)}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?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,clearPendingCoordinationBatch,createCoordinationRequestFromToolCall,createRuntimeActionRequestFromToolCall,getPendingCoordinationBatch,resolvePendingCoordination,resolveToolCallInputObject,setPendingCoordinationBatch};
+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};

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

@@ -1,9 +1,14 @@
 import type { ModelMessage, 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";
 interface AddCurrentMessageOptions {
     readonly cacheFriendly?: boolean;
 }
+interface CurrentAnnouncements {
+    readonly availableSkills?: string;
+    readonly keyed?: Readonly<Record<string, Announcement>>;
+}
 interface CurrentMessagesOptions {
     readonly historyState?: HistoryState;
     readonly currentTurnMessages?: readonly HarnessModelMessage[];
@@ -16,7 +21,7 @@ export declare function createCurrentMessages(history: readonly HarnessModelMess
     readonly nonSystemMessages: readonly HarnessModelMessage[];
     readonly systemMessages: readonly SystemModelMessage[];
     add(message: string, kind: FrameworkMessageKind, options?: AddCurrentMessageOptions): void;
-    addAnnouncements(announcements: HistoryState): void;
+    addAnnouncements(announcements: CurrentAnnouncements): void;
     addSystem(messages: SystemModelMessage | readonly SystemModelMessage[]): void;
 };
 /** True when the history ends with a tool message carrying a tool-approval-response. */

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

@@ -1 +1 @@
-import{createFrameworkUserMessage}from"#harness/messages.js";const ANNOUNCEMENT_KINDS={availableSkills:`context.state`,deliveryInstruction:`context.instruction`,taskState:`context.state`};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 add(e,t,{cacheFriendly:r=!0}={}){if(r&&d){let r=createFrameworkUserMessage(t,e);return a.splice(c,0,r),n.splice(u,0,r),c+=1,u+=1,!0}return i.push({role:`system`,content:e}),!1}return{add,addAnnouncements(e){for(let t of[`availableSkills`,`taskState`,`deliveryInstruction`]){let n=e[t];n!==void 0&&n.length!==0&&r[t]!==n&&add(n,ANNOUNCEMENT_KINDS[t])&&(r[t]=n)}},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,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};

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

@@ -7,6 +7,7 @@ type InlineToolResultPart = Extract<ToolResponsePart, {
 }>;
 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";
@@ -36,6 +37,7 @@ interface FailedStepPayload {
  */
 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` →
@@ -43,16 +45,17 @@ export declare function emitFailedStep(emitFn: HarnessEmitFn, state: HarnessEmis
  */
 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`.
+ * 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): Promise<HarnessEmissionState>;
+export declare function emitTurnEpilogue(emitFn: HarnessEmitFn, state: HarnessEmissionState, messages: readonly ModelMessage[], usage: TokenUsage): Promise<HarnessEmissionState>;
 /**
  * Result of consuming one step's `fullStream`.
  *
@@ -68,6 +71,12 @@ interface EmittedStreamContent {
 }
 interface StreamActionEmissionOptions {
     readonly excludedActionToolNames: ReadonlySet<string>;
+    /**
+     * A child's or schedule's turn is held while its tasks work, so a text step
+     * can't end it: the step reports `"tool-calls"` and channels don't post it
+     * as the reply.
+     */
+    readonly hidesHeldText?: boolean;
     readonly tools: HarnessToolMap;
 }
 /**

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{frameworkMessageKindForStepInput}from"#harness/messages.js";import{collectActionPresentation,createPresentedRuntimeActionRequestFromToolCall}from"#harness/action-presentation.js";import{createRuntimeToolResultFromStepResult,createRuntimeToolResultFromToolError,createToolResultMessagePartFromToolError}from"#harness/action-result-helpers.js";import{hasEmptyDeliverySentinel}from"#shared/empty-delivery.js";import{createInvalidToolCallInputError,isInvalidToolCall,resolveProviderToolCallRequest}from"#harness/tool-call-input-errors.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}`;if(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){let r=frameworkMessageKindForStepInput(t);await e(createMessageReceivedEvent({kind:r===`execution.background_task`?r:void 0,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()),{sessionStarted:t.sessionStarted,sequence:t.sequence+1,stepIndex:0,turnId:``}}function advanceStep(e){return{...e,stepIndex:e.stepIndex+1}}async function emitTurnEpilogue(e,t){return await e(createTurnCompletedEvent({sequence:t.sequence,turnId:t.turnId})),await e(createSessionWaitingEvent()),{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()}}}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);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`&&s!==`tool-calls`&&hasEmptyDeliverySentinel(o)?await e(createMessageCompletedEvent({finishReason:s,message:null,sequence:t.sequence,stepIndex:t.stepIndex,turnId:t.turnId})):s!==`content-filter`&&o.trim().length>0&&await e(createMessageCompletedEvent({finishReason:s,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,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};

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

@@ -1,17 +1,8 @@
 import type { FlexibleSchema } from "ai";
 import type { Approval } from "#approval/definition.js";
-import type { InternalToolLabelDefinition, ToolExecuteOptions } from "#tools/definition.js";
+import type { InternalToolDefinition, InternalToolLabelDefinition, ToolExecuteOptions } from "#tools/definition.js";
 import type { JsonValue } from "#shared/json.js";
 import type { PreparedToolBehavior } from "#tools/behavior.js";
-/**
- * Runtime-owned action metadata attached to one harness-visible tool.
- *
- * `task-control` marks `task_cancel`: it carries no child address of its
- * own — the dispatch step resolves targets through the session task index.
- */
-export type HarnessRuntimeActionDefinition = {
-    readonly kind: "task-control";
-};
 /**
  * Unified harness-owned tool definition.
  */
@@ -21,15 +12,14 @@ export interface HarnessToolDefinition {
     readonly approvalKey?: (toolInput: Readonly<Record<string, unknown>>) => string;
     readonly behavior?: PreparedToolBehavior;
     readonly description: string;
+    /** A successful call ends the turn without a final reply; see `ToolDefinition.endsTurn`. */
+    readonly endsTurn?: InternalToolDefinition["endsTurn"];
     readonly execute?: (input: any, options: ToolExecuteOptions) => any;
     /** Optional JSON input substituted when this tool starts its workflow body. */
     readonly executeInput?: (input: unknown) => JsonValue;
-    readonly execution?: "background";
-    readonly frameworkAction?: "load-skill";
+    readonly frameworkAction?: "load-skill" | "task-cancel" | "task-wait";
     readonly inputSchema: FlexibleSchema;
     readonly name: string;
-    /** Selected agent definition's runtime graph ID; absent for authored workflow tools. */
-    readonly nodeId?: string;
     readonly approval?: Approval;
     readonly outputSchema?: FlexibleSchema;
     /**
@@ -38,7 +28,6 @@ export interface HarnessToolDefinition {
      * cannot delegate recursively. Absent means visible everywhere.
      */
     readonly rootOnly?: boolean;
-    readonly runtimeAction?: HarnessRuntimeActionDefinition;
     readonly toModelOutput?: (output: unknown) => unknown;
     /** Present when this tool starts an associated durable workflow. */
     readonly workflowId?: string;

package/dist/src/harness/held-requests.d.ts

@@ -0,0 +1,18 @@
+import { type AuthorizationChallenge } from "#harness/authorization.js";
+import type { HarnessEmissionState } from "#harness/emission-state.js";
+import { type AuthorizationCompletedStreamEvent } from "#protocol/message.js";
+/**
+ * Ends the sign-ins a held turn waits on when the person moves on, by steering
+ * it with a message or cancelling it: the turn's own sign-ins, and the sign-ins
+ * of responders still checking one of its approvals, whose candidates end as
+ * stale. The approvals themselves resolve with the steering step or the cancel.
+ */
+export declare function withdrawHeldSignIns(state: Record<string, unknown> | undefined, input: {
+    readonly completedAt: number;
+    readonly reason: string;
+}): {
+    readonly state: Record<string, unknown> | undefined;
+    readonly withdrawn: readonly AuthorizationChallenge[];
+};
+/** The `authorization.completed` events reporting withdrawn sign-ins as declined. */
+export declare function declinedSignInEvents(withdrawn: readonly AuthorizationChallenge[], reason: string, emissionState: HarnessEmissionState): AuthorizationCompletedStreamEvent[];

package/dist/src/harness/held-requests.js

@@ -0,0 +1 @@
+import{createAuthorizationCompletedEvent}from"#protocol/message.js";import{clearPendingAuthorization,getPendingAuthorization}from"#harness/authorization.js";import{authorizationEventFields}from"#harness/authorization-event-fields.js";import{finishApprovalCandidate,getApprovalAuditState}from"#harness/approval-candidates.js";function withdrawHeldSignIns(e,t){let n=getPendingAuthorization(e)?.challenges??[],r=n.length===0?e:clearPendingAuthorization(e);for(let e of getApprovalAuditState(r).activeCandidates)r=finishApprovalCandidate({candidateId:e.candidateId,completedAt:t.completedAt,reason:t.reason,state:r,status:`stale`});return{state:r,withdrawn:n}}function declinedSignInEvents(e,t,n){return e.map(e=>createAuthorizationCompletedEvent({...authorizationEventFields(e),outcome:`declined`,reason:t,sequence:n.sequence,stepIndex:n.stepIndex,turnId:n.turnId}))}export{declinedSignInEvents,withdrawHeldSignIns};

package/dist/src/harness/hitl/approval-input-requests.d.ts

@@ -7,5 +7,21 @@ export declare function findAnsweredApprovalBatches(batches: readonly PendingInp
 export declare function resolveApprovalInputBatches(input: InputDomainResolverInput & {
     readonly resolveApprovalKey?: (request: InputRequest) => string | undefined;
 }): ResolvePendingInputResult;
+/**
+ * Resolves the first open approval batch when the person steered the held turn
+ * with a message instead of finishing it. Requests they already answered, as in
+ * a partial approval, keep that answer; the rest report `ignored`. Later
+ * batches stay open, as with answered batches.
+ */
+export declare function ignoreApprovalInputBatch(input: InputDomainResolverInput & {
+    readonly resolveApprovalKey?: (request: InputRequest) => string | undefined;
+}): ResolvePendingInputResult;
+/**
+ * Withdraws every pending tool approval when its turn is cancelled. Each held
+ * call goes into history with a not-run result, so no call is left without one.
+ */
+export declare function cancelApprovalInputBatches(session: HarnessSession): HarnessSession;
+/** Tool approvals still waiting for an answer, which cancelling their turn withdraws. */
+export declare function getPendingApprovalRequests(state: HarnessSession["state"]): readonly InputRequest[];
 /** Returns recorded approval keys that have no matching request still pending. */
 export declare function getApprovedTools(session: HarnessSession, resolveApprovalKey?: (request: InputRequest) => string | undefined): ReadonlySet<string>;

package/dist/src/harness/hitl/approval-input-requests.js

@@ -1 +1 @@
-import{getPendingInputBatches,queueDeferredStepInput,removePendingInputBatches}from"#harness/pending-input-batches.js";import{isApprovalRequest}from"#harness/input-request-class.js";import{TOOL_EXECUTION_DENIED_MESSAGE,buildResolvedInputBatch,resolveApprovalOutcome}from"#harness/input-request-resolution.js";import{appendResolvedBatchTranscript,compactStepInput,finishResolvedInput,responsesForBatches}from"#harness/hitl/pending-input-resolution.js";const APPROVED_TOOLS_KEY=`eve.runtime.hitl.approvedTools`;function findAnsweredApprovalBatches(e,t){let n=new Set(t.map(e=>e.requestId));return e.filter(e=>e.requests.every(e=>!isApprovalRequest(e)||n.has(e.requestId)))}function resolveApprovalInputBatches(e){let t=new Set(findAnsweredApprovalBatches(e.batches,e.responses)),n=e.batches.find(e=>t.has(e)),r=e.batches.filter(e=>e!==n),i=responsesForBatches(e.responses,r);if(n===void 0){if(e.resolvedStepInput?.message===void 0)return{outcome:`unresolved`,messages:[...e.baseHistory],session:queueDeferredStepInput(e.session,compactStepInput(e.resolvedStepInput))};let t=i.length===0?e.session:queueDeferredStepInput(e.session,{inputResponses:i});return{consumedMessage:e.resolvedStepInput.messageConsumed,outcome:`continue`,messages:[...e.baseHistory],session:t}}let a=resolveApprovalBatch({batch:n,messages:[...e.baseHistory],resolveApprovalKey:e.resolveApprovalKey,responses:e.responses,session:e.session}),o=buildResolvedInputBatch(n,e.responses);return finishResolvedInput({deferTurnInput:!0,leftoverResponses:i,messages:a.messages,rejectedActions:a.rejectedActions,resolvedInputs:o===void 0?[]:[o],resolvedStepInput:e.resolvedStepInput,session:removePendingInputBatches(a.session,[n])})}function getApprovedTools(e,t){let n=readRecordedApprovedTools(e);for(let r of getPendingInputBatches(e.state))for(let e of r.requests)isApprovalRequest(e)&&n.delete(t?.(e)??e.action.toolName);return n}function readRecordedApprovedTools(e){let t=e.state?.[APPROVED_TOOLS_KEY];return Array.isArray(t)?new Set(t):new Set}function resolveApprovalBatch(e){let t=recordApprovedTools({pendingBatch:e.batch,resolveApprovalKey:e.resolveApprovalKey,responses:e.responses,session:e.session}),n=buildApprovalBatchToolResponseParts(e.batch,e.responses);appendResolvedBatchTranscript(e.messages,e.batch,n);let r=buildRejectedActionBatch(e.batch,e.responses);return{messages:e.messages,rejectedActions:r===void 0?void 0:[r],session:t}}function recordApprovedTools(e){let t=new Set(e.responses.filter(e=>e.optionId===`approve`).map(e=>e.requestId)),n=e.pendingBatch.requests.filter(e=>isApprovalRequest(e)&&t.has(e.requestId)).map(t=>e.resolveApprovalKey?.(t)??t.action.toolName);if(n.length===0)return e.session;let r={...e.session.state};return r[APPROVED_TOOLS_KEY]=[...new Set([...readRecordedApprovedTools(e.session),...n])],{...e.session,state:r}}function buildRejectedActionBatch(e,t){if(e.event===void 0)return;let n=new Map(t.map(e=>[e.requestId,e])),r=[];for(let t of e.requests){if(!isApprovalRequest(t))continue;let{approved:e,reason:i,status:a}=resolveApprovalOutcome(n.get(t.requestId));e||r.push({callId:t.action.callId,isError:!0,kind:`tool-result`,output:{approval:{requestId:t.requestId,status:a},code:`TOOL_EXECUTION_DENIED`,message:i??TOOL_EXECUTION_DENIED_MESSAGE,tool:{result:`not_run`}},toolName:t.action.toolName})}return r.length>0?{event:e.event,results:r}:void 0}function buildApprovalBatchToolResponseParts(e,t){let n=new Map(t.map(e=>[e.requestId,e])),r=[];for(let t of e.requests){let e=n.get(t.requestId);switch(t.kind){case`tool-approval`:r.push(...buildApprovalToolResponseParts(t,e));break;case`question`:case`session-limit`:throw TypeError(`Approval pending input batches cannot contain a "${t.kind}" request.`);default:{let e=t.kind;throw TypeError(`Unhandled pending input request kind: ${String(e)}`)}}}return r}function buildApprovalToolResponseParts(e,t){let{approved:n,reason:r}=resolveApprovalOutcome(t),i=[{approvalId:e.requestId,approved:n,reason:r,type:`tool-approval-response`}];return n||i.push({output:{type:`execution-denied`,reason:r},toolCallId:e.action.callId,toolName:e.action.toolName,type:`tool-result`}),i}export{findAnsweredApprovalBatches,getApprovedTools,resolveApprovalInputBatches};
+import{validateHarnessModelMessages}from"#harness/messages.js";import{getPendingInputBatches,queueDeferredStepInput,removePendingInputBatches}from"#harness/pending-input-batches.js";import{isApprovalRequest}from"#harness/input-request-class.js";import{TOOL_EXECUTION_DENIED_MESSAGE,buildResolvedInputBatch,resolveApprovalOutcome}from"#harness/input-request-resolution.js";import{appendResolvedBatchTranscript,compactStepInput,finishResolvedInput,responsesForBatches}from"#harness/hitl/pending-input-resolution.js";const APPROVED_TOOLS_KEY=`eve.runtime.hitl.approvedTools`;function findAnsweredApprovalBatches(e,t){let n=new Set(t.map(e=>e.requestId));return e.filter(e=>e.requests.every(e=>!isApprovalRequest(e)||n.has(e.requestId)))}function resolveApprovalInputBatches(e){let t=new Set(findAnsweredApprovalBatches(e.batches,e.responses)),n=e.batches.find(e=>t.has(e)),r=e.batches.filter(e=>e!==n),i=responsesForBatches(e.responses,r);if(n===void 0)return e.resolvedStepInput?.message===void 0?{outcome:`unresolved`,messages:[...e.baseHistory],session:queueDeferredStepInput(e.session,compactStepInput(e.resolvedStepInput))}:ignoreApprovalInputBatch(e);let a=resolveApprovalBatch({batch:n,messages:[...e.baseHistory],resolveApprovalKey:e.resolveApprovalKey,responses:e.responses,session:e.session}),o=buildResolvedInputBatch(n,e.responses);return finishResolvedInput({deferTurnInput:!0,leftoverResponses:i,messages:a.messages,rejectedActions:a.rejectedActions,resolvedInputs:o===void 0?[]:[o],resolvedStepInput:e.resolvedStepInput,session:removePendingInputBatches(a.session,[n])})}function ignoreApprovalInputBatch(e){let t=e.batches[0],n=responsesForBatches(e.responses,[t]),r=resolveApprovalBatch({batch:t,messages:[...e.baseHistory],resolveApprovalKey:e.resolveApprovalKey,responses:n,session:e.session}),i=buildResolvedInputBatch(t,n);return finishResolvedInput({deferTurnInput:n.some(e=>resolveApprovalOutcome(e).approved),leftoverResponses:responsesForBatches(e.responses,e.batches.slice(1)),messages:r.messages,rejectedActions:r.rejectedActions,resolvedInputs:i===void 0?[]:[i],resolvedStepInput:e.resolvedStepInput,session:removePendingInputBatches(r.session,[t])})}function cancelApprovalInputBatches(e){let t=pendingApprovalBatches(e.state);if(t.length===0)return e;let n=[...e.history];for(let e of t)appendResolvedBatchTranscript(n,e,buildApprovalBatchToolResponseParts(e,[],`Cancelled before anyone answered.`));return{...removePendingInputBatches(e,t),history:validateHarnessModelMessages(n)}}function getPendingApprovalRequests(e){return pendingApprovalBatches(e).flatMap(e=>e.requests)}function pendingApprovalBatches(e){return getPendingInputBatches(e).filter(e=>e.requests.every(isApprovalRequest))}function getApprovedTools(e,t){let n=readRecordedApprovedTools(e);for(let r of getPendingInputBatches(e.state))for(let e of r.requests)isApprovalRequest(e)&&n.delete(t?.(e)??e.action.toolName);return n}function readRecordedApprovedTools(e){let t=e.state?.[APPROVED_TOOLS_KEY];return Array.isArray(t)?new Set(t):new Set}function resolveApprovalBatch(e){let t=recordApprovedTools({pendingBatch:e.batch,resolveApprovalKey:e.resolveApprovalKey,responses:e.responses,session:e.session}),n=buildApprovalBatchToolResponseParts(e.batch,e.responses);appendResolvedBatchTranscript(e.messages,e.batch,n);let r=buildRejectedActionBatch(e.batch,e.responses);return{messages:e.messages,rejectedActions:r===void 0?void 0:[r],session:t}}function recordApprovedTools(e){let t=new Set(e.responses.filter(e=>e.optionId===`approve`).map(e=>e.requestId)),n=e.pendingBatch.requests.filter(e=>isApprovalRequest(e)&&t.has(e.requestId)).map(t=>e.resolveApprovalKey?.(t)??t.action.toolName);if(n.length===0)return e.session;let r={...e.session.state};return r[APPROVED_TOOLS_KEY]=[...new Set([...readRecordedApprovedTools(e.session),...n])],{...e.session,state:r}}function buildRejectedActionBatch(e,t){if(e.event===void 0)return;let n=new Map(t.map(e=>[e.requestId,e])),r=[];for(let t of e.requests){if(!isApprovalRequest(t))continue;let{approved:e,reason:i,status:a}=resolveApprovalOutcome(n.get(t.requestId));e||r.push({callId:t.action.callId,isError:!0,kind:`tool-result`,output:{approval:{requestId:t.requestId,status:a},code:`TOOL_EXECUTION_DENIED`,message:i??TOOL_EXECUTION_DENIED_MESSAGE,tool:{result:`not_run`}},toolName:t.action.toolName})}return r.length>0?{event:e.event,results:r}:void 0}function buildApprovalBatchToolResponseParts(e,t,n){let r=new Map(t.map(e=>[e.requestId,e])),i=[];for(let t of e.requests){let e=r.get(t.requestId);switch(t.kind){case`tool-approval`:i.push(...buildApprovalToolResponseParts(t,e,n));break;case`question`:case`session-limit`:throw TypeError(`Approval pending input batches cannot contain a "${t.kind}" request.`);default:{let e=t.kind;throw TypeError(`Unhandled pending input request kind: ${String(e)}`)}}}return i}function buildApprovalToolResponseParts(e,t,n){let r=resolveApprovalOutcome(t),i=r.approved,a=t===void 0?n??r.reason:r.reason,o=[{approvalId:e.requestId,approved:i,reason:a,type:`tool-approval-response`}];return i||o.push({output:{type:`execution-denied`,reason:a},toolCallId:e.action.callId,toolName:e.action.toolName,type:`tool-result`}),o}export{cancelApprovalInputBatches,findAnsweredApprovalBatches,getApprovedTools,getPendingApprovalRequests,ignoreApprovalInputBatch,resolveApprovalInputBatches};

package/dist/src/harness/hitl/session-limit-input-requests.d.ts

@@ -6,5 +6,7 @@ export declare function isSessionLimitInputBatch(batch: PendingInputBatch): bool
 export declare function resolveSessionLimitInput(input: InputDomainResolverInput & {
     readonly pendingBatch: PendingInputBatch;
 }): ResolvePendingInputResult;
+/** A batch of only harness-authored session-limit prompts, which a cancel drops. */
+export declare function isSessionLimitPromptBatch(batch: PendingInputBatch): boolean;
 /** Drops only harness-authored session-limit prompts from a parked session. */
 export declare function clearPendingSessionLimitPrompt(session: HarnessSession): HarnessSession;

package/dist/src/harness/hitl/session-limit-input-requests.js

@@ -1 +1 @@
-import{getPendingInputBatches,queueDeferredStepInput,removePendingInputBatches}from"#harness/pending-input-batches.js";import{buildResolvedInputBatch}from"#harness/input-request-resolution.js";import{appendResolvedBatchTranscript,compactStepInput,finishResolvedInput,responsesForBatches}from"#harness/hitl/pending-input-resolution.js";import{isSessionLimitContinuationRequest,resolveSessionLimitContinuation}from"#harness/session-limit-continuation.js";function isSessionLimitInputBatch(e){let t=e.requests.some(e=>e.kind===`session-limit`);if(t&&e.requests.some(e=>e.kind!==`session-limit`))throw TypeError(`Session-limit pending input batches must contain only session-limit requests.`);return t}function resolveSessionLimitInput(e){let t=new Set(e.responses.map(e=>e.requestId));if(!(e.pendingBatch.requests.some(e=>t.has(e.requestId))&&e.pendingBatch.requests.every(e=>t.has(e.requestId))))return{deferredMessage:!0,outcome:`unresolved`,messages:[...e.baseHistory],session:queueDeferredStepInput(e.session,compactStepInput(e.resolvedStepInput))};let n=e.batches.filter(t=>t!==e.pendingBatch),r=responsesForBatches(e.responses,n),i=n.some(e=>e.requests.some(e=>isSessionLimitContinuationRequest(e))),a=[...e.baseHistory];appendResolvedBatchTranscript(a,e.pendingBatch,[]);let o=removePendingInputBatches(e.session,[e.pendingBatch]),s=resolveSessionLimitContinuation({requests:e.pendingBatch.requests,responses:e.responses});return finishResolvedInput({deferTurnInput:e.deferTurnInput||i,leftoverResponses:r,limitContinuation:s,messages:a,resolvedInputs:[buildResolvedInputBatch(e.pendingBatch,e.responses)].filter(e=>e!==void 0),resolvedStepInput:e.resolvedStepInput,session:o})}function clearPendingSessionLimitPrompt(e){let t=getPendingInputBatches(e.state).filter(e=>e.requests.length>0&&e.requests.every(e=>isSessionLimitContinuationRequest(e)));return t.length===0?e:removePendingInputBatches(e,t)}export{clearPendingSessionLimitPrompt,isSessionLimitInputBatch,resolveSessionLimitInput};
+import{getPendingInputBatches,queueDeferredStepInput,removePendingInputBatches}from"#harness/pending-input-batches.js";import{buildResolvedInputBatch}from"#harness/input-request-resolution.js";import{appendResolvedBatchTranscript,compactStepInput,finishResolvedInput,responsesForBatches}from"#harness/hitl/pending-input-resolution.js";import{isSessionLimitContinuationRequest,resolveSessionLimitContinuation}from"#harness/session-limit-continuation.js";function isSessionLimitInputBatch(e){let t=e.requests.some(e=>e.kind===`session-limit`);if(t&&e.requests.some(e=>e.kind!==`session-limit`))throw TypeError(`Session-limit pending input batches must contain only session-limit requests.`);return t}function resolveSessionLimitInput(e){let t=new Set(e.responses.map(e=>e.requestId));if(!(e.pendingBatch.requests.some(e=>t.has(e.requestId))&&e.pendingBatch.requests.every(e=>t.has(e.requestId))))return{deferredMessage:!0,outcome:`unresolved`,messages:[...e.baseHistory],session:queueDeferredStepInput(e.session,compactStepInput(e.resolvedStepInput))};let n=e.batches.filter(t=>t!==e.pendingBatch),r=responsesForBatches(e.responses,n),i=n.some(e=>e.requests.some(e=>isSessionLimitContinuationRequest(e))),a=[...e.baseHistory];appendResolvedBatchTranscript(a,e.pendingBatch,[]);let o=removePendingInputBatches(e.session,[e.pendingBatch]),s=resolveSessionLimitContinuation({requests:e.pendingBatch.requests,responses:e.responses});return finishResolvedInput({deferTurnInput:e.deferTurnInput||i,leftoverResponses:r,limitContinuation:s,messages:a,resolvedInputs:[buildResolvedInputBatch(e.pendingBatch,e.responses)].filter(e=>e!==void 0),resolvedStepInput:e.resolvedStepInput,session:o})}function isSessionLimitPromptBatch(e){return e.requests.length>0&&e.requests.every(e=>isSessionLimitContinuationRequest(e))}function clearPendingSessionLimitPrompt(e){let t=getPendingInputBatches(e.state).filter(isSessionLimitPromptBatch);return t.length===0?e:removePendingInputBatches(e,t)}export{clearPendingSessionLimitPrompt,isSessionLimitInputBatch,isSessionLimitPromptBatch,resolveSessionLimitInput};

package/dist/src/harness/input-extraction.js

@@ -1 +1 @@
-import{z}from"#compiled/zod/index.js";import{createRuntimeToolCallActionFromToolCall}from"#harness/tool-call-action.js";const ToolCallDescriptorSchema=z.object({input:z.unknown(),toolCallId:z.string(),toolName:z.string()}),PersistedToolCallSchema=ToolCallDescriptorSchema.extend({type:z.literal(`tool-call`)}),ToolApprovalRequestSchema=z.object({approvalId:z.string(),isAutomatic:z.boolean().optional().catch(void 0),toolCall:ToolCallDescriptorSchema.optional().catch(void 0),toolCallId:z.string().optional().catch(void 0),type:z.literal(`tool-approval-request`)});function extractToolApprovalInputRequests(e){return extractApprovalRequests(e)}function extractApprovalRequests(e){let t=[],n=new Map;for(let t of e.content){let e=PersistedToolCallSchema.safeParse(t);e.success&&n.set(e.data.toolCallId,e.data)}for(let r of e.content){let i=ToolApprovalRequestSchema.safeParse(r);if(!i.success)continue;let a=i.data;if(e.includedRequestIds!==void 0&&!e.includedRequestIds.has(a.approvalId)||a.isAutomatic===!0)continue;let o=a.toolCall??(a.toolCallId===void 0?void 0:n.get(a.toolCallId));o!==void 0&&(e.excludedCallIds?.has(o.toolCallId)||t.push({action:createRuntimeToolCallActionFromToolCall({toolCall:o}),allowFreeform:!1,display:`confirmation`,kind:`tool-approval`,options:[{id:`approve`,label:`Approve`},{id:`cancel`,label:`Cancel`}],prompt:`Approve tool call: ${o.toolName}`,requestId:a.approvalId}))}return t}function extractHistoricalInputRequests(e){let t=new Map;for(let n=e.history.length-1;n>=0;--n){let r=e.history[n];if(r?.role!==`assistant`||!Array.isArray(r.content))continue;let i=extractApprovalRequests({content:r.content,includedRequestIds:e.requestIds});for(let n of i)e.requestIds.has(n.requestId)&&!t.has(n.requestId)&&t.set(n.requestId,n);if(t.size===e.requestIds.size)break}return t}export{extractHistoricalInputRequests,extractToolApprovalInputRequests};
+import{z}from"#compiled/zod/index.js";import{toolCallDisplayName}from"#execution/tools/connection-target.js";import{createRuntimeToolCallActionFromToolCall}from"#harness/tool-call-action.js";const ToolCallDescriptorSchema=z.object({input:z.unknown(),toolCallId:z.string(),toolName:z.string()}),PersistedToolCallSchema=ToolCallDescriptorSchema.extend({type:z.literal(`tool-call`)}),ToolApprovalRequestSchema=z.object({approvalId:z.string(),isAutomatic:z.boolean().optional().catch(void 0),toolCall:ToolCallDescriptorSchema.optional().catch(void 0),toolCallId:z.string().optional().catch(void 0),type:z.literal(`tool-approval-request`)});function extractToolApprovalInputRequests(e){return extractApprovalRequests(e)}function extractApprovalRequests(e){let t=[],n=new Map;for(let t of e.content){let e=PersistedToolCallSchema.safeParse(t);e.success&&n.set(e.data.toolCallId,e.data)}for(let r of e.content){let i=ToolApprovalRequestSchema.safeParse(r);if(!i.success)continue;let a=i.data;if(e.includedRequestIds!==void 0&&!e.includedRequestIds.has(a.approvalId)||a.isAutomatic===!0)continue;let o=a.toolCall??(a.toolCallId===void 0?void 0:n.get(a.toolCallId));o!==void 0&&(e.excludedCallIds?.has(o.toolCallId)||t.push({action:createRuntimeToolCallActionFromToolCall({toolCall:o}),allowFreeform:!1,display:`confirmation`,kind:`tool-approval`,options:[{id:`approve`,label:`Approve`},{id:`cancel`,label:`Cancel`}],prompt:`Approve ${toolCallDisplayName(o.toolName,o.input)}?`,requestId:a.approvalId}))}return t}function extractHistoricalInputRequests(e){let t=new Map;for(let n=e.history.length-1;n>=0;--n){let r=e.history[n];if(r?.role!==`assistant`||!Array.isArray(r.content))continue;let i=extractApprovalRequests({content:r.content,includedRequestIds:e.requestIds});for(let n of i)e.requestIds.has(n.requestId)&&!t.has(n.requestId)&&t.set(n.requestId,n);if(t.size===e.requestIds.size)break}return t}export{extractHistoricalInputRequests,extractToolApprovalInputRequests};

package/dist/src/harness/input-request-resolution.d.ts

@@ -8,14 +8,17 @@ export interface ResolvedInputBatch {
         readonly outcome: "answered" | ApprovalTerminalStatus;
         readonly request: InputRequest;
         readonly response?: InputResponse;
-        readonly toolReplayIdentity?: string;
     }[];
 }
 export declare function buildResolvedInputBatch(batch: {
     readonly event?: PendingInputBatchEvent;
     readonly requests: readonly InputRequest[];
-    readonly toolReplayIdentities?: Readonly<Record<string, string>>;
 }, responses: readonly InputResponse[]): ResolvedInputBatch | undefined;
+/**
+ * One request's terminal outcome once its batch resolves: an approval's
+ * decision, or whether a question received a response.
+ */
+export declare function resolveInputOutcome(kind: InputRequest["kind"], response: InputResponse | undefined): "answered" | ApprovalTerminalStatus;
 export declare function resolveApprovalOutcome(response: InputResponse | undefined): {
     readonly approved: boolean;
     readonly reason: string | undefined;

package/dist/src/harness/input-request-resolution.js

@@ -1 +1 @@
-import{isApprovalRequest}from"#harness/input-request-class.js";const TOOL_EXECUTION_DENIED_MESSAGE=`Tool execution was denied.`;function buildResolvedInputBatch(e,t){if(e.event===void 0)return;let n=new Map(t.map(e=>[e.requestId,e]));return{event:e.event,inputs:e.requests.map(t=>{let r=n.get(t.requestId);return{outcome:isApprovalRequest(t)?resolveApprovalOutcome(r).status:r===void 0?`ignored`:`answered`,request:t,response:r,...e.toolReplayIdentities?.[t.requestId]===void 0?{}:{toolReplayIdentity:e.toolReplayIdentities[t.requestId]}}})}}function resolveApprovalOutcome(e){return e===void 0?{approved:!1,reason:`Ignored because the user continued without responding.`,status:`ignored`}:e.optionId===`approve`?{approved:!0,reason:void 0,status:`approved`}:e.optionId===`cancel`||e.optionId===`deny`?{approved:!1,reason:TOOL_EXECUTION_DENIED_MESSAGE,status:`denied`}:{approved:!1,reason:`Invalid approval response.`,status:`invalid`}}export{TOOL_EXECUTION_DENIED_MESSAGE,buildResolvedInputBatch,resolveApprovalOutcome};
+const TOOL_EXECUTION_DENIED_MESSAGE=`Tool execution was denied.`;function buildResolvedInputBatch(e,t){if(e.event===void 0)return;let n=new Map(t.map(e=>[e.requestId,e]));return{event:e.event,inputs:e.requests.map(e=>{let t=n.get(e.requestId);return{outcome:resolveInputOutcome(e.kind,t),request:e,response:t}})}}function resolveInputOutcome(e,t){return e===`tool-approval`?resolveApprovalOutcome(t).status:t===void 0?`ignored`:`answered`}function resolveApprovalOutcome(e){return e===void 0?{approved:!1,reason:`Ignored because the user continued without responding.`,status:`ignored`}:e.optionId===`approve`?{approved:!0,reason:void 0,status:`approved`}:e.optionId===`cancel`||e.optionId===`deny`?{approved:!1,reason:TOOL_EXECUTION_DENIED_MESSAGE,status:`denied`}:{approved:!1,reason:`Invalid approval response.`,status:`invalid`}}export{TOOL_EXECUTION_DENIED_MESSAGE,buildResolvedInputBatch,resolveApprovalOutcome,resolveInputOutcome};

package/dist/src/harness/input-requests.d.ts

@@ -24,10 +24,6 @@ export declare function selectApprovalReplayBatch(session: HarnessSession, stepI
  * requirement.
  */
 export declare function resolvePendingInput(input: {
-    /** The turn currently advancing through the harness tool loop. */
-    readonly activeTurnId?: string;
-    /** True while the harness has an open turn to continue. */
-    readonly internalStep?: boolean;
     readonly history?: readonly ModelMessage[];
     readonly resolveApprovalKey?: (request: InputRequest) => string | undefined;
     readonly session: HarnessSession;

package/dist/src/harness/input-requests.js

@@ -1 +1 @@
-import{readClientContext}from"#internal/client-context.js";import{resolveTextToResponses}from"#channel/resolve-text.js";import{appendPendingInputBatch,consumeDeferredStepInput,getDeferredStepInput,getPendingInputBatches,getPendingInputRequestIds,hasPendingInputBatch,queueDeferredStepInput}from"#harness/pending-input-batches.js";import{isApprovalRequest}from"#harness/input-request-class.js";import{compactStepInput}from"#harness/hitl/pending-input-resolution.js";import{hasTailApprovalResponse}from"#harness/current-messages.js";import{findAnsweredApprovalBatches,getApprovedTools,resolveApprovalInputBatches}from"#harness/hitl/approval-input-requests.js";import{clearPendingSessionLimitPrompt,isSessionLimitInputBatch,resolveSessionLimitInput}from"#harness/hitl/session-limit-input-requests.js";function hasStepInput(e){return e===void 0?!1:e.message!==void 0||(e.inputResponses?.length??0)>0}function hasRunnableDeferredStepInput(e){let t=getDeferredStepInput(e);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=getPendingInputBatches(e.state),i=routePendingInput(r);switch(i.kind){case`session-limit`:return i.batch.requests.every(e=>n.some(t=>t.requestId===e.requestId));case`approvals`:return findAnsweredApprovalBatches(r,n).length>0}}function selectApprovalReplayBatch(e,t){let n=getPendingInputBatches(e.state);if(n.some(isSessionLimitInputBatch))return;let r=canonicalizeInputResponses((n.length===1?resolveTextMessageInput(n[0],t):t)?.inputResponses??[]),i=findAnsweredApprovalBatches(n,r)[0];return i?.requests.some(e=>isApprovalRequest(e)&&r.some(t=>t.requestId===e.requestId&&t.optionId===`approve`))?i:void 0}function resolvePendingInput(e){let t=[...e.history??e.session.history],n=getPendingInputBatches(e.session.state);if(n.length===0)return{outcome:`continue`,messages:t,session:e.session};let r=routePendingInput(n),i=hasTailApprovalResponse(t),a=r.kind===`session-limit`?r.batch:n.length===1?n[0]:void 0,o=a===void 0?e.stepInput:resolveTextMessageInput(a,e.stepInput),s=canonicalizeInputResponses(o?.inputResponses??[]);if(e.internalStep===!0&&canContinuePastHistoricalInput({activeTurnId:e.activeTurnId,batches:n,responses:s,route:r})&&o?.message===void 0)return{outcome:`continue`,messages:t,session:o===void 0?e.session:queueDeferredStepInput(e.session,compactStepInput(o))};if(s.length===0&&o?.message===void 0){let n=compactStepInput(o);return{outcome:`unresolved`,messages:t,session:n.context!==void 0||readClientContext(n)!==void 0||n.outputSchema!==void 0?queueDeferredStepInput(e.session,n):e.session}}let c={baseHistory:t,batches:n,deferTurnInput:i,resolvedStepInput:o,responses:s,session:e.session};switch(r.kind){case`session-limit`:return resolveSessionLimitInput({...c,pendingBatch:r.batch});case`approvals`:return resolveApprovalInputBatches({...c,resolveApprovalKey:e.resolveApprovalKey})}}function canContinuePastHistoricalInput(e){return e.activeTurnId===void 0||e.route.kind===`session-limit`||e.responses.length>0&&findAnsweredApprovalBatches(e.batches,e.responses).length>0?!1:e.batches.every(t=>t.event!==void 0&&t.event.turnId!==e.activeTurnId)}function routePendingInput(e){let t=e.find(e=>isSessionLimitInputBatch(e));if(t!==void 0)return{batch:t,kind:`session-limit`};for(let t of e)for(let e of t.requests)if(!isApprovalRequest(e))throw TypeError(`Unhandled pending input request kind: ${e.kind}`);return{kind:`approvals`}}function canonicalizeInputResponses(e){let t=new Map;for(let n of e)t.set(n.requestId,n);return[...t.values()]}function resolveTextMessageInput(e,t){if(typeof t?.message!=`string`)return t;let n=new Set(e.requests.map(e=>e.requestId));if(t.inputResponses?.some(e=>n.has(e.requestId)))return t;let r=new Set(e.responseAuthRequiredRequestIds??[]),i=e.requests.filter(e=>!r.has(e.requestId)),a=resolveTextToResponses(t.message,i);return a.length===0?t:compactStepInput({...t,inputResponses:[...t.inputResponses??[],...a],messageConsumed:!0,message:void 0})}export{appendPendingInputBatch,clearPendingSessionLimitPrompt,consumeDeferredStepInput,getApprovedTools,getPendingInputRequestIds,hasPendingInputBatch,hasRunnableDeferredStepInput,hasStepInput,resolvePendingInput,selectApprovalReplayBatch};
+import{readClientContext}from"#internal/client-context.js";import{resolveTextToResponses}from"#channel/resolve-text.js";import{appendPendingInputBatch,consumeDeferredStepInput,getDeferredStepInput,getPendingInputBatches,getPendingInputRequestIds,hasPendingInputBatch,queueDeferredStepInput}from"#harness/pending-input-batches.js";import{findAnsweredApprovalBatches,getApprovedTools,resolveApprovalInputBatches}from"#harness/hitl/approval-input-requests.js";import{isApprovalRequest}from"#harness/input-request-class.js";import{compactStepInput,finishResolvedInput}from"#harness/hitl/pending-input-resolution.js";import{hasTailApprovalResponse}from"#harness/current-messages.js";import{clearPendingSessionLimitPrompt,isSessionLimitInputBatch,resolveSessionLimitInput}from"#harness/hitl/session-limit-input-requests.js";function hasStepInput(e){return e===void 0?!1:e.message!==void 0||(e.inputResponses?.length??0)>0}function hasRunnableDeferredStepInput(e){let t=getDeferredStepInput(e);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=getPendingInputBatches(e.state),i=routePendingInput(r);switch(i.kind){case`session-limit`:return i.batch.requests.every(e=>n.some(t=>t.requestId===e.requestId));case`approvals`:return findAnsweredApprovalBatches(r,n).length>0}}function selectApprovalReplayBatch(e,t){let n=getPendingInputBatches(e.state);if(n.some(isSessionLimitInputBatch))return;let r=canonicalizeInputResponses((n.length===1?resolveTextMessageInput(n[0],t):t)?.inputResponses??[]),i=findAnsweredApprovalBatches(n,r)[0];return i?.requests.some(e=>isApprovalRequest(e)&&r.some(t=>t.requestId===e.requestId&&t.optionId===`approve`))?i:void 0}function resolvePendingInput(e){let t=[...e.history??e.session.history],n=getPendingInputBatches(e.session.state),r=routePendingInput(n);if(r.kind===`approvals`&&hasTailApprovalResponse(t))return finishResolvedInput({deferTurnInput:!0,leftoverResponses:e.stepInput?.inputResponses??[],messages:t,resolvedStepInput:e.stepInput,session:e.session});if(n.length===0)return{outcome:`continue`,messages:t,session:e.session};let i=hasTailApprovalResponse(t),a=r.kind===`session-limit`?r.batch:n.length===1?n[0]:void 0,o=a===void 0?e.stepInput:resolveTextMessageInput(a,e.stepInput),s=canonicalizeInputResponses(o?.inputResponses??[]);if(s.length===0&&o?.message===void 0){let n=compactStepInput(o);return{outcome:`unresolved`,messages:t,session:n.context!==void 0||readClientContext(n)!==void 0||n.outputSchema!==void 0?queueDeferredStepInput(e.session,n):e.session}}let c={baseHistory:t,batches:n,deferTurnInput:i,resolvedStepInput:o,responses:s,session:e.session};switch(r.kind){case`session-limit`:return resolveSessionLimitInput({...c,pendingBatch:r.batch});case`approvals`:return resolveApprovalInputBatches({...c,resolveApprovalKey:e.resolveApprovalKey})}}function routePendingInput(e){let t=e.find(e=>isSessionLimitInputBatch(e));if(t!==void 0)return{batch:t,kind:`session-limit`};for(let t of e)for(let e of t.requests)if(!isApprovalRequest(e))throw TypeError(`Unhandled pending input request kind: ${e.kind}`);return{kind:`approvals`}}function canonicalizeInputResponses(e){let t=new Map;for(let n of e)t.set(n.requestId,n);return[...t.values()]}function resolveTextMessageInput(e,t){if(typeof t?.message!=`string`)return t;let n=new Set(e.requests.map(e=>e.requestId));if(t.inputResponses?.some(e=>n.has(e.requestId)))return t;let r=new Set(e.responseAuthRequiredRequestIds??[]),i=e.requests.filter(e=>!r.has(e.requestId)),a=resolveTextToResponses(t.message,i);return a.length===0?t:compactStepInput({...t,inputResponses:[...t.inputResponses??[],...a],messageConsumed:!0,message:void 0})}export{appendPendingInputBatch,clearPendingSessionLimitPrompt,consumeDeferredStepInput,getApprovedTools,getPendingInputRequestIds,hasPendingInputBatch,hasRunnableDeferredStepInput,hasStepInput,resolvePendingInput,selectApprovalReplayBatch};

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

@@ -1,8 +1,8 @@
 import type { ModelMessage, UserContent } from "ai";
-import type { ChannelDeliveryMetadataEntry, DeliverPayload, SessionAuthContext, TurnCaller, TaskDeliveryPolicy } from "#channel/types.js";
+import type { ChannelDeliveryMetadataEntry, DeliverPayload, SessionAuthContext, TurnCaller } from "#channel/types.js";
 import type { StepInput } from "#harness/types.js";
 /** Reason a framework-authored user-role message was added to model history. */
-export type FrameworkMessageKind = "context.instruction" | "context.state" | "context.compaction" | "memory.load" | "execution.background_task" | "execution.continuation" | "execution.retry";
+export type FrameworkMessageKind = "context.instruction" | "context.state" | "context.compaction" | "memory.load" | "execution.continuation" | "execution.retry" | "task.result";
 /** Semantic classification for every user-role message in model history. */
 export type UserMessageKind = "user" | FrameworkMessageKind;
 /** A user-role message that is safe to retain in framework model history. */
@@ -52,6 +52,15 @@ export declare function coalesceTurnInputs(a: StepInput, b: StepInput): StepInpu
  * turn entirely rather than create an empty model prompt block.
  */
 export declare function normalizeUserContent(content: string | UserContent | undefined): string | UserContent | undefined;
+/**
+ * Model-only assistant text between tool results and a person's next message.
+ * Without it, providers such as Anthropic fold the message into the user turn
+ * that carries the tool results, and the model reads it as tool output: it
+ * continues its plan instead of answering.
+ */
+export declare const TOOL_RESULT_BOUNDARY = "\u2026";
+/** Whether a user message appended to `messages` would share a turn with tool results. */
+export declare function followsToolResults(messages: readonly ModelMessage[]): boolean;
 export declare function createTurnInputMessages(input: StepInput | undefined): UserModelMessage[];
 /** Removes blank text blocks that some providers reject from model-bound history. */
 export declare function normalizeModelMessages(messages: readonly ModelMessage[]): ModelMessage[];
@@ -80,7 +89,6 @@ interface DeliverLike {
     readonly auth?: SessionAuthContext | null;
     readonly caller?: TurnCaller;
     readonly deliveryMetadata?: readonly ChannelDeliveryMetadataEntry[];
-    readonly taskDeliveryPolicy?: TaskDeliveryPolicy;
     readonly kind: "deliver";
     readonly payloads: readonly DeliverPayload[];
 }

package/dist/src/harness/messages.js

@@ -1 +1 @@
-import{attachClientContext,readClientContext}from"#internal/client-context.js";function createUserMessage(e,t,n){let r={content:t,kind:e,role:`user`};return n===void 0?r:{...r,metadata:n}}function createFrameworkUserMessage(e,t,n){return createUserMessage(e,t,n)}function isUserMessageKind(e){return e===`user`||isFrameworkMessageKind(e)}function isUserModelMessage(e){if(e.role!==`user`)return!1;let{kind:t}=e;return isUserMessageKind(t)}function isFrameworkUserMessage(e){return isUserModelMessage(e)&&e.kind!==`user`}function validateHarnessModelMessages(e){let t=[];for(let n of e){if(n.role!==`user`){t.push(n);continue}if(!isUserModelMessage(n))throw TypeError(`Expected every user-role model message to have a kind.`);t.push(n)}return t}function isFrameworkMessageKind(e){return e===`context.instruction`||e===`context.state`||e===`context.compaction`||e===`memory.load`||e===`execution.background_task`||e===`execution.continuation`||e===`execution.retry`}function markFrameworkStepInput(e,t){return{...e,frameworkMessageKind:t}}function frameworkMessageKindForStepInput(e){if(e===void 0)return;let{frameworkMessageKind:t}=e;return isFrameworkMessageKind(t)?t:void 0}function coalesceTurnInputs(e,t){let n=coalesceInputResponses({a:e.inputResponses,b:t.inputResponses}),r=coalesceMessage({a:e.message,b:t.message}),i=coalesceContext({a:e.context,b:t.context}),a=coalesceFrameworkMessageKind({a:e,b:t}),o=coalesceContext({a:readClientContext(e),b:readClientContext(t)}),s=t.outputSchema??e.outputSchema,c={};return n!==void 0&&(c.inputResponses=n),r!==void 0&&(c.message=r),i!==void 0&&(c.context=i),s!==void 0&&(c.outputSchema=s),attachClientContext(a===void 0?c:markFrameworkStepInput(c,a),o)}function normalizeUserContent(e){if(e===void 0)return;if(typeof e==`string`)return e.trim().length>0?e:void 0;let t=e.filter(e=>e.type!==`text`||e.text.trim().length>0);if(t.length!==0)return t.length===e.length?e:t}function createTurnInputMessages(e){let t=[...readClientContext(e)??[],...e?.context??[]].map(e=>createFrameworkUserMessage(`context.instruction`,e)),n=normalizeUserContent(e?.message);if(n===void 0)return t;let r=frameworkMessageKindForStepInput(e);return[...t,r===void 0?createUserMessage(`user`,n):createFrameworkUserMessage(r,n)]}function normalizeModelMessages(e){return e.flatMap(e=>{if(typeof e.content==`string`)return e.content.trim().length>0?[e]:[];let t=e.content.filter(e=>e.type!==`text`||e.text.trim().length>0);return t.length===0?[]:t.length===e.content.length?[e]:[{...e,content:t}]})}function resolveAssistantStepText(e,t){for(let t=e.length-1;t>=0;--t){let n=e[t];if(n?.role!==`assistant`)continue;let r=extractMessageText(n);if(r.trim().length>0)return r}return t!==void 0&&t.trim().length>0?t:null}function extractMessageText(e){return typeof e.content==`string`?e.content:Array.isArray(e.content)?e.content.flatMap(e=>typeof e==`string`?[e]:`type`in e&&e.type===`text`&&typeof e.text==`string`?[e.text]:[]).join(``):``}function coalesceInputResponses(e){let t=e.a??[],n=e.b??[];if(t.length!==0||n.length!==0)return[...t,...n]}function coalesceContext(e){let t=e.a??[],n=e.b??[];if(t.length!==0||n.length!==0)return[...t,...n]}function coalesceFrameworkMessageKind(e){let t=frameworkMessageKindForStepInput(e.a),n=frameworkMessageKindForStepInput(e.b);return e.a.message===void 0?n:e.b.message===void 0||t===n?t:void 0}function coalesceMessage(e){let t=normalizeUserContent(e.a),n=normalizeUserContent(e.b);return t===void 0?n:n===void 0?t:appendUserContent({appended:n,existing:t})}function appendUserContent(e){return typeof e.existing==`string`&&typeof e.appended==`string`?`${e.existing}\n\n${e.appended}`:[...toUserContentArray(e.existing),...toUserContentArray(e.appended)]}function toUserContentArray(e){return typeof e==`string`?e.length>0?[{type:`text`,text:e}]:[]:Array.isArray(e)?[...e]:[]}function coalesceDeliveries(e){let[t,...n]=e;if(t===void 0)throw Error(`Cannot coalesce an empty delivery batch.`);let r=t.auth,i=t.taskDeliveryPolicy,a=t.caller,o=[...t.payloads],s=[...t.deliveryMetadata??[]];for(let e of n){let t=o.length;if(i=e.taskDeliveryPolicy??i,e.auth!==void 0&&(r=e.auth),e.caller!==void 0){if(a!==void 0)throw Error(`Cannot coalesce deliveries from different turns.`);a=e.caller}o.push(...e.payloads),s.push(...(e.deliveryMetadata??[]).map(e=>({...e,payloadIndex:e.payloadIndex+t})))}return{...t,taskDeliveryPolicy:i,auth:r,caller:a,deliveryMetadata:s.length===0?void 0:s,payloads:o}}export{appendUserContent,coalesceDeliveries,coalesceTurnInputs,createFrameworkUserMessage,createTurnInputMessages,createUserMessage,frameworkMessageKindForStepInput,isFrameworkMessageKind,isFrameworkUserMessage,isUserMessageKind,isUserModelMessage,markFrameworkStepInput,normalizeModelMessages,normalizeUserContent,resolveAssistantStepText,validateHarnessModelMessages};
+import{attachClientContext,readClientContext}from"#internal/client-context.js";function createUserMessage(e,t,n){let r={content:t,kind:e,role:`user`};return n===void 0?r:{...r,metadata:n}}function createFrameworkUserMessage(e,t,n){return createUserMessage(e,t,n)}function isUserMessageKind(e){return e===`user`||isFrameworkMessageKind(e)}function isUserModelMessage(e){if(e.role!==`user`)return!1;let{kind:t}=e;return isUserMessageKind(t)}function isFrameworkUserMessage(e){return isUserModelMessage(e)&&e.kind!==`user`}function validateHarnessModelMessages(e){let t=[];for(let n of e){if(n.role!==`user`){t.push(n);continue}if(!isUserModelMessage(n))throw TypeError(`Expected every user-role model message to have a kind.`);t.push(n)}return t}function isFrameworkMessageKind(e){return e===`context.instruction`||e===`context.state`||e===`context.compaction`||e===`memory.load`||e===`execution.continuation`||e===`execution.retry`||e===`task.result`}function markFrameworkStepInput(e,t){return{...e,frameworkMessageKind:t}}function frameworkMessageKindForStepInput(e){if(e===void 0)return;let{frameworkMessageKind:t}=e;return isFrameworkMessageKind(t)?t:void 0}function coalesceTurnInputs(e,t){let n=coalesceInputResponses({a:e.inputResponses,b:t.inputResponses}),r=coalesceMessage({a:e.message,b:t.message}),i=coalesceContext({a:e.context,b:t.context}),a=coalesceFrameworkMessageKind({a:e,b:t}),o=coalesceContext({a:readClientContext(e),b:readClientContext(t)}),s=t.outputSchema??e.outputSchema,c={};return n!==void 0&&(c.inputResponses=n),r!==void 0&&(c.message=r),i!==void 0&&(c.context=i),s!==void 0&&(c.outputSchema=s),attachClientContext(a===void 0?c:markFrameworkStepInput(c,a),o)}function normalizeUserContent(e){if(e===void 0)return;if(typeof e==`string`)return e.trim().length>0?e:void 0;let t=e.filter(e=>e.type!==`text`||e.text.trim().length>0);if(t.length!==0)return t.length===e.length?e:t}const TOOL_RESULT_BOUNDARY=`…`;function followsToolResults(e){return e.findLast(e=>e.role!==`user`)?.role===`tool`}function createTurnInputMessages(e){let t=[...readClientContext(e)??[],...e?.context??[]].map(e=>createFrameworkUserMessage(`context.instruction`,e)),n=normalizeUserContent(e?.message);if(n===void 0)return t;let r=frameworkMessageKindForStepInput(e);return[...t,r===void 0?createUserMessage(`user`,n):createFrameworkUserMessage(r,n)]}function normalizeModelMessages(e){return e.flatMap(e=>{if(typeof e.content==`string`)return e.content.trim().length>0?[e]:[];let t=e.content.filter(e=>e.type!==`text`||e.text.trim().length>0);return t.length===0?[]:t.length===e.content.length?[e]:[{...e,content:t}]})}function resolveAssistantStepText(e,t){for(let t=e.length-1;t>=0;--t){let n=e[t];if(n?.role!==`assistant`)continue;let r=extractMessageText(n);if(r.trim().length>0)return r}return t!==void 0&&t.trim().length>0?t:null}function extractMessageText(e){return typeof e.content==`string`?e.content:Array.isArray(e.content)?e.content.flatMap(e=>typeof e==`string`?[e]:`type`in e&&e.type===`text`&&typeof e.text==`string`?[e.text]:[]).join(``):``}function coalesceInputResponses(e){let t=e.a??[],n=e.b??[];if(t.length!==0||n.length!==0)return[...t,...n]}function coalesceContext(e){let t=e.a??[],n=e.b??[];if(t.length!==0||n.length!==0)return[...t,...n]}function coalesceFrameworkMessageKind(e){let t=frameworkMessageKindForStepInput(e.a),n=frameworkMessageKindForStepInput(e.b);return e.a.message===void 0?n:e.b.message===void 0||t===n?t:void 0}function coalesceMessage(e){let t=normalizeUserContent(e.a),n=normalizeUserContent(e.b);return t===void 0?n:n===void 0?t:appendUserContent({appended:n,existing:t})}function appendUserContent(e){return typeof e.existing==`string`&&typeof e.appended==`string`?`${e.existing}\n\n${e.appended}`:[...toUserContentArray(e.existing),...toUserContentArray(e.appended)]}function toUserContentArray(e){return typeof e==`string`?e.length>0?[{type:`text`,text:e}]:[]:Array.isArray(e)?[...e]:[]}function coalesceDeliveries(e){let[t,...n]=e;if(t===void 0)throw Error(`Cannot coalesce an empty delivery batch.`);let r=t.auth,i=t.caller,a=[...t.payloads],o=[...t.deliveryMetadata??[]];for(let e of n){let t=a.length;if(e.auth!==void 0&&(r=e.auth),e.caller!==void 0){if(i!==void 0&&i.callId!==e.caller.callId)throw Error(`Cannot coalesce deliveries from different turns.`);i=e.caller}a.push(...e.payloads),o.push(...(e.deliveryMetadata??[]).map(e=>({...e,payloadIndex:e.payloadIndex+t})))}return{...t,auth:r,caller:i,deliveryMetadata:o.length===0?void 0:o,payloads:a}}export{TOOL_RESULT_BOUNDARY,appendUserContent,coalesceDeliveries,coalesceTurnInputs,createFrameworkUserMessage,createTurnInputMessages,createUserMessage,followsToolResults,frameworkMessageKindForStepInput,isFrameworkMessageKind,isFrameworkUserMessage,isUserMessageKind,isUserModelMessage,markFrameworkStepInput,normalizeModelMessages,normalizeUserContent,resolveAssistantStepText,validateHarnessModelMessages};