eve 0.5.4 → 0.6.0-beta.1

package/dist/src/execution/workflow-steps.d.ts

@@ -0,0 +1,103 @@
+import type { DeliverPayload, SessionAuthContext, SubagentInputRequestHookPayload } from "#channel/types.js";
+import { deserializeContext } from "#context/serialize.js";
+import type { HarnessSession, StepInput } from "#harness/types.js";
+import type { JsonObject } from "#shared/json.js";
+import type { RunMode } from "#shared/run-mode.js";
+import { type DurableSessionState } from "#execution/durable-session-store.js";
+import { type TurnStepInput, type TurnWorkflowDispatchInput } from "#execution/durable-session-migrations/turn-workflow.js";
+/**
+ * Result of one durable harness step, consumed by the turn workflow.
+ *
+ * `park` carries `hasPendingInputBatch`, `hasPendingAuthorization`, and
+ * `pendingRuntimeActionKeys` so the turn workflow can pick the right
+ * {@link import("#execution/next-driver-action.js").NextDriverAction}
+ * arm without re-reading the session.
+ */
+export type DurableStepResult = {
+    readonly action: "continue" | "done";
+    readonly output?: unknown;
+    readonly isError?: boolean;
+    readonly serializedContext: Record<string, unknown>;
+    readonly sessionState: DurableSessionState;
+} | {
+    readonly action: "park";
+    readonly authorizationNames?: readonly string[];
+    readonly hasPendingAuthorization: boolean;
+    readonly hasPendingInputBatch: boolean;
+    readonly pendingRuntimeActionKeys?: readonly string[];
+    readonly serializedContext: Record<string, unknown>;
+    readonly sessionState: DurableSessionState;
+} | {
+    readonly action: "dispatch-code-mode-runtime-actions";
+    readonly pendingRuntimeActionKeys: readonly string[];
+    readonly serializedContext: Record<string, unknown>;
+    readonly sessionState: DurableSessionState;
+};
+export type { TurnStepInput };
+/**
+ * Runs one atomic harness step inside a durable `"use step"` boundary.
+ */
+export declare function turnStep(rawInput: TurnStepInput): Promise<DurableStepResult>;
+/**
+ * Re-stamps `session.continuationToken` from `ContinuationTokenKey`
+ * after channels call `setContinuationToken(...)`. Idempotent when the
+ * token is unchanged.
+ */
+export declare function reconcileSessionContinuationToken(ctx: Awaited<ReturnType<typeof deserializeContext>>, session: HarnessSession): HarnessSession;
+/**
+ * Resolves the single output schema in effect for this turn, decoupling schema
+ * enforcement from {@link RunMode}: downstream the harness reads
+ * `session.outputSchema` unconditionally and never re-derives it from mode.
+ *
+ * A run-scoped (client-supplied) schema on the turn's {@link StepInput} always
+ * wins. With no run-scoped schema, a task run adopts the agent's declared
+ * return schema — its function-output contract, which only applies when the
+ * agent is invoked as a function (subagent / schedule / job), i.e. task mode.
+ * A conversation run with no run-scoped schema enforces nothing. Continuation
+ * steps (no new `StepInput`) preserve whatever is already in effect.
+ */
+export declare function resolveEffectiveOutputSchema(input: {
+    readonly agentOutputSchema: JsonObject | undefined;
+    readonly input: StepInput | undefined;
+    readonly mode: RunMode;
+    readonly session: HarnessSession;
+}): HarnessSession;
+/** Emits a terminal `session.failed` to the adapter and durable stream. */
+export declare function emitTerminalSessionFailureStep(input: {
+    readonly error: unknown;
+    readonly parentWritable: WritableStream<Uint8Array>;
+    readonly serializedContext: Record<string, unknown>;
+}): Promise<void>;
+export interface ProxyInputRequestResult {
+    readonly serializedContext: Record<string, unknown>;
+    readonly sessionState: DurableSessionState;
+}
+/**
+ * Emits a proxied `input.requested` event through the parent's adapter
+ * and records the routing entries on the parent session.
+ */
+export declare function runProxyInputRequestStep(input: {
+    readonly hookPayload: SubagentInputRequestHookPayload;
+    readonly parentWritable: WritableStream<Uint8Array>;
+    readonly serializedContext: Record<string, unknown>;
+    readonly sessionState: DurableSessionState;
+}): Promise<ProxyInputRequestResult>;
+export interface RoutedDeliverResult {
+    /** `undefined` when the entire payload was routed to descendants. */
+    readonly remainder: DeliverPayload | undefined;
+}
+/**
+ * Splits an inbound deliver payload into parent-local and
+ * proxied-child buckets and forwards the child buckets via
+ * `resumeHook`. Read-only: never appends a snapshot.
+ */
+export declare function routeProxiedDeliverStep(input: {
+    readonly auth?: SessionAuthContext | null;
+    readonly parentWritable: WritableStream<Uint8Array>;
+    readonly payload: DeliverPayload;
+    readonly sessionState: DurableSessionState;
+}): Promise<RoutedDeliverResult>;
+/** Starts a per-turn child workflow for the current driver session. */
+export declare function dispatchTurnStep(input: TurnWorkflowDispatchInput): Promise<{
+    readonly runId: string;
+}>;

