eve 0.5.4 → 0.6.0-beta.1

package/dist/src/harness/emission.js

@@ -0,0 +1 @@
+import{createActionResultEvent,createMessageAppendedEvent,createMessageCompletedEvent,createMessageReceivedEvent,createReasoningAppendedEvent,createReasoningCompletedEvent,createSessionCompletedEvent,createSessionFailedEvent,createSessionStartedEvent,createSessionWaitingEvent,createStepFailedEvent,createStepStartedEvent,createTurnCompletedEvent,createTurnFailedEvent,createTurnStartedEvent}from"#protocol/message.js";import{toError}from"#shared/errors.js";import{createRuntimeToolResultFromStepResult}from"#harness/action-result-helpers.js";const HARNESS_EMISSION_STATE_KEY=`eve.harness.emission`,DEFAULT_EMISSION_STATE={sessionStarted:!1,sequence:0,stepIndex:0,turnId:``};function getHarnessEmissionState(e){return e?.[HARNESS_EMISSION_STATE_KEY]??DEFAULT_EMISSION_STATE}function isHarnessBetweenTurns(e){return getHarnessEmissionState(e.state).turnId===``}function setHarnessEmissionState(e,t){return{...e,state:{...e.state,[HARNESS_EMISSION_STATE_KEY]:t}}}async function emitTurnPreamble(e,t,n,i){let a=`turn_${n.sequence}`;return n.sessionStarted||await e(createSessionStartedEvent({runtime:i})),await e(createTurnStartedEvent({sequence:n.sequence,turnId:a})),t.message!==void 0&&await e(createMessageReceivedEvent({message:t.message,sequence:n.sequence,turnId:a})),{sessionStarted:!0,sequence:n.sequence,stepIndex:0,turnId:a}}async function emitStepStarted(e,t,n){await e(createStepStartedEvent({sequence:t.sequence,stepIndex:t.stepIndex,turnId:t.turnId}),n)}async function emitStepAndTurnFailed(e,t,n){await e(createStepFailedEvent({...n,sequence:t.sequence,stepIndex:t.stepIndex,turnId:t.turnId})),await e(createTurnFailedEvent({...n,sequence:t.sequence,turnId:t.turnId}))}async function emitFailedStep(e,t,n){await emitStepAndTurnFailed(e,t,n),await e(createSessionFailedEvent(n))}async function emitRecoverableFailedTurn(e,t,n){return await emitStepAndTurnFailed(e,t,n),await e(createSessionWaitingEvent()),{sessionStarted:t.sessionStarted,sequence:t.sequence+1,stepIndex:0,turnId:``}}function advanceStep(e){return{...e,stepIndex:e.stepIndex+1}}async function emitTurnEpilogue(e,t,n){return await e(createTurnCompletedEvent({sequence:t.sequence,turnId:t.turnId})),n===`conversation`?await e(createSessionWaitingEvent()):await e(createSessionCompletedEvent()),{sessionStarted:t.sessionStarted,sequence:t.sequence+1,stepIndex:0,turnId:``}}function normalizeAssistantStepFinishReason(e){switch(e){case`content-filter`:case`error`:case`length`:case`stop`:case`tool-calls`:return e;default:return`other`}}async function emitStreamContent(r,o,s){let c=``,l=``,u=`stop`,d,f=new Set,p=new Set,m=[],flushCurrentMessage=async()=>{l.length!==0&&(await r(createMessageCompletedEvent({finishReason:`tool-calls`,message:l,sequence:o.sequence,stepIndex:o.stepIndex,turnId:o.turnId})),l=``)};for await(let n of s)if(d===void 0)switch(n.type){case`reasoning-delta`:c+=n.text,await r(createReasoningAppendedEvent({reasoningDelta:n.text,reasoningSoFar:c,sequence:o.sequence,stepIndex:o.stepIndex,turnId:o.turnId}));break;case`text-delta`:c.trim().length>0&&(await r(createReasoningCompletedEvent({reasoning:c,sequence:o.sequence,stepIndex:o.stepIndex,turnId:o.turnId})),c=``),l+=n.text,await r(createMessageAppendedEvent({messageDelta:n.text,messageSoFar:l,sequence:o.sequence,stepIndex:o.stepIndex,turnId:o.turnId}));break;case`tool-call`:f.add(n.toolCallId);break;case`tool-result`:{let t=n;if(t.providerExecuted===!0||f.has(n.toolCallId))break;await flushCurrentMessage(),await r(createActionResultEvent({result:createRuntimeToolResultFromStepResult(t),sequence:o.sequence,stepIndex:o.stepIndex,turnId:o.turnId})),p.add(n.toolCallId);let i=t.output;m.push({type:`tool-result`,toolCallId:t.toolCallId,toolName:t.toolName,output:typeof i==`string`?{type:`text`,value:i}:{type:`json`,value:i??null}});break}case`finish-step`:u=normalizeAssistantStepFinishReason(n.finishReason);break;case`error`:d=toError(n.error);break;default:break}if(d!==void 0)throw d;return c.trim().length>0&&await r(createReasoningCompletedEvent({reasoning:c,sequence:o.sequence,stepIndex:o.stepIndex,turnId:o.turnId})),l.length>0&&await r(createMessageCompletedEvent({finishReason:u,message:l,sequence:o.sequence,stepIndex:o.stepIndex,turnId:o.turnId})),{inlineActionResultCallIds:p,inlineToolResultParts:m}}export{advanceStep,emitFailedStep,emitRecoverableFailedTurn,emitStepStarted,emitStreamContent,emitTurnEpilogue,emitTurnPreamble,getHarnessEmissionState,isHarnessBetweenTurns,normalizeAssistantStepFinishReason,setHarnessEmissionState};

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

@@ -0,0 +1,28 @@
+import type { FlexibleSchema } from "ai";
+import type { NeedsApprovalContext } from "#public/definitions/tool.js";
+/**
+ * Runtime-owned action metadata attached to one harness-visible tool.
+ *
+ * These tools are surfaced to the model without a local `execute` function.
+ * The harness records the tool call and the runtime executes it later.
+ */
+export type HarnessRuntimeActionDefinition = {
+    readonly kind: "remote-agent-call" | "subagent-call";
+    readonly nodeId: string;
+    readonly remoteAgentName?: string;
+    readonly subagentName: string;
+};
+/**
+ * Unified harness-owned tool definition.
+ */
+export interface HarnessToolDefinition {
+    readonly approvalKey?: (toolInput: Readonly<Record<string, unknown>>) => string;
+    readonly description: string;
+    readonly execute?: (input: any) => any;
+    readonly inputSchema: FlexibleSchema;
+    readonly name: string;
+    readonly needsApproval?: (ctx: NeedsApprovalContext) => boolean;
+    readonly outputSchema?: FlexibleSchema;
+    readonly runtimeAction?: HarnessRuntimeActionDefinition;
+    readonly toModelOutput?: (output: unknown) => unknown;
+}

