eve 0.71.3 → 0.72.0

package/dist/src/harness/{stale-input-responses.d.ts → hitl/stale-responses.d.ts}

@@ -1,5 +1,6 @@
-import type { ModelMessage, UserContent } from "ai";
+import type { UserContent } from "ai";
 import type { StepInput } from "#harness/types.js";
+import type { InputRequest } from "#shared/input.js";
 type StaleResponseConversion = {
     readonly kind: "unchanged";
     readonly stepInput?: StepInput;
@@ -31,14 +32,15 @@ export declare function dropStaleSessionLimitContinuationResponses(input: {
  * Responses for pending requests stay structured; stale responses become
  * plain user-message text. A stale response never reaches structured HITL
  * processing, so a stale approval cannot authorize an earlier tool call.
- * Request details recovered from history are best-effort model context.
+ * Request details the session still knows are best-effort model context.
  *
  * Assumes {@link dropStaleSessionLimitContinuationResponses} already ran:
  * stale continuation answers must never reach this conversion.
  */
 export declare function convertStaleResponsesToUserMessage(input: {
-    readonly history: readonly ModelMessage[];
     readonly pendingRequestIds: ReadonlySet<string>;
+    /** Requests the session still knows, by id, closed ones included. */
+    readonly requests: ReadonlyMap<string, InputRequest>;
     readonly stepInput?: StepInput;
 }): StaleResponseConversion;
 export {};

package/dist/src/harness/hitl/stale-responses.js

@@ -0,0 +1,3 @@
+import{appendUserContent,normalizeUserContent}from"#harness/messages.js";import{isSessionLimitContinuationRequestId}from"#harness/hitl/budget-request.js";function dropStaleSessionLimitContinuationResponses(e){if(e.stepInput===void 0)return;let t=e.stepInput.inputResponses??[],n=e.stepInput.attributedInputResponses??[],keep=t=>e.pendingRequestIds.has(t)||!isSessionLimitContinuationRequestId(t),r=t.filter(e=>keep(e.requestId)),i=n.filter(({response:e})=>keep(e.requestId));if(r.length===t.length&&i.length===n.length)return e.stepInput;let{attributedInputResponses:a,inputResponses:o,...s}=e.stepInput,c=s;return r.length>0&&(c.inputResponses=r),i.length>0&&(c.attributedInputResponses=i),c}function convertStaleResponsesToUserMessage(e){if(e.stepInput===void 0)return{kind:`unchanged`};let t=e.stepInput.inputResponses??[],n=e.stepInput.attributedInputResponses??[];if(t.length===0&&n.length===0)return{kind:`unchanged`,stepInput:e.stepInput};let r=[],i=[],a=[];for(let n of t)(e.pendingRequestIds.has(n.requestId)?r:a).push(n);for(let t of n)e.pendingRequestIds.has(t.response.requestId)?i.push(t):a.push(t.response);if(a.length===0)return{kind:`unchanged`,stepInput:e.stepInput};let{requests:o}=e,s=appendOptionalUserContent(e.stepInput.message,formatModelMessage(a,o)),c=appendOptionalUserContent(e.stepInput.message,formatDisplayMessage(a,o)),{attributedInputResponses:l,inputResponses:u,...d}=e.stepInput,f={...d,message:s};return r.length>0&&(f.inputResponses=r),i.length>0&&(f.attributedInputResponses=i),{displayMessage:c,kind:`converted`,stepInput:f}}function formatModelMessage(e,t){let n=e.map(e=>{let n=t.get(e.requestId),r=n?.options?.find(t=>t.id===e.optionId),i={};if(e.optionId!==void 0&&(i.optionId=e.optionId),r!==void 0){let e={id:r.id,label:r.label};r.description!==void 0&&(e.description=r.description),i.selectedOption=e}e.text!==void 0&&(i.text=e.text);let a={requestId:e.requestId,response:i};return n?.kind===`tool-approval`&&(a.prompt=n.prompt,a.requestType=`approval`,a.toolName=n.action.toolName),a});return[`The user submitted the following response to an earlier interactive prompt.`,`Treat it as new input at the current point in the conversation and decide whether it is still relevant. This does not authorize an earlier action; request approval again if that action is still needed.`,JSON.stringify(n,null,2)].join(`
+`)}function formatDisplayMessage(e,t){return e.map(e=>e.text!==void 0&&e.text.length>0?e.text:t.get(e.requestId)?.options?.find(t=>t.id===e.optionId)?.label??e.optionId??`Response to an earlier interactive prompt`).join(`
+`)}function appendOptionalUserContent(e,t){let n=normalizeUserContent(e);return n===void 0?t:appendUserContent({appended:t,existing:n})}export{convertStaleResponsesToUserMessage,dropStaleSessionLimitContinuationResponses};

package/dist/src/harness/inline-tool-authorization.d.ts

@@ -11,5 +11,9 @@ export declare function resolveInlineAuthorizationInterrupt(input: {
     readonly toolResults: readonly TypedToolResult<ToolSet>[] | undefined;
 }): {
     readonly challenges: AuthorizationSignal["challenges"];
+    /** The calls each sign-in stopped, by the challenge's connection name. */
+    readonly callIdsByName: ReadonlyMap<string, readonly string[]>;
     readonly history: ModelMessage[];
 } | undefined;
+/** Drops the given calls and their results, keeping protocol-complete sibling calls. */
+export declare function withoutCalls(messages: readonly ModelMessage[], interruptedCallIds: ReadonlySet<string>): ModelMessage[];

package/dist/src/harness/inline-tool-authorization.js

@@ -1 +1 @@
-import{contextStorage}from"#context/container.js";import{isAuthorizationSignal,isPendingAuthorizationToolOutput,resolveActiveAuthorizationChallenges}from"#harness/authorization.js";import{readToolInterrupt}from"#harness/tool-interrupts.js";function isInlineAuthorizationToolResult(e){return isPendingAuthorizationToolOutput(e.output)||readAuthorizationSignal(e)!==void 0}function resolveInlineAuthorizationInterrupt(e){let t=[],n=new Set;for(let r of e.toolResults??[]){let e=readAuthorizationSignal(r);e!==void 0&&(t.push(e),n.add(r.toolCallId))}if(t.length!==0)return{challenges:resolveActiveAuthorizationChallenges(t.flatMap(e=>e.challenges)),history:projectCompletedSiblingCalls(e.messages,n)}}function readAuthorizationSignal(e){let t=contextStorage.getStore(),n=t===void 0?void 0:readToolInterrupt(t,e.toolCallId);return n!==void 0&&isAuthorizationSignal(n)?n:isAuthorizationSignal(e.output)?e.output:void 0}function projectCompletedSiblingCalls(e,t){return e.flatMap(e=>{if(e.role===`assistant`&&Array.isArray(e.content)){let n=e.content.some(e=>e.type===`tool-call`&&t.has(e.toolCallId)),r=e.content.filter(e=>e.type!==`tool-call`||!t.has(e.toolCallId)),i=r.some(e=>e.type===`tool-call`);return r.length===0||n&&!i?[]:[{...e,content:r}]}if(e.role===`tool`){let n=e.content.filter(e=>e.type!==`tool-result`||!t.has(e.toolCallId));return n.length===0?[]:[{...e,content:n}]}return[e]})}export{isInlineAuthorizationToolResult,resolveInlineAuthorizationInterrupt};
+import{contextStorage}from"#context/container.js";import{isAuthorizationSignal,isPendingAuthorizationToolOutput,resolveActiveAuthorizationChallenges}from"#harness/authorization.js";import{readToolInterrupt}from"#harness/tool-interrupts.js";function isInlineAuthorizationToolResult(e){return isPendingAuthorizationToolOutput(e.output)||readAuthorizationSignal(e)!==void 0}function resolveInlineAuthorizationInterrupt(e){let t=[],n=new Set,r=new Map;for(let i of e.toolResults??[]){let e=readAuthorizationSignal(i);if(e!==void 0){t.push(e),n.add(i.toolCallId);for(let t of e.challenges){let e=r.get(t.name)??[];r.set(t.name,[...e,i.toolCallId])}}}if(t.length!==0)return{callIdsByName:r,challenges:resolveActiveAuthorizationChallenges(t.flatMap(e=>e.challenges)),history:withoutCalls(e.messages,n)}}function readAuthorizationSignal(e){let t=contextStorage.getStore(),n=t===void 0?void 0:readToolInterrupt(t,e.toolCallId);return n!==void 0&&isAuthorizationSignal(n)?n:isAuthorizationSignal(e.output)?e.output:void 0}function withoutCalls(e,t){return e.flatMap(e=>{if(e.role===`assistant`&&Array.isArray(e.content)){let n=e.content.some(e=>e.type===`tool-call`&&t.has(e.toolCallId)),r=e.content.filter(e=>e.type!==`tool-call`||!t.has(e.toolCallId)),i=r.some(e=>e.type===`tool-call`);return r.length===0||n&&!i?[]:[{...e,content:r}]}if(e.role===`tool`){let n=e.content.filter(e=>e.type!==`tool-result`||!t.has(e.toolCallId));return n.length===0?[]:[{...e,content:n}]}return[e]})}export{isInlineAuthorizationToolResult,resolveInlineAuthorizationInterrupt,withoutCalls};

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

@@ -1,4 +1,4 @@
-import type { ContentPart, ModelMessage, ToolSet } from "ai";
+import type { ContentPart, ToolSet } from "ai";
 import type { InputRequest } from "#shared/input.js";
 /**
  * Extracts tool approval input requests from AI SDK content parts that
@@ -8,12 +8,3 @@ export declare function extractToolApprovalInputRequests(input: {
     readonly content: readonly ContentPart<ToolSet>[];
     readonly excludedCallIds?: ReadonlySet<string>;
 }): InputRequest[];
-/**
- * Recovers approval request metadata for submitted input response IDs from
- * model history. The newest occurrence wins so compacted or repeated history
- * does not replace the request that is closest to the current turn.
- */
-export declare function extractHistoricalInputRequests(input: {
-    readonly history: readonly ModelMessage[];
-    readonly requestIds: ReadonlySet<string>;
-}): ReadonlyMap<string, InputRequest>;

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

@@ -1 +1 @@
-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};
+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(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}export{extractToolApprovalInputRequests};

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

@@ -1,4 +1,4 @@
-import type { PendingInputBatchEvent } from "#harness/pending-input-batches.js";
+import type { StepCoordinates as PendingInputBatchEvent } from "#harness/session-machine/view.js";
 import type { InputRequest, InputResponse } from "#shared/input.js";
 export declare const TOOL_EXECUTION_DENIED_MESSAGE = "Tool execution was denied.";
 type ApprovalTerminalStatus = "approved" | "denied" | "ignored" | "invalid";
@@ -10,10 +10,6 @@ export interface ResolvedInputBatch {
         readonly response?: InputResponse;
     }[];
 }
-export declare function buildResolvedInputBatch(batch: {
-    readonly event?: PendingInputBatchEvent;
-    readonly requests: readonly InputRequest[];
-}, 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.

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

@@ -1 +1 @@
-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};
+const TOOL_EXECUTION_DENIED_MESSAGE=`Tool execution was denied.`;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,resolveApprovalOutcome,resolveInputOutcome};

