eve 0.5.4 → 0.6.0-beta.3

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

@@ -0,0 +1,116 @@
+/**
+ * Authorization request/result API for tool execution.
+ *
+ * Public API:
+ * - {@link requestAuthorization} — return from execute to suspend for auth
+ * - {@link getAuthorizationResult} — read the callback on resume
+ * - {@link getHookUrl} — build a callback URL for external systems
+ * - {@link isAuthorizationSignal} — type guard
+ *
+ * ## Resume lifecycle
+ *
+ * `resume` is how an interactive strategy carries data from
+ * `startAuthorization` to `completeAuthorization` across the park:
+ *
+ * 1. `startAuthorization` returns `{ challenge, resume? }`. The runtime
+ *    stores `resume` on the {@link AuthorizationChallenge} and journals it
+ *    onto `session.state` via {@link setPendingAuthorization} when the turn
+ *    parks — so it survives the suspend/resume across a `"use step"`
+ *    boundary.
+ * 2. The IdP redirect hits the framework callback route, which parses it
+ *    (see `projectAuthorizationCallback` — params only, no headers) and
+ *    resumes the workflow.
+ * 3. On resume the journaled `resume` is paired with the parsed callback
+ *    into an {@link AuthorizationResult} and handed back to
+ *    `completeAuthorization({ resume, callback })`.
+ *
+ * `resume` is serialized across workflow steps to survive the park.
+ * Provider-owned strategies (Vercel Connect) omit it so nothing crosses
+ * the boundary; a custom PKCE strategy uses it to carry the verifier (or a
+ * nonce that re-derives it) from start to finish.
+ */
+import { ContextKey } from "#context/key.js";
+import type { ConnectionAuthorizationChallenge } from "#public/connections/errors.js";
+import type { AuthorizationCallback } from "#runtime/connections/types.js";
+import type { JsonValue } from "#public/types/json.js";
+declare const AUTHORIZATION_BRAND: "__eveAuthorization";
+export interface AuthorizationChallenge {
+    readonly name: string;
+    readonly challenge: ConnectionAuthorizationChallenge;
+    readonly hookUrl: string;
+    /**
+     * Opaque resume value from the strategy's `startAuthorization`,
+     * journaled across the park. Absent for provider-owned flows.
+     */
+    readonly resume?: JsonValue;
+}
+export interface AuthorizationSignal {
+    readonly [AUTHORIZATION_BRAND]: true;
+    readonly challenges: readonly AuthorizationChallenge[];
+}
+export interface AuthorizationResult {
+    readonly resume?: JsonValue;
+    readonly callback: AuthorizationCallback;
+    readonly hookUrl: string;
+}
+/**
+ * Creates an authorization signal. Return this from a tool's execute
+ * to suspend the session for OAuth or other external authorization.
+ *
+ * The harness emits `authorization.required` events for each challenge
+ * and parks the session. Channels render sign-in buttons.
+ */
+export declare function requestAuthorization(challenges: readonly AuthorizationChallenge[]): AuthorizationSignal;
+/**
+ * Returns a copy of `signal` with each challenge's `resume` value stripped.
+ *
+ * Used for the copy the AI SDK records as a tool output. The shape stays a
+ * valid {@link AuthorizationSignal} so every `isAuthorizationSignal` consumer
+ * still detects it; the park detector reads the full challenges from the
+ * harness's out-of-band stash.
+ */
+export declare function redactSignalResume(signal: AuthorizationSignal): AuthorizationSignal;
+/**
+ * Reads the authorization callback on resume. Returns `undefined` if
+ * not resuming from an authorization request.
+ *
+ * When `name` is omitted, returns the first result (convenience for
+ * single-challenge tools).
+ */
+export declare function getAuthorizationResult(name?: string): AuthorizationResult | undefined;
+/**
+ * Builds a callback URL for external systems. `name` identifies the
+ * callback in the URL path (e.g. a connection name or custom label).
+ *
+ * The URL embeds a per-authorization hook token derived from the
+ * session ID and name (`${sessionId}:auth:${name}`). This token is
+ * independent of the continuation token, so channel re-keying
+ * mid-turn does not invalidate the callback URL.
+ *
+ * Returns `undefined` if the session context isn't available.
+ */
+export declare function getHookUrl(name: string): string | undefined;
+export declare function isAuthorizationSignal(value: unknown): value is AuthorizationSignal;
+/**
+ * Deterministic hook token for all authorization callbacks in a
+ * session. Both {@link getHookUrl} (inside tool execution) and the
+ * workflow body (which creates the hook upfront) use this token.
+ */
+export declare function authHookToken(sessionId: string): string;
+interface NamedAuthorizationResult extends AuthorizationResult {
+    readonly name: string;
+}
+export declare const PendingAuthorizationResultKey: ContextKey<readonly NamedAuthorizationResult[]>;
+/**
+ * Deployment base URL for building callback URLs. Set by the
+ * framework (turnStep) at the start of each step from workflow
+ * metadata.
+ */
+export declare const CallbackBaseUrlKey: ContextKey<string>;
+export interface PendingAuthorizationState {
+    readonly challenges: readonly AuthorizationChallenge[];
+}
+export declare function setPendingAuthorization(sessionState: Record<string, unknown> | undefined, value: PendingAuthorizationState): Record<string, unknown>;
+export declare function getPendingAuthorization(sessionState: Record<string, unknown> | undefined): PendingAuthorizationState | undefined;
+export declare function hasPendingAuthorization(sessionState: Record<string, unknown> | undefined): boolean;
+export {};