package/dist/src/harness/execute-tool.js

@@ -0,0 +1 @@
+export{};

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

@@ -0,0 +1,17 @@
+import type { ContentPart, ToolSet, TypedToolCall } from "ai";
+import type { InputRequest } from "#runtime/input/types.js";
+/**
+ * Extracts question input requests from tool calls that target the
+ * `ask_question` framework tool.
+ */
+export declare function extractQuestionInputRequests(input: {
+    readonly excludedCallIds: ReadonlySet<string>;
+    readonly toolCalls: readonly TypedToolCall<ToolSet>[];
+}): InputRequest[];
+/**
+ * Extracts tool approval input requests from AI SDK content parts that
+ * contain `tool-approval-request` entries.
+ */
+export declare function extractToolApprovalInputRequests(input: {
+    readonly content: readonly ContentPart<ToolSet>[];
+}): InputRequest[];

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

@@ -0,0 +1 @@
+import{createRuntimeToolCallActionFromToolCall}from"#harness/input-requests.js";import{ASK_QUESTION_TOOL_NAME}from"#runtime/framework-tools/ask-question.js";function extractQuestionInputRequests(n){let r=[];for(let i of n.toolCalls){if(i.toolName!==ASK_QUESTION_TOOL_NAME||n.excludedCallIds.has(i.toolCallId))continue;let a=createRuntimeToolCallActionFromToolCall({toolCall:i}),o=a.input,s={action:a,display:`text`,prompt:String(o.prompt),requestId:a.callId};o.allowFreeform!==void 0&&(s.allowFreeform=o.allowFreeform),o.options!==void 0&&(s.options=o.options,s.display=`select`),r.push(s)}return r}function extractToolApprovalInputRequests(t){let n=[],r=new Map;for(let e of t.content)e.type===`tool-call`&&r.set(e.toolCallId,e);for(let i of t.content){if(i.type!==`tool-approval-request`)continue;let t=i,a=t.toolCall??(t.toolCallId===void 0?void 0:r.get(t.toolCallId));if(a===void 0)continue;let o=createRuntimeToolCallActionFromToolCall({toolCall:a});n.push({action:o,allowFreeform:!1,display:`confirmation`,options:[{id:`approve`,label:`Yes`},{id:`deny`,label:`No`}],prompt:`Approve tool call: ${a.toolName}`,requestId:t.approvalId})}return n}export{extractQuestionInputRequests,extractToolApprovalInputRequests};

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

@@ -0,0 +1,75 @@
+import type { ModelMessage, ToolSet, TypedToolCall } from "ai";
+import type { RuntimeToolCallActionRequest } from "#runtime/actions/types.js";
+import type { InputRequest } from "#runtime/input/types.js";
+import type { HarnessSession, SessionStateMap, StepInput } from "#harness/types.js";
+/**
+ * Returns true when the step input carries user-facing turn input.
+ */
+export declare function hasStepInput(input?: StepInput): boolean;
+/**
+ * Merges any queued follow-up input into the current step input and clears it
+ * from session state.
+ *
+ * Used when the harness has to process a pending tool-approval response first
+ * and defer the user's new message to the next internal model step.
+ */
+export declare function consumeDeferredStepInput(input: {
+    readonly input?: StepInput;
+    readonly session: HarnessSession;
+}): {
+    readonly input?: StepInput;
+    readonly session: HarnessSession;
+};
+/**
+ * Returns true when the session carries queued follow-up input for the next
+ * internal harness step.
+ */
+export declare function hasDeferredStepInput(session: HarnessSession): boolean;
+/**
+ * Resolves pending input at the start of a harness step.
+ *
+ * When the pending batch contains tool-approval requests and the step input
+ * also carries a follow-up user message, the message is deferred to the next
+ * internal harness step rather than appended to the current turn. This is
+ * necessary because AI SDK cannot process tool-approval responses and a new
+ * user message in the same request -- the approval must be resolved in
+ * isolation first, and the user message replayed on the subsequent step via
+ * {@link consumeDeferredStepInput}.
+ */
+export declare function resolvePendingInput(input: {
+    readonly history?: readonly ModelMessage[];
+    readonly resolveApprovalKey?: (request: InputRequest) => string | undefined;
+    readonly session: HarnessSession;
+    readonly stepInput?: StepInput;
+}): ResolvePendingInputResult;
+type ResolvePendingInputResult = {
+    readonly deferredMessage?: boolean;
+    readonly outcome: "resolved" | "continue" | "unresolved";
+    readonly messages: ModelMessage[];
+    readonly session: HarnessSession;
+};
+/**
+ * Returns true when the session is parked on a pending HITL batch
+ * (tool approvals or `ask_question` prompts).
+ */
+export declare function hasPendingInputBatch(state: SessionStateMap | undefined): boolean;
+/**
+ * Stores one pending HITL batch on the session until the user responds.
+ */
+export declare function setPendingInputBatch(input: {
+    readonly requests: readonly InputRequest[];
+    readonly responseMessages: readonly ModelMessage[];
+    readonly session: HarnessSession;
+}): HarnessSession;
+/**
+ * Returns the set of tool names that have been approved at least once
+ * during this session.
+ */
+export declare function getApprovedTools(session: HarnessSession): ReadonlySet<string>;
+/**
+ * Creates a runtime tool-call action shape from an AI SDK tool call.
+ */
+export declare function createRuntimeToolCallActionFromToolCall(input: {
+    readonly toolCall: TypedToolCall<ToolSet>;
+}): RuntimeToolCallActionRequest;
+export {};

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

