eve 0.5.4 → 0.6.0-beta.3

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

@@ -0,0 +1,22 @@
+/**
+ * Per-step holding pen for the full interrupt signal a tool returns from
+ * `execute`.
+ *
+ * A tool signals a park (e.g. connection OAuth) by *returning* an
+ * {@link AuthorizationSignal}. The AI SDK records that return value as the
+ * tool-result `output`, which `experimental_telemetry`'s `recordOutputs`
+ * exports to OTel spans. So the {@link "#harness/tools.js"} wrapper hands the
+ * AI SDK a `resume`-redacted copy of the signal and stashes the full signal
+ * here; the park detector reads it back so the journaled challenges keep
+ * their `resume` value.
+ *
+ * Virtual context: never serialized, wiped each step. Set during `execute`
+ * and read post-step within the same `runStep` scope, so the slot always
+ * outlives the read and never crosses a boundary.
+ */
+import type { AlsContext } from "#context/container.js";
+import type { AuthorizationSignal } from "#harness/authorization.js";
+/** Stashes a tool's full interrupt signal under its `toolCallId` for the current step. */
+export declare function stashToolInterrupt(ctx: AlsContext, toolCallId: string, signal: AuthorizationSignal): void;
+/** Reads the full interrupt signal stashed for `toolCallId`, if any. */
+export declare function readToolInterrupt(ctx: AlsContext, toolCallId: string): AuthorizationSignal | undefined;

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

@@ -0,0 +1 @@
+import{ContextKey}from"#context/key.js";const PendingToolInterruptsKey=new ContextKey(`eve.pendingToolInterrupts`);function stashToolInterrupt(e,t,n){let r=e.get(PendingToolInterruptsKey)??{};asContainer(e).setVirtualContext(PendingToolInterruptsKey,{...r,[t]:n})}function readToolInterrupt(e,t){return e.get(PendingToolInterruptsKey)?.[t]}function asContainer(e){return e}export{readToolInterrupt,stashToolInterrupt};

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

@@ -0,0 +1,2 @@
+import type { StepFn, ToolLoopHarnessConfig } from "#harness/types.js";
+export declare function createToolLoopHarness(config: ToolLoopHarnessConfig): StepFn;

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