package/dist/src/harness/authorization.js

@@ -0,0 +1 @@
+import{createEveConnectionCallbackRoutePath}from"#protocol/routes.js";import{SessionIdKey}from"#context/keys.js";import{loadContext}from"#context/container.js";import{ContextKey}from"#context/key.js";const AUTHORIZATION_BRAND=`__eveAuthorization`;function requestAuthorization(e){return{[AUTHORIZATION_BRAND]:!0,challenges:e}}function redactSignalResume(e){return requestAuthorization(e.challenges.map(e=>({name:e.name,challenge:e.challenge,hookUrl:e.hookUrl})))}function getAuthorizationResult(e){let t=loadContext().get(PendingAuthorizationResultKey);if(!(!t||t.length===0))return e===void 0?t[0]:t.find(t=>t.name===e)}function getHookUrl(n){let r=loadContext(),i=r.get(SessionIdKey),a=r.get(CallbackBaseUrlKey);return!i||!a?void 0:`${a}${createEveConnectionCallbackRoutePath(n,authHookToken(i))}`}function isAuthorizationSignal(e){return typeof e!=`object`||!e?!1:e[AUTHORIZATION_BRAND]===!0}function authHookToken(e){return`${e}:auth`}const PendingAuthorizationResultKey=new ContextKey(`eve.pendingAuthorizationResult`),CallbackBaseUrlKey=new ContextKey(`eve.callbackBaseUrl`),PENDING_AUTHORIZATION_KEY=`eve.runtime.pendingAuthorization`;function setPendingAuthorization(e,t){return{...e,[PENDING_AUTHORIZATION_KEY]:t}}function getPendingAuthorization(e){if(!e)return;let t=e[PENDING_AUTHORIZATION_KEY];if(!(typeof t!=`object`||!t))return t}function hasPendingAuthorization(e){return getPendingAuthorization(e)!==void 0}export{CallbackBaseUrlKey,PendingAuthorizationResultKey,authHookToken,getAuthorizationResult,getHookUrl,getPendingAuthorization,hasPendingAuthorization,isAuthorizationSignal,redactSignalResume,requestAuthorization,setPendingAuthorization};

package/dist/src/harness/code-mode-interrupt-state.d.ts

@@ -0,0 +1,26 @@
+import type { ModelMessage } from "ai";
+import type { HarnessSession, SessionStateMap } from "#harness/types.js";
+import type { CodeModeInterrupt } from "#shared/code-mode.js";
+/**
+ * One code-mode invocation parked on a host interrupt (nested-tool approval,
+ * connection auth, or any future durable interrupt kind), plus the assistant
+ * response messages that produced the outer `code_mode` tool result.
+ *
+ * Every interrupt kind rides this single pending slot; the kind-specific
+ * behavior lives in {@link parkOnCodeModeInterrupt} /
+ * {@link continuePendingCodeModeInterrupt}, keyed by `interrupt.payload.kind`.
+ */
+export interface PendingCodeModeInterrupt {
+    readonly interrupt: CodeModeInterrupt;
+    readonly responseMessages: readonly ModelMessage[];
+}
+/** Returns the pending code-mode interrupt stored on the session, if any. */
+export declare function getPendingCodeModeInterrupt(state: SessionStateMap | undefined): PendingCodeModeInterrupt | undefined;
+/** Stores one pending code-mode interrupt on the session. */
+export declare function setPendingCodeModeInterrupt(input: {
+    readonly interrupt: CodeModeInterrupt;
+    readonly responseMessages: readonly ModelMessage[];
+    readonly session: HarnessSession;
+}): HarnessSession;
+/** Clears any pending code-mode interrupt from the session. */
+export declare function clearPendingCodeModeInterrupt(session: HarnessSession): HarnessSession;