@@ -0,0 +1 @@
+import{parseJsonObject}from"#shared/json.js";import{coalesceTurnInputs}from"#harness/messages.js";const PENDING_INPUT_BATCH_KEY=`eve.runtime.pendingInputBatch`,APPROVED_TOOLS_KEY=`eve.runtime.hitl.approvedTools`,DEFERRED_STEP_INPUT_KEY=`eve.runtime.deferredStepInput`;function hasStepInput(e){return e===void 0?!1:e.message!==void 0||(e.inputResponses?.length??0)>0}function consumeDeferredStepInput(e){let n=getDeferredStepInput(e.session);if(n===void 0)return e;let r=clearDeferredStepInput(e.session);return e.input===void 0?{input:n,session:r}:{input:coalesceTurnInputs(n,e.input),session:r}}function hasDeferredStepInput(e){return getDeferredStepInput(e)!==void 0}function resolvePendingInput(e){let{stepInput:t}=e,n=e.session,r=[...e.history??n.history],i=getPendingInputBatch(n.state);if(i===void 0)return{outcome:`continue`,messages:r,session:n};let a=t?.inputResponses??[];if(a.length===0&&t?.message===void 0)return{outcome:`unresolved`,messages:r,session:n};if(a.length===0&&t?.message!==void 0){let e=buildToolResponseParts(i,[]),a=[...r,...i.responseMessages];return e.length>0&&a.push({content:e,role:`tool`}),n=clearPendingInputBatch(n),i.requests.some(e=>isApprovalRequest(e))?(n=queueDeferredStepInput(n,{message:t.message}),{deferredMessage:!0,outcome:`resolved`,messages:a,session:n}):{outcome:`resolved`,messages:a,session:n}}n=recordApprovedTools({pendingBatch:i,resolveApprovalKey:e.resolveApprovalKey,responses:a,session:n});let o=buildToolResponseParts(i,a),s=[...r,...i.responseMessages];return o.length>0&&s.push({content:o,role:`tool`}),n=clearPendingInputBatch(n),t?.message!==void 0&&i.requests.some(e=>isApprovalRequest(e))?(n=queueDeferredStepInput(n,{message:t.message}),{deferredMessage:!0,outcome:`resolved`,messages:s,session:n}):{outcome:`resolved`,messages:s,session:n}}function hasPendingInputBatch(e){return getPendingInputBatch(e)!==void 0}function getPendingInputBatch(e){let t=e?.[PENDING_INPUT_BATCH_KEY];if(typeof t!=`object`||!t)return;let r=t;if(!(!Array.isArray(r.requests)||!Array.isArray(r.responseMessages)))return r}function setPendingInputBatch(e){let t={...e.session.state};return t[PENDING_INPUT_BATCH_KEY]={requests:[...e.requests],responseMessages:[...e.responseMessages]},{...e.session,state:t}}function clearPendingInputBatch(e){if(e.state?.[PENDING_INPUT_BATCH_KEY]===void 0)return e;let t={...e.state};return delete t[PENDING_INPUT_BATCH_KEY],{...e,state:Object.keys(t).length>0?t:void 0}}function getDeferredStepInput(e){return e.state?.[DEFERRED_STEP_INPUT_KEY]}function queueDeferredStepInput(e,n){let r=getDeferredStepInput(e),a=r===void 0?n:coalesceTurnInputs(r,n),o={...e.state};return o[DEFERRED_STEP_INPUT_KEY]=a,{...e,state:o}}function clearDeferredStepInput(e){if(e.state?.[DEFERRED_STEP_INPUT_KEY]===void 0)return e;let t={...e.state};return delete t[DEFERRED_STEP_INPUT_KEY],{...e,state:Object.keys(t).length>0?t:void 0}}function getApprovedTools(e){let t=e.state?.[APPROVED_TOOLS_KEY];return Array.isArray(t)?new Set(t):new Set}function recordApprovedTools(e){let t=new Set(e.responses.filter(e=>e.optionId===`approve`).map(e=>e.requestId)),n=e.pendingBatch.requests.filter(e=>t.has(e.requestId)).map(t=>e.resolveApprovalKey?.(t)??t.action.toolName);if(n.length===0)return e.session;let i=getApprovedTools(e.session),a=[...new Set([...i,...n])],o={...e.session.state};return o[APPROVED_TOOLS_KEY]=a,{...e.session,state:o}}function buildToolResponseParts(e,t){let n=new Map(t.map(e=>[e.requestId,e])),r=[];for(let t of e.requests)r.push(...buildToolResponsePartsForRequest(t,n.get(t.requestId)));return r}function buildToolResponsePartsForRequest(e,t){if(isApprovalRequest(e)){let n=t?.optionId===`approve`,r=t===void 0?`Ignored because the user continued without responding.`:void 0,i=[{approvalId:e.requestId,approved:n,reason:r,type:`tool-approval-response`}];return n||i.push({output:{type:`execution-denied`,reason:r},toolCallId:e.action.callId,toolName:e.action.toolName,type:`tool-result`}),i}return[{output:{type:`json`,value:t===void 0?{status:`ignored`}:{optionId:t.optionId,text:t.text,status:`answered`}},toolCallId:e.action.callId,toolName:e.action.toolName,type:`tool-result`}]}function isApprovalRequest(e){return e.options?.length===2&&e.options[0]?.id===`approve`&&e.options[1]?.id===`deny`}function createRuntimeToolCallActionFromToolCall(e){return{callId:e.toolCall.toolCallId,input:resolveToolCallInputObject(e.toolCall.input),kind:`tool-call`,toolName:e.toolCall.toolName}}function resolveToolCallInputObject(t){return t==null?{}:parseJsonObject(t)}export{consumeDeferredStepInput,createRuntimeToolCallActionFromToolCall,getApprovedTools,hasDeferredStepInput,hasPendingInputBatch,hasStepInput,resolvePendingInput,setPendingInputBatch};

package/dist/src/harness/instrumentation-config.d.ts

@@ -0,0 +1,18 @@
+import type { InstrumentationDefinition, InstrumentationSetupContext } from "#public/instrumentation/index.js";
+/**
+ * Registers the authored instrumentation config and invokes its `setup`
+ * callback with the resolved agent name.
+ *
+ * Called once by the generated instrumentation Nitro plugin at server
+ * startup. Subsequent calls overwrite the previous value.
+ *
+ * @internal — not part of the public API.
+ */
+export declare function registerInstrumentationConfig(config: InstrumentationDefinition, context: InstrumentationSetupContext): void;
+/**
+ * Returns the registered instrumentation config, or `undefined` when no
+ * `defineInstrumentation` export was provided.
+ *
+ * @internal — not part of the public API.
+ */
+export declare function getInstrumentationConfig(): InstrumentationDefinition | undefined;

package/dist/src/harness/instrumentation-config.js

@@ -0,0 +1 @@
+const INSTRUMENTATION_CONFIG_GLOBAL_KEY=Symbol.for(`eve.harness-instrumentation-config`),globalContainer=globalThis;function registerInstrumentationConfig(e,t){e.setup!==void 0&&e.setup(t),globalContainer[INSTRUMENTATION_CONFIG_GLOBAL_KEY]=e}function getInstrumentationConfig(){return globalContainer[INSTRUMENTATION_CONFIG_GLOBAL_KEY]}export{getInstrumentationConfig,registerInstrumentationConfig};

package/dist/src/harness/instrumentation-runtime-context.d.ts

@@ -0,0 +1,23 @@
+import type { ModelMessage, SystemModelMessage } from "ai";
+import type { HarnessEmissionState } from "#harness/emission.js";
+import type { HarnessSession } from "#harness/types.js";
+import type { InstrumentationDefinition } from "#public/instrumentation/index.js";
+export interface BuildTelemetryRuntimeContextInput {
+    readonly eveVersion: string;
+    readonly authored: InstrumentationDefinition | undefined;
+    readonly emissionState: HarnessEmissionState;
+    readonly environment: string;
+    readonly modelInput: {
+        readonly instructions: string | readonly SystemModelMessage[] | undefined;
+        readonly messages: readonly ModelMessage[];
+    };
+    readonly session: HarnessSession;
+}
+/**
+ * Builds per-model-call runtime context for AI SDK telemetry spans.
+ *
+ * Authored runtime context is parsed defensively. Invalid event results,
+ * reserved `eve.*` keys, and callback failures are warning-only so
+ * instrumentation cannot compromise the normal turn flow.
+ */
+export declare function buildTelemetryRuntimeContext(input: BuildTelemetryRuntimeContextInput): Record<string, unknown> | undefined;