package/dist/src/harness/model-call/call.d.ts

@@ -0,0 +1,78 @@
+import { type LanguageModel, type ModelMessage } from "ai";
+import type { GenerationSteering } from "#harness/generation-steering.js";
+import type { HarnessModelMessage, UserModelMessage } from "#harness/messages.js";
+import { type AnthropicCacheMarker, type PromptCachePath } from "#harness/prompt-cache.js";
+import type { Step } from "#harness/step/context.js";
+import { type Prompt } from "#harness/step/prompt.js";
+import { type HarnessStepResult } from "#harness/step-hooks.js";
+import type { StepResult } from "#harness/types.js";
+import type { InstrumentationAttempt } from "#instrumentation/runtime.js";
+import { type RequestMessages } from "./request.js";
+import { type ModelTools } from "./tools.js";
+/** How one attempt differs from the step's first: what recovery and retries change. */
+export interface ModelCallOptions {
+    readonly disabledProviderTools?: ReadonlySet<string>;
+    readonly extraSystemNote?: string;
+    readonly retryReason?: "empty-response";
+    readonly suppressStepStartedEmission?: boolean;
+    readonly trailingUserNote?: string;
+}
+/** What a model step's caller needs from the step. */
+interface ModelCallerInput {
+    readonly model: LanguageModel;
+    readonly generation: GenerationSteering;
+    readonly hidesHeldText: boolean;
+    readonly turnMessages: readonly UserModelMessage[];
+    readonly approvedTools: ReadonlySet<string>;
+    readonly pendingApprovalsNote: string | undefined;
+    /** The prompt as the step started it, projected for the model. */
+    readonly projectedMessages: HarnessModelMessage[];
+    readonly startStep: (messages: readonly ModelMessage[]) => Promise<void>;
+    readonly setAttemptScope: (scope: InstrumentationAttempt | undefined) => void;
+}
+/**
+ * Calls the model for one step. Each attempt rebuilds the tools, the request, and the agent, so an
+ * earlier stream can't resolve a retry's one-shot step hooks with stale partial output. An attempt
+ * may first compact the prompt, which rewrites the durable messages the step later commits.
+ */
+export declare class ModelCaller {
+    readonly cachePath: PromptCachePath;
+    readonly marker: AnthropicCacheMarker | undefined;
+    private readonly attributionHeaders;
+    /** The prompt as the model reads it, projected for its history view. */
+    private projectedMessages;
+    /** The latest attempt's request; its history is what the step commits. */
+    request: RequestMessages;
+    /** The latest attempt's tools, which decide how the step's calls defer and end the turn. */
+    tools: ModelTools | undefined;
+    /** The messages the latest attempt sent, after attachments were hydrated. */
+    modelMessages: ModelMessage[];
+    requestEnvelopeTokens: number;
+    /** Usage of a call steering interrupted, which the steered step still counts. */
+    private interruptedUsage;
+    private compactionFailure;
+    private attemptIndex;
+    private readonly step;
+    private readonly prompt;
+    private readonly input;
+    constructor(step: Step, prompt: Prompt, input: ModelCallerInput);
+    /** Calls the model, retrying transient failures. */
+    call(options: ModelCallOptions): Promise<HarnessStepResult>;
+    /** A failed compaction fails the step, whatever recovery the call attempted. */
+    throwIfCompactionFailed(): void;
+    /** Steering interrupted the call: the step ends with what it committed, and runs again. */
+    steered(): Promise<StepResult>;
+    /** The step's result counted its usage, so an interrupted call's usage no longer applies. */
+    clearInterruptedUsage(): void;
+    private buildRequest;
+    private instructions;
+    private prepare;
+    /** Compacts the prompt when it's over the threshold, then rebuilds what depends on it. */
+    private compact;
+    private attempt;
+    /** Streams the call, publishing its content as it arrives. */
+    private stream;
+    /** Runs the call without a listener: nothing streams. */
+    private generate;
+}
+export {};

package/dist/src/harness/model-call/call.js