package/dist/src/execution/workflow-steps.js

@@ -0,0 +1 @@
+import{createLogger,formatError}from"#internal/logging.js";import{callAdapterEventHandler,defaultDeliverResult}from"#channel/adapter.js";import{AuthKey,CapabilitiesKey,ContinuationTokenKey,ModeKey}from"#context/keys.js";import{createAuthorizationCompletedEvent,createSessionFailedEvent,encodeMessageStreamEvent,timestampHandleMessageStreamEvent}from"#protocol/message.js";import{BundleKey,ChannelKey}from"#runtime/sessions/runtime-context-keys.js";import{createDurableSessionState,readDurableSession}from"#execution/durable-session-store.js";import{hydrateDurableSession,refreshSessionFromTurnAgent}from"#execution/session.js";import{buildTurnAttributes,readRootSessionId}from"#execution/eve-workflow-attributes.js";import{setEveAttributes}from"#runtime/attributes/emit.js";import{deserializeContext,serializeContext}from"#context/serialize.js";import{getRuntimeActionKeyFromInterrupt,isCodeModeRuntimeActionInterrupt}from"#harness/code-mode-runtime-action-state.js";import{getPendingCodeModeInterrupt}from"#harness/code-mode-interrupt-state.js";import{getPendingRuntimeActionBatch}from"#harness/runtime-actions.js";import{buildAdapterContext}from"#channel/adapter-context.js";import{createWorkflowRuntime,startWorkflowPreferLatest}from"#execution/workflow-runtime.js";import{getHarnessEmissionState}from"#harness/emission.js";import{upsertProxyInputRequests}from"#harness/proxy-input-requests.js";import{setChannelContext}from"#execution/channel-context.js";import{createTurnWorkflowInput}from"#execution/durable-session-migrations/turn-workflow.js";import{coalesceTurnInputs}from"#harness/messages.js";import{dispatchStreamEventHooks}from"#context/hook-lifecycle.js";import{dispatchDynamicInstructionEvent}from"#context/dynamic-instruction-lifecycle.js";import{dispatchDynamicSkillEvent}from"#context/dynamic-skill-lifecycle.js";import{dispatchDynamicToolEvent}from"#context/dynamic-tool-lifecycle.js";import{runStep,withContextScope}from"#context/run-step.js";import{hasPendingInputBatch}from"#harness/input-requests.js";import{getRuntimeActionRequestKey}from"#runtime/actions/keys.js";import{CallbackBaseUrlKey,PendingAuthorizationResultKey,getPendingAuthorization}from"#harness/authorization.js";import{createExecutionNodeStep}from"#execution/node-step.js";import{emitProxiedInputRequest,routeDeliverPayload}from"#execution/subagent-hitl-proxy.js";import{turnWorkflow}from"#execution/turn-workflow.js";async function turnStep(e){"use step";let t=e;await setEveAttributes(buildTurnAttributes({parentSessionId:t.sessionState.sessionId,rootSessionId:readRootSessionId(t.serializedContext)??t.sessionState.sessionId}));let o=await readDurableSession(t.sessionState),l=await deserializeContext(t.serializedContext),f=l.require(ChannelKey),p=l.require(BundleKey),m=hydrateDurableSession({compactionOverrides:{thresholdPercent:p.resolvedAgent.config.compaction?.thresholdPercent},durable:o,turnAgent:p.turnAgent});try{let{getWorkflowMetadata:e}=await import(`#compiled/@workflow/core/index.js`),t=e();typeof t.url==`string`&&l.set(CallbackBaseUrlKey,t.url.replace(/\/$/,``))}catch{}let h=getPendingAuthorization(o.state),g;if(h&&t.input?.kind===`deliver`){let e=[],n=[];for(let r of t.input.payloads){let t=r.authorizationCallback;if(t){let n=h.challenges.find(e=>e.name===t.connectionName);n&&e.push({name:n.name,resume:n.resume,callback:t.callback,hookUrl:n.hookUrl})}else n.push(r)}e.length>0&&(l.set(PendingAuthorizationResultKey,e),g=e.map(e=>e.name),t=n.length>0?{...t,input:{...t.input,payloads:n}}:{...t,input:void 0})}t.input?.kind===`deliver`&&t.input.auth!==void 0&&l.set(AuthKey,t.input.auth??null);let _=buildAdapterContext(f,l),v;if(t.input?.kind===`deliver`){let e=[];for(let n of t.input.payloads){let t=f.deliver?await f.deliver(n,_):defaultDeliverResult(n);t!=null&&e.push(t)}v=e.length===0?void 0:e.reduce(coalesceTurnInputs)}else t.input?.kind===`runtime-action-result`&&(v={runtimeActionResults:t.input.results});if(t.input?.kind===`deliver`&&setChannelContext(l,{...f,state:{..._.state}}),t.input?.kind===`deliver`&&v===void 0){let e=reconcileSessionContinuationToken(l,m),n=serializeContext(l),r=e===m?t.sessionState:createDurableSessionState({session:e});return{action:`park`,...derivePendingState(e),serializedContext:n,sessionState:r}}let y=t.parentWritable.getWriter(),b=p.hookRegistry,x=p.resolvedAgent.dynamicInstructionsResolvers??[],S=p.resolvedAgent.dynamicSkillResolvers??[],C=p.resolvedAgent.dynamicToolResolvers??[],emit=async e=>{let t=await callAdapterEventHandler(f,e,_);return setChannelContext(l,{...f,state:{..._.state}}),await y.write(encodeMessageStreamEvent(timestampHandleMessageStreamEvent(t))),t},handleEvent=async(e,t)=>{let n=await emit(e);await dispatchStreamEventHooks({ctx:l,registry:b,event:n}),await dispatchDynamicToolEvent({ctx:l,resolvers:C,event:n,messages:t??[]}),await dispatchDynamicSkillEvent({ctx:l,resolvers:S,event:n,messages:t??[]}),await dispatchDynamicInstructionEvent({ctx:l,resolvers:x,event:n,messages:t??[]})},w=l.require(ModeKey),T=await runStep(l,m,async e=>{let t=resolveEffectiveOutputSchema({agentOutputSchema:p.turnAgent.outputSchema,input:v,mode:w,session:e});if(g){let e=getHarnessEmissionState(t.state);for(let t of g)await handleEvent(createAuthorizationCompletedEvent({name:t,outcome:`authorized`,sequence:e.sequence,stepIndex:e.stepIndex,turnId:e.turnId}))}let n=l.get(CapabilitiesKey);return(async(e,t)=>{let r=refreshSessionFromTurnAgent({compactionOverrides:{thresholdPercent:p.resolvedAgent.config.compaction?.thresholdPercent},refreshSystemPrompt:shouldRefreshSystemPromptFromTurnAgent(p.compiledArtifactsSource),session:e,turnAgent:p.turnAgent});return createExecutionNodeStep({capabilities:n,compiledArtifactsSource:p.compiledArtifactsSource,createRuntime:createWorkflowRuntime,handleEvent,mode:w,node:p.graph.root})(r,t)})(t,v)}),E=reconcileSessionContinuationToken(l,T.session),D=serializeContext(l);T={...T,session:E};let O=createDurableSessionState({session:T.session});if(T.next!==null&&typeof T.next==`object`&&`done`in T.next)return await y.close(),{action:`done`,output:T.next.output,isError:T.next.isError,serializedContext:D,sessionState:O};if(T.next===null){y.releaseLock();let e=getPendingCodeModeInterrupt(T.session.state);return e!==void 0&&isCodeModeRuntimeActionInterrupt(e.interrupt)?{action:`dispatch-code-mode-runtime-actions`,pendingRuntimeActionKeys:[getRuntimeActionKeyFromInterrupt(e.interrupt)],serializedContext:D,sessionState:O}:{action:`park`,...derivePendingState(T.session),serializedContext:D,sessionState:O}}return y.releaseLock(),{action:`continue`,serializedContext:D,sessionState:O}}function shouldRefreshSystemPromptFromTurnAgent(e){return e.kind===`disk`&&e.moduleMapLoaderPath!==void 0}function derivePendingState(e){let t=getPendingRuntimeActionBatch(e.state),n=getPendingAuthorization(e.state),r={authorizationNames:n?.challenges.map(e=>e.name),hasPendingAuthorization:n!==void 0,hasPendingInputBatch:hasPendingInputBatch(e.state)};return t===void 0?r:{...r,pendingRuntimeActionKeys:t.actions.map(e=>getRuntimeActionRequestKey(e))}}function reconcileSessionContinuationToken(e,t){let n=e.get(ContinuationTokenKey);return n===void 0||n===t.continuationToken?t:{...t,continuationToken:n}}function resolveEffectiveOutputSchema(e){let{agentOutputSchema:t,input:n,mode:r,session:i}=e;return n?.outputSchema===void 0?r===`task`&&i.outputSchema===void 0&&t!==void 0?{...i,outputSchema:t}:i:{...i,outputSchema:n.outputSchema}}const log=createLogger(`execution.workflow-entry`);async function emitTerminalSessionFailureStep(e){"use step";let r=formatError(e.error),i=typeof r.name==`string`?r.name:`WORKFLOW_EXECUTION_FAILED`,a=typeof r.message==`string`?r.message:String(e.error),o=e.serializedContext[`eve.sessionId`]??``;log.error(`workflow loop threw — emitting terminal session.failed`,{sessionId:o,errorId:typeof r.errorId==`string`?r.errorId:void 0,code:i,message:a,detail:typeof r.detail==`string`?r.detail:void 0});let s=createSessionFailedEvent({code:i,details:r,message:a,sessionId:o});try{let t=await deserializeContext(e.serializedContext),r=t.get(ChannelKey);r!==void 0&&await callAdapterEventHandler(r,s,buildAdapterContext(r,t))}catch(e){log.error(`adapter failed to handle terminal session.failed event`,{errorId:typeof r.errorId==`string`?r.errorId:void 0,sessionId:o,error:e})}try{let t=e.parentWritable.getWriter();try{await t.write(encodeMessageStreamEvent(timestampHandleMessageStreamEvent(s)))}finally{t.releaseLock()}}catch(e){log.error(`failed to write terminal session.failed event to durable stream`,{errorId:typeof r.errorId==`string`?r.errorId:void 0,sessionId:o,error:e})}}async function runProxyInputRequestStep(e){"use step";let t=await readDurableSession(e.sessionState),r=await deserializeContext(e.serializedContext),i=r.require(ChannelKey),a=buildAdapterContext(i,r),o=r.require(ModeKey),c=r.require(BundleKey),l=hydrateDurableSession({compactionOverrides:{thresholdPercent:c.resolvedAgent.config.compaction?.thresholdPercent},durable:t,turnAgent:c.turnAgent}),u=e.parentWritable.getWriter(),d;try{let emit=async e=>{let t=await callAdapterEventHandler(i,e,a);await u.write(encodeMessageStreamEvent(timestampHandleMessageStreamEvent(t)))};d=await withContextScope(r,l,async t=>{let n=await emitProxiedInputRequest({emit,hookPayload:e.hookPayload,mode:o,session:t});return{result:n.entries,session:n.session}})}finally{u.releaseLock()}return setChannelContext(r,{...i,state:{...a.state}}),{serializedContext:serializeContext(r),sessionState:createDurableSessionState({session:reconcileSessionContinuationToken(r,upsertProxyInputRequests({entries:d.result,forChildContinuationToken:e.hookPayload.childContinuationToken,session:d.session}))})}}async function routeProxiedDeliverStep(e){"use step";let t=await readDurableSession(e.sessionState),n=routeDeliverPayload({payload:e.payload,state:t.state}),{resumeHook:r}=await import(`#compiled/@workflow/core/runtime.js`);for(let t of n.forChildren)await r(t.childContinuationToken,{auth:e.auth,kind:`deliver`,payloads:[t.payload]});return{remainder:n.forSelf}}async function dispatchTurnStep(e){"use step";return{runId:(await startWorkflowPreferLatest(turnWorkflow,[createTurnWorkflowInput(e)])).runId}}export{dispatchTurnStep,emitTerminalSessionFailureStep,reconcileSessionContinuationToken,resolveEffectiveOutputSchema,routeProxiedDeliverStep,runProxyInputRequestStep,turnStep};