package/dist/src/harness/code-mode-interrupt-state.js

@@ -0,0 +1 @@
+const PENDING_KEY=`eve.harness.pendingCodeModeInterrupt`;function getPendingCodeModeInterrupt(t){let n=t?.[PENDING_KEY];if(isRecord(n)&&!(!isCodeModeInterruptShape(n.interrupt)||!Array.isArray(n.responseMessages)))return{interrupt:n.interrupt,responseMessages:n.responseMessages}}function setPendingCodeModeInterrupt(t){return{...t.session,state:{...t.session.state,[PENDING_KEY]:{interrupt:t.interrupt,responseMessages:t.responseMessages}}}}function clearPendingCodeModeInterrupt(t){if(t.state?.[PENDING_KEY]===void 0)return t;let n={...t.state};return delete n[PENDING_KEY],{...t,state:Object.keys(n).length>0?n:void 0}}function isCodeModeInterruptShape(e){return isRecord(e)&&e.type===`code-mode-interrupt`&&typeof e.interruptId==`string`&&typeof e.outerToolCallId==`string`&&isRecord(e.payload)&&typeof e.payload.kind==`string`&&isRecord(e.continuation)&&typeof e.continuation.outerToolCallId==`string`}function isRecord(e){return typeof e==`object`&&!!e&&!Array.isArray(e)}export{clearPendingCodeModeInterrupt,getPendingCodeModeInterrupt,setPendingCodeModeInterrupt};

package/dist/src/harness/code-mode-lifecycle.d.ts

@@ -0,0 +1,16 @@
+import { type HandleMessageStreamEvent } from "#protocol/message.js";
+import type { HarnessEmissionState } from "#harness/emission.js";
+import type { HarnessToolMap } from "#harness/types.js";
+import type { CodeModeOptions } from "#shared/code-mode.js";
+type EmitCodeModeLifecycleEvent = (event: HandleMessageStreamEvent) => Promise<void>;
+/**
+ * Builds code-mode lifecycle hooks that project nested host tool calls onto
+ * Eve's existing action event stream.
+ */
+export declare function createCodeModeLifecycle(input: {
+    readonly emit: EmitCodeModeLifecycleEvent;
+    readonly emissionState: HarnessEmissionState;
+    readonly skipReplayed?: boolean;
+    readonly tools: HarnessToolMap;
+}): NonNullable<CodeModeOptions["lifecycle"]>;
+export {};

package/dist/src/harness/code-mode-lifecycle.js

@@ -0,0 +1 @@
+import{createLogger}from"#internal/logging.js";import{createActionResultEvent,createActionsRequestedEvent}from"#protocol/message.js";import{toErrorMessage}from"#shared/errors.js";import{createRuntimeActionRequestFromToolCall}from"#harness/runtime-actions.js";import{createRuntimeToolResultFromValue}from"#harness/action-result-helpers.js";const log=createLogger(`harness.code-mode-lifecycle`);function createCodeModeLifecycle(e){return{onHookError(e,t){log.warn(`code-mode lifecycle hook failed`,{error:e,hook:t.hook})},async onNestedToolCall(t){if(e.skipReplayed===!0&&t.replayed)return;let r={input:t.input,toolCallId:t.toolCallId,toolName:t.toolName,type:`tool-call`};await e.emit(createActionsRequestedEvent({actions:[createRuntimeActionRequestFromToolCall({toolCall:r,tools:e.tools})],sequence:e.emissionState.sequence,stepIndex:e.emissionState.stepIndex,turnId:e.emissionState.turnId}))},async onNestedToolResult(n){if(e.skipReplayed===!0&&n.replayed||n.status===`interrupted`)return;let i=createRuntimeToolResultFromValue({callId:n.toolCallId,output:n.status===`rejected`?toErrorMessage(n.error):n.output,toolName:n.toolName,isError:n.status===`rejected`});await e.emit(createActionResultEvent({result:i,sequence:e.emissionState.sequence,stepIndex:e.emissionState.stepIndex,turnId:e.emissionState.turnId}))}}}export{createCodeModeLifecycle};