@@ -0,0 +1 @@
+import{buildGatewayAttributionHeaders}from"./model.js";import{isEmptyModelResponse,rethrowNoOutputAsEmptyResponse}from"./recovery.js";import{modelInstructions,requestMessages,withTrailingUserNote}from"./request.js";import{answerSkippedToolCalls,appendMissingToolResultMessages,extractToolResultCallIds,withAccumulatedResponseMessages}from"./response.js";import{runModelCallWithRetries}from"./retry.js";import{logToolExecutionError,prepareModelTools}from"./tools.js";import{extractGatewayCostUsd,extractTokenUsageDelta}from"./usage.js";import{ToolLoopAgent,isStepCount}from"ai";import{createLogger,logError}from"#internal/logging.js";import{AuthKey,HistoryStateKey}from"#context/keys.js";import{createStepCompletedEvent}from"#protocol/message.js";import{activeTurnId}from"#harness/session-machine/view.js";import{accumulateTurnUsage,getTurnUsageState,setTurnUsageState}from"#harness/turn-tag-state.js";import{hydrateSandboxAttachments,moveToolResultFilesToUserMessages}from"#harness/attachment-staging.js";import{throwIfTurnAborted}from"#harness/turn-cancellation.js";import{summarizeKnownError}from"#harness/semantic-errors/index.js";import{estimateTokens}from"#harness/token-estimate.js";import{estimateRequestEnvelope}from"#harness/request-envelope.js";import{workingTaskIds}from"#execution/tasks/model-step.js";import{ContentFilteredModelResponseError,EmptyModelResponseError}from"#harness/model-call/errors.js";import{interruptStreamOnFailure}from"#harness/interruptible-stream.js";import{buildToolApproval}from"#harness/tools.js";import{compactPrompt,projectPrompt,withClientContext}from"#harness/step/prompt.js";import{emitStreamContent}from"#harness/emission.js";import{FINAL_OUTPUT_TOOL_NAME}from"#harness/final-output.js";import{detectPromptCachePath,getAnthropicCacheMarker}from"#harness/prompt-cache.js";import{buildStepHooks,emitStepActions,readGatewayGenerationId}from"#harness/step-hooks.js";import{maybeCompact}from"#harness/compaction/step.js";const environment=process.env.NODE_ENV??`unknown`,log=createLogger(`harness.tool-loop`);var ModelCaller=class{cachePath;marker;attributionHeaders;projectedMessages;request;tools;modelMessages=[];requestEnvelopeTokens=0;interruptedUsage;compactionFailure;attemptIndex=0;step;prompt;input;constructor(e,t,n){this.step=e,this.prompt=t,this.input=n,this.cachePath=detectPromptCachePath(n.model),this.marker=this.cachePath.kind===`anthropic-direct`?getAnthropicCacheMarker():void 0,this.attributionHeaders=buildGatewayAttributionHeaders(n.model,e.config.runtimeIdentity),this.projectedMessages=n.projectedMessages,this.request=this.buildRequest(e.config.tools)}async call(e){return await runModelCallWithRetries(t=>this.attempt({...e,suppressStepStartedEmission:t!==1||e.suppressStepStartedEmission}),{canRetry:()=>this.compactionFailure===void 0,sessionId:this.step.session.sessionId,turnId:this.step.position().turnId},this.input.generation.signal)}throwIfCompactionFailed(){if(this.compactionFailure!==void 0)throw this.compactionFailure.error}async steered(){let{step:e}=this;return throwIfTurnAborted(e.config.abortSignal),e.ctx?.set(HistoryStateKey,this.request.historyState),this.interruptedUsage!==void 0&&(e.session=setTurnUsageState(e.session,accumulateTurnUsage({previous:getTurnUsageState(e.session.state),turnId:e.position().turnId,usage:this.interruptedUsage}))),await e.emit?.(createStepCompletedEvent({...e.position(),finishReason:`other`,usage:this.interruptedUsage})),{next:e.runStep,session:{...e.session,history:[...this.request.history]},steered:!0}}clearInterruptedUsage(){this.interruptedUsage=void 0}buildRequest(e){return requestMessages(this.step,{coordinationTools:e,hidesHeldText:this.input.hidesHeldText,messages:this.prompt.messages,pendingApprovalsNote:this.input.pendingApprovalsNote,projectedMessages:this.projectedMessages,turnMessages:this.input.turnMessages})}instructions(e){return modelInstructions({extraSystemNote:e,marker:this.marker,session:this.step.session,systemMessages:this.request.systemMessages})}async prepare(e){let t=await prepareModelTools(this.step,{model:this.input.model,approvedTools:this.input.approvedTools,disabledProviderTools:e.disabledProviderTools,generation:this.input.generation,marker:this.marker});return this.tools=t,this.request=this.buildRequest(t.coordinationTools),this.requestEnvelopeTokens=await estimateRequestEnvelope({history:this.projectedMessages,instructions:this.instructions(e.extraSystemNote),messages:withTrailingUserNote(this.request.nonSystemMessages,e.trailingUserNote),tools:t.effectiveTools}),t}async compact(e,t){let{step:n,prompt:r}=this,{config:i}=n,a;try{a=await maybeCompact({abortSignal:i.abortSignal,auth:n.ctx?.get(AuthKey)??null,emissionState:n.position(),historyProjector:i.historyProjector,messages:[...r.messages],model:this.input.model,promptMessages:withClientContext(r),publish:n.publish,requestEnvelopeTokens:this.requestEnvelopeTokens,resolveModel:i.resolveModel,runtimeIdentity:i.runtimeIdentity,session:n.session,telemetry:n.instrumentation?.telemetry()})}catch(e){throw this.compactionFailure={error:e},e}if(n.session=a.session,!a.compacted)return t;compactPrompt(n,r,a.messages);let{compaction:o}=n.session;return n.session={...n.session,compaction:{recentWindowSize:o.recentWindowSize,threshold:o.threshold,thresholdPercent:o.thresholdPercent}},this.projectedMessages=projectPrompt(n,r),await this.prepare(e)}async attempt(e){let{step:t}=this,{generation:n,model:r}=this.input,i=await this.compact(e,await this.prepare(e));this.requestEnvelopeTokens=Math.max(0,this.requestEnvelopeTokens-(estimateTokens(this.request.history)-estimateTokens(this.prompt.messages))),n.begin(),this.modelMessages=await hydrateSandboxAttachments(this.request.nonSystemMessages),typeof this.input.model!=`string`&&typeof this.input.model.provider==`string`&&this.input.model.provider.endsWith(`.chat`)&&(this.modelMessages=moveToolResultFilesToUserMessages(this.modelMessages));let a=this.instructions(e.extraSystemNote),o=t.instrumentation?.resolveRuntimeContext({emissionState:t.position(),environment,modelInput:{instructions:a,messages:this.modelMessages},session:t.session})??{};e.retryReason&&(o[`eve.retry.reason`]=e.retryReason);let s=withTrailingUserNote(this.modelMessages,e.trailingUserNote),c=t.position(),l=t.instrumentation?.prepareAttempt({isFrameworkTool:e=>t.frameworkToolNames.has(e),attemptIndex:this.attemptIndex++,runtimeContext:o,stepIndex:c.stepIndex,turnId:activeTurnId(c)});this.input.setAttemptScope(l?.scope);let u=buildStepHooks({auth:t.ctx?.get(AuthKey)??null,cachePath:this.cachePath,marker:this.marker,session:t.session,startStep:e.suppressStepStartedEmission===!0?void 0:this.input.startStep}),d={headers:this.attributionHeaders,instructions:a,model:r,onLanguageModelCallEnd:e=>{n.interrupted||(this.interruptedUsage=extractTokenUsageDelta({costUsd:extractGatewayCostUsd(e.providerMetadata),usage:e.usage}))},onToolExecutionEnd:logToolExecutionError,onError(e){n.interrupted||summarizeKnownError(e.error)?.tags.includes(`config`)!==!0&&logError(log,`tool-loop stream error`,e.error)},onStepEnd:u.onStepEnd,onStepStart:u.onStepStart,prepareStep:u.prepareStep,reasoning:t.session.agent.modelReference?.reasoning??t.session.agent.reasoning,runtimeContext:o,stopWhen:isStepCount(1),telemetry:l?.telemetry,toolApproval:buildToolApproval(i.modelTools,n.signal),tools:i.effectiveTools},f=new ToolLoopAgent(d);try{let e=t.emit===void 0?await this.generate(f,s,u.stepResult):await this.stream(f,s,u.stepResult,i);return await l?.complete(),e}catch(e){return n.interrupted?await l?.complete():await l?.fail(e),n.check(),rethrowNoOutputAsEmptyResponse(e)}}async stream(e,t,n,r){let{step:i}=this,{generation:a}=this.input,o=new Set([FINAL_OUTPUT_TOOL_NAME]),s=await e.stream({abortSignal:a.signal,messages:t}),{emittedActionCallIds:c,handledInlineToolResultCallIds:l,invalidInputToolCallIds:u,inlineAuthorizationResults:d,trailingInlineToolResultParts:f}=await emitStreamContent(i.publish,i.position(),interruptStreamOnFailure(s.fullStream,a.signal),{excludedActionToolNames:o,hidesHeldText:this.input.hidesHeldText&&workingTaskIds(i.session).length>0,tools:r.presentationTools});throwIfTurnAborted(i.config.abortSignal),a.check();let[p,m]=await Promise.all([n,s.responseMessages]);assertUsableResponse(p,m,d.length>0||f.length>0);let h=answerSkippedToolCalls(p,r.effectiveTools);await emitStepActions(i.publish,i.position(),h.length===0?p:withAccumulatedResponseMessages({stepResult:p,responseMessages:appendMissingToolResultMessages({append:h,responseMessages:p.response.messages})}),{emittedActionCallIds:c,excludedActionCallIds:u,excludedActionToolNames:o,handledInlineToolResultCallIds:l,tools:r.presentationTools});let g=new Map(p.toolResults.map(e=>[e.toolCallId,e]));for(let e of d)g.set(e.toolCallId,e);return withAccumulatedResponseMessages({invalidInputToolCallIds:u,responseMessages:appendMissingToolResultMessages({append:[...f,...answerSkippedToolCalls(p,r.effectiveTools)],responseMessages:m}),stepResult:p,toolResults:[...g.values()]})}async generate(e,t,n){let{generation:r}=this.input,i=await e.generate({abortSignal:r.signal,messages:t});throwIfTurnAborted(this.step.config.abortSignal),r.check();let a=await n;return assertUsableResponse(a,i.responseMessages,!1),withAccumulatedResponseMessages({responseMessages:appendMissingToolResultMessages({append:answerSkippedToolCalls(a,this.tools.effectiveTools),responseMessages:i.responseMessages}),stepResult:a})}};function assertUsableResponse(e,t,n){if(e.finishReason===`content-filter`)throw new ContentFilteredModelResponseError(readGatewayGenerationId(e.providerMetadata));if(isEmptyModelResponse(e)&&extractToolResultCallIds(t).size===0&&!n)throw new EmptyModelResponseError}export{ModelCaller};