package/dist/src/harness/instrumentation-runtime-context.js

@@ -0,0 +1 @@
+import{createLogger,formatError}from"#internal/logging.js";import{normalizeInstrumentationChannelKind,resolveInstrumentationProjection}from"#internal/instrumentation.js";import{AuthKey,ChannelInstrumentationKey,InitiatorAuthKey,ParentSessionKey}from"#context/keys.js";import{parseJsonObject,parseJsonValue}from"#shared/json.js";import{contextStorage}from"#context/container.js";const log=createLogger(`harness.instrumentation-runtime-context`);function buildTelemetryRuntimeContext(e){if(e.authored===void 0)return;let t=resolveStepStartedRuntimeContext(e),r=contextStorage.getStore()?.get(ChannelInstrumentationKey);return{...t,"eve.channel.kind":normalizeInstrumentationChannelKind(r?.kind),"eve.environment":e.environment,"eve.session.id":e.session.sessionId,"eve.step.index":String(e.emissionState.stepIndex),"eve.turn.id":e.emissionState.turnId,"eve.turn.sequence":String(e.emissionState.sequence),"eve.version":e.eveVersion}}function buildInstrumentationStepStartedInput(e){let t=contextStorage.getStore(),r=t?.get(ChannelInstrumentationKey);return{channel:{kind:normalizeInstrumentationChannelKind(r?.kind),metadata:snapshotForInstrumentation(r?.metadata,`channel.metadata`)??{}},modelInput:snapshotForInstrumentation(e.modelInput,`modelInput`)??{instructions:void 0,messages:[]},session:{auth:projectSessionAuth(t),id:e.session.sessionId,parent:snapshotForInstrumentation(t?.get(ParentSessionKey),`session.parent`)},step:{index:e.emissionState.stepIndex},turn:{id:e.emissionState.turnId,sequence:e.emissionState.sequence}}}function filterAuthoredRuntimeContext(e,t){let n={};for(let[r,i]of Object.entries(e)){if(r.startsWith(`eve.`)){log.warn(`ignoring reserved instrumentation runtime context key`,{key:r,source:t});continue}n[r]=i}return Object.keys(n).length>0?n:void 0}function resolveStepStartedRuntimeContext(e){let n=e.authored?.events?.[`step.started`];if(n===void 0)return;let i=`events["step.started"]`,a=resolveInstrumentationProjection({invoke:()=>n(buildInstrumentationStepStartedInput(e)),log,source:i});if(a===void 0)return;if(!(`runtimeContext`in a)){log.warn(`ignoring instrumentation event result because runtimeContext is missing`,{source:i});return}let o;try{o=parseJsonObject(a.runtimeContext)}catch(e){log.warn(`ignoring instrumentation event result because runtimeContext is invalid`,{error:formatError(e),source:i});return}return filterAuthoredRuntimeContext(o,i)}function projectSessionAuth(e){let t=e?.get(AuthKey)??null,n=e?.get(InitiatorAuthKey)??t;return{current:snapshotForInstrumentation(t,`session.auth.current`)??null,initiator:snapshotForInstrumentation(n,`session.auth.initiator`)??null}}function snapshotForInstrumentation(e,n){if(e!==void 0)try{return parseJsonValue(e)}catch(e){log.warn(`dropping non-serializable instrumentation snapshot`,{error:formatError(e),source:n});return}}export{buildTelemetryRuntimeContext};

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

@@ -0,0 +1,41 @@
+import type { ModelMessage } from "ai";
+import type { DeliverPayload, SessionAuthContext } from "#channel/types.js";
+import type { StepInput } from "#harness/types.js";
+/**
+ * Merges two {@link StepInput} values into one.
+ *
+ * Used by the harness to coalesce deferred step input with the current
+ * turn's input, and by the execution layer after calling `onDeliver`
+ * for each queued delivery payload.
+ */
+export declare function coalesceTurnInputs(a: StepInput, b: StepInput): StepInput;
+/**
+ * Extracts the final visible assistant text from model response messages.
+ *
+ * Prefers text extracted from the last assistant message that contains visible
+ * text. Falls back to the raw `text` property from the AI SDK result when no
+ * assistant message contains text. Returns `null` when neither source contains
+ * text.
+ */
+export declare function resolveAssistantStepText(messages: readonly ModelMessage[], fallback: string | undefined): string | null;
+/**
+ * Structural shape of the workflow `DeliverHookPayload`. Using a
+ * structural type keeps this helper decoupled from the concrete
+ * runtime type.
+ */
+interface DeliverLike {
+    readonly auth?: SessionAuthContext | null;
+    readonly kind: "deliver";
+    readonly payloads: readonly DeliverPayload[];
+}
+/**
+ * Coalesces an array of deliver-like items into a single item by
+ * collecting all payloads and keeping the most recent auth value.
+ *
+ * Used by the workflow runtime to batch follow-up deliveries that
+ * arrived while a turn or subagent delegation was in progress. Each
+ * payload is later passed to `onDeliver` individually so channel-
+ * specific fields are never lost.
+ */
+export declare function coalesceDeliveries<T extends DeliverLike>(items: readonly T[]): T;
+export {};

package/dist/src/harness/messages.js

@@ -0,0 +1 @@
+function coalesceTurnInputs(e,t){let n=coalesceInputResponses({a:e.inputResponses,b:t.inputResponses}),r=coalesceMessage({a:e.message,b:t.message}),i=coalesceContext({a:e.context,b:t.context}),a=t.outputSchema??e.outputSchema,o={};return n!==void 0&&(o.inputResponses=n),r!==void 0&&(o.message=r),i!==void 0&&(o.context=i),a!==void 0&&(o.outputSchema=a),o}function resolveAssistantStepText(e,t){for(let t=e.length-1;t>=0;--t){let n=e[t];if(n?.role!==`assistant`)continue;let r=extractMessageText(n);if(r.length>0)return r}return t!==void 0&&t.length>0?t:null}function extractMessageText(e){return typeof e.content==`string`?e.content:Array.isArray(e.content)?e.content.flatMap(e=>typeof e==`string`?[e]:`type`in e&&e.type===`text`&&typeof e.text==`string`?[e.text]:[]).join(``):``}function coalesceInputResponses(e){let t=e.a??[],n=e.b??[];if(!(t.length===0&&n.length===0))return[...t,...n]}function coalesceContext(e){let t=e.a??[],n=e.b??[];if(!(t.length===0&&n.length===0))return[...t,...n]}function coalesceMessage(e){return e.a===void 0?e.b:e.b===void 0?e.a:typeof e.a==`string`&&typeof e.b==`string`?`${e.a}\n\n${e.b}`:[...toUserContentArray(e.a),...toUserContentArray(e.b)]}function toUserContentArray(e){return typeof e==`string`?e.length>0?[{type:`text`,text:e}]:[]:Array.isArray(e)?[...e]:[]}function coalesceDeliveries(e){let[t,...n]=e;if(t===void 0)throw Error(`Cannot coalesce an empty delivery batch.`);let r=t.auth,i=[...t.payloads];for(let e of n)e.auth!==void 0&&(r=e.auth),i.push(...e.payloads);return{...t,auth:r,payloads:i}}export{coalesceDeliveries,coalesceTurnInputs,resolveAssistantStepText};

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