package/dist/src/harness/code-mode-runtime-action-state.d.ts

@@ -0,0 +1,6 @@
+import type { RuntimeActionRequest } from "#runtime/actions/types.js";
+import type { CodeModeInterrupt } from "#shared/code-mode.js";
+export declare const CODE_MODE_RUNTIME_ACTION_INTERRUPT_KIND = "eve.runtime-action";
+export declare function isCodeModeRuntimeActionInterrupt(interrupt: unknown): boolean;
+export declare function buildRuntimeActionFromInterrupt(interrupt: CodeModeInterrupt): RuntimeActionRequest;
+export declare function getRuntimeActionKeyFromInterrupt(interrupt: CodeModeInterrupt): string;

package/dist/src/harness/code-mode-runtime-action-state.js

@@ -0,0 +1 @@
+import{getRuntimeActionRequestKey}from"#runtime/actions/keys.js";const CODE_MODE_RUNTIME_ACTION_INTERRUPT_KIND=`eve.runtime-action`;function isCodeModeRuntimeActionInterrupt(e){return isRecord(e)&&isRecord(e.payload)&&e.payload.kind===`eve.runtime-action`}function buildRuntimeActionFromInterrupt(e){let t=e.payload,n=t.runtimeAction,r=t.toolInput,i=t.toolName,a=sanitizeCallId(`${i}_${`interruptId`in e?String(e.interruptId):``}`);return n.kind===`remote-agent-call`?{callId:a,description:``,input:r,kind:`remote-agent-call`,name:i,nodeId:n.nodeId,remoteAgentName:n.remoteAgentName??i}:{callId:a,description:``,input:r,kind:`subagent-call`,name:i,nodeId:n.nodeId,subagentName:n.subagentName}}function getRuntimeActionKeyFromInterrupt(t){return getRuntimeActionRequestKey(buildRuntimeActionFromInterrupt(t))}function sanitizeCallId(e){return e.replace(/[^a-zA-Z0-9_-]/g,`_`)}function isRecord(e){return typeof e==`object`&&!!e&&!Array.isArray(e)}export{CODE_MODE_RUNTIME_ACTION_INTERRUPT_KIND,buildRuntimeActionFromInterrupt,getRuntimeActionKeyFromInterrupt,isCodeModeRuntimeActionInterrupt};

package/dist/src/harness/code-mode.d.ts

@@ -0,0 +1,26 @@
+import { type ToolSet } from "ai";
+import type { SessionCapabilities } from "#channel/types.js";
+import type { HarnessToolMap } from "#harness/types.js";
+import { type CodeModeOptions } from "#shared/code-mode.js";
+import { type SandboxSurface } from "#harness/sandbox-surface.js";
+interface SandboxPartitionInput {
+    readonly lifecycle?: CodeModeOptions["lifecycle"];
+    readonly tools: ToolSet;
+    readonly harnessTools: HarnessToolMap;
+    /** Sandbox surfaces to emit, in claim-priority order (first claim wins). */
+    readonly surfaces: readonly SandboxSurface[];
+}
+interface SandboxPartition {
+    readonly hostTools: ToolSet;
+    readonly modelTools: ToolSet;
+}
+export declare function createEveCodeModeOptions(input?: {
+    readonly lifecycle?: CodeModeOptions["lifecycle"];
+}): CodeModeOptions;
+export declare function applySandboxToolSet(input: SandboxPartitionInput): Promise<SandboxPartition>;
+export declare function buildSandboxHostTools(input: {
+    readonly approvedTools?: ReadonlySet<string>;
+    readonly capabilities?: SessionCapabilities;
+    readonly tools: HarnessToolMap;
+}): Promise<ToolSet>;
+export {};

package/dist/src/harness/code-mode.js