package/dist/src/harness/action-result-helpers.d.ts

@@ -0,0 +1,40 @@
+import type { ModelMessage, ToolSet, TypedToolResult } from "ai";
+import type { RuntimeToolResultActionResult } from "#runtime/actions/types.js";
+type ToolResponsePart = Extract<ModelMessage, {
+    role: "tool";
+}>["content"][number];
+type ToolResultPart = Extract<ToolResponsePart, {
+    type: "tool-result";
+}>;
+/**
+ * Builds a `RuntimeToolResultActionResult` from a raw tool output value.
+ *
+ * This is the single coercion point for `action.result` projection. Both
+ * native tool execution (via {@link createRuntimeToolResultFromStepResult} /
+ * {@link createRuntimeToolResultFromMessagePart}) and code-mode nested tool
+ * calls funnel through here, so the raw-output-vs-`toModelOutput` decision —
+ * always raw — is decided once. The output is passed through structurally
+ * because it is already JSON-serialized (the AI SDK tool result, or the
+ * code-mode worker bridge).
+ */
+export declare function createRuntimeToolResultFromValue(input: {
+    readonly callId: string;
+    readonly toolName: string;
+    readonly output: unknown;
+    readonly isError?: boolean;
+}): RuntimeToolResultActionResult;
+/**
+ * Builds a `RuntimeToolResultActionResult` from one AI SDK
+ * {@link TypedToolResult}. Used for tool results captured on the AI SDK
+ * step result and for `tool-result` parts that arrive on the stream.
+ */
+export declare function createRuntimeToolResultFromStepResult(toolResult: TypedToolResult<ToolSet>): RuntimeToolResultActionResult;
+/**
+ * Builds a `RuntimeToolResultActionResult` from one tool-result message
+ * part as it appears on `step.response.messages`. Used as a fallback when
+ * the result is missing from `step.toolResults` (some providers — notably
+ * after `tool-output-denied` chunks — surface the result only on the
+ * response messages array).
+ */
+export declare function createRuntimeToolResultFromMessagePart(part: ToolResultPart): RuntimeToolResultActionResult;
+export {};

