eve 0.71.2 → 0.72.0

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};

package/dist/src/harness/nested-actions.d.ts

@@ -1,4 +1,4 @@
-import type { HarnessEmissionState } from "#harness/emission-state.js";
+import type { TurnPosition } from "#harness/session-machine/view.js";
 import type { HarnessEmitFn } from "#harness/types.js";
 import type { JsonObject } from "#shared/json.js";
 /**
@@ -20,4 +20,4 @@ export declare function reportNestedToolAction(parentCallId: string, action: Nes
  * `actions.requested` and `action.result` pair. Call ids derive from the
  * parent's, so a re-run step reports the same ids.
  */
-export declare function emitNestedToolActions(emitFn: HarnessEmitFn, state: Pick<HarnessEmissionState, "sequence" | "stepIndex" | "turnId">, parentCallId: string): Promise<void>;
+export declare function emitNestedToolActions(emitFn: HarnessEmitFn, state: Pick<TurnPosition, "sequence" | "stepIndex" | "turnId">, parentCallId: string): Promise<void>;

package/dist/src/harness/provider-tools.d.ts

@@ -5,7 +5,7 @@ import type { WebSearchProvider } from "#shared/web-search.js";
 /**
  * The provider backend resolved for one web search tool invocation.
  */
-type WebSearchBackend = "anthropic" | "exa" | "google" | "openai" | "parallel";
+type WebSearchBackend = "anthropic" | "exa" | "google" | "openai" | "parallel" | "browserbase";
 /**
  * Returns the framework tool name that produced an upstream provider tool
  * `type`, or `null` when the type is not one we know how to remove.
@@ -19,7 +19,7 @@ export declare function resolveFrameworkToolFromUpstreamType(type: string): stri
  * Returns the output schema for the provider-managed web search tool that
  * will be injected for `backend`.
  */
-export declare function resolveWebSearchOutputSchema(backend: WebSearchBackend): JsonObject;
+export declare function resolveWebSearchOutputSchema(backend: Exclude<WebSearchBackend, "browserbase">): JsonObject;
 /**
  * Determines the web search backend for a model reference.
  *
@@ -28,8 +28,12 @@ export declare function resolveWebSearchOutputSchema(backend: WebSearchBackend):
  * - Direct/BYO Anthropic models: native Anthropic search
  * - Direct/BYO Google models: native Google search grounding
  * - Other BYO models: not available (returns `null`)
+ *
+ * `modelProvider` is the provider of the resolved AI SDK model. It is needed
+ * for live dynamic selections because their runtime reference has no source
+ * metadata to distinguish a direct provider from AI Gateway.
  */