@@ -0,0 +1 @@
+import"ai";import{contextStorage}from"#context/container.js";import{CODE_MODE_RUNTIME_ACTION_INTERRUPT_KIND}from"#harness/code-mode-runtime-action-state.js";import{loadCodeModeModule}from"#shared/code-mode.js";import{isAuthorizationSignal}from"#harness/authorization.js";import{buildDynamicTools}from"#context/build-dynamic-tools.js";import{CODE_MODE_CONNECTION_AUTH_INTERRUPT_KIND,markCodeModeToolExecutionOptions,toCodeModeConnectionAuthArgs}from"#runtime/framework-tools/code-mode-connection-auth.js";import{ALL_SANDBOX_SURFACES}from"#harness/sandbox-surface.js";import{LOAD_SKILL_TOOL_NAME}from"#runtime/skills/fragment-context.js";import{buildToolSet}from"#harness/tools.js";const NEVER_SANDBOXED_TOOL_NAMES=new Set([LOAD_SKILL_TOOL_NAME]);function createEveCodeModeOptions(e={}){let t={approval:{mode:`interrupt`}};return e.lifecycle!==void 0&&(t.lifecycle=e.lifecycle),t}async function applySandboxToolSet(e){let t={},n=new Map(e.surfaces.map(e=>[e,{}]));for(let[r,i]of Object.entries(e.tools)){if(NEVER_SANDBOXED_TOOL_NAMES.has(r)){t[r]=i;continue}let a=e.harnessTools.get(r),o=a?.runtimeAction!==void 0;o&&(t[r]=i);let s=e.surfaces.filter(e=>e.claims(a,i));if(s.length===0){o||(t[r]=i);continue}let c=o&&a!==void 0?createRuntimeActionHostTool(a):wrapHostToolForCodeMode(i);for(let e of s)n.get(e)[r]=c}let r={};for(let i of e.surfaces){let a=n.get(i);Object.keys(a).length!==0&&(Object.assign(r,a),t[i.toolName]=await createSandboxTool(i,a,e.lifecycle))}return{hostTools:r,modelTools:t}}async function createSandboxTool(e,t,r){let{createCodeModeTool:i}=await loadCodeModeModule(),a=i(t,createEveCodeModeOptions({lifecycle:r}));if(e.describe===void 0)return a;let o=typeof a.description==`string`?a.description:``;return{...a,description:e.describe({generated:o,toolNames:Object.keys(t)})}}async function buildSandboxHostTools(t){let n=buildToolSet({approvedTools:t.approvedTools,capabilities:t.capabilities,tools:t.tools}),r=contextStorage.getStore();if(r!==void 0){let e=buildDynamicTools(r);for(let t of e)n[t.name]??={description:t.description,inputSchema:t.inputSchema,execute:t.execute,outputSchema:t.outputSchema}}return(await applySandboxToolSet({harnessTools:t.tools,tools:n,surfaces:ALL_SANDBOX_SURFACES})).hostTools}function createRuntimeActionHostTool(e){return{description:e.description,inputSchema:e.inputSchema,execute:async(r,i)=>{let a=i?.codeModeInterrupt;if(a?.resolution!==void 0)return a.resolution;let{requestCodeModeInterrupt:o}=await loadCodeModeModule();return o({kind:CODE_MODE_RUNTIME_ACTION_INTERRUPT_KIND,runtimeAction:e.runtimeAction,toolInput:r,toolName:e.name})}}}function wrapHostToolForCodeMode(e){let t=e.execute;if(t===void 0)return e;let invoke=async(e,i)=>{let c=await resolveExecuteOutput(t(e,markCodeModeToolExecutionOptions(i)));if(isAuthorizationSignal(c)){let{requestCodeModeInterrupt:t}=await loadCodeModeModule(),r=c.challenges[0]?.name;r&&t({args:toCodeModeConnectionAuthArgs(e),challenges:c.challenges,connectionName:r,kind:CODE_MODE_CONNECTION_AUTH_INTERRUPT_KIND,toolName:``})}return c};return{...e,execute:(e,t)=>invoke(e,t)}}async function resolveExecuteOutput(e){if(isAsyncIterable(e)){let t;for await(let n of e)t=n;return t}return await e}function isAsyncIterable(e){return typeof e==`object`&&!!e&&Symbol.asyncIterator in e&&typeof e[Symbol.asyncIterator]==`function`}export{applySandboxToolSet,buildSandboxHostTools,createEveCodeModeOptions};

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