package/dist/src/harness/{model-call-error.d.ts → model-call/errors.d.ts}

@@ -41,7 +41,7 @@ export declare function extractUnsupportedProviderToolTypes(error: unknown): rea
  */
 export declare function extractModelCallErrorDetails(error: unknown): JsonObject;
 /**
- * A model call that produced no content. Raised by tool-loop.ts from
+ * A model call that produced no content. Raised by the model caller from
  * either of its two triggers: `isEmptyModelResponse` (a completed step
  * with finishReason 'other' and no output — AI Gateway HTTP 200 whose
  * stream carries no content, no usage, and no error) or

package/dist/src/harness/model-call/failure.d.ts

@@ -0,0 +1,52 @@
+import type { JsonObject } from "#shared/json.js";
+import type { SemanticErrorSummary } from "#harness/semantic-errors/rule.js";
+import { type UpstreamRejectionSummary } from "#harness/model-call/errors.js";
+import type { Step } from "#harness/step/context.js";
+import type { StepResult } from "#harness/types.js";
+/**
+ * Projects a model-call failure into the `step.failed` / `turn.failed`
+ * `details` payload. Three mutually exclusive branches:
+ *
+ * 1. Catalog match → the rule's curated `name`/`message`/`hint` plus its
+ *    registered `semanticErrorId`, no SDK inspector dump.
+ * 2. Upstream rejection → raw error `message` with the extracted upstream
+ *    identity, no inspector dump. No `semanticErrorId`: the message is
+ *    arbitrary provider prose, not a registered failure shape.
+ * 3. Fallback → full {@link formatError} projection (cause chain via
+ *    `util.inspect`) so unrecognized failures still carry the upstream
+ *    stack to log aggregators.
+ *
+ * All branches merge {@link extractModelCallErrorDetails} on top so the
+ * compact gateway diagnostics (`statusCode`, `upstreamMessage`,
+ * `responseBodySnippet`, ...) always show up next to the message.
+ */
+export declare function buildModelCallFailureDetails(input: {
+    readonly catalogSummary: SemanticErrorSummary | null;
+    readonly error: unknown;
+    readonly errorId: string;
+    readonly modelCallDetails: JsonObject;
+    readonly upstreamRejection: UpstreamRejectionSummary | null;
+}): JsonObject;
+/**
+ * Builds the structured log fields for a model-call failure. When the
+ * failure was recognized (catalog match or extracted upstream rejection),
+ * attach the compact `details` payload and *omit* the raw `error` so the
+ * logger's `util.inspect` of the cause chain (which would render
+ * `[object Object]` for upstream `APICallError` shapes) is bypassed.
+ * Otherwise fall back to the raw error so unrecognized failures keep
+ * their full stack in logs.
+ */
+export declare function buildModelCallFailureLogFields(input: {
+    readonly error: unknown;
+    readonly errorId: string;
+    readonly modelCallDetails: JsonObject;
+    readonly recognized: boolean;
+    readonly sessionId: string;
+    readonly turnId: string;
+}): Record<string, unknown>;
+/**
+ * The model call failed past its retries and recoveries. A failed write to the session's stream is
+ * the workflow's failure, not the model's: the session parks for the user to retry. A terminal
+ * failure ends the session; any other fails the turn recoverably.
+ */
+export declare function reportModelCallFailure(step: Step, error: unknown): Promise<StepResult>;

package/dist/src/harness/model-call/failure.js

@@ -0,0 +1 @@
+import{createErrorId,createLogger,formatError}from"#internal/logging.js";import{toErrorMessage}from"#shared/errors.js";import{fail}from"#harness/session-machine/transitions.js";import{summarizeKnownError}from"#harness/semantic-errors/index.js";import{classifyModelCallError,extractModelCallErrorDetails,extractUpstreamRejectionMessage}from"#harness/model-call/errors.js";import{extractWorkflowStreamWriteErrorDetails}from"#harness/workflow-stream-error.js";const log=createLogger(`harness.tool-loop`);function buildModelCallFailureDetails(e){let{catalogSummary:t,error:n,errorId:r,modelCallDetails:i,upstreamRejection:a}=e;if(t!==null){let e={errorId:r,message:t.message,name:t.name,semanticErrorId:t.id,...i};return t.hint!==void 0&&(e.hint=t.hint),e}return a===null?{...formatError(n,r),...i}:{errorId:r,message:toErrorMessage(n),name:a.name,...i}}function buildModelCallFailureLogFields(e){let t={errorId:e.errorId,sessionId:e.sessionId,turnId:e.turnId};return e.recognized?{...t,details:e.modelCallDetails}:{...t,error:e.error}}async function reportModelCallFailure(e,t){if(e.instrumentation?.recordError(t),e.emit===void 0)throw t;let{sessionId:n}=e.session,{turnId:r}=e.position(),i=extractWorkflowStreamWriteErrorDetails(t);if(i!==null){let a=createErrorId();return log.error(`workflow stream write failed — parking session for retry by the user`,{...i,errorId:a,error:t,sessionId:n,turnId:r}),await e.apply(fail(e.view(),{code:`WORKFLOW_STREAM_WRITE_FAILED`,details:{...i,errorId:a},message:toErrorMessage(t)})),{next:null,session:e.session}}let a=createErrorId(),o=summarizeKnownError(t),s=o===null?extractUpstreamRejectionMessage(t):null,c=o?.message??s?.message??toErrorMessage(t),l=o?.hint===void 0?c:`${c} ${o.hint}`,u=extractModelCallErrorDetails(t),d=buildModelCallFailureDetails({catalogSummary:o,error:t,errorId:a,modelCallDetails:u,upstreamRejection:s}),f=buildModelCallFailureLogFields({error:t,errorId:a,modelCallDetails:u,recognized:o!==null||s!==null,sessionId:n,turnId:r});return classifyModelCallError(t)===`terminal`?(o===null?log.error(s?.message??`model call failed terminally`,f):log.error(`${o.name}: ${o.message}`,{errorId:a,hint:o.hint,sessionId:n,turnId:r}),await e.apply(fail(e.view(),{code:`MODEL_CALL_FAILED`,details:d,message:c,terminal:{sessionId:n}})),{next:e.hasDelegatedCaller?{done:!0,isError:!0,output:l}:{done:!0,output:``},session:e.session}):(log.error(s?.message??`model call failed — parking session for retry by the user`,f),await e.apply(fail(e.view(),{code:`MODEL_CALL_FAILED`,details:d,message:c})),e.session={...e.session,outputSchema:void 0},{next:null,session:e.session,settledTurn:{isError:!0,output:l}})}export{buildModelCallFailureDetails,buildModelCallFailureLogFields,reportModelCallFailure};

package/dist/src/harness/model-call/model.d.ts

@@ -0,0 +1,18 @@
+import type { LanguageModel } from "ai";
+import type { HarnessSession, ToolLoopHarnessConfig } from "#harness/types.js";
+import { contextStorage } from "#context/container.js";
+/**
+ * Builds AI Gateway app attribution headers when the model is gateway-routed.
+ *
+ * Bare model ids and `gateway.*` model instances route through AI Gateway.
+ * Direct-provider model instances receive no Gateway-specific headers.
+ */
+export declare function buildGatewayAttributionHeaders(model: LanguageModel, runtimeIdentity: ToolLoopHarnessConfig["runtimeIdentity"]): Record<string, string> | undefined;
+export declare function resolveEffectiveRuntimeModel(input: {
+    readonly config: ToolLoopHarnessConfig;
+    readonly ctx: ReturnType<typeof contextStorage.getStore>;
+    readonly session: HarnessSession;
+}): Promise<{
+    readonly model: LanguageModel;
+    readonly session: HarnessSession;
+}>;