-export declare function resolveWebSearchBackend(modelRef: RuntimeModelReference, gatewayProvider?: WebSearchProvider): WebSearchBackend | null;
+export declare function resolveWebSearchBackend(modelRef: RuntimeModelReference, gatewayProvider?: WebSearchProvider, modelProvider?: string): WebSearchBackend | null;
 /**
  * Constructs the AI SDK provider tool for web search based on the resolved
  * backend. Called once per harness step when web search is enabled.

package/dist/src/harness/provider-tools.js

@@ -1 +1 @@
-import{jsonSchema}from"ai";import{WEB_SEARCH_ANTHROPIC_OUTPUT_SCHEMA,WEB_SEARCH_EXA_OUTPUT_SCHEMA,WEB_SEARCH_GOOGLE_OUTPUT_SCHEMA,WEB_SEARCH_OPENAI_OUTPUT_SCHEMA,WEB_SEARCH_PARALLEL_OUTPUT_SCHEMA,WEB_SEARCH_TOOL_NAME}from"#harness/provider-tool-schemas.js";const UPSTREAM_TOOL_TYPE_TO_FRAMEWORK_NAME={web_search_20250305:WEB_SEARCH_TOOL_NAME};function resolveFrameworkToolFromUpstreamType(e){return UPSTREAM_TOOL_TYPE_TO_FRAMEWORK_NAME[e]??null}function resolveWebSearchOutputSchema(e){switch(e){case`anthropic`:return WEB_SEARCH_ANTHROPIC_OUTPUT_SCHEMA;case`exa`:return WEB_SEARCH_EXA_OUTPUT_SCHEMA;case`google`:return WEB_SEARCH_GOOGLE_OUTPUT_SCHEMA;case`openai`:return WEB_SEARCH_OPENAI_OUTPUT_SCHEMA;case`parallel`:return WEB_SEARCH_PARALLEL_OUTPUT_SCHEMA}}function resolveWebSearchBackend(e,t=`exa`){if(e.source===void 0)return t;let n=e.id.split(`/`)[0]??``;return n===`openai`||n.startsWith(`openai.`)?`openai`:n===`anthropic`||n.startsWith(`anthropic.`)?`anthropic`:n.startsWith(`google.`)?`google`:null}async function resolveWebSearchProviderTool(e){switch(e){case`openai`:{let{openai:t}=await import(`#compiled/@ai-sdk/openai/index.js`);return attachWebSearchOutputSchema(t.tools.webSearch({}),e)}case`anthropic`:{let{anthropic:t}=await import(`#compiled/@ai-sdk/anthropic/index.js`);return attachWebSearchOutputSchema(t.tools.webSearch_20250305(),e)}case`google`:{let{google:t}=await import(`#compiled/@ai-sdk/google/index.js`);return attachWebSearchOutputSchema(t.tools.googleSearch({}),e)}case`exa`:{let{gateway:t}=await import(`ai`);return attachWebSearchOutputSchema(t.tools.exaSearch({contents:{highlights:{maxCharacters:1e3}},numResults:10}),e)}case`parallel`:{let{gateway:t}=await import(`ai`);return attachWebSearchOutputSchema(t.tools.parallelSearch(),e)}}}function attachWebSearchOutputSchema(e,t){return{...e,outputSchema:jsonSchema(resolveWebSearchOutputSchema(t))}}export{resolveFrameworkToolFromUpstreamType,resolveWebSearchBackend,resolveWebSearchOutputSchema,resolveWebSearchProviderTool};
+import{jsonSchema}from"ai";import{WEB_SEARCH_ANTHROPIC_OUTPUT_SCHEMA,WEB_SEARCH_EXA_OUTPUT_SCHEMA,WEB_SEARCH_GOOGLE_OUTPUT_SCHEMA,WEB_SEARCH_OPENAI_OUTPUT_SCHEMA,WEB_SEARCH_PARALLEL_OUTPUT_SCHEMA,WEB_SEARCH_TOOL_NAME}from"#harness/provider-tool-schemas.js";const UPSTREAM_TOOL_TYPE_TO_FRAMEWORK_NAME={web_search_20250305:WEB_SEARCH_TOOL_NAME};function resolveFrameworkToolFromUpstreamType(e){return UPSTREAM_TOOL_TYPE_TO_FRAMEWORK_NAME[e]??null}function resolveWebSearchOutputSchema(e){switch(e){case`anthropic`:return WEB_SEARCH_ANTHROPIC_OUTPUT_SCHEMA;case`exa`:return WEB_SEARCH_EXA_OUTPUT_SCHEMA;case`google`:return WEB_SEARCH_GOOGLE_OUTPUT_SCHEMA;case`openai`:return WEB_SEARCH_OPENAI_OUTPUT_SCHEMA;case`parallel`:return WEB_SEARCH_PARALLEL_OUTPUT_SCHEMA}}function resolveWebSearchBackend(e,t=`exa`,n){let r=n?.split(`.`)[0]??(e.source===void 0?`gateway`:e.id.split(`/`)[0]??``);return r===`gateway`?t:r===`openai`||r.startsWith(`openai.`)?`openai`:r===`anthropic`||r.startsWith(`anthropic.`)?`anthropic`:r===`google`||r.startsWith(`google.`)?`google`:null}async function resolveWebSearchProviderTool(e){switch(e){case`browserbase`:{let{gateway:e}=await import(`ai`);return e.tools.browserbaseSearch()}case`openai`:{let{openai:t}=await import(`#compiled/@ai-sdk/openai/index.js`);return attachWebSearchOutputSchema(t.tools.webSearch({}),e)}case`anthropic`:{let{anthropic:t}=await import(`#compiled/@ai-sdk/anthropic/index.js`);return attachWebSearchOutputSchema(t.tools.webSearch_20250305(),e)}case`google`:{let{google:t}=await import(`#compiled/@ai-sdk/google/index.js`);return attachWebSearchOutputSchema(t.tools.googleSearch({}),e)}case`exa`:{let{gateway:t}=await import(`ai`);return attachWebSearchOutputSchema(t.tools.exaSearch({contents:{highlights:{maxCharacters:1e3}},numResults:10}),e)}case`parallel`:{let{gateway:t}=await import(`ai`);return attachWebSearchOutputSchema(t.tools.parallelSearch(),e)}}}function attachWebSearchOutputSchema(e,t){return{...e,outputSchema:jsonSchema(resolveWebSearchOutputSchema(t))}}export{resolveFrameworkToolFromUpstreamType,resolveWebSearchBackend,resolveWebSearchOutputSchema,resolveWebSearchProviderTool};

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

@@ -1,10 +1,9 @@
 import type { SubagentInputRequestHookPayload } from "#channel/types.js";
-import type { PendingInputBatchEvent } from "#harness/pending-input-batches.js";
+import type { StepCoordinates as PendingInputBatchEvent } from "#harness/session-machine/view.js";
 import type { HarnessSessionBase, SessionStateMap } from "#harness/types.js";
 import { type InputOption, type InputRequestKind } from "#shared/input.js";
 import { type SessionInboxAddress } from "#execution/session-inbox/address.js";
 import type { RemoteAgentBinding } from "#eve-channel/support.js";
-import { type InputResolvedStreamEvent } from "#protocol/message.js";
 /**
  * Marks a request as a workflow tool run's `ctx.ask()` question, rather than a
  * child session's. Its answer goes to the run's control hook, which carries
@@ -79,17 +78,10 @@ export declare function upsertProxyInputRequestState(input: {
     readonly forChildContinuationToken: string;
     readonly state: SessionStateMap | undefined;
 }): SessionStateMap | undefined;
-/**
- * Retires the requests `select` picks, which nobody can answer anymore, and
- * returns the `input.resolved` events that report them `cancelled` so
- * channels stop offering them. Publish the events as relayed.
- */
-export declare function withdrawProxyInputRequests<T extends {
+/** Removes every proxy route the predicate selects. */
+export declare function clearProxyInputRequestsWhere<T extends {
     readonly state?: SessionStateMap;
-}>(session: T, select: (requestId: string, route: ProxyInputRequest) => boolean): {
-    readonly events: readonly InputResolvedStreamEvent[];
-    readonly session: T;
-};
+}>(session: T, select: (route: ProxyInputRequest, requestId: string) => boolean): T;
 /** Removes only the request IDs whose responses were successfully forwarded. */
 export declare function retireProxyInputRequests<T extends {
     readonly state?: SessionStateMap;

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

@@ -1 +1 @@
-import{isSessionInboxAddress}from"#execution/session-inbox/address.js";import{inputOptionSchema}from"#shared/input.js";import{createInputResolvedEvent}from"#protocol/message.js";const PROXY_INPUT_REQUESTS_KEY=`eve.runtime.proxyInputRequests`,PROXY_INPUT_REQUEST_KINDS={question:!0,"session-limit":!0,"tool-approval":!0};function getProxyInputRequests(e){return new Map(Object.entries(readMap(e)))}function hasProxyInputRequests(e){for(let t of Object.keys(readMap(e)))return!0;return!1}function upsertProxyInputRequests(e){return{...e.session,state:upsertProxyInputRequestState({entries:e.entries,forChildContinuationToken:e.forChildContinuationToken,inputSource:e.inputSource,state:e.session.state})}}function upsertProxyInputRequestState(e){let t={};for(let[n,r]of Object.entries(readMap(e.state)))(r.childContinuationToken!==e.forChildContinuationToken||r.inputSource!==e.inputSource)&&(t[n]=r);for(let[n,r]of e.entries)t[n]=r;let n={...e.state};return Object.keys(t).length===0?delete n[PROXY_INPUT_REQUESTS_KEY]:n[PROXY_INPUT_REQUESTS_KEY]=t,Object.keys(n).length>0?n:void 0}function withdrawProxyInputRequests(e,t){let n=[],r=[];for(let[i,a]of Object.entries(readMap(e.state)))t(i,a)&&(n.push(i),r.push(createInputResolvedEvent({resolutions:[{kind:a.kind,outcome:`cancelled`,requestId:i}],...a.event})));return{events:r,session:retireProxyInputRequests(e,n)}}function retireProxyInputRequests(e,t){let n={...readMap(e.state)},r=!1;for(let e of t)Object.hasOwn(n,e)&&(delete n[e],r=!0);return r?writeMap(e,n):e}function toProxyInputRequestEntries(e){let t={approvalRequestIds:e.event.requests.flatMap(e=>e.kind===`tool-approval`?[e.requestId]:[]),requestIds:e.event.requests.map(e=>e.requestId)},n={sequence:e.event.sequence,stepIndex:e.event.stepIndex,turnId:e.event.turnId};return e.event.requests.map(r=>{let i={batch:t,childContinuationToken:e.childContinuationToken,...e.inputSource!==void 0&&{inputSource:e.inputSource},...e.remote!==void 0&&{remote:e.remote},event:n,kind:r.kind};return r.kind===`question`&&(i.question={...r.allowFreeform!==void 0&&{allowFreeform:r.allowFreeform},...r.options!==void 0&&{options:[...r.options]}}),e.childSessionInbox?.sessionId===e.childSessionId&&(i.childSessionInbox=e.childSessionInbox),[r.requestId,i]})}function readMap(e){let t=e?.[PROXY_INPUT_REQUESTS_KEY];if(typeof t!=`object`||!t||Array.isArray(t))return{};let n={};for(let[e,r]of Object.entries(t)){let t=parseProxyInputRequest(r,e);t!==void 0&&(n[e]=t)}return n}function writeMap(e,t){let n={...e.state};return Object.keys(t).length===0?(delete n[PROXY_INPUT_REQUESTS_KEY],{...e,state:Object.keys(n).length>0?n:void 0}):(n[PROXY_INPUT_REQUESTS_KEY]=t,{...e,state:n})}function parseProxyInputRequest(e,t){if(typeof e!=`object`||!e||Array.isArray(e)||!(`childContinuationToken`in e)||!(`kind`in e)||typeof e.childContinuationToken!=`string`||!isInputRequestKind(e.kind))return;let n=`remote`in e?parseRemoteAgentBinding(e.remote):void 0;if(`remote`in e&&n===void 0)return;let r=`inputSource`in e?e.inputSource:void 0;if(r!==void 0&&(typeof r!=`string`||r.length===0))return;let i=`event`in e?parseInputRequestEvent(e.event):void 0;if(i===void 0)return;let a=`batch`in e?parseProxyInputRequestBatch(e.batch):void 0,o=`workflowAsk`in e?parseWorkflowAskRoute(e.workflowAsk):void 0;if(`workflowAsk`in e&&o===void 0)return;let s=`runId`in e?e.runId:void 0;if(s!==void 0&&(typeof s!=`string`||s.length===0))return;let c=`question`in e?parseProxyInputQuestion(e.question):void 0;if(`question`in e&&c===void 0)return;let l=`childSessionInbox`in e?e.childSessionInbox:void 0;if(l!==void 0&&!isSessionInboxAddress(l))return;let u={childContinuationToken:e.childContinuationToken,event:i,kind:e.kind};return typeof r==`string`&&(u.inputSource=r),n!==void 0&&(u.remote=n),o!==void 0&&(u.workflowAsk=o),typeof s==`string`&&(u.runId=s),l!==void 0&&(u.childSessionInbox=l),a!==void 0&&a.requestIds.includes(t)&&(u.batch=a),c!==void 0&&(u.question=c),u}function parseInputRequestEvent(e){if(typeof e!=`object`||!e||Array.isArray(e))return;let t=Reflect.get(e,`sequence`),n=Reflect.get(e,`stepIndex`),r=Reflect.get(e,`turnId`);if(typeof t==`number`&&typeof n==`number`&&typeof r==`string`)return{sequence:t,stepIndex:n,turnId:r}}function parseWorkflowAskRoute(e){if(typeof e!=`object`||!e)return;let t=Reflect.get(e,`control`);if(typeof t!=`string`||t.length===0)return;let n=parseProxyInputQuestion(Reflect.get(e,`question`));if(n!==void 0)return{control:t,question:n}}function parseRemoteAgentBinding(e){if(typeof e!=`object`||!e||Array.isArray(e))return;let t=Reflect.get(e,`name`),n=Reflect.get(e,`url`),r=Reflect.get(e,`resolverId`),i=Reflect.get(e,`forwardPrincipal`),a=Reflect.get(e,`sessionId`);if(typeof t==`string`&&t&&typeof n==`string`&&n&&typeof a==`string`&&a&&(r===void 0||typeof r==`string`&&r)&&(i===void 0||typeof i==`boolean`))return{name:t,url:n,sessionId:a,...r!==void 0&&{resolverId:r},...i!==void 0&&{forwardPrincipal:i}}}function parseProxyInputQuestion(e){if(typeof e!=`object`||!e||Array.isArray(e))return;let t={},n=Reflect.get(e,`allowFreeform`);if(n!==void 0){if(typeof n!=`boolean`)return;t.allowFreeform=n}let r=Reflect.get(e,`options`);if(r!==void 0){let e=inputOptionSchema.array().safeParse(r);if(!e.success)return;t.options=e.data}return t}function parseProxyInputRequestBatch(e){if(typeof e!=`object`||!e||Array.isArray(e)||!(`approvalRequestIds`in e)||!(`requestIds`in e)||!isStringArray(e.approvalRequestIds)||!isStringArray(e.requestIds))return;let t=new Set(e.requestIds);if(!(t.size!==e.requestIds.length||e.approvalRequestIds.some(e=>!t.has(e))))return{approvalRequestIds:e.approvalRequestIds,requestIds:e.requestIds}}function isStringArray(e){return Array.isArray(e)&&e.every(e=>typeof e==`string`)}function isInputRequestKind(e){return typeof e==`string`&&Object.hasOwn(PROXY_INPUT_REQUEST_KINDS,e)}export{getProxyInputRequests,hasProxyInputRequests,retireProxyInputRequests,toProxyInputRequestEntries,upsertProxyInputRequestState,upsertProxyInputRequests,withdrawProxyInputRequests};
+import{isSessionInboxAddress}from"#execution/session-inbox/address.js";import{inputOptionSchema}from"#shared/input.js";const PROXY_INPUT_REQUESTS_KEY=`eve.runtime.proxyInputRequests`,PROXY_INPUT_REQUEST_KINDS={question:!0,"session-limit":!0,"tool-approval":!0};function getProxyInputRequests(e){return new Map(Object.entries(readMap(e)))}function hasProxyInputRequests(e){for(let t of Object.keys(readMap(e)))return!0;return!1}function upsertProxyInputRequests(e){return{...e.session,state:upsertProxyInputRequestState({entries:e.entries,forChildContinuationToken:e.forChildContinuationToken,inputSource:e.inputSource,state:e.session.state})}}function upsertProxyInputRequestState(e){let t={};for(let[n,r]of Object.entries(readMap(e.state)))(r.childContinuationToken!==e.forChildContinuationToken||r.inputSource!==e.inputSource)&&(t[n]=r);for(let[n,r]of e.entries)t[n]=r;let n={...e.state};return Object.keys(t).length===0?delete n[PROXY_INPUT_REQUESTS_KEY]:n[PROXY_INPUT_REQUESTS_KEY]=t,Object.keys(n).length>0?n:void 0}function clearProxyInputRequestsWhere(e,t){return retireProxyInputRequests(e,Object.entries(readMap(e.state)).filter(([e,n])=>t(n,e)).map(([e])=>e))}function retireProxyInputRequests(e,t){let n={...readMap(e.state)},r=!1;for(let e of t)Object.hasOwn(n,e)&&(delete n[e],r=!0);return r?writeMap(e,n):e}function toProxyInputRequestEntries(e){let t={approvalRequestIds:e.event.requests.flatMap(e=>e.kind===`tool-approval`?[e.requestId]:[]),requestIds:e.event.requests.map(e=>e.requestId)},n={sequence:e.event.sequence,stepIndex:e.event.stepIndex,turnId:e.event.turnId};return e.event.requests.map(r=>{let i={batch:t,childContinuationToken:e.childContinuationToken,...e.inputSource!==void 0&&{inputSource:e.inputSource},...e.remote!==void 0&&{remote:e.remote},event:n,kind:r.kind};return r.kind===`question`&&(i.question={...r.allowFreeform!==void 0&&{allowFreeform:r.allowFreeform},...r.options!==void 0&&{options:[...r.options]}}),e.childSessionInbox?.sessionId===e.childSessionId&&(i.childSessionInbox=e.childSessionInbox),[r.requestId,i]})}function readMap(e){let t=e?.[PROXY_INPUT_REQUESTS_KEY];if(typeof t!=`object`||!t||Array.isArray(t))return{};let n={};for(let[e,r]of Object.entries(t)){let t=parseProxyInputRequest(r,e);t!==void 0&&(n[e]=t)}return n}function writeMap(e,t){let n={...e.state};return Object.keys(t).length===0?(delete n[PROXY_INPUT_REQUESTS_KEY],{...e,state:Object.keys(n).length>0?n:void 0}):(n[PROXY_INPUT_REQUESTS_KEY]=t,{...e,state:n})}function parseProxyInputRequest(e,t){if(typeof e!=`object`||!e||Array.isArray(e)||!(`childContinuationToken`in e)||!(`kind`in e)||typeof e.childContinuationToken!=`string`||!isInputRequestKind(e.kind))return;let n=`remote`in e?parseRemoteAgentBinding(e.remote):void 0;if(`remote`in e&&n===void 0)return;let r=`inputSource`in e?e.inputSource:void 0;if(r!==void 0&&(typeof r!=`string`||r.length===0))return;let i=`event`in e?parseInputRequestEvent(e.event):void 0;if(i===void 0)return;let a=`batch`in e?parseProxyInputRequestBatch(e.batch):void 0,o=`workflowAsk`in e?parseWorkflowAskRoute(e.workflowAsk):void 0;if(`workflowAsk`in e&&o===void 0)return;let s=`runId`in e?e.runId:void 0;if(s!==void 0&&(typeof s!=`string`||s.length===0))return;let c=`question`in e?parseProxyInputQuestion(e.question):void 0;if(`question`in e&&c===void 0)return;let l=`childSessionInbox`in e?e.childSessionInbox:void 0;if(l!==void 0&&!isSessionInboxAddress(l))return;let u={childContinuationToken:e.childContinuationToken,event:i,kind:e.kind};return typeof r==`string`&&(u.inputSource=r),n!==void 0&&(u.remote=n),o!==void 0&&(u.workflowAsk=o),typeof s==`string`&&(u.runId=s),l!==void 0&&(u.childSessionInbox=l),a!==void 0&&a.requestIds.includes(t)&&(u.batch=a),c!==void 0&&(u.question=c),u}function parseInputRequestEvent(e){if(typeof e!=`object`||!e||Array.isArray(e))return;let t=Reflect.get(e,`sequence`),n=Reflect.get(e,`stepIndex`),r=Reflect.get(e,`turnId`);if(typeof t==`number`&&typeof n==`number`&&typeof r==`string`)return{sequence:t,stepIndex:n,turnId:r}}function parseWorkflowAskRoute(e){if(typeof e!=`object`||!e)return;let t=Reflect.get(e,`control`);if(typeof t!=`string`||t.length===0)return;let n=parseProxyInputQuestion(Reflect.get(e,`question`));if(n!==void 0)return{control:t,question:n}}function parseRemoteAgentBinding(e){if(typeof e!=`object`||!e||Array.isArray(e))return;let t=Reflect.get(e,`name`),n=Reflect.get(e,`url`),r=Reflect.get(e,`resolverId`),i=Reflect.get(e,`forwardPrincipal`),a=Reflect.get(e,`sessionId`);if(typeof t==`string`&&t&&typeof n==`string`&&n&&typeof a==`string`&&a&&(r===void 0||typeof r==`string`&&r)&&(i===void 0||typeof i==`boolean`))return{name:t,url:n,sessionId:a,...r!==void 0&&{resolverId:r},...i!==void 0&&{forwardPrincipal:i}}}function parseProxyInputQuestion(e){if(typeof e!=`object`||!e||Array.isArray(e))return;let t={},n=Reflect.get(e,`allowFreeform`);if(n!==void 0){if(typeof n!=`boolean`)return;t.allowFreeform=n}let r=Reflect.get(e,`options`);if(r!==void 0){let e=inputOptionSchema.array().safeParse(r);if(!e.success)return;t.options=e.data}return t}function parseProxyInputRequestBatch(e){if(typeof e!=`object`||!e||Array.isArray(e)||!(`approvalRequestIds`in e)||!(`requestIds`in e)||!isStringArray(e.approvalRequestIds)||!isStringArray(e.requestIds))return;let t=new Set(e.requestIds);if(!(t.size!==e.requestIds.length||e.approvalRequestIds.some(e=>!t.has(e))))return{approvalRequestIds:e.approvalRequestIds,requestIds:e.requestIds}}function isStringArray(e){return Array.isArray(e)&&e.every(e=>typeof e==`string`)}function isInputRequestKind(e){return typeof e==`string`&&Object.hasOwn(PROXY_INPUT_REQUEST_KINDS,e)}export{clearProxyInputRequestsWhere,getProxyInputRequests,hasProxyInputRequests,retireProxyInputRequests,toProxyInputRequestEntries,upsertProxyInputRequestState,upsertProxyInputRequests};

package/dist/src/harness/session-machine/commit.d.ts

@@ -0,0 +1,28 @@
+import type { ModelMessage } from "ai";
+import { type AuthorizationChallenge } from "#harness/authorization.js";
+import type { HarnessSessionBase, SessionStateMap } from "#harness/types.js";
+import type { UnstampedMessageStreamEvent } from "#protocol/message.js";
+import type { SessionProjection } from "#protocol/session-projection.js";
+import { type TurnState } from "./state.js";
+import type { SessionView } from "./view.js";
+/** What a transition returns. Nothing else changes session state. */
+export interface Transition {
+    readonly turn: TurnState;
+    readonly events: readonly UnstampedMessageStreamEvent[];
+    /** Messages the transition commits to the end of history. */
+    readonly commit?: readonly ModelMessage[];
+    /** The transition empties history, as `clear` does. */
+    readonly clearsHistory?: true;
+    /** Every sign-in the session waits on once the transition applies; `[]` withdraws them all. */
+    readonly signIns?: readonly AuthorizationChallenge[];
+}
+/** Publishes one event; `messages` is the conversation hooks see with it. */
+export type Publish = (event: UnstampedMessageStreamEvent, messages?: readonly ModelMessage[]) => Promise<void>;
+export declare function sessionView(projection: SessionProjection, state: SessionStateMap | undefined): SessionView;
+/**
+ * Publishes a transition's events, then saves what it changed. A transition that changes history
+ * needs a session restored with it.
+ */
+export declare function applyTransition<T extends HarnessSessionBase>(session: T, transition: Transition, publish: Publish, messages?: readonly ModelMessage[]): Promise<T>;
+/** Drops the private records whose owner the projection shows closed. */
+export declare function dropClosedRecords<T extends HarnessSessionBase>(session: T, projection: SessionProjection): T;

package/dist/src/harness/session-machine/commit.js

@@ -0,0 +1 @@
+import{readTurnState,writeTurnState}from"./state.js";import{validateHarnessModelMessages}from"#harness/messages.js";import{getSessionUsage}from"#harness/turn-tag-state.js";import{clearProxyInputRequestsWhere,getProxyInputRequests}from"#harness/proxy-input-requests.js";import{clearPendingAuthorization,getPendingAuthorization,setPendingAuthorization}from"#harness/authorization.js";function sessionView(e,t){return{projection:e,relayedRequestIds:new Set(getProxyInputRequests(t).keys()),signIns:getPendingAuthorization(t)?.challenges??[],turn:readTurnState(t),usage:getSessionUsage({state:t})}}const READS_HISTORY=new Set([`turn.started`,`step.started`,`turn.completed`]);async function applyTransition(e,t,n,r){for(let e of t.events)await n(e,READS_HISTORY.has(e.type)?r:void 0);let i=t.signIns===void 0?e.state:t.signIns.length===0?clearPendingAuthorization(e.state):setPendingAuthorization(clearPendingAuthorization(e.state),{challenges:t.signIns}),a=writeTurnState({...e,state:i},t.turn),o=t.commit??[];if(t.clearsHistory!==!0&&o.length===0)return a;if(!(`history`in e))throw Error(`A transition that changes history needs the session's history.`);let{history:s}=e,c=t.clearsHistory?[]:validateHarnessModelMessages([...s,...o]);return{...a,history:c}}function dropClosedRecords(e,t){return clearProxyInputRequestsWhere(e,(e,n)=>{let r=t.inputs[n];return r===void 0||r.status===`settled`})}export{applyTransition,dropClosedRecords,sessionView};

package/dist/src/harness/session-machine/current.d.ts

@@ -0,0 +1,29 @@
+import type { ContextReader } from "#context/key.js";
+import type { HarnessSessionBase, SessionStateMap } from "#harness/types.js";
+import { type SessionProjection } from "#protocol/session-projection.js";
+import type { MessageStreamEvent, UnstampedMessageStreamEvent } from "#protocol/message.js";
+export declare function enterSessionProjection(ctx: ContextReader, state: SessionStateMap | undefined): void;
+/** Enters the stored projection unless this step already did. */
+export declare function ensureSessionProjection(ctx: ContextReader, state: SessionStateMap | undefined): void;
+/** The projection as of the last event the current step published. */
+export declare function currentProjection(ctx?: ContextReader | undefined): SessionProjection;
+/** The step's live projection, or the session's stored one when no step entered it. */
+export declare function projectionFor(ctx: ContextReader, state: SessionStateMap | undefined): SessionProjection;
+export declare function recordPublishedEvent(ctx: ContextReader, event: MessageStreamEvent | UnstampedMessageStreamEvent): void;
+export declare function saveSessionProjection<T extends HarnessSessionBase>(session: T, ctx: ContextReader): T;
+/**
+ * The session saves the lifecycle its steps read. Calls and tasks are for the stream's readers,
+ * which fold them from the events, and their outputs can be large, so the checkpoint omits them.
+ */
+export declare function saveProjection<T extends HarnessSessionBase>(session: T, projection: SessionProjection): T;
+/** The projection one step reads and folds what it publishes into. */
+export interface StepProjection {
+    read(): SessionProjection;
+    /** Folds an event no publish sink folded: the step runs without one. */
+    record(event: UnstampedMessageStreamEvent): void;
+}
+/**
+ * A step's projection: the context's live one, which the publish sink folds, or, for a step
+ * that runs without a context, a detached one the step folds itself.
+ */
+export declare function stepProjection(ctx: ContextReader | undefined, state: SessionStateMap | undefined): StepProjection;

package/dist/src/harness/session-machine/current.js

@@ -0,0 +1 @@
+import{SESSION_PROJECTION_STATE_KEY,storedProjection}from"./view.js";import{foldSession,pruneSessionProjection}from"#protocol/session-projection.js";import{contextStorage}from"#context/container.js";const liveProjections=new WeakMap;function enterSessionProjection(e,t){liveProjections.set(e,{projection:storedProjection(t)})}function ensureSessionProjection(e,t){liveProjections.has(e)||enterSessionProjection(e,t)}function currentProjection(e=contextStorage.getStore()){let t=e===void 0?void 0:liveProjections.get(e);if(t===void 0)throw Error(`Session lifecycle requires an initialized projection.`);return t.projection}function projectionFor(e,t){return liveProjections.get(e)?.projection??storedProjection(t)}function recordPublishedEvent(e,t){let n=liveProjections.get(e);if(n===void 0)throw Error(`Session publication requires an initialized projection.`);let r=foldSession(n.projection,t);n.projection=t.type===`session.waiting`?pruneSessionProjection(r):r}function saveSessionProjection(e,t){return saveProjection(e,currentProjection(t))}function saveProjection(e,t){let n={...t,calls:{},tasks:{}};return{...e,state:{...e.state,[SESSION_PROJECTION_STATE_KEY]:n}}}function stepProjection(e,t){if(e!==void 0)return ensureSessionProjection(e,t),{read:()=>currentProjection(e),record:t=>recordPublishedEvent(e,t)};let n=storedProjection(t);return{read:()=>n,record(e){let t=foldSession(n,e);n=e.type===`session.waiting`?pruneSessionProjection(t):t}}}export{currentProjection,ensureSessionProjection,enterSessionProjection,projectionFor,recordPublishedEvent,saveProjection,saveSessionProjection,stepProjection};

package/dist/src/harness/session-machine/events.d.ts

@@ -0,0 +1,6 @@
+import { type AuthorizationCompletedStreamEvent, type InputResolvedStreamEvent } from "#protocol/message.js";
+import type { SessionAuthorization, SessionInput } from "#protocol/session-projection.js";
+/** Reports an open request withdrawn: nobody may answer it anymore. */
+export declare function inputWithdrawn(input: SessionInput): InputResolvedStreamEvent;
+/** Reports an open sign-in withdrawn, as declined: its callback no longer resumes anything. */
+export declare function signInWithdrawn(attempt: SessionAuthorization, reason: string): AuthorizationCompletedStreamEvent;

package/dist/src/harness/session-machine/events.js

@@ -0,0 +1 @@
+import{createAuthorizationCompletedEvent,createInputResolvedEvent}from"#protocol/message.js";function inputWithdrawn(e){return createInputResolvedEvent({resolutions:[{kind:e.request.kind,outcome:`cancelled`,requestId:e.request.requestId}],sequence:e.sequence,stepIndex:e.stepIndex,turnId:e.turnId})}function signInWithdrawn(e,t){return createAuthorizationCompletedEvent({attemptId:e.attemptId,candidateId:e.candidateId,name:e.name,outcome:`declined`,principalId:e.principalId,reason:t,sequence:e.sequence,stepIndex:e.stepIndex,taskId:e.taskId,turnId:e.turnId})}export{inputWithdrawn,signInWithdrawn};

package/dist/src/harness/session-machine/resolver-events.d.ts

@@ -0,0 +1,12 @@
+import { type RuntimeIdentity } from "#protocol/message.js";
+export declare function sessionStartedForResolvers(runtime?: RuntimeIdentity): import("#protocol/message.js").SessionStartedStreamEvent;
+export declare function turnStartedForResolvers(turn: {
+    readonly sequence: number;
+    readonly turnId: string;
+}): import("#protocol/message.js").TurnStartedStreamEvent;
+export declare function stepStartedForResolvers(step: {
+    readonly modelId: string;
+    readonly sequence: number;
+    readonly stepIndex: number;
+    readonly turnId: string;
+}): import("#protocol/message.js").StepStartedStreamEvent;

package/dist/src/harness/session-machine/resolver-events.js

@@ -0,0 +1 @@
+import{createSessionStartedEvent,createStepStartedEvent,createTurnStartedEvent}from"#protocol/message.js";function sessionStartedForResolvers(e){return createSessionStartedEvent({runtime:e})}function turnStartedForResolvers(e){return createTurnStartedEvent(e)}function stepStartedForResolvers(e){return createStepStartedEvent(e)}export{sessionStartedForResolvers,stepStartedForResolvers,turnStartedForResolvers};

package/dist/src/harness/session-machine/state.d.ts

@@ -0,0 +1,47 @@
+import type { ModelMessage } from "ai";
+import type { SessionAuthContext } from "#channel/types.js";
+import type { SessionStateMap, StepInput } from "#harness/types.js";
+import type { RuntimeWorkflowTaskRequest } from "#shared/action-types.js";
+import type { InputRequest } from "#shared/input.js";
+/** The coordinates of the model step a suspended step parked from. */
+export interface StepCoordinates {
+    readonly sequence: number;
+    readonly stepIndex: number;
+    readonly turnId: string;
+}
+/**
+ * A model step whose calls can't all settle yet: some await an approval, others the runtime.
+ * Its response stays out of history until every call it made has a result there, so a call
+ * never reaches the model without its result.
+ */
+export interface SuspendedStep {
+    readonly event: StepCoordinates;
+    /** The withheld response. Results join it as they arrive. */
+    readonly messages: readonly ModelMessage[];
+    /** Approvals the step still waits on. */
+    readonly requests: readonly InputRequest[];
+    /**
+     * Calls a person approved that haven't run. They run when the turn next calls the model, after
+     * its step starts and its budget allows it, as calls the model makes do.
+     */
+    readonly approved?: readonly InputRequest[];
+    /** Workflow and agent calls the runtime runs for the step. */
+    readonly tasks: readonly RuntimeWorkflowTaskRequest[];
+    /** Who approved each task an approval started, by call id: the task runs as them. */
+    readonly approvers?: Readonly<Record<string, SessionAuthContext>>;
+    readonly responseAuthRequiredRequestIds?: readonly string[];
+    /** The caller whose turn parked the step; `null` when unauthenticated. */
+    readonly requester?: SessionAuthContext | null;
+}
+export interface TurnState {
+    /** Input that arrived before it could run: a partial answer, or input behind a policy pass. */
+    readonly queued?: StepInput;
+    readonly suspended: readonly SuspendedStep[];
+    /** Approval keys a `once()` approval granted for the rest of the session. */
+    readonly grants: readonly string[];
+}
+export declare const EMPTY_TURN_STATE: TurnState;
+export declare function readTurnState(state: SessionStateMap | undefined): TurnState;
+export declare function writeTurnState<T extends {
+    readonly state?: SessionStateMap;
+}>(session: T, turn: TurnState): T;

package/dist/src/harness/session-machine/state.js

@@ -0,0 +1 @@
+const TURN_STATE_KEY=`eve.harness.turnState`,EMPTY_TURN_STATE={grants:[],suspended:[]};function readTurnState(e){return e?.[TURN_STATE_KEY]??EMPTY_TURN_STATE}function writeTurnState(e,t){let n={...e.state};return t.suspended.length===0&&t.queued===void 0&&t.grants.length===0?delete n[TURN_STATE_KEY]:n[TURN_STATE_KEY]=t,{...e,state:Object.keys(n).length===0?void 0:n}}export{EMPTY_TURN_STATE,readTurnState,writeTurnState};