@@ -0,0 +1,43 @@
+import { generateText, type LanguageModel, type ModelMessage, type TelemetryOptions } from "ai";
+import type { RuntimeModelReference } from "#runtime/agent/bootstrap.js";
+import type { CompactionConfig, ToolLoopHarnessConfig } from "#harness/types.js";
+/**
+ * Rough token estimate: serialized JSON length / 4. Good enough for
+ * deciding whether compaction is needed; the real token count comes back
+ * from the model each step via {@link CompactionConfig.lastKnownInputTokens}.
+ *
+ * Accepts any JSON-serializable value so the reactive pruning system can
+ * apply the same heuristic to individual tool-result parts — keeping
+ * every layer of context management on one consistent token ruler.
+ */
+export declare function estimateTokens(value: unknown): number;
+/**
+ * Best available input-token count: the model-reported count from the last
+ * step, plus a rough character-based estimate of whatever messages have been
+ * appended since.
+ */
+export declare function getInputTokenCount(messages: readonly ModelMessage[], config: CompactionConfig): number;
+/**
+ * Returns true when the message history exceeds the compaction threshold.
+ */
+export declare function shouldCompact(messages: readonly ModelMessage[], config: CompactionConfig): boolean;
+/**
+ * Resolves the model used to summarize older context during compaction.
+ *
+ * Reuses the active turn model when compaction should summarize with the same
+ * reference, and resolves the authored compaction model only when configured.
+ */
+export declare function resolveCompactionModel(input: {
+    readonly compactionModelReference?: RuntimeModelReference;
+    readonly model: LanguageModel;
+    readonly modelReference: RuntimeModelReference;
+    readonly resolveModel: ToolLoopHarnessConfig["resolveModel"];
+}): Promise<{
+    readonly model: LanguageModel;
+    readonly providerOptions: Parameters<typeof generateText>[0]["providerOptions"];
+}>;
+/**
+ * Compacts messages by summarizing older history and keeping only the most
+ * recent messages.
+ */
+export declare function compactMessages(messages: ModelMessage[], model: LanguageModel, config: CompactionConfig, providerOptions?: Parameters<typeof generateText>[0]["providerOptions"], telemetry?: TelemetryOptions, headers?: Record<string, string>): Promise<ModelMessage[]>;

package/dist/src/harness/compaction.js

@@ -0,0 +1,4 @@
+import{generateText}from"ai";const COMPACTION_SYSTEM_PROMPT=[`You are a conversation summarizer.`,`Write a concise but useful summary for continuing the work.`,`Preserve the goal, important instructions, technical decisions, discoveries, open work, and relevant tool results.`,`Use the same language as the conversation.`,`Prefer short labeled sections such as Goal, Instructions, Discoveries, Accomplished, and Next steps when helpful.`,`Do not answer questions or invent facts.`].join(` `);function estimateTokens(e){return JSON.stringify(e).length/4}function getInputTokenCount(e,t){let n=t.lastKnownInputTokens,r=t.lastKnownPromptMessageCount;return n===void 0||r===void 0||!Number.isInteger(r)||r<0||r>e.length?estimateTokens(e):n+estimateTokens(e.slice(r))}function shouldCompact(e,t){return getInputTokenCount(e,t)>t.threshold}async function resolveCompactionModel(e){let t=e.compactionModelReference??e.modelReference;return{model:t===e.modelReference?e.model:await e.resolveModel(t),providerOptions:t.providerOptions}}async function compactMessages(n,r,i,a,o,s){let c=selectRecentWindowSize(n,i);for(;;){let{older:l,recent:u}=splitMessagesForCompaction(n,c);if(l.length===0)return u;let d=await generateText({headers:s,model:r,prompt:formatCompactionPrompt(l.map(e=>({content:summarizeCompactionMessageContent(e),role:e.role}))),providerOptions:a,system:COMPACTION_SYSTEM_PROMPT,telemetry:o?{...o,functionId:`eve.compaction`}:void 0,temperature:0}),f=u.length>0&&u.at(-1)?.role===`assistant`?[{role:`user`,content:`Continue.`}]:[],p=[{content:`Summary of our conversation so far:`,role:`user`},{content:d.text,role:`assistant`},...u,...f];if(estimateTokens(p)<=i.threshold||c===0)return p;--c}}function selectRecentWindowSize(e,t){let n=Math.min(t.recentWindowSize,Math.max(e.length-1,0)),r=resolveCompactionSummaryReserve(t),i=0,a=0;for(let o=e.length-1;o>=0&&i<n;--o){let n=e[o];if(n===void 0)continue;let s=estimateTokens([n]);if(a+s+r>t.threshold)break;a+=s,i+=1}return i}function resolveCompactionSummaryReserve(e){return Math.min(2048,Math.max(64,Math.floor(e.threshold/4)))}function splitMessagesForCompaction(e,t){return t<=0?{older:[...e],recent:[]}:{older:e.slice(0,-t),recent:e.slice(-t)}}function formatCompactionPrompt(e){let t=e.filter(e=>e.content.trim().length>0).map(e=>`### ${e.role}\n${e.content.trim()}`);return t.length===0?`Summarize the conversation so far.`:[`Conversation transcript:`,...t].join(`
+
+`)}function summarizeCompactionMessageContent(e){return typeof e.content==`string`?summarizeText(e.content):e.content.map(e=>summarizeCompactionContentPart(e)).filter(e=>e.length>0).join(`
+`).trim()}function summarizeCompactionContentPart(e){switch(e.type){case`text`:return summarizeText(e.text);case`reasoning`:return``;case`file`:return e.filename?`Attached file ${e.filename} (${e.mediaType})`:`Attached file attachment (${e.mediaType})`;case`tool-call`:return summarizeToolCallPart(e);case`tool-result`:return summarizeToolResultPart(e);default:return``}}function summarizeToolCallPart(e){let t=e.input===void 0?``:summarizeCompactValue(e.input);return t?`Called ${e.toolName} with ${t}`:`Called ${e.toolName}`}function summarizeToolResultPart(e){let t=e.output===void 0?``:summarizeCompactValue(e.output),n=e.isError?`errored`:`returned`;return t?`Tool ${e.toolName} ${n} ${t}`:`Tool ${e.toolName} ${n}`}function summarizeCompactValue(e,t=0){if(e===null)return`null`;if(e===void 0)return``;if(typeof e==`string`)return summarizeText(e);if(typeof e==`number`||typeof e==`boolean`||typeof e==`bigint`)return String(e);if(Array.isArray(e)){if(e.length===0)return`array(0)`;if(t>=2)return`array(${e.length})`;let n=e.slice(0,3).map(e=>summarizeCompactValue(e,t+1)),r=e.length>3?`, …`:``;return`array(${e.length}: ${n.join(`, `)}${r})`}if(typeof e==`object`){let n=Object.entries(e);if(n.length===0)return`object(0)`;if(t>=2)return`object(${n.length} keys)`;let r=n.slice(0,3).map(([e,n])=>`${e}=${summarizeCompactValue(n,t+1)}`),i=n.length>3?`, …`:``;return`object(${r.join(`, `)}${i})`}return``}function summarizeText(e){let t=e.replace(/\s+/g,` `).trim();return t.length<=280?t:`${t.slice(0,280).trimEnd()}…`}export{compactMessages,estimateTokens,getInputTokenCount,resolveCompactionModel,shouldCompact};

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