@@ -0,0 +1,53 @@
+import type { JsonObject } from "#shared/json.js";
+/**
+ * One human-readable summary of a known model-call configuration failure.
+ *
+ * Returned by {@link summarizeKnownModelCallConfigError} for terminal
+ * failures that point at a fixable setup mistake (missing API key,
+ * gateway auth failure). Surfaces actionable text in REPL output and in
+ * structured `step.failed` events without dumping the full SDK error
+ * inspection into user-facing logs.
+ */
+export interface ModelCallConfigErrorSummary {
+    readonly name: string;
+    readonly message: string;
+}
+/**
+ * Returns a concise actionable summary for known terminal configuration
+ * errors raised during a model call. Returns `null` for everything else
+ * so the caller falls back to the raw SDK message.
+ */
+export declare function summarizeKnownModelCallConfigError(error: unknown): ModelCallConfigErrorSummary | null;
+/**
+ * Returns a concise summary for known model-call request failures that are not
+ * configuration errors. These failures happen before the agent can produce a
+ * response, so the user-facing message should avoid implying a bad tool call.
+ */
+export declare function summarizeKnownModelCallRequestError(error: unknown): ModelCallConfigErrorSummary | null;
+/**
+ * Returns the distinct upstream tool types referenced by any
+ * "tool type 'X' is not supported" rejection in an AI Gateway error's
+ * provider attempt list.
+ *
+ * Walks the cause chain to find the gateway error and inspects both the
+ * structured `data` field and the raw `responseBody` JSON. Returns an
+ * empty array for errors that are not of this shape.
+ *
+ * Used by the harness recovery path to identify which framework tools
+ * to drop before retrying the failing step. Detection is by string
+ * match on the upstream tool type — see
+ * {@link resolveFrameworkToolFromUpstreamType} for the mapping back to
+ * framework tool names.
+ */
+export declare function extractUnsupportedProviderToolTypes(error: unknown): readonly string[];
+/**
+ * Extracts compact, structured diagnostics from AI SDK / AI Gateway model-call
+ * errors. The full SDK error can include very large request bodies (especially
+ * tool schemas), so this shape lifts the important upstream response fields into
+ * `step.failed.details` before any inspector output gets truncated.
+ */
+export declare function extractModelCallErrorDetails(error: unknown): JsonObject;
+/**
+ * Classifies a model-call failure into the runtime's recovery policy.
+ */
+export declare function classifyModelCallError(error: unknown): "retry" | "recoverable" | "terminal";

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