package/dist/src/harness/action-result-helpers.js

@@ -0,0 +1 @@
+function toJsonValue(e){return e===null||typeof e==`string`||typeof e==`number`||typeof e==`boolean`?e:e instanceof Error?e.message:typeof e==`object`?e:String(e)}function createRuntimeToolResultFromValue(e){let t={callId:e.callId,kind:`tool-result`,output:toJsonValue(e.output),toolName:e.toolName};return e.isError===!0?{...t,isError:!0}:t}function createRuntimeToolResultFromStepResult(e){return createRuntimeToolResultFromValue({callId:e.toolCallId,output:e.output,toolName:e.toolName})}function createRuntimeToolResultFromMessagePart(e){return createRuntimeToolResultFromValue({callId:e.toolCallId,output:toolResultOutputToJsonValue(e.output),toolName:e.toolName,isError:isToolResultError(e.output)})}function toolResultOutputToJsonValue(e){switch(e.type){case`text`:case`error-text`:return e.value;case`json`:case`error-json`:return toJsonValue(e.value);case`execution-denied`:return{code:`TOOL_EXECUTION_DENIED`,message:e.reason??`Tool execution was denied.`};case`content`:return toJsonValue(e.value)}}function isToolResultError(e){return e.type===`error-json`||e.type===`error-text`||e.type===`execution-denied`}export{createRuntimeToolResultFromMessagePart,createRuntimeToolResultFromStepResult,createRuntimeToolResultFromValue};