package/dist/src/harness/model-call/model.js

@@ -0,0 +1 @@
+import"#context/container.js";import{resolveProviderHeaders}from"#internal/gateway.js";import{getEffectiveModelSelection}from"#context/effective-model.js";function buildGatewayAttributionHeaders(e,t){let n=resolveProviderHeaders(e);if(n===void 0)return;let r=t?.agentName??t?.agentId,i=process.env.VERCEL_PROJECT_PRODUCTION_URL||process.env.VERCEL_URL,a=i?`https://${i}`:void 0,o={...n};return r&&(o[`x-title`]=r),a&&(o[`http-referer`]=a),o}async function resolveEffectiveRuntimeModel(e){if(e.ctx===void 0){let t=e.session.agent.modelReference;if(t===void 0)throw Error(`Dynamic model selection is unavailable outside an eve runtime context.`);return{model:await e.config.resolveModel(t),session:e.session}}let t=getEffectiveModelSelection(e.ctx);if(t===null)throw Error(`Dynamic model selection is required before model-dependent work begins. Add a matching resolver handler that returns a concrete model.`);return{model:t.model===void 0?await e.config.resolveModel(t.reference):t.model,session:updateSessionModelReference(e.session,t.reference)}}function updateSessionModelReference(e,t){return e.agent.modelReference===t?e:{...e,agent:{...e.agent,modelReference:t},compaction:updateCompactionThresholdForModelReference({compaction:e.compaction,modelReference:t})}}function updateCompactionThresholdForModelReference(e){return e.modelReference.contextWindowTokens===void 0?e.compaction:{...e.compaction,threshold:Math.max(1,Math.floor(e.modelReference.contextWindowTokens*(e.compaction.thresholdPercent??.9)))}}export{buildGatewayAttributionHeaders,resolveEffectiveRuntimeModel};

package/dist/src/harness/model-call/recovery.d.ts

@@ -0,0 +1,52 @@
+import type { HarnessStepResult } from "#harness/step-hooks.js";
+/** How a recovery reissues the call. */
+type RecoveryCall = (options: {
+    readonly disabledProviderTools?: ReadonlySet<string>;
+    readonly extraSystemNote?: string;
+    readonly retryReason?: "empty-response";
+    readonly suppressStepStartedEmission?: boolean;
+    readonly trailingUserNote?: string;
+}) => Promise<HarnessStepResult>;
+/**
+ * Recovers a failed model call, each recovery at most once and within the current step, so the
+ * reissue suppresses a second `step.started`:
+ *
+ * 1. AI Gateway rejected a provider-specific tool a fallback provider can't serve ("tool type 'X'
+ *    is not supported"): the call is reissued without it, and a system note tells the model which
+ *    capability went away. Only known provider tools are dropped, never an authored one.
+ * 2. The response was empty (see {@link EmptyModelResponseError}), including the first
+ *    recovery's: the call is reissued with {@link EMPTY_RESPONSE_NUDGE}, repeating what the first
+ *    recovery removed.
+ *
+ * Each reissue goes through `call` so it gets fresh step hooks: the failed attempt's one-shot
+ * `stepResult` already resolved. Returns the error that remains when nothing recovered.
+ */
+export declare function recoverModelCall(input: {
+    readonly error: unknown;
+    readonly call: RecoveryCall;
+    readonly sessionId: string;
+    readonly turnId: string;
+}): Promise<{
+    readonly result: HarnessStepResult;
+} | {
+    readonly error: unknown;
+}>;
+/**
+ * True when a step produced no assistant text and no tool calls. A blank
+ * response is ambiguous and must be retried instead of silently dropping a
+ * HITL reply.
+ */
+export declare function isEmptyModelResponse(step: HarnessStepResult): boolean;
+/**
+ * Rethrows the AI SDK's `NoOutputGeneratedError` as
+ * {@link EmptyModelResponseError}. Since `ai@7.0.0-canary.169`
+ * (vercel/ai#15938) a stream that closes after metadata without output or
+ * a finish chunk rejects — the SDK enqueues the error onto `fullStream`
+ * (so `emitStreamContent` throws it) and never emits `finish-step`, so
+ * `onStepEnd` does not fire and the step hooks' `stepResult` promise
+ * would never settle. The same condition previously completed as an empty
+ * step caught by {@link isEmptyModelResponse}; normalizing here funnels
+ * both shapes into the one-shot empty-response reissue.
+ */
+export declare function rethrowNoOutputAsEmptyResponse(error: unknown): never;
+export {};

package/dist/src/harness/model-call/recovery.js

@@ -0,0 +1 @@
+import{createLogger}from"#internal/logging.js";import{resolveAssistantStepText}from"#harness/messages.js";import{EmptyModelResponseError,extractUnsupportedProviderToolTypes,isNoOutputGeneratedError}from"#harness/model-call/errors.js";import{resolveFrameworkToolFromUpstreamType}from"#harness/provider-tools.js";const log=createLogger(`harness.tool-loop`);async function recoverModelCall(e){let{error:t}=e,n={sessionId:e.sessionId,turnId:e.turnId},r={},i=extractUnsupportedProviderToolTypes(t),a=[...new Set(i.flatMap(e=>resolveFrameworkToolFromUpstreamType(e)??[]))];if(a.length>0){log.warn(`disabling unsupported provider tool(s); retrying step once`,{...n,disabled:a,upstreamTypes:i}),r={disabledProviderTools:new Set(a),extraSystemNote:buildDisabledToolNote(a)};try{return{result:await e.call({...r,suppressStepStartedEmission:!0})}}catch(e){t=e}}if(t instanceof EmptyModelResponseError){log.warn(`empty model response; reissuing the model call once`,n);try{return{result:await e.call({...r,retryReason:`empty-response`,suppressStepStartedEmission:!0,trailingUserNote:EMPTY_RESPONSE_NUDGE})}}catch(e){t=e}}return{error:t}}function buildDisabledToolNote(e){let t=e.join(`, `);return`The following ${e.length===1?`tool is`:`tools are`} not available with the current model and has been removed: ${t}. Proceed using the remaining tools or your training knowledge.`}function isEmptyModelResponse(e){return e.toolCalls.length===0&&e.toolResults.length===0&&resolveAssistantStepText(e.response.messages,e.text)===null}function rethrowNoOutputAsEmptyResponse(e){throw isNoOutputGeneratedError(e)?new EmptyModelResponseError({cause:e}):e}const EMPTY_RESPONSE_NUDGE=`Your previous reply was empty and was not delivered. Continue the current user request. Reuse completed results when they satisfy the request. If existing results are stale or insufficient, use the appropriate read tools to get fresh results. Do not repeat writes or other side effects that already completed. Do not mention this notice.`;export{isEmptyModelResponse,recoverModelCall,rethrowNoOutputAsEmptyResponse};

package/dist/src/harness/model-call/request.d.ts

@@ -0,0 +1,30 @@
+import type { ModelMessage, SystemModelMessage } from "ai";
+import { createCurrentMessages } from "#harness/current-messages.js";
+import { type HarnessModelMessage, type UserModelMessage } from "#harness/messages.js";
+import { type AnthropicCacheMarker } from "#harness/prompt-cache.js";
+import type { Step } from "#harness/step/context.js";
+import type { HarnessSession, HarnessToolMap } from "#harness/types.js";
+export type RequestMessages = ReturnType<typeof createCurrentMessages>;
+/**
+ * The messages one model call sends: the durable prompt, then the step's system instructions and
+ * announcements. Announcements persist ahead of the new input, or after earlier tool results on a
+ * continuation, so later requests keep the full prefix.
+ */
+export declare function requestMessages(step: Step, input: {
+    readonly messages: readonly HarnessModelMessage[];
+    readonly projectedMessages: readonly HarnessModelMessage[];
+    readonly turnMessages: readonly UserModelMessage[];
+    readonly coordinationTools: HarnessToolMap;
+    readonly hidesHeldText: boolean;
+    readonly pendingApprovalsNote: string | undefined;
+}): RequestMessages;
+/** The call's system instructions: a retry's note, the agent's system prompt, then the step's. */
+export declare function modelInstructions(input: {
+    readonly session: HarnessSession;
+    readonly systemMessages: readonly SystemModelMessage[];
+    readonly marker: AnthropicCacheMarker | undefined;
+    readonly extraSystemNote?: string;
+}): SystemModelMessage | string | undefined;
+/** A retry's note, trailing the call's messages. */
+export declare function withTrailingUserNote(messages: readonly ModelMessage[], note?: string): ModelMessage[];
+export declare function mergeSystemInstructions(instructions: readonly SystemModelMessage[]): SystemModelMessage | undefined;