@@ -0,0 +1 @@
+import{isObject}from"#shared/guards.js";const UNSUPPORTED_TOOL_TYPE_REGEX=/tool type ['"]([\w.-]+)['"] is not supported/i;function summarizeKnownModelCallConfigError(e){let t=readErrorName(e),n=readErrorMessage(e);return t===`GatewayAuthenticationError`||/AI Gateway authentication/i.test(n)?/Invalid API key/i.test(n)?{name:`AI Gateway authentication failed`,message:"AI Gateway rejected the provided API key. Update or unset `AI_GATEWAY_API_KEY` (check your shell profile if you did not set it for this project) — manage keys at https://vercel.com/dashboard/ai/api-keys. Unsetting it falls back to OIDC via `vercel link` + `vercel env pull`."}:/Invalid OIDC token/i.test(n)?{name:`AI Gateway authentication failed`,message:"AI Gateway rejected the OIDC token. Run `vercel env pull` to refresh `VERCEL_OIDC_TOKEN` in `.env.local`, or set `AI_GATEWAY_API_KEY` — create a key at https://vercel.com/dashboard/ai/api-keys."}:{name:`AI Gateway authentication failed`,message:"AI Gateway received no credentials. Run `vercel link` + `vercel env pull` to populate `VERCEL_OIDC_TOKEN`, or set `AI_GATEWAY_API_KEY` — create a key at https://vercel.com/dashboard/ai/api-keys."}:t===`LoadAPIKeyError`||/API key is missing/i.test(n)?{name:`Model provider API key missing`,message:"The model provider could not load an API key. Export the provider's API key environment variable (for example `AI_GATEWAY_API_KEY` or `OPENAI_API_KEY`) and try again."}:null}function summarizeKnownModelCallRequestError(e){let t=readModelCallErrorSignals(e);return t.statusCode===400&&isGatewayErrorSignal(t)?{name:`AI Gateway model request rejected`,message:`AI Gateway rejected the model request before the agent produced a response.`}:null}function extractUnsupportedProviderToolTypes(e){let n=new Set;for(let r of walkCauseChain(e)){collectUnsupportedToolTypesFromValue(readObjectField(r,`data`),n);let e=readStringField(r,`responseBody`);if(e!==void 0)try{collectUnsupportedToolTypesFromValue(JSON.parse(e),n)}catch{let r=UNSUPPORTED_TOOL_TYPE_REGEX.exec(e);r?.[1]!==void 0&&n.add(r[1])}}return[...n]}function collectUnsupportedToolTypesFromValue(n,r){if(n!=null){if(typeof n==`string`){let e=UNSUPPORTED_TOOL_TYPE_REGEX.exec(n);e?.[1]!==void 0&&r.add(e[1]);return}if(Array.isArray(n)){for(let e of n)collectUnsupportedToolTypesFromValue(e,r);return}if(isObject(n))for(let e of Object.values(n))collectUnsupportedToolTypesFromValue(e,r)}}function extractModelCallErrorDetails(e){let t=readModelCallErrorSignals(e),n={};return appendJsonField(n,`gatewayName`,t.gatewayName),appendJsonField(n,`gatewayType`,t.gatewayType),appendJsonField(n,`statusCode`,t.statusCode),appendJsonField(n,`generationId`,t.generationId),appendJsonField(n,`upstreamStatusCode`,t.upstreamStatusCode),appendJsonField(n,`upstreamType`,t.upstreamType),appendJsonField(n,`upstreamMessage`,t.upstreamMessage),appendJsonField(n,`responseBodySnippet`,t.responseBodySnippet),n}function readErrorName(t){if(t instanceof Error||isObject(t)&&typeof t.name==`string`)return t.name}function readErrorMessage(t){return t instanceof Error||isObject(t)&&typeof t.message==`string`?t.message:``}function classifyModelCallError(e){if(hasRetryableFlag(e))return`retry`;if(summarizeKnownModelCallConfigError(e)!==null)return`terminal`;let t=readModelCallErrorSignals(e);if(isRetryableGatewayType(t.gatewayType)||isRetryableGatewayType(t.upstreamType))return`retry`;if(isTerminalGatewayType(t.gatewayType)||isTerminalGatewayType(t.upstreamType)||t.gatewayName===`GatewayInvalidRequestError`)return`terminal`;let n=t.statusCode;if(n!==void 0){if(n===408||n===409||n===429||n>=500)return`retry`;if(isAmbiguousGatewayInternalBadRequest(t))return`recoverable`;if(n>=400&&n<500)return`terminal`}return isLikelyNetworkError(e)?`retry`:`recoverable`}function hasRetryableFlag(t){for(let n of walkCauseChain(t))if(isObject(n)&&n.isRetryable===!0)return!0;return!1}function isLikelyNetworkError(e){if(!(e instanceof Error))return!1;let t=e.message.toLowerCase();return t.includes(`econnreset`)||t.includes(`etimedout`)||t.includes(`eai_again`)||t.includes(`socket hang up`)||t.includes(`network`)||t.includes(`fetch failed`)?!0:e.cause!==void 0&&e.cause!==e?isLikelyNetworkError(e.cause):!1}function readModelCallErrorSignals(e){let t=findGatewayError(e),n=findUpstreamApiCallError(e),r=readStringField(n,`responseBody`),i=readGatewayErrorBody(n);return{gatewayName:readErrorName(t),gatewayType:readStringField(t,`type`),generationId:readStringField(t,`generationId`)??i?.generationId,responseBodySnippet:r===void 0?void 0:truncateSnippet(r,1e3),statusCode:readStatusCode(t)??readStatusCode(n)??findStatusCode(e),upstreamMessage:i?.message,upstreamStatusCode:readStatusCode(n),upstreamType:i?.type}}function findGatewayError(e){for(let t of walkCauseChain(e)){let e=readErrorName(t),n=readStringField(t,`type`);if(e?.startsWith(`Gateway`)||n?.endsWith(`_error`)||n===`rate_limit_exceeded`)return t}}function findUpstreamApiCallError(e){for(let t of walkCauseChain(e))if(readErrorName(t)===`AI_APICallError`||readStringField(t,`responseBody`)!==void 0||readObjectField(t,`data`)!==void 0||readObjectField(t,`requestBodyValues`)!==void 0)return t}function readGatewayErrorBody(e){let t=readGatewayErrorBodyFromValue(readObjectField(e,`data`));if(t!==void 0)return t;let n=readStringField(e,`responseBody`);if(n!==void 0)try{return readGatewayErrorBodyFromValue(JSON.parse(n))}catch{return}}function readGatewayErrorBodyFromValue(t){if(!isObject(t))return;let n=readObjectField(t,`error`);if(n===void 0)return;let r=readStringField(t,`generationId`),i=readStringField(n,`message`),a=readStringField(n,`type`);return i===void 0&&a===void 0&&r===void 0?void 0:{generationId:r,message:i,type:a}}function readStatusCode(t){if(isObject(t))return typeof t.statusCode==`number`?t.statusCode:void 0}function findStatusCode(e){for(let t of walkCauseChain(e)){let e=readStatusCode(t);if(e!==void 0)return e}}function readStringField(t,n){if(!isObject(t))return;let r=t[n];return typeof r==`string`&&r.length>0?r:void 0}function readObjectField(t,n){if(!isObject(t))return;let r=t[n];return isObject(r)?r:void 0}function isRetryableGatewayType(e){return e===`rate_limit_exceeded`||e===`timeout_error`}function isTerminalGatewayType(e){return e===`authentication_error`||e===`invalid_request_error`||e===`model_not_found`}function isGatewayErrorSignal(e){return e.gatewayName!==void 0||e.gatewayType!==void 0}function isAmbiguousGatewayInternalBadRequest(e){return e.statusCode===400&&(e.gatewayName===`GatewayInternalServerError`||e.gatewayType===`internal_server_error`)&&(e.upstreamType===void 0||e.upstreamType===`internal_server_error`)}function*walkCauseChain(t){let n=new Set,r=t;for(;isObject(r)&&!n.has(r);)n.add(r),yield r,r=r.cause}function appendJsonField(e,t,n){if(typeof n==`string`&&n.length>0){e[t]=n;return}typeof n==`number`&&Number.isFinite(n)&&(e[t]=n)}function truncateSnippet(e,t){return e.length<=t?e:`${e.slice(0,t)}...<truncated>`}export{classifyModelCallError,extractModelCallErrorDetails,extractUnsupportedProviderToolTypes,summarizeKnownModelCallConfigError,summarizeKnownModelCallRequestError};

package/dist/src/harness/otel-integration.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Registers the AI SDK OpenTelemetry integration once so that model
+ * calls emit OTel spans, including runtime-context attributes. Safe to
+ * call multiple times — only the first call has an effect.
+ *
+ * In AI SDK v7 the built-in OTel tracing was moved to `@ai-sdk/otel`
+ * and must be registered explicitly.
+ */
+export declare function ensureOtelIntegration(): void;

package/dist/src/harness/otel-integration.js

@@ -0,0 +1 @@
+import{registerTelemetry}from"ai";import{OpenTelemetry}from"#compiled/@ai-sdk/otel/index.js";let registered=!1;function ensureOtelIntegration(){registered||(registered=!0,registerTelemetry(new OpenTelemetry({runtimeContext:!0})))}export{ensureOtelIntegration};

package/dist/src/harness/prompt-cache.d.ts

@@ -0,0 +1,83 @@
+import type { LanguageModel, ModelMessage, SystemModelMessage, ToolSet } from "ai";
+/**
+ * The caching strategy to apply for one harness step.
+ */
+export type PromptCachePath = {
+    readonly kind: "gateway-auto";
+} | {
+    readonly kind: "anthropic-direct";
+} | {
+    readonly kind: "none";
+};
+/**
+ * Cache marker injected on the Anthropic-direct path.
+ *
+ * The AI SDK Anthropic provider reads `providerOptions.anthropic.cacheControl`
+ * from message, message-part, system-message, and tool objects. The same
+ * namespace is used by `@ai-sdk/amazon-bedrock/anthropic` and
+ * `@ai-sdk/google-vertex/anthropic`, which both implement the native
+ * Anthropic Messages API.
+ */
+export interface AnthropicCacheMarker {
+    readonly anthropic: {
+        readonly cacheControl: {
+            readonly type: "ephemeral";
+        };
+    };
+}
+/**
+ * Detects which prompt caching path applies to a resolved model.
+ *
+ * Runs once per harness step right after `resolveModel()`.
+ */
+export declare function detectPromptCachePath(model: LanguageModel): PromptCachePath;
+/**
+ * Returns the shared Anthropic cache marker used on the `anthropic-direct`
+ * path. Exposed for unit tests and for the harness wiring layer.
+ */
+export declare function getAnthropicCacheMarker(): AnthropicCacheMarker;
+/**
+ * Returns a new `providerOptions` object with
+ * `gateway.caching = "auto"` merged into the existing `gateway` sub-object.
+ *
+ * Preserves any existing author-provided `gateway` keys (such as
+ * `order: ["anthropic", "bedrock"]` load balancing), and leaves an
+ * explicit author override on `gateway.caching` untouched so callers can
+ * opt out by setting `providerOptions.gateway.caching` to `false` or
+ * another value.
+ */
+export declare function mergeGatewayAutoCaching(base: Readonly<Record<string, unknown>> | undefined): Record<string, unknown>;
+/**
+ * Returns a new ToolSet where the last tool entry carries the Anthropic
+ * cache marker on `providerOptions`. Used on the `anthropic-direct` path
+ * to place a stable breakpoint at the end of the tools block, caching the
+ * full tool definitions across every turn.
+ *
+ * No-op when `tools` has no entries. Preserves existing `providerOptions`
+ * on tools (merges the cache marker in via spread).
+ */
+export declare function applyLastToolCacheBreakpoint(tools: ToolSet, marker: AnthropicCacheMarker): ToolSet;
+/**
+ * Marks the last system message in an instructions array with the Anthropic
+ * cache marker. This creates a cache breakpoint at the end of the system
+ * prompt, preserving the system prefix when tools change between steps.
+ *
+ * When `instructions` is a string or undefined, returns it unchanged —
+ * single-string system prompts don't support per-message providerOptions.
+ * No-op when the array is empty.
+ */
+export declare function applySystemCacheBreakpoint(instructions: readonly SystemModelMessage[], marker: AnthropicCacheMarker): SystemModelMessage[];
+/**
+ * Walks backward through `messages` and attaches the Anthropic cache marker
+ * to the most recent `assistant` and most recent `user` message. Returns a
+ * new array; does not mutate the input.
+ *
+ * This implements the "automatic cache advancement" pattern: each turn the
+ * breakpoints move forward, and the prior turn's breakpoints still warm the
+ * cache prefix, so the new breakpoints just extend the cached region.
+ *
+ * Tool-result messages (`role: "tool"`) are intentionally skipped — the
+ * adjacent assistant message's cache marker already covers the prefix
+ * through any preceding tool results.
+ */
+export declare function applyConversationCacheControl(messages: readonly ModelMessage[], marker: AnthropicCacheMarker): ModelMessage[];

package/dist/src/harness/prompt-cache.js

@@ -0,0 +1 @@
+const ANTHROPIC_CACHE_MARKER=Object.freeze({anthropic:Object.freeze({cacheControl:Object.freeze({type:`ephemeral`})})});function detectPromptCachePath(e){return typeof e==`string`?{kind:`gateway-auto`}:(typeof e.provider==`string`?e.provider.toLowerCase():``).includes(`anthropic`)?{kind:`anthropic-direct`}:{kind:`none`}}function getAnthropicCacheMarker(){return ANTHROPIC_CACHE_MARKER}function mergeGatewayAutoCaching(e){let t=e?.gateway!==void 0&&typeof e.gateway==`object`&&e.gateway!==null?e.gateway:void 0,n={...t,caching:t?.caching??`auto`};return{...e,gateway:n}}function applyLastToolCacheBreakpoint(e,t){let n=Object.entries(e);if(n.length===0)return e;let r={};for(let e=0;e<n.length;e++){let[i,a]=n[e];if(e===n.length-1){let e=a.providerOptions!==void 0&&typeof a.providerOptions==`object`?a.providerOptions:void 0;r[i]={...a,providerOptions:{...e,...t}}}else r[i]=a}return r}function applySystemCacheBreakpoint(e,t){if(e.length===0)return[...e];let n=[...e],r=n[n.length-1];return n[n.length-1]={...r,providerOptions:{...r.providerOptions,...t}},n}function applyConversationCacheControl(e,t){if(e.length===0)return[...e];let n=[...e],r=!1,i=!1;for(let e=n.length-1;e>=0&&(!r||!i);e--){let a=n[e];a!==void 0&&(!r&&a.role===`assistant`?(n[e]={...a,providerOptions:{...a.providerOptions,...t}},r=!0):!i&&a.role===`user`&&(n[e]={...a,providerOptions:{...a.providerOptions,...t}},i=!0))}return n}export{applyConversationCacheControl,applyLastToolCacheBreakpoint,applySystemCacheBreakpoint,detectPromptCachePath,getAnthropicCacheMarker,mergeGatewayAutoCaching};

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

@@ -0,0 +1,62 @@
+import { type ToolSet } from "ai";
+import type { RuntimeModelReference } from "#runtime/agent/bootstrap.js";
+import type { JsonObject } from "#shared/json.js";
+/**
+ * The provider backend resolved for one web search tool invocation.
+ */
+export type WebSearchBackend = "anthropic" | "gateway" | "google" | "openai";
+/**
+ * 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.
+ *
+ * Used by the harness recovery path to decide which tools to drop when a
+ * gateway fallback provider rejects a tool. Unknown types fall through to
+ * the existing terminal/recoverable handling.
+ */
+export declare function resolveFrameworkToolFromUpstreamType(type: string): string | null;
+/**
+ * Maps a {@link WebSearchBackend} to the gateway provider slug used in
+ * `providerOptions.gateway.only` to pin routing to that provider.
+ *
+ * Returns `null` for the `"gateway"` backend (Perplexity via AI Gateway),
+ * which is served by the gateway directly and does not need pinning.
+ */
+export declare function resolveGatewayPinForWebSearchBackend(backend: WebSearchBackend): string | null;
+/**
+ * Returns the output schema for the provider-managed web search tool that
+ * will be injected for `backend`.
+ */
+export declare function resolveWebSearchOutputSchema(backend: WebSearchBackend): JsonObject;
+/**
+ * Returns a new `providerOptions` object with
+ * `gateway.only = [provider]` merged into the existing `gateway`
+ * sub-object so the AI Gateway only attempts the given provider.
+ *
+ * Used by the harness to pin routing when a provider-specific tool
+ * (e.g. Anthropic's `web_search_20250305`) is in the per-step toolset,
+ * so a transient primary outage produces a clean retryable 503 instead
+ * of a fallback-to-incompatible-provider 400.
+ *
+ * Author overrides win — if `base.gateway.only` or `base.gateway.order`
+ * is already set, the input is returned unchanged so explicit routing
+ * preferences are never silently overwritten.
+ */
+export declare function mergeGatewayProviderPin(base: Readonly<Record<string, unknown>> | undefined, provider: string): Record<string, unknown>;
+/**
+ * Determines the web search backend for a model reference.
+ *
+ * - OpenAI models (gateway or BYO): native OpenAI search
+ * - Anthropic models (gateway or BYO): native Anthropic search
+ * - Direct/BYO Google models: native Google search grounding
+ * - Other models on AI Gateway (including `google/...`): Perplexity search via gateway
+ * - Other BYO models: not available (returns `null`)
+ */
+export declare function resolveWebSearchBackend(modelRef: RuntimeModelReference): 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.
+ *
+ * Dynamic imports keep unused provider SDKs out of the bundle — only the
+ * provider matching the current model is loaded.
+ */
+export declare function resolveWebSearchProviderTool(backend: WebSearchBackend): Promise<ToolSet[string]>;

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

@@ -0,0 +1 @@
+import{isObject}from"#shared/guards.js";import{jsonSchema}from"ai";import{WEB_SEARCH_ANTHROPIC_OUTPUT_SCHEMA,WEB_SEARCH_GATEWAY_OUTPUT_SCHEMA,WEB_SEARCH_GOOGLE_OUTPUT_SCHEMA,WEB_SEARCH_OPENAI_OUTPUT_SCHEMA,WEB_SEARCH_TOOL_DEFINITION}from"#runtime/framework-tools/web-search.js";const UPSTREAM_TOOL_TYPE_TO_FRAMEWORK_NAME={web_search_20250305:WEB_SEARCH_TOOL_DEFINITION.name};function resolveFrameworkToolFromUpstreamType(e){return UPSTREAM_TOOL_TYPE_TO_FRAMEWORK_NAME[e]??null}function resolveGatewayPinForWebSearchBackend(e){switch(e){case`anthropic`:return`anthropic`;case`openai`:return`openai`;case`google`:return`google`;case`gateway`:return null}}function resolveWebSearchOutputSchema(e){switch(e){case`anthropic`:return WEB_SEARCH_ANTHROPIC_OUTPUT_SCHEMA;case`gateway`:return WEB_SEARCH_GATEWAY_OUTPUT_SCHEMA;case`google`:return WEB_SEARCH_GOOGLE_OUTPUT_SCHEMA;case`openai`:return WEB_SEARCH_OPENAI_OUTPUT_SCHEMA}}function mergeGatewayProviderPin(t,n){let r=isObject(t?.gateway)?t.gateway:void 0;if(r?.only!==void 0||r?.order!==void 0)return{...t};let i={...r,only:[n]};return{...t,gateway:i}}function resolveWebSearchBackend(e){let t=e.id.split(`/`)[0]??``;return t===`openai`||t.startsWith(`openai.`)?`openai`:t===`anthropic`||t.startsWith(`anthropic.`)?`anthropic`:t.startsWith(`google.`)?`google`:e.source===void 0?`gateway`: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`gateway`:{let{gateway:t}=await import(`ai`);return attachWebSearchOutputSchema(t.tools.perplexitySearch(),e)}}}function attachWebSearchOutputSchema(e,n){return{...e,outputSchema:jsonSchema(resolveWebSearchOutputSchema(n))}}export{mergeGatewayProviderPin,resolveFrameworkToolFromUpstreamType,resolveGatewayPinForWebSearchBackend,resolveWebSearchBackend,resolveWebSearchOutputSchema,resolveWebSearchProviderTool};

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