@@ -0,0 +1 @@
+import{createErrorId,createLogger,formatError,logError,recordErrorOnSpan}from"#internal/logging.js";import{createAuthorizationRequiredEvent,createCompactionCompletedEvent,createCompactionRequestedEvent,createInputRequestedEvent,createResultCompletedEvent}from"#protocol/message.js";import{toErrorMessage}from"#shared/errors.js";import{ToolLoopAgent,isStepCount}from"ai";import{resolveInstalledPackageInfo}from"#internal/application/package.js";import{formatLanguageModelGatewayId}from"#internal/runtime-model.js";import{contextStorage,loadContext}from"#context/container.js";import{setEveAttributes}from"#runtime/attributes/emit.js";import{isCodeModeRuntimeActionInterrupt}from"#harness/code-mode-runtime-action-state.js";import{clearPendingCodeModeInterrupt,getPendingCodeModeInterrupt,setPendingCodeModeInterrupt}from"#harness/code-mode-interrupt-state.js";import{createRuntimeActionRequestFromToolCall,resolvePendingRuntimeActions,setPendingRuntimeActionBatch}from"#harness/runtime-actions.js";import{advanceStep,emitFailedStep,emitRecoverableFailedTurn,emitStepStarted,emitStreamContent,emitTurnEpilogue,emitTurnPreamble,getHarnessEmissionState,setHarnessEmissionState}from"#harness/emission.js";import{CODE_MODE_TOOL_NAME,loadCodeModeModule}from"#shared/code-mode.js";import{resolveAssistantStepText}from"#harness/messages.js";import{buildDynamicInstructionMessages}from"#context/dynamic-instruction-lifecycle.js";import{PendingSkillAnnouncementKey}from"#context/dynamic-skill-lifecycle.js";import{consumeDeferredStepInput,getApprovedTools,hasDeferredStepInput,hasStepInput,resolvePendingInput,setPendingInputBatch}from"#harness/input-requests.js";import{isAuthorizationSignal,setPendingAuthorization}from"#harness/authorization.js";import{buildDynamicTools}from"#context/build-dynamic-tools.js";import{isCodeModeConnectionAuthInterrupt}from"#runtime/framework-tools/code-mode-connection-auth.js";import{isSandboxEnabled,selectSandboxSurfaces}from"#harness/sandbox-surface.js";import{buildToolSetWithProviderTools}from"#harness/tools.js";import{ASK_QUESTION_TOOL_NAME}from"#runtime/framework-tools/ask-question.js";import{WEB_SEARCH_TOOL_DEFINITION}from"#runtime/framework-tools/web-search.js";import{extractQuestionInputRequests,extractToolApprovalInputRequests}from"#harness/input-extraction.js";import{applyLastToolCacheBreakpoint,applySystemCacheBreakpoint,detectPromptCachePath,getAnthropicCacheMarker}from"#harness/prompt-cache.js";import{resolveFrameworkToolFromUpstreamType,resolveGatewayPinForWebSearchBackend,resolveWebSearchBackend}from"#harness/provider-tools.js";import{context,trace}from"#compiled/@opentelemetry/api/index.js";import{hydrateSandboxAttachments,stageAttachmentsToSandbox}from"#harness/attachment-staging.js";import{applySandboxToolSet,buildSandboxHostTools,createEveCodeModeOptions}from"#harness/code-mode.js";import{createCodeModeLifecycle}from"#harness/code-mode-lifecycle.js";import{compactMessages,getInputTokenCount,resolveCompactionModel,shouldCompact}from"#harness/compaction.js";import{accumulateTurnUsage,getTurnUsageState,setTurnUsageState}from"#harness/turn-tag-state.js";import{buildTelemetryRuntimeContext}from"#harness/instrumentation-runtime-context.js";import{getInstrumentationConfig}from"#harness/instrumentation-config.js";import{readToolInterrupt}from"#harness/tool-interrupts.js";import{classifyModelCallError,extractModelCallErrorDetails,extractUnsupportedProviderToolTypes,summarizeKnownModelCallConfigError,summarizeKnownModelCallRequestError}from"#harness/model-call-error.js";import{extractWorkflowStreamWriteErrorDetails}from"#harness/workflow-stream-error.js";import{ensureOtelIntegration}from"#harness/otel-integration.js";import{buildStepHooks,emitStepActions,isInvalidToolCall}from"#harness/step-hooks.js";import{pruneToolResults}from"#harness/tool-result-pruning.js";import{FINAL_OUTPUT_TOOL_NAME,buildFinalOutputTool}from"#runtime/framework-tools/final-output.js";const environment=process.env.NODE_ENV??`unknown`,eveVersion=resolveInstalledPackageInfo().version,log=createLogger(`harness.tool-loop`);function logToolExecutionError(e){e.toolOutput.type===`tool-error`&&logError(log,`tool execution failed`,e.toolOutput.error,{toolName:e.toolCall.toolName,toolCallId:e.toolCall.toolCallId})}function enrichTelemetry(e,t,n){if(e===void 0)return;let r={};for(let e of Object.keys(n??{}))r[e]=!0;return{functionId:e.functionId??t,includeRuntimeContext:r,isEnabled:!0,recordInputs:e.recordInputs??!0,recordOutputs:e.recordOutputs??!0}}function resolveGatewayPinForStep(e){if(e.cachePath.kind!==`gateway-auto`||e.tools[WEB_SEARCH_TOOL_DEFINITION.name]===void 0)return;let t=resolveWebSearchBackend(e.modelReference);return t===null?void 0:resolveGatewayPinForWebSearchBackend(t)??void 0}function buildGatewayAttributionHeaders(e,t){if(typeof e!=`string`)return;let n=t?.agentName??t?.agentId,r=process.env.VERCEL_PROJECT_PRODUCTION_URL||process.env.VERCEL_URL,i=r?`https://${r}`:void 0;if(!n&&!i)return;let a={};return n&&(a[`x-title`]=n),i&&(a[`http-referer`]=i),a}const TURN_TRACE_STATE_KEY=`eve.harness.turnTrace`;function getTurnTraceState(e){return e.state?.[TURN_TRACE_STATE_KEY]}function setTurnTraceState(e,t){let n={traceId:t.traceId,spanId:t.spanId,traceFlags:t.traceFlags};return{...e,state:{...e.state,[TURN_TRACE_STATE_KEY]:n}}}function resolveStepOtelContext(e,t,n){if(t)return trace.setSpan(context.active(),t);if(e){let e=getTurnTraceState(n);if(e){let t=trace.wrapSpanContext({traceId:e.traceId,spanId:e.spanId,traceFlags:e.traceFlags});return trace.setSpan(context.active(),t)}}}function createToolLoopHarness(t){let n=t.handleEvent,a=getInstrumentationConfig();a!==void 0&&ensureOtelIntegration();let o=a===void 0?void 0:trace.getTracer(`eve`),s=t.runtimeIdentity?.agentName;async function runStep(e,t){let n;if(o&&hasStepInput(t)){let t=a?.functionId??s,r={"eve.version":eveVersion,"eve.environment":environment,"eve.session.id":e.sessionId};t&&(r[`ai.telemetry.functionId`]=t),n=o.startSpan(`ai.eve.turn`,{attributes:r})}let r=resolveStepOtelContext(o,n,e),executeStep=()=>executeStepBody(e,t,n);try{return r?await context.with(r,executeStep):await executeStep()}finally{n?.end()}}async function executeStepBody(o,c,l){let p=o;l&&(p=setTurnTraceState(p,l.spanContext()));let g=getHarnessEmissionState(p.state),v=consumeDeferredStepInput({input:c,session:p});p=v.session;let y=await resolvePendingRuntimeActions({emit:n,session:p,stepInput:v.input});if(y.outcome===`unresolved`)return{next:null,session:y.session};p=y.session;let b=resolvePendingInput({history:y.messages,resolveApprovalKey:resolveApprovalKeyFromTools(t.tools),session:p,stepInput:v.input});if(b.outcome===`unresolved`)return{next:null,session:b.session};n&&hasStepInput(c)&&(g=await emitTurnPreamble(n,c??{},g,t.runtimeIdentity),p=setHarnessEmissionState(p,g),l&&l.setAttribute(`eve.turn.id`,g.turnId)),p=b.session;let x=b.messages;if(v.input?.context!==void 0)for(let e of v.input.context)x.push({content:e,role:`user`});if(v.input?.message!==void 0&&!b.deferredMessage){let e=await stageAttachmentsToSandbox(v.input.message);x.push({content:e,role:`user`})}let S=await t.resolveModel(p.agent.modelReference),w=detectPromptCachePath(S),T=w.kind===`anthropic-direct`?getAnthropicCacheMarker():void 0,k=buildGatewayAttributionHeaders(S,t.runtimeIdentity);({messages:x,session:p}=await maybeCompact({emit:n,emissionState:g,headers:k,messages:x,model:S,onCompaction:t.onCompaction,resolveModel:t.resolveModel,session:p,telemetry:enrichTelemetry(a,s)??void 0}));let A=getApprovedTools(p),j=contextStorage.getStore(),M=await hydrateSandboxAttachments(x),N=[],P=[];for(let e of M)e.role===`system`?N.push(e):P.push(e);if(j!==void 0){N.push(...buildDynamicInstructionMessages(j));let e=j.get(PendingSkillAnnouncementKey);e!==void 0&&e.length>0&&N.push({role:`system`,content:e})}let F=P,prepareModelCallInput=e=>{let t=e?[{role:`system`,content:e}]:[],n=p.agent.system?[{role:`system`,content:p.agent.system}]:[],r=N.length>0||t.length>0?[...t,...n,...N]:void 0,i=r!==void 0&&T?applySystemCacheBreakpoint(r,T):r??p.agent.system??void 0;return{instructions:i,telemetryRuntimeContext:buildTelemetryRuntimeContext({eveVersion,authored:a,emissionState:g,environment,modelInput:{instructions:i,messages:F},session:p})}},runOneModelCall=async e=>{let{instructions:i,telemetryRuntimeContext:o}=e.preparedInput??prepareModelCallInput(e.extraSystemNote),c=selectSandboxSurfaces(t),l=await buildToolSetWithProviderTools({approvedTools:A,capabilities:t.capabilities,disabledProviderTools:e.disabledProviderTools,modelReference:p.agent.modelReference,tools:t.tools});if(j!==void 0){let e=buildDynamicTools(j);for(let t of e)l[t.name]??={description:t.description,inputSchema:t.inputSchema,execute:t.execute,outputSchema:t.outputSchema}}p.outputSchema!==void 0&&(l[FINAL_OUTPUT_TOOL_NAME]=buildFinalOutputTool(p.outputSchema));let u=c.length>0?(await applySandboxToolSet({harnessTools:t.tools,lifecycle:n===void 0?void 0:createCodeModeLifecycle({emit:n,emissionState:g,tools:t.tools}),tools:l,surfaces:c})).modelTools:l,m=T?applyLastToolCacheBreakpoint(u,T):u,h=resolveGatewayPinForStep({cachePath:w,modelReference:p.agent.modelReference,tools:m}),_=buildStepHooks({cachePath:w,emit:n,emissionState:g,emitStepStarted:e.suppressStepStartedEmission!==!0,gatewayPinProvider:h,marker:T,session:p}),v=new ToolLoopAgent({headers:k,instructions:i,model:S,onToolExecutionEnd:logToolExecutionError,onError(e){logError(log,`tool-loop stream error`,e.error)},onStepFinish:_.onStepFinish,prepareStep:_.prepareStep,runtimeContext:o,stopWhen:isStepCount(1),telemetry:enrichTelemetry(a,s,o),tools:m});return runModelCallWithRetries(async()=>{if(n){let e=await v.stream({messages:F}),{inlineActionResultCallIds:r,inlineToolResultParts:i}=await emitStreamContent(n,g,e.fullStream),a=await _.stepResult;return await emitStepActions(n,g,a,{excludedActionToolNames:new Set([ASK_QUESTION_TOOL_NAME,CODE_MODE_TOOL_NAME,FINAL_OUTPUT_TOOL_NAME]),inlineActionResultCallIds:r,tools:t.tools}),i.length>0?{content:a.content,finishReason:a.finishReason,response:{...a.response,messages:[{role:`tool`,content:[...i]},...a.response.messages]},text:a.text,toolCalls:a.toolCalls,toolResults:a.toolResults,usage:a.usage}:a}return await v.generate({messages:F}),await _.stepResult},{sessionId:p.sessionId,turnId:g.turnId})},I=prepareModelCallInput();n&&await emitStepStarted(n,g,x);let L=await continuePendingCodeModeInterrupt({capabilities:t.capabilities,childResults:v.input?.runtimeActionResults,config:t,emit:n,emissionState:g,messages:x,runStep,session:p});if(L!==null)return L;let R;try{R=await runOneModelCall({preparedInput:I,suppressStepStartedEmission:!0})}catch(t){let r=await attemptUnsupportedProviderToolRecovery({error:t,runOneModelCall,sessionId:p.sessionId,turnId:g.turnId});if(r.outcome===`recovered`)R=r.result;else{let t=r.error;if(l&&recordErrorOnSpan(l,t),!n)throw t;let a=extractWorkflowStreamWriteErrorDetails(t);if(a!==null){let r=createErrorId();return log.error(`workflow stream write failed — parking session for retry by the user`,{...a,errorId:r,error:t,sessionId:p.sessionId,turnId:g.turnId}),g=await emitRecoverableFailedTurn(n,g,{code:`WORKFLOW_STREAM_WRITE_FAILED`,details:{...a,errorId:r},message:toErrorMessage(t)}),{next:null,session:setHarnessEmissionState(p,g)}}let o=classifyModelCallError(t),s=createErrorId(),c=o===`terminal`?summarizeKnownModelCallConfigError(t):null,d=c===null?summarizeKnownModelCallRequestError(t):null,f=c?.message??d?.message??toErrorMessage(t),m=extractModelCallErrorDetails(t),h=buildModelCallFailureDetails({configSummary:c,error:t,errorId:s,modelCallDetails:m,requestSummary:d}),_=buildModelCallFailureLogFields({error:t,errorId:s,modelCallDetails:m,requestSummary:d,sessionId:p.sessionId,turnId:g.turnId});return o===`terminal`?(c===null?log.error(d?.message??`model call failed terminally`,_):log.error(`${c.name}: ${c.message}`,{errorId:s,sessionId:p.sessionId,turnId:g.turnId}),await emitFailedStep(n,g,{code:`MODEL_CALL_FAILED`,details:h,message:f,sessionId:p.sessionId}),{next:{done:!0,output:``},session:p}):(log.error(d?.message??`model call failed — parking session for retry by the user`,_),g=await emitRecoverableFailedTurn(n,g,{code:`MODEL_CALL_FAILED`,details:h,message:f}),{next:null,session:setHarnessEmissionState(p,g)})}}let z=accumulateTurnUsage({previous:getTurnUsageState(p.state),turnId:g.turnId,usage:R.usage??{}});p=setTurnUsageState(p,z);let B;try{B=formatLanguageModelGatewayId(S)}catch{B=void 0}return await setEveAttributes({"$eve.model":B,"$eve.input_tokens":z.inputTokens,"$eve.output_tokens":z.outputTokens,"$eve.cache_read_tokens":z.cacheReadTokens,"$eve.tool_count":t.tools.size}),handleStepResult({config:t,emit:n,emissionState:g,promptMessages:x,result:R,runStep,session:p})}return runStep}function buildModelCallFailureDetails(e){let{configSummary:t,error:r,errorId:i,modelCallDetails:a,requestSummary:o}=e;return t===null?o===null?{...formatError(r,i),...a}:{errorId:i,message:toErrorMessage(r),name:o.name,...a}:{errorId:i,message:t.message,name:t.name,...a}}function buildModelCallFailureLogFields(e){let t={errorId:e.errorId,sessionId:e.sessionId,turnId:e.turnId};return e.requestSummary===null?{...t,error:e.error}:{...t,details:e.modelCallDetails}}async function attemptUnsupportedProviderToolRecovery(e){let t=extractUnsupportedProviderToolTypes(e.error);if(t.length===0)return{outcome:`failed`,error:e.error};let n=[];for(let e of t){let t=resolveFrameworkToolFromUpstreamType(e);t!==null&&!n.includes(t)&&n.push(t)}if(n.length===0)return{outcome:`failed`,error:e.error};log.warn(`disabling unsupported provider tool(s); retrying step once`,{disabled:n,sessionId:e.sessionId,turnId:e.turnId,upstreamTypes:t});try{return{outcome:`recovered`,result:await e.runOneModelCall({disabledProviderTools:new Set(n),extraSystemNote:buildDisabledToolNote(n),suppressStepStartedEmission:!0})}}catch(e){return{outcome:`failed`,error:e}}}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.`}async function handleStepResult(e){let{config:t,emit:n,promptMessages:r,result:i,runStep:o}=e,{emissionState:s,session:l}=e,u=i.response.messages,d=resolveAssistantStepText(u,i.text),f={...l,compaction:createNextCompactionConfig(l.compaction,r,i)};if(isSandboxEnabled(t)){let{getCodeModeInterrupt:e}=await loadCodeModeModule(),a=e(i);if(a!==void 0)return parkOnCodeModeInterrupt({baseSession:f,config:t,emit:n,emissionState:s,interrupt:a,promptMessages:r,responseMessages:u})}let p=extractToolApprovalInputRequests({content:i.content??[]}),m=new Set(p.map(e=>e.action.callId)),h=extractQuestionInputRequests({toolCalls:i.toolCalls,excludedCallIds:m}),_=[...p,...h],v=(i.toolCalls??[]).filter(e=>!isInvalidToolCall(e)).filter(e=>t.tools.get(e.toolName)?.runtimeAction!==void 0).map(e=>createRuntimeActionRequestFromToolCall({toolCall:e,tools:t.tools}));if(v.length>0)return{next:null,session:setHarnessEmissionState(setPendingRuntimeActionBatch({actions:v,event:{sequence:s.sequence,stepIndex:s.stepIndex,turnId:s.turnId},responseMessages:u,session:{...f,history:[...r]}}),s)};if(_.length>0){let e=setPendingInputBatch({requests:_,responseMessages:u,session:{...f,history:[...r]}});return n&&(await n(createInputRequestedEvent({requests:_,sequence:s.sequence,stepIndex:s.stepIndex,turnId:s.turnId})),t.mode===`conversation`&&(s=await emitTurnEpilogue(n,s,t.mode),e=setHarnessEmissionState(e,s))),{next:null,session:e}}let y=(i.toolResults??[]).find(e=>isAuthorizationSignal(e.output));if(y&&isAuthorizationSignal(y.output)){let{challenges:e}=readToolInterrupt(loadContext(),y.toolCallId)??y.output;if(n)for(let t of e)await n(createAuthorizationRequiredEvent({authorization:t.challenge,name:t.name,description:t.challenge.instructions??`Authorization required for ${t.name}`,webhookUrl:t.hookUrl,sequence:s.sequence,stepIndex:s.stepIndex,turnId:s.turnId}));return{next:null,session:setHarnessEmissionState({...f,history:[...r],state:setPendingAuthorization(f.state,{challenges:e})},s)}}let b=pruneToolResults(r),x=b!==r,C=f.compaction;x&&C.lastKnownInputTokens!==void 0&&(C={recentWindowSize:C.recentWindowSize,threshold:C.threshold});let E=[...b,...u],D={...f,compaction:C,history:E},O=!(D.outputSchema!==void 0&&extractFinalOutput(i)!==void 0)&&(u.at(-1)?.role===`tool`||hasDeferredStepInput(D));return!O&&D.outputSchema===void 0&&d===null&&log.warn(`model completed terminal step without visible assistant text`,{finishReason:i.finishReason,mode:t.mode,responseMessageCount:u.length,responseMessageRoles:u.map(e=>e.role),sequence:s.sequence,sessionId:l.sessionId,stepIndex:s.stepIndex,turnId:s.turnId}),O?(n&&(s=advanceStep(s),D=setHarnessEmissionState(D,s)),{next:o,session:D}):t.mode===`task`?finishTaskTurn({emissionState:s,emit:n,prunedHistory:b,result:i,schema:D.outputSchema,session:D,stepOutput:d}):finishConversationTurn({emissionState:s,emit:n,prunedHistory:b,result:i,schema:D.outputSchema,session:D})}const OUTPUT_SCHEMA_NOT_FULFILLED={code:`OUTPUT_SCHEMA_NOT_FULFILLED`,message:`The agent could not produce a result matching the requested schema.`};function extractFinalOutput(e){return(e.toolCalls??[]).find(e=>e.toolName===FINAL_OUTPUT_TOOL_NAME)?.input}function persistStructuredAssistantTurn(e,t,n){return{...e,history:[...t,{content:JSON.stringify(n),role:`assistant`}],outputSchema:void 0}}async function emitStructuredResult(e,t,n,r){return await e(createResultCompletedEvent({result:n,sequence:t.sequence,stepIndex:t.stepIndex,turnId:t.turnId})),emitTurnEpilogue(e,t,r)}async function finishTaskTurn(e){let{emit:t,prunedHistory:n,result:r,schema:i,stepOutput:a}=e,{emissionState:o,session:s}=e;if(i===void 0)return t&&(o=await emitTurnEpilogue(t,o,`task`),s=setHarnessEmissionState(s,o)),{next:{done:!0,output:a??``},session:s};let c=extractFinalOutput(r);return c===void 0?(t&&await emitFailedStep(t,o,{...OUTPUT_SCHEMA_NOT_FULFILLED,sessionId:s.sessionId}),{next:{done:!0,isError:!0,output:OUTPUT_SCHEMA_NOT_FULFILLED.message},session:s}):(s=persistStructuredAssistantTurn(s,n,c),t&&(o=await emitStructuredResult(t,o,c,`task`),s=setHarnessEmissionState(s,o)),{next:{done:!0,output:c},session:s})}async function finishConversationTurn(e){let{emit:t,prunedHistory:n,result:r,schema:i}=e,{emissionState:a,session:o}=e;if(i===void 0)return t&&(a=await emitTurnEpilogue(t,a,`conversation`),o=setHarnessEmissionState(o,a)),{next:null,session:o};let s=extractFinalOutput(r);return s===void 0?(t&&(a=await emitRecoverableFailedTurn(t,a,OUTPUT_SCHEMA_NOT_FULFILLED),o=setHarnessEmissionState(o,a)),{next:null,session:o}):(o=persistStructuredAssistantTurn(o,n,s),t&&(a=await emitStructuredResult(t,a,s,`conversation`),o=setHarnessEmissionState(o,a)),{next:null,session:o})}async function continuePendingCodeModeInterrupt(e){let t=getPendingCodeModeInterrupt(e.session.state);if(t===void 0)return null;let{continueCodeModeApproval:n,continueCodeModeInterrupt:i,getCodeModeApprovalResponse:a,isCodeModeApprovalInterrupt:o,replaceCodeModeInterruptResult:s,unwrapCodeModeResult:c}=await loadCodeModeModule(),l=t.interrupt,d=o(l)?a([...e.messages],l):void 0;if(o(l)&&d===void 0)return{next:null,session:e.session};let f=createEveCodeModeOptions({lifecycle:e.emit===void 0?void 0:createCodeModeLifecycle({emit:e.emit,emissionState:e.emissionState,skipReplayed:!0,tools:e.config.tools})}),p;try{let t=await buildSandboxHostTools({approvedTools:getApprovedTools(e.session),capabilities:e.capabilities,tools:e.config.tools});if(o(l)&&d!==void 0)p=await n({approvalResponse:d,interrupt:l,options:f,tools:t});else if(isCodeModeConnectionAuthInterrupt(l))p=await i({interrupt:l,resolution:{status:`authorized`},tools:t,options:f});else if(isCodeModeRuntimeActionInterrupt(l)){let n=e.childResults??[],r=l,a=0;for(;;){p=await i({interrupt:r,resolution:n[a]?.output,tools:t,options:f});let e=c(p);if(e.status!==`interrupted`||!isCodeModeRuntimeActionInterrupt(e.interrupt)||a+1>=n.length)break;a++,r=e.interrupt}}else throw Error(`Unsupported code-mode interrupt kind "${l.payload.kind}".`)}catch(e){logError(log,`code-mode interrupt continuation failed`,e),p={error:`code_mode_continuation_failed`,message:toErrorMessage(e),retryable:!1}}let m=c(p),h=m.status===`interrupted`?m.interrupt:m.output,g=[...e.session.history,...t.responseMessages],_=isCodeModeRuntimeActionInterrupt(l)?replaceCodeModeToolResult(g,l.outerToolCallId,h):s(g,l,h),x=clearPendingCodeModeInterrupt({...e.session,history:_});if(m.status===`interrupted`){let t=e.session.history.length,n=_.slice(0,t),r=_.slice(t);return x={...x,history:n},parkOnCodeModeInterrupt({baseSession:x,config:e.config,emit:e.emit,emissionState:e.emissionState,interrupt:m.interrupt,promptMessages:n,responseMessages:r})}return{next:e.runStep,session:x}}function replaceCodeModeToolResult(e,t,n){if(t===void 0)return[...e];let r=typeof n==`string`?{type:`text`,value:n}:{type:`json`,value:n};return e.map(e=>{if(e.role!==`tool`)return e;let n=e.content.map(e=>e.type!==`tool-result`||e.toolCallId!==t?e:{...e,output:r});return{...e,content:n}})}async function parkOnCodeModeInterrupt(e){let{isCodeModeApprovalInterrupt:t,toCodeModeApprovalMessages:n}=await loadCodeModeModule(),r=e.interrupt,i={...e.baseSession,history:[...e.promptMessages]};if(isCodeModeConnectionAuthInterrupt(r)){let t=[...r.payload.challenges??[]];if(e.emit)for(let n of t)await e.emit(createAuthorizationRequiredEvent({authorization:n.challenge,name:n.name,description:n.challenge.instructions??`Authorization required for ${n.name}`,webhookUrl:n.hookUrl,sequence:e.emissionState.sequence,stepIndex:e.emissionState.stepIndex,turnId:e.emissionState.turnId}));return{next:null,session:setPendingCodeModeInterrupt({interrupt:r,responseMessages:e.responseMessages,session:{...i,state:setPendingAuthorization(i.state,{challenges:t})}})}}if(t(r)){let t=n(r),a=extractToolApprovalInputRequests({content:extractAssistantContent(t)}),o=setPendingInputBatch({requests:a,responseMessages:t,session:setPendingCodeModeInterrupt({interrupt:r,responseMessages:e.responseMessages,session:i})});if(e.emit&&(await e.emit(createInputRequestedEvent({requests:a,sequence:e.emissionState.sequence,stepIndex:e.emissionState.stepIndex,turnId:e.emissionState.turnId})),e.config.mode===`conversation`)){let t=await emitTurnEpilogue(e.emit,e.emissionState,e.config.mode);o=setHarnessEmissionState(o,t)}return{next:null,session:o}}return{next:null,session:setHarnessEmissionState(setPendingCodeModeInterrupt({interrupt:r,responseMessages:e.responseMessages,session:i}),e.emissionState)}}function extractAssistantContent(e){let t=[];for(let n of e)n.role===`assistant`&&Array.isArray(n.content)&&t.push(...n.content);return t}function createNextCompactionConfig(e,t,n){let r={recentWindowSize:e.recentWindowSize,threshold:e.threshold};return n.usage?.inputTokens!==void 0&&(r.lastKnownInputTokens=n.usage.inputTokens,r.lastKnownPromptMessageCount=t.length),r}async function maybeCompact(e){let{emit:t,emissionState:n}=e,r=e.messages,i=e.session;if(!shouldCompact(r,i.compaction))return{messages:r,session:i};let a=await resolveCompactionModel({compactionModelReference:i.agent.compactionModelReference,model:e.model,modelReference:i.agent.modelReference,resolveModel:e.resolveModel});if(t&&await t(createCompactionRequestedEvent({modelId:formatLanguageModelGatewayId(a.model),sequence:n.sequence,sessionId:i.sessionId,turnId:n.turnId,usageInputTokens:getInputTokenCount(r,i.compaction)})),r=await compactMessages(r,a.model,i.compaction,a.providerOptions,e.telemetry,e.headers),e.onCompaction){let t=await e.onCompaction(i);i=t.session;for(let e of t.messages)r.push(e)}return t&&await t(createCompactionCompletedEvent({modelId:formatLanguageModelGatewayId(a.model),sequence:n.sequence,sessionId:i.sessionId,turnId:n.turnId})),{messages:r,session:i}}function resolveApprovalKeyFromTools(e){return t=>{let n=e.get(t.action.toolName);if(n?.approvalKey!==void 0)return n.approvalKey(t.action.input)}}async function runModelCallWithRetries(e,t){for(let n=1;;n++)try{return await e()}catch(e){if(n===3||classifyModelCallError(e)!==`retry`)throw e;let r=500*2**(n-1)+Math.floor(Math.random()*250);log.warn(`model call failed transiently — retrying`,{attempt:n,delayMs:r,sessionId:t.sessionId,turnId:t.turnId,error:e}),await new Promise(e=>setTimeout(e,r))}}export{createToolLoopHarness};

package/dist/src/harness/tool-result-pruning.d.ts

@@ -0,0 +1,8 @@
+import type { ModelMessage } from "ai";
+/**
+ * Reactively prunes old tool-result content from conversation history.
+ *
+ * Recent results inside {@link PRUNE_PROTECT_TOKENS} are preserved.
+ * Older results are replaced with {@link PRUNED_PLACEHOLDER}.
+ */
+export declare function pruneToolResults(messages: readonly ModelMessage[]): ModelMessage[];

package/dist/src/harness/tool-result-pruning.js

@@ -0,0 +1 @@
+import{estimateTokens}from"#harness/compaction.js";function pruneToolResults(e){let t=collectToolResultLocations(e);if(t.length===0)return e;let n=0,r=0,i=new Set;for(let e of t)n<4e4?n+=e.tokens:(i.add(e.key),r+=e.tokens);return r<2e4?e:e.map((e,t)=>{if(e.role!==`tool`||!Array.isArray(e.content))return e;let n=!1,r=e.content.map((e,r)=>{let a=`${t}:${r}`;return i.has(a)?(n=!0,{...e,output:createPrunedToolResultOutput(`[Tool result pruned to save context. Call the tool again if needed.]`)}):e});return n?{...e,content:r}:e})}function collectToolResultLocations(t){let n=[];for(let r=t.length-1;r>=0;r--){let i=t[r];if(!(i===void 0||i.role!==`tool`||!Array.isArray(i.content)))for(let t=i.content.length-1;t>=0;t--){let a=i.content[t];a?.type===`tool-result`&&n.push({key:`${r}:${t}`,tokens:estimateTokens(a)})}}return n}function createPrunedToolResultOutput(e){return{type:`text`,value:e}}export{pruneToolResults};

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

@@ -0,0 +1,69 @@
+import { type ToolSet } from "ai";
+import type { SessionCapabilities } from "#channel/types.js";
+import type { RuntimeModelReference } from "#runtime/agent/bootstrap.js";
+import type { HarnessToolDefinition } from "#harness/execute-tool.js";
+import type { HarnessToolMap } from "#harness/types.js";
+/**
+ * Builds an AI SDK `ToolSet` from unified harness tool definitions.
+ *
+ * Tools without `execute` are surfaced to the model as client-side tools
+ * (no server execution).
+ *
+ * The framework's `ask_question` tool is only exposed to the model when
+ * {@link SessionCapabilities.requestInput} is `true`. Sessions without
+ * the HITL capability (scheduled task roots and any subagent chain
+ * descending from one) never see the tool.
+ *
+ * Entries listed in `disabledProviderTools` are skipped entirely. Used
+ * by the harness recovery path when a gateway fallback provider has
+ * rejected a provider-specific tool — the tool is dropped for the
+ * retry call so the request can proceed without it.
+ */
+export declare function buildToolSet(input: {
+    readonly approvedTools?: ReadonlySet<string>;
+    readonly capabilities?: SessionCapabilities;
+    readonly disabledProviderTools?: ReadonlySet<string>;
+    readonly tools: HarnessToolMap;
+}): ToolSet;
+/**
+ * Wraps a tool's `execute` so a returned {@link AuthorizationSignal} keeps the
+ * signal shape every consumer expects (the park detector, code-mode's
+ * host-tool bridge), while the per-challenge `resume` value (e.g. a custom-PKCE
+ * verifier) is stripped from the copy the AI SDK records, so it never lands in
+ * the recorded tool output / OTel span. The full signal is stashed out-of-band
+ * ({@link stashToolInterrupt}) for the park detector to journal.
+ *
+ * Code-mode host executions consume the raw signal directly (see
+ * `harness/code-mode.ts`) and their output is not a model-facing tool result,
+ * so they pass through untouched. Returns `undefined` for client-side tools
+ * (no `execute`).
+ */
+export declare function wrapToolExecute(definition: HarnessToolDefinition): ((input: any, options: {
+    readonly toolCallId: string;
+}) => Promise<any>) | undefined;
+/**
+ * Builds the AI SDK ToolSet for one harness step.
+ *
+ * Most tools have local executors and are assembled by {@link buildToolSet}.
+ * Provider-managed tools (e.g. web_search) have no local `execute` — the
+ * execution layer intentionally omits it. This function detects the gap and
+ * injects the real AI SDK provider tool in their place.
+ * If the current model cannot supply that provider tool, the framework
+ * sentinel is removed instead of being exposed as an unexecutable tool.
+ *
+ * When a user overrides a provider-managed tool via `defineTool()`, their
+ * tool has a real executor and flows through the normal path — no
+ * replacement occurs.
+ *
+ * Tool names listed in `disabledProviderTools` are skipped entirely —
+ * both the framework definition and the injected provider tool are
+ * omitted from the returned set. Used by the harness recovery path when
+ * a gateway fallback provider has rejected a provider-specific tool.
+ */
+export declare function buildToolSetWithProviderTools(input: {
+    readonly approvedTools?: ReadonlySet<string>;
+    readonly capabilities?: SessionCapabilities;
+    readonly disabledProviderTools?: ReadonlySet<string>;
+    readonly modelReference: RuntimeModelReference;
+    readonly tools: HarnessToolMap;
+}): Promise<ToolSet>;

package/dist/src/harness/tools.js

@@ -0,0 +1 @@
+import{isObject}from"#shared/guards.js";import{tool}from"ai";import{loadContext}from"#context/container.js";import{isAuthorizationSignal,redactSignalResume}from"#harness/authorization.js";import{isCodeModeToolExecutionOptions}from"#runtime/framework-tools/code-mode-connection-auth.js";import{ASK_QUESTION_TOOL_NAME}from"#runtime/framework-tools/ask-question.js";import{WEB_SEARCH_TOOL_DEFINITION}from"#runtime/framework-tools/web-search.js";import{resolveWebSearchBackend,resolveWebSearchProviderTool}from"#harness/provider-tools.js";import{stashToolInterrupt}from"#harness/tool-interrupts.js";function buildToolSet(e){let n={},r=e.capabilities?.requestInput===!0,i=e.disabledProviderTools;for(let a of e.tools.values())a.name===ASK_QUESTION_TOOL_NAME&&!r||i?.has(a.name)||(n[a.name]=tool({description:a.description,execute:wrapToolExecute(a),inputSchema:a.inputSchema,needsApproval:buildNeedsApprovalFn(a,e),outputSchema:a.outputSchema,...a.toModelOutput===void 0?{}:{toModelOutput:({output:e})=>a.toModelOutput(e)}}));return n}function wrapToolExecute(e){let t=e.execute;if(t!==void 0)return async(e,o)=>{let s=await t(e);return!isAuthorizationSignal(s)||isCodeModeToolExecutionOptions(o)?s:(stashToolInterrupt(loadContext(),o.toolCallId,s),redactSignalResume(s))}}async function buildToolSetWithProviderTools(e){let t=e.disabledProviderTools,n={...buildToolSet({approvedTools:e.approvedTools,capabilities:e.capabilities,disabledProviderTools:t,tools:e.tools})};if(!t?.has(WEB_SEARCH_TOOL_DEFINITION.name)){let t=e.tools.get(WEB_SEARCH_TOOL_DEFINITION.name);if(t!==void 0&&t.execute===void 0){let t=resolveWebSearchBackend(e.modelReference);t===null?delete n[WEB_SEARCH_TOOL_DEFINITION.name]:n[WEB_SEARCH_TOOL_DEFINITION.name]=await resolveWebSearchProviderTool(t)}}return n}function buildNeedsApprovalFn(t,n){return async r=>{if(t.needsApproval===void 0)return!1;let i=isObject(r)?r:void 0;return t.needsApproval({approvedTools:n.approvedTools??new Set,toolInput:i,toolName:t.name})}}export{buildToolSet,buildToolSetWithProviderTools,wrapToolExecute};

package/dist/src/harness/turn-tag-state.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Per-turn rolling token-usage accumulator for `$eve.*` observability
+ * tags. Lives on `session.state` so the totals survive workflow step
+ * boundaries the way the rest of the harness state does.
+ *
+ * The harness runs each turn as a sequence of `"use step"` invocations
+ * (one per tool-loop iteration). Each step knows its own
+ * `result.usage`, but the dashboard cares about totals **per turn**.
+ * The workflow runtime's attribute store is "last write wins" per key,
+ * so the simplest cumulative pattern is: read the previous total from
+ * `session.state`, add the new step's usage, write the running total
+ * back. The most recent emit then carries the final per-turn total.
+ *
+ * `turnId` keys the state so a fresh turn starts at zero without
+ * relying on a separate "reset" code path — when the harness moves to
+ * a new turn, the stale totals are discarded automatically.
+ */
+import type { HarnessSession, SessionStateMap } from "#harness/types.js";
+/**
+ * Rolling token usage for the in-flight turn.
+ *
+ * `turnId` is the in-flight turn's stable id; when the harness step
+ * runs in a different turn (or with the empty-string between-turns
+ * sentinel), totals are reset.
+ */
+export interface TurnUsageState {
+    readonly cacheReadTokens: number;
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    readonly turnId: string;
+}
+/** Reads the stored per-turn token state, or `undefined` when absent. */
+export declare function getTurnUsageState(state: SessionStateMap | undefined): TurnUsageState | undefined;
+/** Writes per-turn token state onto a new copy of the session. */
+export declare function setTurnUsageState(session: HarnessSession, next: TurnUsageState): HarnessSession;
+/**
+ * Folds one step's `usage` into the running per-turn totals. When
+ * `turnId` differs from the stored state (e.g. a new turn just
+ * started), the previous totals are discarded — fresh turns start at
+ * zero without an explicit reset path.
+ */
+export declare function accumulateTurnUsage(input: {
+    readonly previous: TurnUsageState | undefined;
+    readonly turnId: string;
+    readonly usage: {
+        readonly cachedInputTokens?: number;
+        readonly inputTokens?: number;
+        readonly outputTokens?: number;
+    };
+}): TurnUsageState;

package/dist/src/harness/turn-tag-state.js

@@ -0,0 +1 @@
+const HARNESS_TURN_USAGE_STATE_KEY=`eve.harness.turnUsage`,ZERO_USAGE={cacheReadTokens:0,inputTokens:0,outputTokens:0};function getTurnUsageState(t){return t?.[HARNESS_TURN_USAGE_STATE_KEY]}function setTurnUsageState(t,n){return{...t,state:{...t.state,[HARNESS_TURN_USAGE_STATE_KEY]:n}}}function accumulateTurnUsage(e){let n=e.previous!==void 0&&e.previous.turnId===e.turnId?e.previous:{...ZERO_USAGE,turnId:e.turnId};return{turnId:e.turnId,cacheReadTokens:n.cacheReadTokens+(e.usage.cachedInputTokens??0),inputTokens:n.inputTokens+(e.usage.inputTokens??0),outputTokens:n.outputTokens+(e.usage.outputTokens??0)}}export{accumulateTurnUsage,getTurnUsageState,setTurnUsageState};

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

@@ -0,0 +1,229 @@
+import type { LanguageModel, ModelMessage, UserContent } from "ai";
+import type { SessionCapabilities } from "#channel/types.js";
+import type { HandleMessageStreamEvent, RuntimeIdentity } from "#protocol/message.js";
+import type { RunMode } from "#shared/run-mode.js";
+import type { RuntimeActionResult } from "#runtime/actions/types.js";
+import type { RuntimeModelReference } from "#runtime/agent/bootstrap.js";
+import type { InputResponse } from "#runtime/input/types.js";
+import type { SandboxState } from "#sandbox/state.js";
+import type { JsonObject } from "#shared/json.js";
+import type { InternalToolDefinition } from "#shared/tool-definition.js";
+import type { HarnessToolDefinition } from "#harness/execute-tool.js";
+/**
+ * Serializable tool definition stored on the session.
+ *
+ * Carries schema but no execute function so the session stays serializable
+ * across workflow step boundaries.
+ */
+export type SessionToolDefinition = Readonly<InternalToolDefinition>;
+/** Authored-key → opaque-value map stored on `session.state`. */
+export type SessionStateMap = Readonly<Record<string, unknown>>;
+/**
+ * Compaction configuration stored on the session.
+ */
+export interface CompactionConfig {
+    readonly lastKnownInputTokens?: number;
+    readonly lastKnownPromptMessageCount?: number;
+    readonly recentWindowSize: number;
+    readonly threshold: number;
+}
+/**
+ * Serializable agent configuration stored on the session.
+ */
+export interface SessionAgent {
+    /**
+     * Optional model used only for compaction summaries.
+     *
+     * When omitted, the harness uses the active turn model for compaction.
+     */
+    readonly compactionModelReference?: RuntimeModelReference;
+    readonly modelReference: RuntimeModelReference;
+    readonly system: string;
+    readonly tools: readonly SessionToolDefinition[];
+}
+/**
+ * Serializable session state passed between harness and runtime.
+ *
+ * Only contains plain data -- no resolved model instances or tool execute
+ * functions. The harness resolves those at step time via injected config.
+ */
+export interface HarnessSession {
+    readonly agent: SessionAgent;
+    readonly compaction: CompactionConfig;
+    readonly continuationToken: string;
+    readonly history: ModelMessage[];
+    readonly outputSchema?: JsonObject;
+    /**
+     * Stable identifier of the top user-facing session in the dispatch
+     * chain. For a top-level session this field is `undefined` and
+     * `sessionId` itself is the root. For any delegated subagent session,
+     * `rootSessionId` carries the original root sessionId so descendant
+     * dispatch sites (and observability tags) can attribute work back to
+     * the user-facing session without walking the chain.
+     */
+    readonly rootSessionId?: string;
+    readonly sessionId: string;
+    readonly sandboxState?: SandboxState;
+    readonly state?: SessionStateMap;
+}
+/**
+ * Result returned by the compaction callback.
+ *
+ * `session` carries any state resets (e.g. clearing active skills).
+ * `messages` carries context to append to the compacted history
+ * (e.g. the current todo list as a user message).
+ */
+export interface CompactionCallbackResult {
+    readonly messages: readonly ModelMessage[];
+    readonly session: HarnessSession;
+}
+/**
+ * Input payload for a harness turn.
+ *
+ * Carries an optional message and/or structured input responses from the
+ * channel emitter's `onDeliver`. The message may be a plain text string or
+ * a structured AI SDK {@link UserContent} array (mixing `text`, `image`,
+ * and `file` parts) to support multimodal attachments delivered by
+ * channels. The harness resolves any pending input batch at the start of
+ * `runStep` before the model call.
+ */
+export interface StepInput {
+    readonly inputResponses?: readonly InputResponse[];
+    readonly message?: string | UserContent;
+    /**
+     * Context strings from the channel delivery. Each entry is appended
+     * as a `role: "user"` message to `session.history` before the
+     * delivery message. Populated by channels via `SendPayload.context`.
+     */
+    readonly context?: readonly string[];
+    /**
+     * Run-scoped schema that replaces the session's current output schema when
+     * present. Omitted continuations keep the existing schema.
+     */
+    readonly outputSchema?: JsonObject;
+    /**
+     * Runtime-owned action results being resumed into the current turn.
+     *
+     * This field is internal to the execution/harness boundary and is never
+     * produced by channels.
+     */
+    readonly runtimeActionResults?: readonly RuntimeActionResult[];
+}
+/**
+ * Terminal result indicating the conversation is finished.
+ */
+export interface StepDone {
+    readonly done: true;
+    readonly output: unknown;
+    /**
+     * Marks a terminal turn that failed (e.g. a task-mode turn that could not
+     * fulfil its output schema). For a delegated subagent this routes the result
+     * to the parent as an error tool-result rather than an empty success.
+     */
+    readonly isError?: boolean;
+}
+/**
+ * The harness's instruction to the runtime about what to do next.
+ *
+ * - A `StepFn` reference means "call this step immediately" (tool loop continuation).
+ * - `null` means "park and wait for the next user message."
+ * - `StepDone` means "the conversation is finished."
+ */
+export type StepNext = StepDone | StepFn | null;
+/**
+ * Result returned by one harness step invocation.
+ */
+export interface StepResult {
+    readonly next: StepNext;
+    readonly session: HarnessSession;
+}
+/**
+ * A single step of AI work. Takes the current session and optional user input,
+ * returns the updated session and an instruction for the runtime.
+ */
+export type StepFn = (session: HarnessSession, input?: StepInput) => Promise<StepResult>;
+/**
+ * Map from tool name to its harness-owned definition.
+ *
+ * The harness uses these definitions for schema extraction, tool execution
+ * (via {@link buildToolSet}), approval gates, and compaction hooks.
+ */
+export type HarnessToolMap = ReadonlyMap<string, HarnessToolDefinition>;
+/**
+ * Callback that writes one event to the event stream.
+ *
+ * Composed by the runtime from the underlying writable and the channel's
+ * event handler, then injected into the harness so it can emit lifecycle
+ * events without knowing about writables or handlers.
+ */
+export type HarnessEmitFn = (event: HandleMessageStreamEvent, messages?: readonly import("ai").ModelMessage[]) => Promise<void>;
+/**
+ * Unified event handler: emits the event to the stream, then
+ * dispatches to hook subscribers and dynamic tool resolvers.
+ *
+ * Same signature as {@link HarnessEmitFn} but semantically broader —
+ * every event goes through channel adapter, stream write, hooks,
+ * and dynamic tool dispatch in one call.
+ */
+export type HandleEventFn = (event: HandleMessageStreamEvent, messages?: readonly import("ai").ModelMessage[]) => Promise<void>;
+/**
+ * Dependencies injected into the tool-loop harness at construction time.
+ */
+export interface ToolLoopHarnessConfig {
+    /**
+     * Session-level capabilities. The harness reads
+     * {@link SessionCapabilities.requestInput} when assembling the
+     * per-step toolset to decide whether `ask_question` is available.
+     */
+    readonly capabilities?: SessionCapabilities;
+    /**
+     * Routes executable tools through the sandboxed code-execution wrapper
+     * instead of exposing them directly to the model. Resolved by the
+     * runtime from the agent's `experimental.codeMode` flag (with the
+     * `EVE_EXPERIMENTAL_CODE_MODE` env backstop). Defaults to `false`.
+     */
+    readonly codeMode?: boolean;
+    /**
+     * Exposes the `Workflow` orchestration tool — a code-mode-style sandbox
+     * whose only callable operations are this agent's subagents and remote
+     * agents. Resolved by the runtime from the agent's `workflowEnabled` flag
+     * (set when `agent/tools/workflow.ts` re-exports the `Workflow` marker).
+     * Independent of {@link ToolLoopHarnessConfig.codeMode} — both may be on at
+     * once. Defaults to `false`.
+     */
+    readonly workflow?: boolean;
+    readonly handleEvent?: HandleEventFn;
+    /**
+     * Execution mode for the current harness.
+     *
+     * Conversation mode parks after a final assistant reply so the runtime can
+     * await the next user message. Task mode must return `{ done: true, output }`
+     * for terminal assistant text inside the current invocation.
+     */
+    readonly mode: RunMode;
+    /**
+     * Called after compaction to let the execution layer run session
+     * lifecycle hooks (e.g. tool compaction hooks). The harness applies
+     * the returned session and appends the returned messages to the
+     * compacted history.
+     */
+    readonly onCompaction?: (session: HarnessSession) => CompactionCallbackResult | Promise<CompactionCallbackResult>;
+    readonly resolveModel: (reference: RuntimeModelReference) => Promise<LanguageModel>;
+    /**
+     * Runtime identity metadata attached to the `session.started` event.
+     *
+     * When provided, the harness includes this in the first `session.started`
+     * event so remote consumers (eval runners, reporters) receive
+     * authoritative server-side metadata.
+     */
+    readonly runtimeIdentity?: RuntimeIdentity;
+    /**
+     * Unified tool definitions for this harness step.
+     *
+     * Each entry carries schema, execution, and approval gates. The
+     * harness derives AI SDK tool definitions, runs
+     * {@link buildToolSet}, and checks approval gates from these
+     * definitions directly.
+     */
+    readonly tools: HarnessToolMap;
+}

package/dist/src/harness/types.js

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

package/dist/src/harness/workflow-stream-error.d.ts

@@ -0,0 +1,29 @@
+import type { JsonObject } from "#shared/json.js";
+/**
+ * Parses a durable event-stream write failure raised by the workflow
+ * runtime's stream transport into structured diagnostics, or returns
+ * `null` when `error` is not such a failure.
+ *
+ * The harness emits every runtime event by writing to the workflow's
+ * durable `getWritable()` stream, and those writes are flushed to the
+ * workflow server over HTTP. Because the stream is consumed inside the
+ * harness's model-call try/catch, a failed flush (timeout, 5xx) would
+ * otherwise be misattributed to the model. This lets the harness label
+ * it as the workflow-infrastructure failure it is and attach the
+ * failing endpoint + platform error code as evidence.
+ *
+ * The returned object carries `operation` (`"write"`/`"close"`) and,
+ * when present in the message, `statusCode`, `url` (the `PUT` target),
+ * `vercelId` (`x-vercel-id`), and `vercelError` (`x-vercel-error`, e.g.
+ * `"FUNCTION_INVOCATION_TIMEOUT"`).
+ *
+ * Walks the cause chain so a wrapped transport error is still detected.
+ */
+export declare function extractWorkflowStreamWriteErrorDetails(error: unknown): JsonObject | null;
+/**
+ * Returns `true` when `error` is a durable event-stream write failure
+ * raised by the workflow runtime's stream transport, not by the model
+ * provider. Thin predicate over
+ * {@link extractWorkflowStreamWriteErrorDetails}.
+ */
+export declare function isWorkflowStreamWriteError(error: unknown): boolean;

package/dist/src/harness/workflow-stream-error.js

@@ -0,0 +1 @@
+import{isObject}from"#shared/guards.js";const WORKFLOW_STREAM_WRITE_ERROR_PATTERN=/^Stream (write|close) failed: HTTP (\d+)(?: \(([^)]*)\))?/;function extractWorkflowStreamWriteErrorDetails(e){for(let t of causeChainMessages(e)){let e=parseStreamErrorMessage(t);if(e!==null)return e}return null}function isWorkflowStreamWriteError(e){return extractWorkflowStreamWriteErrorDetails(e)!==null}function parseStreamErrorMessage(e){let n=WORKFLOW_STREAM_WRITE_ERROR_PATTERN.exec(e);if(n===null)return null;let r=Number(n[2]),i={operation:n[1]??``};Number.isFinite(r)&&(i.statusCode=r);for(let e of(n[3]??``).split(`; `))e.startsWith(`PUT `)?i.url=e.slice(4):e.startsWith(`x-vercel-id=`)?i.vercelId=e.slice(12):e.startsWith(`x-vercel-error=`)&&(i.vercelError=e.slice(15));return i}function*causeChainMessages(t){let n=new Set,r=t;for(;r!=null&&!n.has(r);){if(n.add(r),r instanceof Error){yield r.message,r=r.cause;continue}if(isObject(r)&&typeof r.message==`string`){yield r.message,r=r.cause;continue}return}}export{extractWorkflowStreamWriteErrorDetails,isWorkflowStreamWriteError};

package/dist/src/harness/workflow-tool-description.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Builds the model-facing description for the `Workflow` orchestration tool.
+ *
+ * Dynamic in the agent's callable agents:
+ * - lists every callable agent by name (the built-in `agent` plus one per
+ *   declared subagent and remote agent);
+ * - the worked example uses only the built-in `agent`, so it is valid for any
+ *   agent;
+ * - a single simple subagent example is appended *only when* the agent has a
+ *   declared subagent or remote agent (i.e. an agent other than `agent`).
+ *
+ * The exact input signatures auto-generated by `createCodeModeTool` are appended
+ * after this framing.
+ *
+ * @param toolNames - Names of the agent functions callable inside the sandbox.
+ */
+export declare function workflowToolDescription(toolNames: readonly string[]): string;

package/dist/src/harness/workflow-tool-description.js

@@ -0,0 +1,23 @@
+function workflowToolDescription(e){let t=e.length>0?e:[`agent`],n=t.map(e=>`\`${e}\``).join(`, `),r=t.filter(e=>e!==`agent`);return`Orchestrate this agent's subagents by writing a JavaScript program the runtime executes deterministically — fan out independent subtasks, run staged pipelines, and combine results in code, in a single step.
+
+The only callable operations are these agents — no filesystem, network, shell, or other tools: ${n}. Call each as \`await tools.<name>(input)\`; it resolves to the child's result, or a typed object when you pass an \`outputSchema\`. Sequence with \`await\`, run agents concurrently with \`Promise.all([...])\`, and use \`map\`/\`filter\`/\`flatMap\` to build calls and combine results. The program's return value becomes the tool result.
+
+Reach for this when work decomposes into independent or staged subtasks — map-reduce over a list, a plan-then-verify pipeline, or fan-out-and-gather. For a single delegation, call the agent directly.
+
+Example — fan out across areas with \`agent\`, then pipe the results into a synthesis step:
+\`\`\`js
+const areas = ["correctness", "security", "performance"];
+const reviews = await Promise.all(
+  areas.map((area) =>
+    tools.agent({
+      message: \`Review the change for \${area}.\`,
+      outputSchema: { type: "object", properties: { findings: { type: "array", items: { type: "string" } } } },
+    }),
+  ),
+);
+const verdict = await tools.agent({
+  message: \`Summarize these findings into a verdict: \${JSON.stringify(reviews)}\`,
+  outputSchema: { type: "object", properties: { verdict: { type: "string" }, blocking: { type: "boolean" } } },
+});
+return verdict;
+\`\`\`${r.length>0?`\n\nDeclared subagents are called the same way — e.g. \`const note = await tools.${r[0]}({ message: "..." });\`.`:``}`}export{workflowToolDescription};

package/dist/src/index.d.ts

@@ -0,0 +1 @@
+export * from "#public/index.js";

package/dist/src/index.js

@@ -0,0 +1 @@
+export*from"#public/index.js";export{};

package/dist/src/internal/application/cache-metadata.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Clears one Eve-owned cache directory when its recorded Eve version is missing
+ * or differs from the currently installed package version.
+ */
+export declare function prepareEveVersionedCacheDirectory(directoryPath: string): Promise<void>;
+/**
+ * Writes the current installed Eve version into one Eve-owned cache directory.
+ */
+export declare function writeEveVersionedCacheMetadata(directoryPath: string): Promise<void>;

package/dist/src/internal/application/cache-metadata.js

@@ -0,0 +1 @@
+import{join}from"node:path";import{mkdir,readFile,rm,writeFile}from"node:fs/promises";import{resolveInstalledPackageInfo}from"#internal/application/package.js";const EVE_CACHE_METADATA_FILE=`eve-cache.json`;async function prepareEveVersionedCacheDirectory(e){let t=await readEveCacheVersion(e),n=resolveInstalledPackageInfo().version;t!==null&&t===n||await rm(e,{force:!0,recursive:!0})}async function writeEveVersionedCacheMetadata(n){await mkdir(n,{recursive:!0}),await writeFile(join(n,EVE_CACHE_METADATA_FILE),`${JSON.stringify({eveVersion:resolveInstalledPackageInfo().version},null,2)}\n`)}async function readEveCacheVersion(t){try{let r=JSON.parse(await readFile(join(t,EVE_CACHE_METADATA_FILE),`utf8`));return typeof r.eveVersion==`string`?r.eveVersion:null}catch(e){return e instanceof Error&&`code`in e&&e.code,null}}export{prepareEveVersionedCacheDirectory,writeEveVersionedCacheMetadata};

package/dist/src/internal/application/compiled-artifacts.d.ts

@@ -0,0 +1,33 @@
+import type { CompileAgentResult } from "#compiler/compile-agent.js";
+/**
+ * Paths to the generated compiled-artifacts files shared by Nitro and the
+ * vendored workflow bundles for one application.
+ */
+export interface GeneratedCompiledArtifactsFiles {
+    /**
+     * Shared bundled-artifacts bootstrap installed by Nitro and vendored
+     * workflow handlers.
+     */
+    bootstrapPath: string;
+    /**
+     * Optional Nitro plugin that imports the authored instrumentation module
+     * from the application when present.
+     */
+    instrumentationPluginPath?: string;
+    /**
+     * Absolute path to the authored instrumentation module when present.
+     * Nitro uses this to preserve the module's side effects during bundling.
+     */
+    instrumentationSourcePath?: string;
+}
+/**
+ * Writes the generated compiled-artifacts bootstrap module.
+ *
+ * The bootstrap self-installs bundled artifacts on import and exports a
+ * default function so it can be used directly as a Nitro plugin — no
+ * separate plugin wrapper file is needed.
+ */
+export declare function writeCompiledArtifactsFiles(input: {
+    compileResult: CompileAgentResult;
+    outDir: string;
+}): Promise<GeneratedCompiledArtifactsFiles>;

package/dist/src/internal/application/compiled-artifacts.js

@@ -0,0 +1,4 @@
+import{join}from"node:path";import{mkdir,writeFile}from"node:fs/promises";import{existsSync}from"node:fs";import{resolvePackageSourceFilePath}from"#internal/application/package.js";import{createCompiledModuleMapSource}from"#compiler/module-map.js";import{stringifyEsmImportSpecifier}from"#internal/application/import-specifier.js";async function writeCompiledArtifactsFiles(r){let a=join(r.outDir,`compiled-artifacts-bootstrap.mjs`),o=join(r.outDir,`compiled-artifacts-instrumentation.mjs`),s=resolveInstrumentationModule(r.compileResult.manifest.agentRoot);await mkdir(r.outDir,{recursive:!0}),await writeFile(a,await createCompiledArtifactsBootstrapSource({compileResult:r.compileResult,installModulePath:resolvePackageSourceFilePath(`src/runtime/loaders/bundled-artifacts.ts`),moduleMapPath:a,metadata:r.compileResult.metadata})),s!==void 0&&await writeFile(o,createInstrumentationPluginSource({agentName:r.compileResult.manifest.config.name,instrumentationPath:s,registerConfigPath:resolvePackageSourceFilePath(`src/harness/instrumentation-config.ts`)}));let c={bootstrapPath:a};return s!==void 0&&(c.instrumentationPluginPath=o,c.instrumentationSourcePath=s),c}const INSTRUMENTATION_EXTENSIONS=[`.ts`,`.mts`,`.js`,`.mjs`];function resolveInstrumentationModule(t){for(let n of INSTRUMENTATION_EXTENSIONS){let i=join(t,`instrumentation${n}`);if(existsSync(i))return i}}function stripCompiledModuleMapExports(e){return e.replace(/^export const moduleMap = /m,`const moduleMap = `).replace(/\nexport default moduleMap;\n?$/,`
+`)}async function createCompiledArtifactsBootstrapSource(e){let t=stripCompiledModuleMapExports(createCompiledModuleMapSource({importSpecifierStyle:`absolute`,manifest:e.compileResult.manifest,moduleMapPath:e.moduleMapPath})).trim();return[`// Generated by Eve. Do not edit by hand.`,`import { installBundledCompiledArtifacts } from ${stringifyEsmImportSpecifier(e.installModulePath)};`,``,t,``,`const metadata = ${JSON.stringify(e.metadata,null,2)};`,``,`const manifest = ${JSON.stringify(e.compileResult.manifest,null,2)};`,``,`export function installCompiledArtifactsBootstrap() {`,`  installBundledCompiledArtifacts({`,`    manifest,`,`    metadata,`,`    moduleMap,`,`  });`,`}`,``,`installCompiledArtifactsBootstrap();`,``,`// Default export satisfies the Nitro plugin contract so this file`,`// can be used directly as a Nitro plugin without a separate wrapper.`,`export default function installCompiledArtifactsPlugin() {`,`  // Already installed on import above.`,`}`,``,`export async function __eveInstallCompiledArtifactsStep() {`,`  "use step";`,`  return null;`,`}`,``].join(`
+`)}function createInstrumentationPluginSource(e){return[`// Generated by Eve. Do not edit by hand.`,`import * as instrumentationModule from ${stringifyEsmImportSpecifier(e.instrumentationPath)};`,`import { registerInstrumentationConfig } from ${stringifyEsmImportSpecifier(e.registerConfigPath)};`,``,`if (instrumentationModule.default != null) {`,`  registerInstrumentationConfig(instrumentationModule.default, { agentName: ${JSON.stringify(e.agentName)} });`,`}`,``,`// Default export satisfies the Nitro plugin contract so this file`,`// can be used directly as a Nitro plugin without a separate wrapper.`,`export default function installInstrumentationPlugin() {}`,``].join(`
+`)}export{writeCompiledArtifactsFiles};

package/dist/src/internal/application/import-specifier.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Converts filesystem paths into ESM-safe import specifiers.
+ *
+ * Node's ESM loader rejects raw Windows absolute paths such as
+ * `G:\app\handler.js` because the drive letter is parsed as a URL scheme.
+ * Generated source should import filesystem targets through `file://` URLs
+ * while leaving virtual, package, and relative specifiers usable by bundlers.
+ */
+export declare function normalizeEsmImportSpecifier(specifier: string): string;
+/**
+ * Serializes an import specifier for direct insertion into generated ESM code.
+ */
+export declare function stringifyEsmImportSpecifier(specifier: string): string;
+/**
+ * Rewrites generated ESM source containing raw Windows absolute imports.
+ */
+export declare function normalizeGeneratedEsmImportSpecifiers(source: string): string;