package/dist/src/harness/model-call/request.js

@@ -0,0 +1,3 @@
+import{HistoryStateKey}from"#context/keys.js";import{createFrameworkUserMessage}from"#harness/messages.js";import{getPendingAnnouncements}from"#harness/announcements.js";import{buildDynamicInstructionMessages}from"#context/dynamic-instruction-lifecycle.js";import{PendingSkillAnnouncementKey}from"#context/dynamic-skill-lifecycle.js";import{taskSystemMessages}from"#execution/tasks/model-step.js";import{applySystemCacheBreakpoint}from"#harness/prompt-cache.js";import{createCurrentMessages}from"#harness/current-messages.js";function requestMessages(e,t){let{ctx:n}=e,r=createCurrentMessages(t.messages,{historyState:n?.get(HistoryStateKey),currentTurnMessages:t.turnMessages,projectedMessages:t.projectedMessages});return n!==void 0&&r.addSystem(buildDynamicInstructionMessages(n)),r.addSystem(taskSystemMessages(t.coordinationTools,{finalReplyOnly:t.hidesHeldText})),r.addAnnouncements({availableSkills:n?.get(PendingSkillAnnouncementKey),keyed:getPendingAnnouncements(n)}),t.pendingApprovalsNote!==void 0&&r.add(t.pendingApprovalsNote,`context.state`,{cacheFriendly:!1}),r}function modelInstructions(e){let{session:t}=e,n=e.extraSystemNote?[{role:`system`,content:e.extraSystemNote}]:[];if(e.systemMessages.length===0&&n.length===0)return t.agent.system??void 0;let r=t.agent.system?[{role:`system`,content:t.agent.system}]:[],i=[...n,...r,...e.systemMessages];return mergeSystemInstructions(e.marker?applySystemCacheBreakpoint(i,e.marker):i)}function withTrailingUserNote(e,t){return t?[...e,createFrameworkUserMessage(`execution.retry`,t)]:[...e]}function mergeSystemInstructions(e){if(e.length===0)return;if(e.length===1)return{...e[0]};let t;for(let n of e)n.providerOptions!==void 0&&(t={...t,...n.providerOptions});let n={role:`system`,content:e.map(e=>e.content).join(`
+
+`)};return t!==void 0&&(n.providerOptions=t),n}export{mergeSystemInstructions,modelInstructions,requestMessages,withTrailingUserNote};

package/dist/src/harness/model-call/response.d.ts

@@ -0,0 +1,39 @@
+import type { ModelMessage, ToolSet, TypedToolResult } from "ai";
+import type { HarnessStepResult } from "#harness/step-hooks.js";
+type StepResponseMessage = HarnessStepResult["response"]["messages"][number];
+type ToolResponsePart = Extract<ModelMessage, {
+    role: "tool";
+}>["content"][number];
+type ToolResultPart = Extract<ToolResponsePart, {
+    type: "tool-result";
+}>;
+export declare function withAccumulatedResponseMessages(input: {
+    readonly invalidInputToolCallIds?: ReadonlySet<string>;
+    readonly responseMessages: readonly StepResponseMessage[];
+    readonly stepResult: HarnessStepResult;
+    readonly toolResults?: readonly TypedToolResult<ToolSet>[];
+}): HarnessStepResult;
+/** True when provider history still owes a result for any assistant tool call. */
+export declare function hasUnansweredToolCall(messages: readonly ModelMessage[]): boolean;
+/**
+ * Appends synthesized tool results for calls that have no result anywhere in
+ * the step's response messages. Exported for its dedupe contract: a call
+ * already answered — including provider-executed results the SDK keeps
+ * inline in the assistant message — must never receive a second
+ * `tool-result`, or the next Anthropic call rejects the history with
+ * "each tool_use must have a single result".
+ */
+export declare function appendMissingToolResultMessages(input: {
+    readonly append: readonly ToolResultPart[];
+    readonly responseMessages: readonly StepResponseMessage[];
+}): StepResponseMessage[];
+/**
+ * CallIds answered anywhere in the response messages. Scans every message
+ * role: provider-executed tool results arrive inline in the *assistant*
+ * message (the SDK only moves them to a `tool` message during provider
+ * history normalization, which runs after the backfill paths), so a
+ * tool-message-only scan would let a synthesized result duplicate them.
+ */
+export declare function extractToolResultCallIds(messages: readonly ModelMessage[]): ReadonlySet<string>;
+export declare function answerSkippedToolCalls(step: HarnessStepResult, tools: ToolSet): ToolResultPart[];
+export {};

package/dist/src/harness/model-call/response.js

@@ -0,0 +1 @@
+import{getInvalidToolCallInputError,isInvalidToolCall}from"#harness/tool-call-input-errors.js";function withAccumulatedResponseMessages(e){let{stepResult:t}=e;return{content:t.content,finishReason:t.finishReason,...e.invalidInputToolCallIds===void 0?{}:{invalidInputToolCallIds:e.invalidInputToolCallIds},providerMetadata:t.providerMetadata,response:{...t.response,messages:[...e.responseMessages]},text:t.text,toolCalls:t.toolCalls,toolResults:e.toolResults===void 0?t.toolResults:[...e.toolResults],usage:t.usage}}function hasUnansweredToolCall(e){let t=new Set,n=new Set;for(let r of e)if(Array.isArray(r.content))for(let e of r.content)typeof e==`object`&&e&&(e.type===`tool-call`&&t.add(e.toolCallId),e.type===`tool-result`&&n.add(e.toolCallId));for(let e of t)if(!n.has(e))return!0;return!1}function appendMissingToolResultMessages(e){let t=extractToolResultCallIds(e.responseMessages),n=e.append.filter(e=>!t.has(e.toolCallId));return[...e.responseMessages,...n.length>0?[{role:`tool`,content:[...n]}]:[]]}function extractToolResultCallIds(e){let t=new Set;for(let n of e)if(Array.isArray(n.content))for(let e of n.content)typeof e==`object`&&e&&e.type===`tool-result`&&t.add(e.toolCallId);return t}function answerSkippedToolCalls(e,t){let{finishReason:n}=e;if(n===`stop`||n===`tool-calls`)return[];let r=extractToolResultCallIds(e.response.messages),i=new Set((e.content??[]).flatMap(e=>e.type===`tool-approval-request`&&e.isAutomatic!==!0?[e.toolCall.toolCallId]:[])),a=`The tool did not run because the model response ended early (finish reason: ${n}). Call the tool again if you still need its result.`;return(e.toolCalls??[]).filter(e=>t[e.toolName]?.execute!==void 0&&e.providerExecuted!==!0&&!isInvalidToolCall(e)&&getInvalidToolCallInputError({toolCall:e})===void 0&&!r.has(e.toolCallId)&&!i.has(e.toolCallId)).map(e=>({output:{type:`error-text`,value:a},toolCallId:e.toolCallId,toolName:e.toolName,type:`tool-result`}))}export{answerSkippedToolCalls,appendMissingToolResultMessages,extractToolResultCallIds,hasUnansweredToolCall,withAccumulatedResponseMessages};

package/dist/src/harness/model-call/retry.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Retries `fn` with exponential backoff while the thrown error is
+ * classified as `"retry"`. Rethrows the last error once attempts are
+ * exhausted or the error is classified as something other than
+ * transient.
+ */
+export declare function runModelCallWithRetries<T>(fn: (attempt: number) => Promise<T>, diag: {
+    readonly sessionId: string;
+    readonly turnId: string;
+    readonly canRetry?: () => boolean;
+}, signal: AbortSignal): Promise<T>;

package/dist/src/harness/model-call/retry.js