@@ -0,0 +1,32 @@
+import type { SubagentInputRequestHookPayload } from "#channel/types.js";
+import type { HarnessSession, SessionStateMap } from "#harness/types.js";
+/**
+ * Returns the proxy-routing map as a fresh `Map`. Never returns a live
+ * reference so accidental mutation cannot corrupt session state.
+ */
+export declare function getProxyInputRequests(state: SessionStateMap | undefined): ReadonlyMap<string, string>;
+/**
+ * Returns true when the session is currently proxying one or more
+ * HITL requests on behalf of a descendant subagent.
+ */
+export declare function hasProxyInputRequests(state: SessionStateMap | undefined): boolean;
+/**
+ * Replaces prior entries for `forChildContinuationToken` with the
+ * provided ones. A child raising a fresh batch overwrites its prior
+ * batch — the parent never keeps stale request metadata.
+ */
+export declare function upsertProxyInputRequests(input: {
+    readonly entries: readonly (readonly [requestId: string, childContinuationToken: string])[];
+    readonly forChildContinuationToken: string;
+    readonly session: HarnessSession;
+}): HarnessSession;
+/**
+ * Removes every entry for `childContinuationToken`. Called when a
+ * child subagent finishes so stale clicks no longer route to it.
+ */
+export declare function clearProxyInputRequestsForChild(session: HarnessSession, childContinuationToken: string): HarnessSession;
+/**
+ * Projects a {@link SubagentInputRequestHookPayload} into the
+ * `(requestId, childContinuationToken)` tuples the session stores.
+ */
+export declare function toProxyInputRequestEntries(payload: SubagentInputRequestHookPayload): readonly (readonly [requestId: string, childContinuationToken: string])[];

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