package/dist/src/internal/application/import-specifier.js

@@ -0,0 +1 @@
+const WINDOWS_DRIVE_ABSOLUTE_PATH_PATTERN=/^\/?[A-Za-z]:[\\/]/,WINDOWS_UNC_ABSOLUTE_PATH_PATTERN=/^\\\\[^\\]/,IMPORT_SPECIFIER_PATTERN=/(\b(?:from|import)\s*(?:\(\s*)?)(["'])([A-Za-z]:[\\/][^"'\n\r]*)\2/g;function isWindowsAbsolutePath(n){return WINDOWS_DRIVE_ABSOLUTE_PATH_PATTERN.test(n)||WINDOWS_UNC_ABSOLUTE_PATH_PATTERN.test(n)}function convertWindowsPathToFileUrl(e){let t=e.replaceAll(`\\`,`/`);return t.startsWith(`//`)?new URL(`file:${t}`).href:(/^\/[A-Za-z]:\//.test(t)&&(t=t.slice(1)),new URL(`file:///${t}`).href)}function splitPathSpecifierSuffix(e){let t=e.indexOf(`?`),n=e.indexOf(`#`),r=t===-1?n:n===-1?t:Math.min(t,n);return r===-1?{path:e,suffix:``}:{path:e.slice(0,r),suffix:e.slice(r)}}function normalizeEsmImportSpecifier(e){if(e.startsWith(`file://`))return e;let{path:t,suffix:n}=splitPathSpecifierSuffix(e);return isWindowsAbsolutePath(t)?`${convertWindowsPathToFileUrl(t)}${n}`:e.replaceAll(`\\`,`/`)}function stringifyEsmImportSpecifier(e){return JSON.stringify(normalizeEsmImportSpecifier(e))}function normalizeGeneratedEsmImportSpecifiers(e){return e.replace(IMPORT_SPECIFIER_PATTERN,(e,t,n,r)=>`${t}${n}${normalizeEsmImportSpecifier(r)}${n}`)}export{normalizeEsmImportSpecifier,normalizeGeneratedEsmImportSpecifiers,stringifyEsmImportSpecifier};