package/dist/src/harness/attachment-staging.d.ts

@@ -0,0 +1,30 @@
+import type { ModelMessage, UserContent } from "ai";
+import type { ChannelAdapterContext } from "#channel/adapter.js";
+import type { SandboxSession } from "#public/definitions/sandbox.js";
+/**
+ * Sandbox directory where inbound file attachments are staged before the
+ * model call. Authored canonical path — {@link SandboxSession.writeFile}
+ * translates to the backend-native location.
+ */
+export declare const ATTACHMENTS_ROOT = "/workspace/attachments";
+/**
+ * Writes inbound `FilePart` bytes into the sandbox and rewrites each
+ * staged part to a compact `eve-sandbox:` ref.
+ *
+ * Remote HTTP URLs pass through for provider-side fetches; existing
+ * `eve-sandbox:` refs pass through so staging is idempotent.
+ */
+export declare function stageAttachmentsForAdapter(content: string | UserContent, sandbox: SandboxSession, adapterCtx: ChannelAdapterContext): Promise<string | UserContent>;
+/**
+ * Context-bound variant of {@link stageAttachmentsForAdapter}. Returns
+ * the input unchanged when there is no active sandbox or no file parts.
+ */
+export declare function stageAttachmentsToSandbox(message: string | UserContent): Promise<string | UserContent>;
+/**
+ * Hydrates `eve-sandbox:` file refs for a single model call.
+ *
+ * Small images and PDFs are inlined as bytes; larger or unsupported files
+ * become text references to their sandbox path. The returned messages must
+ * not be written back to session history, which stays ref-only across steps.
+ */
+export declare function hydrateSandboxAttachments(messages: readonly ModelMessage[]): Promise<ModelMessage[]>;