@@ -0,0 +1 @@
+const PROXY_INPUT_REQUESTS_KEY=`eve.runtime.proxyInputRequests`;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){let t={};for(let[n,r]of Object.entries(readMap(e.session.state)))r!==e.forChildContinuationToken&&(t[n]=r);for(let[n,r]of e.entries)t[n]=r;return writeMap(e.session,t)}function clearProxyInputRequestsForChild(e,t){let n=readMap(e.state),r={},i=!1;for(let[e,a]of Object.entries(n)){if(a===t){i=!0;continue}r[e]=a}return i?writeMap(e,r):e}function toProxyInputRequestEntries(e){return e.event.requests.map(t=>[t.requestId,e.childContinuationToken])}function readMap(t){let n=t?.[PROXY_INPUT_REQUESTS_KEY];if(typeof n!=`object`||!n||Array.isArray(n))return{};let r={};for(let[e,t]of Object.entries(n))typeof t==`string`&&(r[e]=t);return r}function writeMap(t,n){let r={...t.state};return Object.keys(n).length===0?(delete r[PROXY_INPUT_REQUESTS_KEY],{...t,state:Object.keys(r).length>0?r:void 0}):(r[PROXY_INPUT_REQUESTS_KEY]=n,{...t,state:r})}export{clearProxyInputRequestsForChild,getProxyInputRequests,hasProxyInputRequests,toProxyInputRequestEntries,upsertProxyInputRequests};