@@ -0,0 +1 @@
+import{createLogger}from"#internal/logging.js";import{setTimeout}from"node:timers/promises";import{classifyModelCallError}from"#harness/model-call/errors.js";const log=createLogger(`harness.tool-loop`);async function runModelCallWithRetries(e,t,n){for(let r=1;;r++){n.throwIfAborted();try{return await e(r)}catch(e){if(n.throwIfAborted(),t.canRetry?.()===!1||r===3||classifyModelCallError(e)!==`retry`)throw e;let i=500*2**(r-1)+Math.floor(Math.random()*250);log.warn(`model call failed transiently — retrying`,{attempt:r,delayMs:i,sessionId:t.sessionId,turnId:t.turnId,error:e}),await setTimeout(i,void 0,{signal:n})}}}export{runModelCallWithRetries};

package/dist/src/harness/model-call/run.d.ts

@@ -0,0 +1,38 @@
+import type { GenerationSteering } from "#harness/generation-steering.js";
+import { type HarnessModelMessage } from "#harness/messages.js";
+import { type ApprovedWork } from "#harness/hitl/index.js";
+import { type Step } from "#harness/step/context.js";
+import type { TurnInput } from "#harness/step/intake.js";
+import type { HarnessStepResult } from "#harness/step-hooks.js";
+import { type HarnessToolMap, type StepResult } from "#harness/types.js";
+import type { InstrumentationAttempt } from "#instrumentation/runtime.js";
+import type { EndsTurnTools } from "./tools.js";
+/** A model step's response, for the session to act on. */
+export interface ModelResponse {
+    readonly coordinationTools: HarnessToolMap;
+    /** How many prompt messages the model read, when no client context was spliced in. */
+    readonly durableModelPromptMessageCount?: number;
+    /** Tools that can end the turn in this step, with their `endsTurn` option. */
+    readonly endsTurnTools: EndsTurnTools;
+    readonly promptMessages: readonly HarnessModelMessage[];
+    readonly requestEnvelopeTokens?: number;
+    readonly result: HarnessStepResult;
+}
+/**
+ * One model step of the open turn: the prompt it reads, the model that serves it, and the call
+ * with its retries and recoveries. `onResponse` decides what the session does with the response.
+ *
+ * Approved work runs where the AI SDK ran it, between the step's start and the model call:
+ * approved workflow calls join their runs, the budget gate passes, then approved local calls run
+ * and the model reads their results.
+ */
+export declare function runModelStep(step: Step, input: {
+    readonly onResponse: (response: ModelResponse) => Promise<StepResult>;
+    readonly turn: TurnInput;
+    readonly approved: ApprovedWork;
+    readonly generation: GenerationSteering;
+    /** A child's caller and a schedule hear only the turn's real end. */
+    readonly hidesHeldText: boolean;
+    /** The attempt the step's events belong to, for instrumentation. */
+    readonly setAttemptScope: (scope: InstrumentationAttempt | undefined) => void;
+}): Promise<StepResult>;

package/dist/src/harness/model-call/run.js

@@ -0,0 +1 @@
+import{resolveEffectiveRuntimeModel}from"./model.js";import{recoverModelCall}from"./recovery.js";import{recordModelUsage}from"./usage.js";import{ModelCaller}from"./call.js";import{reportModelCallFailure}from"./failure.js";import{HistoryStateKey}from"#context/keys.js";import{validateHarnessModelMessages}from"#harness/messages.js";import{activeTurnId}from"#harness/session-machine/view.js";import{startStep}from"#harness/session-machine/transitions.js";import{stepStartedForResolvers}from"#harness/session-machine/resolver-events.js";import{throwIfTurnAborted}from"#harness/turn-cancellation.js";import{dispatchApprovedWorkflows,enforceBudget,hasApprovedWork,humanInputContext,runApprovedLocalCalls}from"#harness/hitl/index.js";import{requireSessionModelReference}from"#harness/types.js";import{failBoundaryEvent,failModelSelection}from"#harness/step/context.js";import{buildPrompt,previewPrompt,projectPrompt,withClientContext}from"#harness/step/prompt.js";async function runModelStep(e,t){let{generation:n}=t,r=hasApprovedWork(e),i=r?previewPrompt(e,t.turn):await buildPrompt(e,t.turn),a=await selectModel(e,i);if(!(`model`in a))return a.failed;let start=t=>e.apply(startStep(e.view(),{modelId:requireSessionModelReference(e.session).id}),t),o=projectPrompt(e,i);try{await start(o)}catch(t){return failBoundaryEvent(e,t)}if(r&&await dispatchApprovedWorkflows(e,t.approved))return{next:null,session:e.session};let s=await enforceBudget(e,i.messages);if(s!==void 0)return s;if(r){let n=await runApprovedLocalCalls(e,t.approved,t.setAttemptScope);if(n!==void 0)return n;i=await buildPrompt(e,t.turn),o=projectPrompt(e,i)}let{approvedTools:c,pendingApprovalsNote:l}=humanInputContext(e),u=new ModelCaller(e,i,{approvedTools:c,generation:n,hidesHeldText:t.hidesHeldText,model:a.model,pendingApprovalsNote:l,projectedMessages:o,setAttemptScope:t.setAttemptScope,startStep:start,turnMessages:t.turn.messages}),d;try{d=await u.call({suppressStepStartedEmission:!0})}catch(t){if(u.throwIfCompactionFailed(),throwIfTurnAborted(e.config.abortSignal),n.interrupted)return u.steered();let r=await recoverModelCall({call:e=>u.call(e),error:t,sessionId:e.session.sessionId,turnId:e.position().turnId});if(u.throwIfCompactionFailed(),throwIfTurnAborted(e.config.abortSignal),n.interrupted)return u.steered();if(!(`result`in r))return reportModelCallFailure(e,r.error);d=r.result}await recordModelUsage(e,{model:a.model,result:d}),u.clearInterruptedUsage();let f;try{n.check(),f=await t.onResponse({coordinationTools:u.tools?.coordinationTools??e.config.tools,durableModelPromptMessageCount:i.clientContext===void 0||i.clientContext.messages.length===0?u.modelMessages.length:void 0,endsTurnTools:u.tools?.endsTurnTools??new Map,promptMessages:u.request.history,requestEnvelopeTokens:u.requestEnvelopeTokens,result:d})}catch(t){if(throwIfTurnAborted(e.config.abortSignal),n.interrupted)return u.steered();throw t}return e.ctx?.set(HistoryStateKey,u.request.historyState),f}async function selectModel(e,t){let{config:n,ctx:r}=e;try{if(r!==void 0&&n.dispatchDynamicModelEvent!==void 0){let i=e.position();await n.dispatchDynamicModelEvent({ctx:r,event:stepStartedForResolvers({modelId:e.session.agent.modelReference?.id??`dynamic`,sequence:i.sequence,stepIndex:i.stepIndex,turnId:activeTurnId(i)}),messages:validateHarnessModelMessages(e.projectHistory(withClientContext(t)))})}let i=await resolveEffectiveRuntimeModel({config:n,ctx:r,session:e.session});return e.session=i.session,{model:i.model}}catch(t){return{failed:await failModelSelection(e,t)}}}export{runModelStep};

package/dist/src/harness/model-call/tools.d.ts

@@ -0,0 +1,48 @@
+import type { ToolSet } from "ai";
+import type { HarnessToolDefinition } from "#harness/execute-tool.js";
+import type { GenerationSteering } from "#harness/generation-steering.js";
+import { type AnthropicCacheMarker } from "#harness/prompt-cache.js";
+import type { Step } from "#harness/step/context.js";
+import { type HarnessToolMap } from "#harness/types.js";
+/** The tools one model call offers, and the views of them the step reads afterwards. */
+export interface ModelTools {
+    /** What the AI SDK receives. */
+    readonly effectiveTools: ToolSet;
+    readonly modelTools: ToolSet;
+    /** Every tool the model can call, by name, for presenting its calls. */
+    readonly presentationTools: HarnessToolMap;
+    /** The advertised harness tools; they decide which calls defer to the runtime. */
+    readonly coordinationTools: HarnessToolMap;
+    /** Tools that can end the turn, with their `endsTurn` option. */
+    readonly endsTurnTools: EndsTurnTools;
+}
+/**
+ * Assembles the tools one model call offers: authored and dynamic subagent tools, task tools,
+ * provider tools, dynamic tools (which override a same-named authored tool), and `final_output`
+ * when the turn asks for a structured result.
+ */
+export declare function prepareModelTools(step: Step, input: {
+    readonly approvedTools: ReadonlySet<string>;
+    readonly model: import("ai").LanguageModel;
+    readonly disabledProviderTools?: ReadonlySet<string>;
+    readonly generation: GenerationSteering;
+    readonly marker: AnthropicCacheMarker | undefined;
+}): Promise<ModelTools>;
+/**
+ * Wired as the agent's `onToolExecutionEnd`. On the `tool-error` branch
+ * the `error` is still the original throwable (stack/cause intact),
+ * unlike the message-only `tool-error` part the model later sees.
+ */
+export declare function logToolExecutionError(event: {
+    readonly toolCall: {
+        readonly toolName: string;
+        readonly toolCallId: string;
+    };
+    readonly toolOutput: {
+        readonly type: string;
+        readonly error?: unknown;
+    };
+}): void;
+/** Appended to the model-facing description of every tool with `endsTurn: true`. */
+export declare const ENDS_TURN_TOOL_NOTE = "Calling this tool ends your turn once it succeeds: do not write a reply or call other tools in the same step. If it fails, you will see the error and can continue.";
+export type EndsTurnTools = ReadonlyMap<string, NonNullable<HarnessToolDefinition["endsTurn"]>>;