@@ -0,0 +1,124 @@
+import type { ModelMessage, TextStreamPart, ToolSet } from "ai";
+type ToolResponsePart = Extract<ModelMessage, {
+    role: "tool";
+}>["content"][number];
+type InlineToolResultPart = Extract<ToolResponsePart, {
+    type: "tool-result";
+}>;
+import type { AssistantStepFinishReason, RuntimeIdentity } from "#protocol/message.js";
+import type { RunMode } from "#shared/run-mode.js";
+import type { JsonObject } from "#shared/json.js";
+import type { HarnessEmitFn, HarnessSession, SessionStateMap, StepInput } from "#harness/types.js";
+/**
+ * Tracks emission lifecycle state across harness step invocations.
+ *
+ * Persisted on `session.state` so the state survives when the durable
+ * workflow runtime recreates the harness at each `"use step"` boundary.
+ */
+export interface HarnessEmissionState {
+    readonly sessionStarted: boolean;
+    readonly sequence: number;
+    readonly stepIndex: number;
+    readonly turnId: string;
+}
+/** Reads the emission state, returning defaults when absent. */
+export declare function getHarnessEmissionState(state: SessionStateMap | undefined): HarnessEmissionState;
+/**
+ * Returns `true` when the harness is **between turns** — either no turn
+ * has started yet (initial state) or the previous turn has emitted its
+ * epilogue (or recoverable failure cascade) and reset.
+ *
+ * Returns `false` while a turn is in progress, including during
+ * tool-loop continuations and runtime-action resumes within the same
+ * turn. Callers that gate per-turn work (eg. lifecycle hook dispatch)
+ * use this predicate to distinguish a fresh delivery from a
+ * continuation of an in-flight turn.
+ *
+ * Implemented over the empty-`turnId` sentinel that `emitTurnEpilogue`
+ * and `emitRecoverableFailedTurn` write — clients should never read
+ * `state.turnId` directly to make this distinction.
+ */
+export declare function isHarnessBetweenTurns(session: HarnessSession): boolean;
+/**
+ * Writes the emission state onto a new copy of the session.
+ */
+export declare function setHarnessEmissionState(session: HarnessSession, state: HarnessEmissionState): HarnessSession;
+/**
+ * Emits `session.started` (once), `turn.started`, and `message.received` at the
+ * beginning of a new turn. Returns updated emission state.
+ */
+export declare function emitTurnPreamble(emitFn: HarnessEmitFn, input: StepInput, state: HarnessEmissionState, runtimeIdentity?: RuntimeIdentity): Promise<HarnessEmissionState>;
+/**
+ * Emits `step.started` for one model call.
+ */
+export declare function emitStepStarted(emitFn: HarnessEmitFn, state: HarnessEmissionState, messages?: readonly import("ai").ModelMessage[]): Promise<void>;
+interface FailedStepPayload {
+    readonly code: string;
+    readonly details?: JsonObject;
+    readonly message: string;
+}
+/**
+ * Emits the full terminal failure cascade: `step.failed` →
+ * `turn.failed` → `session.failed`.
+ *
+ * Use this when the session cannot be salvaged (structural config
+ * error, auth misconfig, non-recoverable provider response). The
+ * `session.failed` tail tells adapters the session is dead and no
+ * further follow-up is possible on the same continuation token.
+ */
+export declare function emitFailedStep(emitFn: HarnessEmitFn, state: HarnessEmissionState, input: FailedStepPayload & {
+    readonly sessionId: string;
+}): Promise<void>;
+/**
+ * Emits the recoverable failure cascade: `step.failed` →
+ * `turn.failed` → `session.waiting`.
+ */
+export declare function emitRecoverableFailedTurn(emitFn: HarnessEmitFn, state: HarnessEmissionState, input: FailedStepPayload): Promise<HarnessEmissionState>;
+/**
+ * Returns updated emission state for the next step in the current turn.
+ */
+export declare function advanceStep(state: HarnessEmissionState): HarnessEmissionState;
+/**
+ * Emits `turn.completed` and either `session.waiting` or `session.completed`.
+ * Returns updated emission state with an incremented sequence.
+ */
+export declare function emitTurnEpilogue(emitFn: HarnessEmitFn, state: HarnessEmissionState, mode: RunMode): Promise<HarnessEmissionState>;
+/**
+ * Maps an AI SDK finish reason string to the Eve-owned
+ * {@link AssistantStepFinishReason} union. Unknown values become `"other"`.
+ */
+export declare function normalizeAssistantStepFinishReason(value: string | undefined): AssistantStepFinishReason;
+/**
+ * Result of consuming one step's `fullStream`.
+ *
+ * `inlineActionResultCallIds` lists tool-result call ids the stream
+ * already emitted as `action.result` events. `emitStepActions` skips
+ * these to avoid double-emission.
+ *
+ * `inlineToolResultParts` holds the same tool-results in
+ * `ToolResultPart` shape. The AI SDK omits them from
+ * `stepResult.response.messages` on the approval-resume path, so the
+ * harness splices them into persisted history to keep the prior turn's
+ * `tool_use` block balanced with a matching `tool_result` on replay.
+ */
+interface EmittedStreamContent {
+    readonly inlineActionResultCallIds: ReadonlySet<string>;
+    readonly inlineToolResultParts: readonly InlineToolResultPart[];
+}
+/**
+ * Consumes the AI SDK `fullStream` and emits real-time text and reasoning
+ * events.
+ *
+ * `tool-result` parts that have no preceding `tool-call` in this stream
+ * are emitted inline as `action.result` events. This is the
+ * approval-resume path: when a previously-parked tool call is approved,
+ * the AI SDK enqueues the executed tool-result onto the same step's
+ * stream before the next LLM call. Emitting `action.result` inline keeps
+ * it ahead of the message events that depend on it.
+ *
+ * Tool-call, tool-approval-request, and non-resumed tool-result events
+ * are still emitted by `emitStepActions` from the `onStepFinish`
+ * callback so the existing single-step batch ordering is preserved.
+ */
+export declare function emitStreamContent(emitFn: HarnessEmitFn, state: HarnessEmissionState, fullStream: AsyncIterable<TextStreamPart<ToolSet>>): Promise<EmittedStreamContent>;
+export {};

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