package/dist/src/harness/attachment-staging.js

@@ -0,0 +1 @@
+import{buildSessionHandle}from"#channel/session.js";import{getAdapterKind}from"#channel/adapter.js";import{deserializeUrlFilePart,isSerializedUrlFilePart}from"#internal/attachments/url-refs.js";import{SandboxKey}from"#context/keys.js";import{basename}from"node:path";import{toErrorMessage}from"#shared/errors.js";import{createHash}from"node:crypto";import{loadContext}from"#context/container.js";import{ChannelKey}from"#runtime/sessions/runtime-context-keys.js";import{buildAdapterContext}from"#channel/adapter-context.js";import{fileDataToBytes}from"#internal/attachments/data.js";import{EveAttachmentError}from"#internal/attachments/errors.js";import{decodeSandboxRef,encodeSandboxRef,isSandboxRefUrl}from"#internal/attachments/sandbox-refs.js";const ATTACHMENTS_ROOT=`/workspace/attachments`,UNSAFE_FILENAME_CHARS=/[^\w.-]+/g;async function stageAttachmentsForAdapter(e,t,n){if(typeof e==`string`)return e;let r=reconstitueFilePartUrls(e);return Promise.all(r.map(async e=>e.type===`file`?stageFilePart(e,t,n):e))}async function stageAttachmentsToSandbox(t){if(typeof t==`string`||!Array.isArray(t)||!hasFileParts(t))return t;let n=loadContext(),r=n.get(SandboxKey);if(r===void 0)return t;let a=await r.get();if(a===null)return t;let o=n.get(ChannelKey);return stageAttachmentsForAdapter(t,a,o?buildAdapterContext(o,n):{ctx:n,state:{},session:buildSessionHandle(n)})}async function hydrateSandboxAttachments(e){if(!messagesContainSandboxRef(e))return e;let t=loadContext().get(SandboxKey);if(t===void 0)throw Error(`Cannot hydrate sandbox-ref FilePart: no SandboxKey is bound on the active Eve context. Hydration must run inside a step scope with the framework sandbox provider installed.`);let n=await t.get();if(n===null)throw Error(`Cannot hydrate sandbox-ref FilePart: SandboxKey is bound but no active sandbox session is available.`);return Promise.all(e.map(async e=>{if(!messageContainsSandboxRef(e))return e;let t=await hydrateMessageContent(e.content,n);return{...e,content:t}}))}function hasFileParts(e){for(let t of e)if(t.type===`file`)return!0;return!1}function messagesContainSandboxRef(e){for(let t of e)if(messageContainsSandboxRef(t))return!0;return!1}function messageContainsSandboxRef(e){let t=e.content;if(!Array.isArray(t))return!1;for(let e of t)if(isSandboxRefFilePart(e))return!0;return!1}function isSandboxRefFilePart(e){return typeof e==`object`&&!!e&&e.type===`file`&&isSandboxRefUrl(e.data)}async function hydrateMessageContent(e,t){return Array.isArray(e)?Promise.all(e.map(async e=>{if(!isSandboxRefFilePart(e))return e;let n=e,r=decodeSandboxRef(n.data);if(!shouldInlineSandboxRefAsBytes(r))return renderSandboxRefAsTextPart(r);let i=await t.readBinaryFile({path:r.path});if(i===null)throw Error(`Sandbox-ref FilePart references missing file: "${r.path}". The staging pipeline invariant (every eve-sandbox: ref has bytes on disk) was violated.`);return{...n,data:i,mediaType:r.mediaType}})):e}function shouldInlineSandboxRefAsBytes(e){return e.mediaType.startsWith(`image/`)?e.size<=3145728:e.mediaType===`application/pdf`?e.size<=20971520:!1}function renderSandboxRefAsTextPart(e){return{text:`Attached file ${e.path} (${e.mediaType})`,type:`text`}}async function stageFilePart(e,t,n){if(isSandboxRefUrl(e.data))return e;if(e.data instanceof URL&&e.data.protocol!==`data:`){let r=await tryFetchFile(e.data.href,n);return r===null?e:stageResolvedBytes(e,r,t)}let r=await fileDataToBytes(e.data);return r===null?e:stageResolvedBytes(e,{bytes:r},t)}async function stageResolvedBytes(e,t,n){let r=t.bytes,i=sha256Prefix(r),a=t.mediaType??e.mediaType??`application/octet-stream`,o=`${ATTACHMENTS_ROOT}/${i}/${safeFilename(t.filename??e.filename,i)}`;await n.writeBinaryFile({content:r,path:o});let s=n.resolvePath(o);return{...e,data:encodeSandboxRef({mediaType:a,path:s,size:r.byteLength}),filename:s,mediaType:a}}async function tryFetchFile(e,n){let r=n.ctx.get(ChannelKey);if(r?.fetchFile===void 0)return null;let i=getAdapterKind(r);try{let t=await r.fetchFile(e);return t===null?null:Buffer.isBuffer(t)?{bytes:t}:t}catch(e){throw e instanceof EveAttachmentError?e:new EveAttachmentError({adapterKind:i,cause:e,kind:`resolver-threw`,message:`fetchFile for adapter kind="${i}" threw: ${toErrorMessage(e)}`})}}function reconstitueFilePartUrls(e){let t=!1,i=e.map(e=>e.type===`file`&&isSerializedUrlFilePart(e.data)?(t=!0,{...e,data:deserializeUrlFilePart(e.data)}):e);return t?i:e}function sha256Prefix(e){return createHash(`sha256`).update(e).digest(`hex`).slice(0,16)}function safeFilename(e,t){if(e===void 0)return`file-${t}`;let n=basename(e).replace(UNSAFE_FILENAME_CHARS,`_`);return n.length>0?n:`file-${t}`}export{ATTACHMENTS_ROOT,hydrateSandboxAttachments,stageAttachmentsForAdapter,stageAttachmentsToSandbox};

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