package/dist/src/harness/model-call/tools.js

@@ -0,0 +1 @@
+import{createLogger,logError}from"#internal/logging.js";import{toModelSchema}from"#tools/schema.js";import{resolveModelProvider}from"#internal/gateway.js";import{buildDynamicSubagentTools}from"#context/dynamic-subagent-lifecycle.js";import{isTurnCancellation}from"#harness/turn-cancellation.js";import{requireSessionModelReference}from"#harness/types.js";import{withTaskTools}from"#execution/tasks/model-step.js";import{buildToolSetFromDefinitions,buildToolSetWithProviderTools}from"#harness/tools.js";import{buildDynamicTools}from"#context/build-dynamic-tools.js";import{FINAL_OUTPUT_TOOL_NAME,buildFinalOutputTool}from"#harness/final-output.js";import{applyLastToolCacheBreakpoint}from"#harness/prompt-cache.js";import{getAdvertisedTools}from"#harness/advertised-tools.js";const log=createLogger(`harness.tool-loop`);async function prepareModelTools(e,t){let{ctx:n}=e,{approvedTools:r,disabledProviderTools:i,marker:a}=t,o=withTaskTools(getAdvertisedTools({session:e.session,tools:buildHarnessToolsWithDynamicSubagents(e.config.tools,n)})),s=await buildToolSetWithProviderTools({approvedTools:r,disabledProviderTools:i,modelProvider:resolveModelProvider(t.model),modelReference:requireSessionModelReference(e.session),tools:o}),c=new Map(o);if(n!==void 0){let t=getAdvertisedTools({session:e.session,tools:buildDynamicTools(n)}),a=buildToolSetFromDefinitions({approvedTools:r,disabledProviderTools:i,tools:t});for(let[e,t]of Object.entries(a)){if(o.get(e)?.workflowId!==void 0)throw Error(`Dynamic tool "${e}" collides with a coordination-visible deferred tool.`);s[e]=t}let l=new Set;for(let e of t)l.has(e.name)||(l.add(e.name),c.set(e.name,e))}e.session.outputSchema!==void 0&&(s[FINAL_OUTPUT_TOOL_NAME]=buildFinalOutputTool(e.session.outputSchema));let l=await getAdvertisedTools({modelTools:s,session:e.session,tools:o});e.session=l.session;let{modelTools:u}=l,d=new Map;if(!e.hasDelegatedCaller&&e.session.outputSchema===void 0)for(let[e,t]of Object.entries(u)){let n=c.get(e)?.endsTurn;t.type!==`provider`&&n!==void 0&&n!==!1&&(d.set(e,n),n===!0&&(t.description=`${t.description??``}\n\n${ENDS_TURN_TOOL_NOTE}`.trimStart()))}let f=a?applyLastToolCacheBreakpoint(u,a):u;for(let e of Object.values(f)){e.inputSchema=toModelSchema(e.inputSchema,`input`),e.outputSchema!==void 0&&(e.outputSchema=toModelSchema(e.outputSchema,`output`));let n=e.execute;n!==void 0&&(e.execute=(...e)=>(t.generation.protectToolExecution(),n(...e)))}return e.frameworkToolNames=new Set([...c].filter(([,e])=>e.frameworkTool===!0).map(([e])=>e)),{coordinationTools:o,effectiveTools:f,endsTurnTools:d,modelTools:u,presentationTools:c}}function logToolExecutionError(e){e.toolOutput.type!==`tool-error`||isTurnCancellation(e.toolOutput.error)||logError(log,`tool execution failed`,e.toolOutput.error,{toolName:e.toolCall.toolName,toolCallId:e.toolCall.toolCallId})}function buildHarnessToolsWithDynamicSubagents(e,t){let n=new Map(e);if(t===void 0)return n;for(let e of buildDynamicSubagentTools(t)){if(n.has(e.name))throw Error(`Dynamic subagent "${e.name}" collides with another runtime-visible tool name.`);n.set(e.name,e)}return n}const ENDS_TURN_TOOL_NOTE=`Calling this tool ends your turn once it succeeds: do not write a reply or call other tools in the same step. If it fails, you will see the error and can continue.`;export{ENDS_TURN_TOOL_NOTE,logToolExecutionError,prepareModelTools};

package/dist/src/harness/model-call/usage.d.ts

@@ -0,0 +1,23 @@
+import type { LanguageModel, ProviderMetadata } from "ai";
+import type { HarnessStepResult } from "#harness/step-hooks.js";
+import { type TokenUsageDelta } from "#harness/turn-tag-state.js";
+import type { Step } from "#harness/step/context.js";
+/**
+ * The model's gateway id, or `undefined` for a model without a string `provider`, such as a
+ * test double, so a missing field never throws into the tool loop.
+ */
+export declare function gatewayModelId(model: LanguageModel): string | undefined;
+export declare function extractTokenUsageDelta(input: {
+    readonly costUsd: number | undefined;
+    readonly usage: HarnessStepResult["usage"] | undefined;
+}): TokenUsageDelta | undefined;
+export declare function extractGatewayCostUsd(providerMetadata: ProviderMetadata | undefined): number | undefined;
+/**
+ * Tags the turn's workflow run with the model and the turn's running token totals. Each model
+ * step is its own workflow step and attributes are last-write-wins, so the running total, kept in
+ * session state, is what reaches the dashboard. Best-effort: tagging never breaks the loop.
+ */
+export declare function recordModelUsage(step: Step, input: {
+    readonly model: LanguageModel;
+    readonly result: HarnessStepResult;
+}): Promise<void>;

package/dist/src/harness/model-call/usage.js

@@ -0,0 +1 @@
+import{formatLanguageModelGatewayId}from"#internal/runtime-model.js";import{accumulateTurnUsage,getTurnUsageState,setTurnUsageState}from"#harness/turn-tag-state.js";import{setEveAttributes}from"#runtime/attributes/emit.js";function gatewayModelId(e){try{return formatLanguageModelGatewayId(e)}catch{return}}function extractTokenUsageDelta(e){let t=e.usage;if(t!==void 0||e.costUsd!==void 0)return{cacheReadTokens:t?.inputTokenDetails?.cacheReadTokens,cacheWriteTokens:t?.inputTokenDetails?.cacheWriteTokens,costUsd:e.costUsd,inputTokens:t?.inputTokens,outputTokens:t?.outputTokens}}function extractGatewayCostUsd(e){let t=readGatewayMetadata(e)?.cost;if(typeof t==`number`&&Number.isFinite(t))return t;if(typeof t==`string`){let e=Number(t);return Number.isFinite(e)?e:void 0}}function readGatewayMetadata(e){let t=e?.gateway;return t&&typeof t==`object`&&!Array.isArray(t)?t:void 0}async function recordModelUsage(e,t){let n=accumulateTurnUsage({previous:getTurnUsageState(e.session.state),turnId:e.position().turnId,usage:extractTokenUsageDelta({costUsd:extractGatewayCostUsd(t.result.providerMetadata),usage:t.result.usage})});e.session=setTurnUsageState(e.session,n),await setEveAttributes({"$eve.model":gatewayModelId(t.model),"$eve.input_tokens":n.inputTokens,"$eve.output_tokens":n.outputTokens,"$eve.cache_read_tokens":n.cacheReadTokens,"$eve.cache_write_tokens":n.cacheWriteTokens,"$eve.cost_usd":n.sawCost?n.costUsd:void 0,"$eve.tool_count":e.config.tools.size})}export{extractGatewayCostUsd,extractTokenUsageDelta,gatewayModelId,recordModelUsage};