eve 0.5.3 → 0.6.0-beta.1

package/dist/src/execution/delegated-parent-notification.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Bridges a delegated subagent's terminal outcome back to its parent
+ * driver via the subagent-result hook. Pure projection helpers live
+ * in `delegated-parent-result.ts` so the workflow step-proxy transform
+ * doesn't strip them from this file.
+ */
+import type { RuntimeSubagentResultActionResult } from "#runtime/actions/types.js";
+/**
+ * Resumes the parent driver's hook with a delegated subagent result.
+ * No-op for root sessions.
+ */
+export declare function notifyDelegatedParentStep(input: {
+    readonly result: RuntimeSubagentResultActionResult | undefined;
+    readonly serializedContext: Record<string, unknown>;
+}): Promise<void>;

package/dist/src/execution/delegated-parent-notification.js

@@ -0,0 +1 @@
+import{ChannelKey}from"#runtime/sessions/runtime-context-keys.js";import{deserializeContext}from"#context/serialize.js";import{SUBAGENT_ADAPTER_KIND}from"#execution/subagent-adapter.js";async function notifyDelegatedParentStep(e){"use step";if(e.result===void 0)return;let t=(await deserializeContext(e.serializedContext)).get(ChannelKey);if(t?.kind!==SUBAGENT_ADAPTER_KIND)return;let n=String(t.state?.parentContinuationToken??``);if(n===``)return;let{resumeHook:r}=await import(`#compiled/@workflow/core/runtime.js`);await r(n,{kind:`runtime-action-result`,results:[e.result]})}export{notifyDelegatedParentStep};

package/dist/src/execution/delegated-parent-result.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Pure helpers that project a delegated subagent's terminal output
+ * into the runtime-action result shape its parent driver expects.
+ * Lives in its own (non-directive) file to escape the workflow
+ * step-proxy transform.
+ */
+import type { RuntimeSubagentResultActionResult } from "#runtime/actions/types.js";
+/**
+ * Builds the success-shaped {@link RuntimeSubagentResultActionResult}.
+ * Returns `undefined` for root sessions (no parent to notify).
+ */
+export declare function createDelegatedSubagentSuccessResult(serializedContext: Record<string, unknown>, output: unknown): RuntimeSubagentResultActionResult | undefined;
+/** Failure-path mirror of {@link createDelegatedSubagentSuccessResult}. */
+export declare function createDelegatedSubagentErrorResult(serializedContext: Record<string, unknown>, error: unknown): RuntimeSubagentResultActionResult | undefined;

package/dist/src/execution/delegated-parent-result.js

@@ -0,0 +1 @@
+import{toErrorMessage}from"#shared/errors.js";import{SUBAGENT_ADAPTER_KIND}from"#execution/subagent-adapter.js";function createDelegatedSubagentSuccessResult(e,n){let r=e[`eve.channel`];if(r?.kind===SUBAGENT_ADAPTER_KIND)return{callId:String(r.state?.callId??``),kind:`subagent-result`,output:n,subagentName:String(r.state?.subagentName??``)}}function createDelegatedSubagentErrorResult(t,n){let r=createDelegatedSubagentSuccessResult(t,``);if(r!==void 0)return{...r,isError:!0,output:{code:`SUBAGENT_EXECUTION_FAILED`,message:toErrorMessage(n)}}}export{createDelegatedSubagentErrorResult,createDelegatedSubagentSuccessResult};

package/dist/src/execution/dispatch-code-mode-runtime-actions-step.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Dispatches runtime actions originating from code mode.
+ *
+ * Reads the pending code mode runtime action from session state,
+ * builds a runtime action request from the interrupt payload, stores
+ * it as a temporary PendingRuntimeActionBatch, and delegates to the
+ * standard dispatch step. The batch is only needed for dispatch —
+ * the harness never sees it because results flow through
+ * continuePendingCodeModeRuntimeAction, not resolvePendingRuntimeActions.
+ */
+import type { RuntimeSubagentResultActionResult } from "#runtime/actions/types.js";
+import { type DurableSessionState } from "#execution/durable-session-store.js";
+export declare function dispatchCodeModeRuntimeActionsStep(input: {
+    readonly callbackBaseUrl?: string;
+    readonly parentWritable: WritableStream<Uint8Array>;
+    readonly serializedContext: Record<string, unknown>;
+    readonly sessionState: DurableSessionState;
+}): Promise<{
+    readonly results: readonly RuntimeSubagentResultActionResult[];
+    readonly sessionState: DurableSessionState;
+}>;

package/dist/src/execution/dispatch-code-mode-runtime-actions-step.js

@@ -0,0 +1 @@
+import{BundleKey}from"#runtime/sessions/runtime-context-keys.js";import{createDurableSessionState,readDurableSession}from"#execution/durable-session-store.js";import{hydrateDurableSession}from"#execution/session.js";import{deserializeContext}from"#context/serialize.js";import{buildRuntimeActionFromInterrupt}from"#harness/code-mode-runtime-action-state.js";import{getPendingCodeModeInterrupt}from"#harness/code-mode-interrupt-state.js";import{setPendingRuntimeActionBatch}from"#harness/runtime-actions.js";import{dispatchRuntimeActionsStep}from"#execution/dispatch-runtime-actions-step.js";async function dispatchCodeModeRuntimeActionsStep(e){"use step";let t=await readDurableSession(e.sessionState),n=getPendingCodeModeInterrupt(t.state);if(n===void 0)return{results:[],sessionState:e.sessionState};let r=buildRuntimeActionFromInterrupt(n.interrupt),i=(await deserializeContext(e.serializedContext)).require(BundleKey),a=hydrateDurableSession({compactionOverrides:{thresholdPercent:i.resolvedAgent.config.compaction?.thresholdPercent},durable:t,turnAgent:i.turnAgent}),o=createDurableSessionState({session:setPendingRuntimeActionBatch({actions:[r],event:{sequence:0,stepIndex:0,turnId:`code-mode-dispatch`},responseMessages:[],session:a})});return dispatchRuntimeActionsStep({callbackBaseUrl:e.callbackBaseUrl,parentWritable:e.parentWritable,serializedContext:e.serializedContext,sessionState:o})}export{dispatchCodeModeRuntimeActionsStep};

package/dist/src/execution/dispatch-runtime-actions-step.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Starts every pending runtime action for the parked parent session.
+ *
+ * Each child run starts in task mode, emits a parent `subagent.called`
+ * control-plane event, and then runs independently on its own child
+ * stream. Records each child's continuation token on the parent
+ * session and returns the updated snapshot-bearing state.
+ */
+import type { RuntimeSubagentResultActionResult } from "#runtime/actions/types.js";
+import { type DurableSessionState } from "#execution/durable-session-store.js";
+export declare function dispatchRuntimeActionsStep(input: {
+    readonly callbackBaseUrl?: string;
+    readonly parentWritable: WritableStream<Uint8Array>;
+    readonly serializedContext: Record<string, unknown>;
+    readonly sessionState: DurableSessionState;
+}): Promise<{
+    readonly results: readonly RuntimeSubagentResultActionResult[];
+    readonly sessionState: DurableSessionState;
+}>;

package/dist/src/execution/dispatch-runtime-actions-step.js

@@ -0,0 +1 @@
+import{createLogger,logError}from"#internal/logging.js";import{callAdapterEventHandler}from"#channel/adapter.js";import{AuthKey,CapabilitiesKey,ChannelInstrumentationKey,InitiatorAuthKey}from"#context/keys.js";import{createSubagentCalledEvent,encodeMessageStreamEvent,timestampHandleMessageStreamEvent}from"#protocol/message.js";import{toErrorMessage}from"#shared/errors.js";import{BundleKey,ChannelKey}from"#runtime/sessions/runtime-context-keys.js";import{createDurableSessionState,readDurableSession}from"#execution/durable-session-store.js";import{hydrateDurableSession}from"#execution/session.js";import{deserializeContext}from"#context/serialize.js";import{getPendingRuntimeActionBatch,recordPendingSubagentChildToken}from"#harness/runtime-actions.js";import{buildAdapterContext}from"#channel/adapter-context.js";import{resolveRemoteAgentForAction,startRemoteAgentSession}from"#execution/remote-agent-dispatch.js";import{buildSubagentRunInput}from"#execution/subagent-tool.js";import{createWorkflowRuntime,workflowEntryReference}from"#execution/workflow-runtime.js";const log=createLogger(`execution.dispatch-runtime-actions`);async function dispatchRuntimeActionsStep(e){"use step";let s=await readDurableSession(e.sessionState),l=getPendingRuntimeActionBatch(s.state);if(l===void 0||l.actions.length===0)return{results:[],sessionState:e.sessionState};let u=await deserializeContext(e.serializedContext),d=u.require(BundleKey),f=hydrateDurableSession({compactionOverrides:{thresholdPercent:d.resolvedAgent.config.compaction?.thresholdPercent},durable:s,turnAgent:d.turnAgent}),p=u.require(ChannelKey),m=u.get(AuthKey)??null,h=u.get(CapabilitiesKey),g=u.get(ChannelInstrumentationKey),_=u.get(InitiatorAuthKey)??null,v=e.parentWritable.getWriter(),y=buildAdapterContext(p,u),b=f,x=[];try{for(let r of l.actions){let i,a,o,s;switch(r.kind){case`subagent-call`:{let e=createWorkflowRuntime({compiledArtifactsSource:d.compiledArtifactsSource,nodeId:r.nodeId}),{childContinuationToken:t,runInput:n}=buildSubagentRunInput({action:r,auth:m,batchEvent:l.event,capabilities:h,channelMetadata:g,initiatorAuth:_,session:f}),o=await e.run(n);b=recordPendingSubagentChildToken({callId:r.callId,childContinuationToken:t,session:b}),i=o.sessionId,a=r.name,s=r.subagentName;break}case`remote-agent-call`:{let n;try{n=resolveRemoteAgentForAction({nodeId:r.nodeId,remoteAgentName:r.remoteAgentName,registry:d.subagentRegistry.subagentsByNodeId}),i=await startRemoteAgentSession({action:r,callbackBaseUrl:e.callbackBaseUrl,remote:n,session:f})}catch(e){logError(log,`remote agent start failed`,e,{remoteAgentName:r.remoteAgentName,nodeId:r.nodeId,callId:r.callId}),x.push(createRemoteAgentStartFailureResult({action:r,error:e}));continue}a=r.name,o={url:n.url},s=r.remoteAgentName;break}default:throw Error(`Unsupported runtime action kind "${r.kind}" in workflow runtime.`)}let c=await callAdapterEventHandler(p,createSubagentCalledEvent({callId:r.callId,childSessionId:i,name:a,remote:o,sequence:l.event.sequence,sessionId:f.sessionId,toolName:s,turnId:l.event.turnId,workflowId:workflowEntryReference.workflowId}),y);await v.write(encodeMessageStreamEvent(timestampHandleMessageStreamEvent(c)))}}finally{v.releaseLock()}return{results:x,sessionState:b===f?e.sessionState:createDurableSessionState({session:b})}}function createRemoteAgentStartFailureResult(e){return{callId:e.action.callId,isError:!0,kind:`subagent-result`,output:{code:`REMOTE_AGENT_START_FAILED`,message:toErrorMessage(e.error)},subagentName:e.action.remoteAgentName}}export{dispatchRuntimeActionsStep};

package/dist/src/execution/durable-session-migrations/chain.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Generic version-walking migration framework for versioned durable
+ * wire shapes. Each migration steps a value one version forward; the
+ * runner chains them so a value written at any historic version can
+ * be read at the current one.
+ */
+/**
+ * One migration step in a version chain. `to` MUST equal `from + 1`
+ * and `migrate` MUST stamp the returned value's `version` field with
+ * `to`; the runner verifies both.
+ */
+export interface VersionMigration {
+    readonly from: number;
+    readonly to: number;
+    migrate: (prior: unknown) => {
+        readonly version: number;
+    };
+}
+/**
+ * Walks `value` through `migrations` until its `version` matches
+ * `targetVersion`. Throws on missing migrations, malformed steps, or
+ * a value newer than the runner supports.
+ */
+export declare function runMigrationChain<TOut extends {
+    readonly version: number;
+}>(input: {
+    readonly value: unknown;
+    readonly migrations: readonly VersionMigration[];
+    readonly targetVersion: number;
+    readonly label: string;
+    /**
+     * Version to read a wire value as when it carries no `version` field —
+     * for shapes that predate versioning ("version 0"). Omit to require an
+     * explicit numeric `version` (the default). A present but non-numeric
+     * `version` is always malformed, opt-in or not.
+     */
+    readonly initialVersion?: number;
+}): TOut;

package/dist/src/execution/durable-session-migrations/chain.js

@@ -0,0 +1 @@
+function runMigrationChain(e){if(typeof e.value!=`object`||e.value===null)throw Error(`${e.label}: value has no numeric "version" field.`);let t=e.value.version,n;if(typeof t==`number`)n=e.value;else if(!(`version`in e.value)&&e.initialVersion!==void 0)n={...e.value,version:e.initialVersion};else throw Error(`${e.label}: value has no numeric "version" field.`);let r=e.initialVersion??1;if(!Number.isInteger(n.version)||n.version<r)throw Error(`${e.label}: version ${n.version} is not a positive integer.`);if(n.version>e.targetVersion)throw Error(`${e.label}: encountered version ${n.version}, which is newer than the supported version ${e.targetVersion}. This usually indicates the wire was written by a newer Eve deployment than the one reading it.`);for(;n.version<e.targetVersion;){let t=e.migrations.find(e=>e.from===n.version);if(!t)throw Error(`${e.label}: no migration registered for version ${n.version} → ${n.version+1}.`);if(t.to!==t.from+1)throw Error(`${e.label}: migration ${t.from} → ${t.to} must step exactly one version at a time.`);let r=t.migrate(n);if(r.version!==t.to)throw Error(`${e.label}: migration ${t.from} → ${t.to} produced a value with version ${r.version}.`);n=r}return n}export{runMigrationChain};

package/dist/src/execution/durable-session-migrations/snapshot.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Durable session snapshot migrations.
+ *
+ * ## Adding a new snapshot version
+ *
+ * When a shape change cannot be expressed as a purely additive field:
+ *
+ * 1. Bump `DURABLE_SESSION_VERSION` in `durable-session-store.ts`.
+ * 2. Update {@link DurableSessionSnapshot}, {@link DurableSession},
+ *    `projectToDurableSession`, and `hydrateDurableSession`.
+ * 3. Add `snapshot-v{N}-to-v{N+1}.ts` exporting one
+ *    {@link VersionMigration} (`from: N`, `to: N + 1`, pure
+ *    function, stamps the new `version`).
+ * 4. Append the migration to {@link snapshotMigrations}.
+ * 5. Cover it in `snapshot.test.ts`.
+ */
+import type { DurableSessionSnapshot } from "#execution/durable-session-store.js";
+/**
+ * Migrates a {@link DurableSessionSnapshot} up to
+ * {@link DURABLE_SESSION_VERSION}. Pure; safe to call inline.
+ */
+export declare function migrateDurableSessionSnapshot(value: unknown): DurableSessionSnapshot;

package/dist/src/execution/durable-session-migrations/snapshot.js

@@ -0,0 +1 @@
+import{runMigrationChain}from"./chain.js";import{DURABLE_SESSION_VERSION}from"#execution/durable-session-store.js";const snapshotMigrations=[];function migrateDurableSessionSnapshot(e){return runMigrationChain({label:`durable session snapshot`,migrations:snapshotMigrations,targetVersion:DURABLE_SESSION_VERSION,value:e})}export{migrateDurableSessionSnapshot};

package/dist/src/execution/durable-session-migrations/turn-workflow-v0-to-v1.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Turn workflow input v0 → v1 migration.
+ *
+ * Before versioning, the driver wrote a flat, unversioned run input;
+ * `runMigrationChain` reads that as version 0 (via its `initialVersion`
+ * option) and this lifts the flat shape into the nested v1 input. The
+ * reshape is inlined rather than delegating to `createTurnWorkflowInput`,
+ * so the historical transform stays frozen as the live dispatch
+ * constructor evolves.
+ */
+import type { VersionMigration } from "./chain.js";
+export declare const turnWorkflowInputV0ToV1: VersionMigration;

package/dist/src/execution/durable-session-migrations/turn-workflow-v0-to-v1.js

@@ -0,0 +1 @@
+const turnWorkflowInputV0ToV1={from:0,migrate(e){if(!isPreVersionTurnWorkflowInput(e))throw Error(`turn workflow input: version 0 value is not a recognized pre-version shape.`);return{capabilities:e.capabilities,completionToken:e.completionToken,mode:e.mode,stepInput:{input:e.delivery,parentWritable:e.parentWritable,serializedContext:e.serializedContext,sessionState:e.sessionState},version:1}},to:1};function isPreVersionTurnWorkflowInput(e){return typeof e==`object`&&!!e&&`delivery`in e}export{turnWorkflowInputV0ToV1};

package/dist/src/execution/durable-session-migrations/turn-workflow.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Turn workflow input migrations.
+ *
+ * The driver workflow can stay pinned while per-turn child workflows
+ * route to latest, so the child workflow run input is a durable wire
+ * shape newer code must read. Inputs written before
+ * {@link TURN_WORKFLOW_INPUT_VERSION} carry no `version`; the chain reads
+ * them as version 0 and the registered v0 → v1 migration lifts the flat
+ * shape into the current input, so a turn dispatched by an older
+ * deployment still runs after a rollout. Future shape changes bump
+ * {@link TURN_WORKFLOW_INPUT_VERSION} and append a v{N} → v{N+1} migration.
+ */
+import type { HookPayload, SessionCapabilities } from "#channel/types.js";
+import type { DurableSessionState } from "#execution/durable-session-store.js";
+import type { RunMode } from "#shared/run-mode.js";
+export declare const TURN_WORKFLOW_INPUT_VERSION = 1;
+export interface TurnStepInput {
+    readonly input: HookPayload | undefined;
+    readonly parentWritable: WritableStream<Uint8Array>;
+    readonly serializedContext: Record<string, unknown>;
+    readonly sessionState: DurableSessionState;
+}
+export interface TurnWorkflowInput {
+    readonly version: typeof TURN_WORKFLOW_INPUT_VERSION;
+    readonly capabilities: SessionCapabilities | undefined;
+    readonly completionToken: string;
+    readonly mode: RunMode;
+    readonly stepInput: TurnStepInput;
+}
+export interface TurnWorkflowDispatchInput {
+    readonly capabilities: SessionCapabilities | undefined;
+    readonly completionToken: string;
+    readonly delivery: HookPayload;
+    readonly mode: RunMode;
+    readonly parentWritable: WritableStream<Uint8Array>;
+    readonly serializedContext: Record<string, unknown>;
+    readonly sessionState: DurableSessionState;
+}
+export declare function createTurnWorkflowInput(input: TurnWorkflowDispatchInput): TurnWorkflowInput;
+export declare function migrateTurnWorkflowInput(value: unknown): TurnWorkflowInput;

package/dist/src/execution/durable-session-migrations/turn-workflow.js

@@ -0,0 +1 @@
+import{runMigrationChain}from"./chain.js";import{turnWorkflowInputV0ToV1}from"./turn-workflow-v0-to-v1.js";const TURN_WORKFLOW_INPUT_VERSION=1,turnWorkflowInputMigrations=[turnWorkflowInputV0ToV1];function createTurnWorkflowInput(e){return{capabilities:e.capabilities,completionToken:e.completionToken,mode:e.mode,stepInput:{input:e.delivery,parentWritable:e.parentWritable,serializedContext:e.serializedContext,sessionState:e.sessionState},version:1}}function migrateTurnWorkflowInput(t){return runMigrationChain({initialVersion:0,label:`turn workflow input`,migrations:turnWorkflowInputMigrations,targetVersion:1,value:t})}export{TURN_WORKFLOW_INPUT_VERSION,createTurnWorkflowInput,migrateTurnWorkflowInput};

package/dist/src/execution/durable-session-store.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Durable session storage.
+ *
+ * Session-mutating steps return the current snapshot inside
+ * {@link DurableSessionState}; Workflow step results are the atomic
+ * persistence boundary for session program memory. The legacy
+ * `"eve.session"` stream remains as a fallback for old in-flight
+ * sessions that only carry a small state handle.
+ *
+ * The driver workflow run is pinned to the deployment that called
+ * `start()`; child turn workflows run on latest. Both
+ * {@link DurableSessionState} and {@link DurableSessionSnapshot} carry
+ * a `version` so a pinned driver can ferry shapes written by newer
+ * steps. Adding optional fields is forward-compatible (devalue
+ * preserves unknown POJO fields); shape-breaking changes bump
+ * `version` and add a migrator.
+ */
+import type { ModelMessage } from "ai";
+import { type HarnessEmissionState } from "#harness/emission.js";
+import type { HarnessSession, SessionStateMap } from "#harness/types.js";
+import type { SandboxState } from "#sandbox/state.js";
+import type { JsonObject } from "#shared/json.js";
+/** Current wire version for {@link DurableSessionState} and {@link DurableSessionSnapshot}. */
+export declare const DURABLE_SESSION_VERSION = 1;
+/**
+ * Serializable handle to a durable session.
+ *
+ * Carries the current session snapshot plus the small projections the
+ * workflow body needs without taking a step boundary: identity, the
+ * hook continuation token,
+ * `hasProxyInputRequests` (a closed-contract short-circuit that lets
+ * the driver skip a per-delivery proxy-routing step when no
+ * descendant subagent is active), and `emissionState` (so workflow-body
+ * framework steps can stamp protocol events
+ * with `{ turnId, sequence, stepIndex }` without reading the full
+ * durable session). All other control-plane state travels via
+ * {@link import("#execution/next-driver-action.js").NextDriverAction}.
+ * `snapshot` is optional so old stream-backed states can still read
+ * from the legacy `eve.session` fallback.
+ */
+export interface DurableSessionState {
+    readonly version: typeof DURABLE_SESSION_VERSION;
+    readonly sessionId: string;
+    readonly continuationToken: string;
+    readonly hasProxyInputRequests: boolean;
+    readonly emissionState: HarnessEmissionState;
+    readonly snapshot?: DurableSessionSnapshot;
+}
+/**
+ * Durable projection of {@link HarnessSession} embedded in state
+ * snapshots or legacy `eve.session` stream chunks.
+ *
+ * Omits `agent.modelReference`, `agent.tools`,
+ * `agent.compactionModelReference`, and the `compaction` thresholds —
+ * those are rebuilt every turn from `bundle.turnAgent` by
+ * {@link import("#execution/session.js").hydrateDurableSession}.
+ * `agent.system` is the session-start prompt snapshot, pinned at
+ * `createSession`.
+ */
+export interface DurableSession {
+    readonly sessionId: string;
+    /**
+     * Top user-facing session id in the dispatch chain. Optional because
+     * a top-level session is its own root. Persisted so a rehydrated
+     * subagent session still knows its root after a workflow step
+     * boundary.
+     */
+    readonly rootSessionId?: string;
+    readonly continuationToken: string;
+    readonly history: ModelMessage[];
+    readonly outputSchema?: JsonObject;
+    readonly state?: SessionStateMap;
+    readonly sandboxState?: SandboxState;
+    readonly agent: {
+        readonly system: string;
+    };
+    readonly compaction?: {
+        readonly lastKnownInputTokens?: number;
+        readonly lastKnownPromptMessageCount?: number;
+    };
+}
+/** Versioned wrapper around a {@link DurableSession} on the wire. */
+export interface DurableSessionSnapshot {
+    readonly version: typeof DURABLE_SESSION_VERSION;
+    readonly session: DurableSession;
+}
+/** Projects a {@link HarnessSession} into the boundary-safe state value. */
+export declare function projectSessionState(input: {
+    readonly session: HarnessSession;
+}): DurableSessionState;
+/**
+ * Reads the latest durable session snapshot and returns the
+ * {@link DurableSession} inside.
+ *
+ * New states carry the snapshot directly through Workflow step
+ * results. States without `snapshot` fall back to the legacy
+ * `eve.session` stream tail (`startIndex: -1`). The snapshot is
+ * migrated to {@link DURABLE_SESSION_VERSION} before return; unknown
+ * versions throw.
+ *
+ * Devalue handles encode/decode so rich types in the session (URL
+ * `FilePart.data`, Buffer, Date, Map, Set) round-trip structurally.
+ *
+ * MUST be called from inside a `"use step"` body.
+ */
+export declare function readDurableSession(state: DurableSessionState): Promise<DurableSession>;
+/**
+ * Creates the projected {@link DurableSessionState} with the current
+ * snapshot embedded in the Workflow step result.
+ */
+export declare function createDurableSessionState(input: {
+    readonly session: HarnessSession;
+}): DurableSessionState;

package/dist/src/execution/durable-session-store.js

@@ -0,0 +1 @@
+import{projectToDurableSession}from"#execution/session.js";import{getHarnessEmissionState}from"#harness/emission.js";import{hasProxyInputRequests}from"#harness/proxy-input-requests.js";import{migrateDurableSessionSnapshot}from"#execution/durable-session-migrations/snapshot.js";const EVE_SESSION_STREAM_NAMESPACE=`eve.session`,DURABLE_SESSION_VERSION=1,DURABLE_SESSION_READ_TIMEOUT_MS=1e4;function projectSessionState(e){return{continuationToken:e.session.continuationToken,emissionState:getHarnessEmissionState(e.session.state),hasProxyInputRequests:hasProxyInputRequests(e.session.state),sessionId:e.session.sessionId,version:1}}async function readDurableSession(e){if(e.snapshot!==void 0)return migrateDurableSessionSnapshot(e.snapshot).session;let{getRun:t}=await import(`#compiled/@workflow/core/runtime.js`),n=t(e.sessionId).getReadable({namespace:EVE_SESSION_STREAM_NAMESPACE,startIndex:-1}).getReader(),r=`eve durable session tail read failed`,i;try{let t=await Promise.race([n.read().then(e=>({kind:`read`,read:e})),new Promise(e=>{i=setTimeout(()=>e({kind:`timeout`}),DURABLE_SESSION_READ_TIMEOUT_MS)})]);if(t.kind===`timeout`)throw r=`eve durable session tail read timed out after ${DURABLE_SESSION_READ_TIMEOUT_MS}ms`,new DurableSessionReadTimeoutError(e);if(t.read.done||t.read.value===void 0)throw r=`eve durable session tail read returned no snapshot`,Error(`No durable session snapshot found in stream "${EVE_SESSION_STREAM_NAMESPACE}" for run ${e.sessionId}.`);return r=`eve durable session tail read complete`,migrateDurableSessionSnapshot(t.read.value).session}finally{i!==void 0&&clearTimeout(i),await n.cancel(r).catch(()=>{}),n.releaseLock()}}var DurableSessionReadTimeoutError=class extends Error{constructor(e){super(`Timed out reading durable session snapshot from stream "${EVE_SESSION_STREAM_NAMESPACE}" for run ${e.sessionId} after ${DURABLE_SESSION_READ_TIMEOUT_MS}ms.`),this.name=`DurableSessionReadTimeoutError`}};function createDurableSessionState(t){let n={session:projectToDurableSession(t.session),version:1};return{...projectSessionState({session:t.session}),snapshot:n}}export{DURABLE_SESSION_VERSION,createDurableSessionState,projectSessionState,readDurableSession};

package/dist/src/execution/eve-workflow-attributes.d.ts

@@ -0,0 +1,136 @@
+/**
+ * Builders for the framework's reserved `$eve.*` workflow attributes.
+ *
+ * Each builder returns a plain `Record<string, string | number | undefined>`
+ * suitable for `setEveAttributes` from
+ * {@link "#runtime/attributes/emit.js" }. Builders are intentionally
+ * pure data → data transforms: they hold zero dependencies on the
+ * workflow runtime so the workflow body, step bodies, and tests can
+ * all call them identically.
+ *
+ * `$eve.*` is the framework-owned attribute namespace. Authored code
+ * never emits these tags directly — they describe the structural shape
+ * of a session/turn/subagent run so dashboards can stitch a tree of
+ * workflow runs back together without inspecting their bodies.
+ *
+ * Tag inventory (recap):
+ * - `$eve.type`         — `"session" | "turn" | "subagent"`
+ * - `$eve.parent`       — sessionId of the **immediate** parent
+ * - `$eve.root`         — sessionId of the **root** session in the chain
+ * - `$eve.parent_call`  — parent runtime-action tool call id (subagent rows only)
+ * - `$eve.parent_turn`  — parent turn id that dispatched the subagent (subagent rows only)
+ * - `$eve.subagent`     — active compiled graph node id (subagent rows only)
+ * - `$eve.trigger`      — channel adapter kind (session/subagent rows)
+ * - `$eve.title`        — truncated session title from the first user message
+ */
+import type { EveAttributeValue } from "#runtime/attributes/emit.js";
+/**
+ * Active compiled graph node id for the session's agent. Returned by
+ * `createSessionStep` so workflow bodies don't have to load the bundle
+ * themselves. Equal to the framework root sentinel (`"__root__"`) for
+ * the root agent; equal to the subagent's compiled node id for
+ * delegated child runs. Tag emitters use this to populate
+ * `$eve.subagent`.
+ */
+export interface SessionIdentitySummary {
+    readonly nodeId: string;
+}
+/**
+ * Parent session lineage decoded from the serialized run context.
+ */
+export interface SessionParentLineage {
+    readonly callId?: string;
+    readonly rootSessionId?: string;
+    readonly sessionId?: string;
+    readonly turnId?: string;
+}
+/**
+ * Reads the active channel kind from a deserialized context map.
+ * Returns `undefined` when the channel slot is missing or malformed —
+ * tag emission silently drops undefined values.
+ */
+export declare function readChannelKind(serializedContext: Record<string, unknown>): string | undefined;
+/**
+ * Reads parent session lineage from a deserialized context map. Returns
+ * an empty object for top-level runs or malformed delegated contexts.
+ */
+export declare function readParentLineage(serializedContext: Record<string, unknown>): SessionParentLineage;
+/**
+ * Reads the immediate parent session id from a deserialized context map.
+ * Returns `undefined` when the run is a top-level session.
+ */
+export declare function readParentSessionId(serializedContext: Record<string, unknown>): string | undefined;
+/**
+ * Reads the **root** session id from a deserialized context map.
+ *
+ * `eve.parentSession.rootSessionId` is denormalized at every dispatch
+ * site (see {@link "#channel/types.js".SessionParent}) so a subagent
+ * five levels deep can still attribute itself to the top user-facing
+ * session without walking the chain. Returns `undefined` for top-level
+ * runs, which carry no `eve.parentSession`.
+ */
+export declare function readRootSessionId(serializedContext: Record<string, unknown>): string | undefined;
+/**
+ * Maximum visible length (in code points) of a derived `$eve.title`.
+ *
+ * The runtime separately caps every tag value to a byte budget
+ * (`EVE_ATTRIBUTE_VALUE_MAX_BYTES`), but titles render as the first
+ * column of the dashboard's run table, so they get a tighter,
+ * display-oriented cap here. Kept well under the byte budget so the
+ * value never reaches the runtime truncator.
+ */
+export declare const EVE_SESSION_TITLE_MAX_CHARS = 80;
+/**
+ * Derives the `$eve.title` value from the first user message of a
+ * top-level session.
+ *
+ * Returns `undefined` when no plain-text content is available; the
+ * attribute emitter strips undefined values. Multimodal messages
+ * (image/file parts) contribute only their text parts to keep the
+ * title human-readable. Long prompts are truncated to
+ * {@link EVE_SESSION_TITLE_MAX_CHARS} code points with a trailing
+ * ellipsis so the dashboard's title column stays readable.
+ */
+export declare function deriveSessionTitle(message: unknown): string | undefined;
+/**
+ * Builds the `$eve.*` attribute payload for a top-level session run
+ * (`workflowEntry` invoked without an `eve.parentSession`).
+ *
+ * `$eve.root` is intentionally omitted — the session row IS the root,
+ * so its own `workflowRunId` already identifies the chain root.
+ */
+export declare function buildSessionAttributes(input: {
+    readonly inputMessage: unknown;
+    readonly serializedContext: Record<string, unknown>;
+}): Record<string, EveAttributeValue>;
+/**
+ * Builds the `$eve.*` attribute payload for a delegated subagent root
+ * run (`workflowEntry` invoked with an `eve.parentSession`).
+ *
+ * `$eve.root` carries the **root** session id so the dashboard can
+ * group every descendant under one query: `search($eve.root=<root>)`
+ * returns all turns and nested subagents under that user-facing
+ * session in a single round trip.
+ */
+export declare function buildSubagentRootAttributes(input: {
+    readonly identity: SessionIdentitySummary;
+    readonly parentCallId?: string;
+    readonly parentSessionId: string;
+    readonly parentTurnId?: string;
+    readonly rootSessionId: string;
+    readonly serializedContext: Record<string, unknown>;
+}): Record<string, EveAttributeValue>;
+/**
+ * Builds the `$eve.*` attribute payload for one turn workflow run.
+ *
+ * Turns live one level below their session: `$eve.parent` always points
+ * to the parent's sessionId (which is the session-row's
+ * `workflowRunId`), and `$eve.root` denormalizes the chain root (equal
+ * to `$eve.parent` for turns of top-level sessions). Turn ordering is
+ * recovered from each run's `createdAt`, so no explicit sequence tag is
+ * emitted.
+ */
+export declare function buildTurnAttributes(input: {
+    readonly parentSessionId: string;
+    readonly rootSessionId: string;
+}): Record<string, EveAttributeValue>;

package/dist/src/execution/eve-workflow-attributes.js

@@ -0,0 +1 @@
+import{isNonEmptyString}from"#shared/guards.js";function readChannelKind(t){let n=t[`eve.channel`]?.kind;return isNonEmptyString(n)?n:void 0}function readParentLineage(t){let n=t[`eve.parentSession`],r=n?.callId,i=n?.rootSessionId,a=n?.sessionId,o=n?.turn?.id;return{callId:isNonEmptyString(r)?r:void 0,rootSessionId:isNonEmptyString(i)?i:void 0,sessionId:isNonEmptyString(a)?a:void 0,turnId:isNonEmptyString(o)?o:void 0}}function readParentSessionId(e){return readParentLineage(e).sessionId}function readRootSessionId(e){return readParentLineage(e).rootSessionId}const EVE_SESSION_TITLE_MAX_CHARS=80;function deriveSessionTitle(e){let t=collectMessageText(e);if(t===void 0||t.length===0)return;let n=t.replace(/\s+/gu,` `).trim();if(n.length===0)return;let r=Array.from(n);return r.length<=80?n:`${r.slice(0,79).join(``)}…`}function collectMessageText(e){if(typeof e==`string`)return e;if(!Array.isArray(e))return;let t=[];for(let n of e)n&&typeof n==`object`&&n.type===`text`&&typeof n.text==`string`&&t.push(n.text);return t.length>0?t.join(` `):void 0}function buildSessionAttributes(e){return{"$eve.type":`session`,"$eve.trigger":readChannelKind(e.serializedContext),"$eve.title":deriveSessionTitle(e.inputMessage)}}function buildSubagentRootAttributes(e){return{"$eve.type":`subagent`,"$eve.parent":e.parentSessionId,"$eve.parent_call":e.parentCallId,"$eve.parent_turn":e.parentTurnId,"$eve.root":e.rootSessionId,"$eve.subagent":e.identity.nodeId,"$eve.trigger":readChannelKind(e.serializedContext)}}function buildTurnAttributes(e){return{"$eve.type":`turn`,"$eve.parent":e.parentSessionId,"$eve.root":e.rootSessionId}}export{EVE_SESSION_TITLE_MAX_CHARS,buildSessionAttributes,buildSubagentRootAttributes,buildTurnAttributes,deriveSessionTitle,readChannelKind,readParentLineage,readParentSessionId,readRootSessionId};

package/dist/src/execution/next-driver-action.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Closed-contract dispatch surface between session-mutating step
+ * bodies (latest deployment) and the durable driver workflow (pinned
+ * to whichever deployment called `start()`).
+ *
+ * The driver matches on `kind` and follows a fixed playbook per arm.
+ * Adding a new arm is breaking (pinned drivers can't dispatch an
+ * unknown `kind`); adding optional fields inside an existing arm is
+ * forward-compatible because the driver passes the action through by
+ * reference and devalue preserves unknown POJO fields. Do not
+ * destructure-and-rebuild a `NextDriverAction` — full destructuring
+ * strips unknown fields.
+ */
+import type { DurableSessionState } from "#execution/durable-session-store.js";
+/** Discriminated union the driver workflow body dispatches on. */
+export type NextDriverAction = {
+    readonly kind: "done";
+    readonly output: unknown;
+    readonly isError?: boolean;
+    readonly sessionState: DurableSessionState;
+    readonly serializedContext: Record<string, unknown>;
+} | {
+    readonly kind: "park";
+    readonly sessionState: DurableSessionState;
+    readonly serializedContext: Record<string, unknown>;
+    readonly authorizationNames?: readonly string[];
+} | {
+    readonly kind: "dispatch-runtime-actions";
+    readonly pendingActionKeys: readonly string[];
+    readonly sessionState: DurableSessionState;
+    readonly serializedContext: Record<string, unknown>;
+} | {
+    readonly kind: "dispatch-code-mode-runtime-actions";
+    readonly pendingActionKeys: readonly string[];
+    readonly sessionState: DurableSessionState;
+    readonly serializedContext: Record<string, unknown>;
+};

package/dist/src/execution/next-driver-action.js

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

package/dist/src/execution/node-step.d.ts

@@ -0,0 +1,52 @@
+import type { Runtime, SessionCapabilities } from "#channel/types.js";
+import type { HandleEventFn, HarnessToolMap, StepFn } from "#harness/types.js";
+import type { RunMode } from "#shared/run-mode.js";
+import type { RuntimeCompiledArtifactsSource } from "#runtime/compiled-artifacts-source.js";
+import type { ResolvedRuntimeAgentNode } from "#runtime/graph.js";
+/**
+ * Factory that creates a {@link Runtime} for the given compiled
+ * artifacts source and optional node id. Matches the signature of
+ * `createWorkflowRuntime`, so callers pass the constructor directly —
+ * no wrapper needed.
+ */
+export type CreateRuntime = (config: {
+    readonly compiledArtifactsSource: RuntimeCompiledArtifactsSource;
+    readonly nodeId?: string;
+}) => Runtime;
+/**
+ * Input for building a harness step for one resolved runtime node.
+ */
+export interface CreateExecutionNodeStepInput {
+    /**
+     * Session-level capabilities propagated from the runtime. The
+     * harness passes this through to `buildToolSet` so `ask_question`
+     * registration and any other capability-gated behavior tracks the
+     * current run.
+     */
+    readonly capabilities?: SessionCapabilities;
+    readonly compiledArtifactsSource: RuntimeCompiledArtifactsSource;
+    /**
+     * Runtime constructor used by the subagent tool executor to start
+     * delegated child runs on the same workflow runtime as the parent.
+     */
+    readonly createRuntime: CreateRuntime;
+    readonly handleEvent?: HandleEventFn;
+    readonly mode: RunMode;
+    readonly node: ResolvedRuntimeAgentNode;
+}
+/**
+ * Builds a harness step for one resolved runtime node using the execution-owned
+ * tool, sandbox, and subagent wiring.
+ */
+export declare function createExecutionNodeStep(input: CreateExecutionNodeStepInput): StepFn;
+/**
+ * Resolves unified {@link HarnessToolDefinition}s from the node's registries.
+ *
+ * For authored tools: copies all lifecycle fields from the resolved definition.
+ * For subagent tools: surfaces runtime-owned subagent-call metadata and leaves
+ * execution to the runtime layer.
+ * Tools without `execute` (provider-managed) get entries with schema but no execute.
+ */
+export declare function createNodeHarnessTools(input: {
+    readonly node: ResolvedRuntimeAgentNode;
+}): HarnessToolMap;

package/dist/src/execution/node-step.js

@@ -0,0 +1 @@
+import{createLogger}from"#internal/logging.js";import{jsonSchema}from"ai";import{resolveInstalledPackageInfo}from"#internal/application/package.js";import{createToolLoopHarness}from"#harness/tool-loop.js";import{resolveCodeModeEnabled}from"#shared/code-mode.js";import{resolveRuntimeModelReference}from"#runtime/agent/resolve-model.js";import{findRegisteredRuntimeTool}from"#runtime/tools/registry.js";import{SUBAGENT_TOOL_INPUT_SCHEMA}from"#runtime/subagents/registry.js";import{createToolCompactionHandler}from"#execution/tool-compaction.js";import{buildUnauthorizedToolContext,createAuthorizedToolExecute}from"#execution/tool-auth.js";const log=createLogger(`execution.node-step`);function createExecutionNodeStep(e){let t=createRuntimeModelResolver(e.compiledArtifactsSource),n=createNodeHarnessTools({node:e.node}),a=createToolCompactionHandler(collectResolvedTools(e.node));return createToolLoopHarness({capabilities:e.capabilities,codeMode:resolveCodeModeEnabled(e.node.agent.config?.experimental?.codeMode),workflow:e.node.agent.workflowEnabled===!0,handleEvent:e.handleEvent,mode:e.mode,onCompaction:a,resolveModel:t,runtimeIdentity:buildRuntimeIdentity(e.node),tools:n})}function buildRuntimeIdentity(e){let t=resolveInstalledPackageInfo(),r={agentId:e.turnAgent.id,agentName:e.agent.config?.name,eveVersion:t.version,modelId:e.turnAgent.model.id},i=process.env.VERCEL_GIT_COMMIT_SHA?.trim(),a=process.env.VERCEL_GIT_COMMIT_REF?.trim(),o=process.env.VERCEL_DEPLOYMENT_CREATED_AT?.trim();return i||a||o?{...r,build:{deployedAt:o||void 0,gitBranch:a||void 0,gitSha:i||void 0}}:r}function createRuntimeModelResolver(e){return t=>resolveRuntimeModelReference(t,{compiledArtifactsSource:e})}function collectResolvedTools(e){return[...e.toolRegistry.toolsByName.values()].map(e=>e.definition)}function createNodeHarnessTools(e){let n=new Map;for(let t of e.node.turnAgent.tools){let r=resolveHarnessToolDefinition({node:e.node,tool:t});r!==null&&n.set(t.name,r)}return n.has(`agent`)||n.set(`agent`,{description:`Launch a new agent to handle a complex, multi-step subtask.`,inputSchema:jsonSchema(SUBAGENT_TOOL_INPUT_SCHEMA),name:`agent`,runtimeAction:{kind:`subagent-call`,nodeId:e.node.nodeId,subagentName:`agent`}}),n}function resolveHarnessToolDefinition(e){if(e.tool.kind===`subagent`)return{description:e.tool.description??``,inputSchema:jsonSchema(e.tool.inputSchema??{}),name:e.tool.name,outputSchema:e.tool.outputSchema===void 0?void 0:jsonSchema(e.tool.outputSchema),runtimeAction:{kind:`subagent-call`,nodeId:e.tool.nodeId,subagentName:e.tool.name}};if(e.tool.kind===`remote`)return{description:e.tool.description??``,inputSchema:jsonSchema(e.tool.inputSchema??{}),name:e.tool.name,outputSchema:e.tool.outputSchema===void 0?void 0:jsonSchema(e.tool.outputSchema),runtimeAction:{kind:`remote-agent-call`,nodeId:e.tool.nodeId,remoteAgentName:e.tool.name,subagentName:e.tool.name}};let n=findRegisteredRuntimeTool(e.node.toolRegistry,e.tool.name);if(n===null)return log.warn(`declared tool is not registered — omitting from toolset`,{toolName:e.tool.name,nodeId:e.node.nodeId}),null;let r=n.definition,i=r.sourceId.startsWith(`eve:`),a=r.execute;return{approvalKey:r.approvalKey,description:r.description,execute:resolveAuthoredExecute({auth:r.auth,isFrameworkTool:i,rawExecute:a,scope:r.name}),inputSchema:r.inputStandardSchema??jsonSchema(r.inputSchema??{}),name:r.name,needsApproval:r.needsApproval,outputSchema:r.outputStandardSchema??maybeJsonSchema(r.outputSchema),toModelOutput:r.toModelOutput}}function resolveAuthoredExecute(e){let{auth:t,isFrameworkTool:n,rawExecute:r,scope:i}=e;if(r===void 0)return;if(n)return r;let a=r;return t===void 0?e=>a(e,buildUnauthorizedToolContext(i)):createAuthorizedToolExecute({auth:t,execute:a,scope:i})}function maybeJsonSchema(e){return e===void 0?void 0:jsonSchema(e)}export{createExecutionNodeStep,createNodeHarnessTools};

package/dist/src/execution/remote-agent-dispatch.d.ts

@@ -0,0 +1,15 @@
+import type { HarnessSession } from "#harness/types.js";
+import type { RuntimeRemoteAgentCallActionRequest } from "#runtime/actions/types.js";
+import type { RuntimeSubagentRegistry } from "#runtime/subagents/registry.js";
+import type { ResolvedRuntimeRemoteAgentNode } from "#runtime/types.js";
+export declare function startRemoteAgentSession(input: {
+    readonly action: RuntimeRemoteAgentCallActionRequest;
+    readonly callbackBaseUrl: string | undefined;
+    readonly remote: ResolvedRuntimeRemoteAgentNode;
+    readonly session: HarnessSession;
+}): Promise<string>;
+export declare function resolveRemoteAgentForAction(input: {
+    readonly nodeId: string;
+    readonly registry: RuntimeSubagentRegistry["subagentsByNodeId"];
+    readonly remoteAgentName: string;
+}): ResolvedRuntimeRemoteAgentNode;

package/dist/src/execution/remote-agent-dispatch.js

@@ -0,0 +1 @@
+import{createEveCallbackRoutePath}from"#protocol/routes.js";import{EVE_SESSION_ID_HEADER}from"#protocol/message.js";import{createWorkflowCallbackUrl}from"#execution/workflow-callback-url.js";import{formatSubagentInvocation}from"#execution/subagent-invocation.js";async function startRemoteAgentSession(n){let r=n.session.continuationToken;if(!r)throw Error(`Cannot dispatch remote agent without a parent continuation token.`);if(!n.callbackBaseUrl)throw Error(`Cannot dispatch remote agent without a callback base URL.`);let i=await resolveRemoteAgentRequestHeaders(n.remote),a=await fetch(createRemoteAgentSessionUrl(n.remote),{body:JSON.stringify({callback:{callId:n.action.callId,subagentName:n.action.remoteAgentName,token:r,url:createWorkflowCallbackUrl(n.callbackBaseUrl,createEveCallbackRoutePath(r))},message:formatRemoteAgentCallInputMessage(n.action),mode:`task`,outputSchema:n.action.input.outputSchema??n.remote.outputSchema}),headers:{"content-type":`application/json`,...i},method:`POST`});if(!a.ok)throw Error(`Remote agent "${n.action.remoteAgentName}" create-session request failed with HTTP ${a.status}.`);let o=a.headers.get(EVE_SESSION_ID_HEADER);if(o!==null&&o.length>0)return o;try{let e=await a.json();if(typeof e.sessionId==`string`&&e.sessionId.length>0)return e.sessionId}catch{}throw Error(`Remote agent "${n.action.remoteAgentName}" create-session response did not include a session id.`)}function resolveRemoteAgentForAction(e){let t=e.registry.get(e.nodeId)?.definition;if(t?.kind!==`remote`)throw Error(`Missing remote agent "${e.remoteAgentName}" in runtime registry.`);return t}function createRemoteAgentSessionUrl(e){return new URL(e.path,`${trimTrailingSlash(e.url)}/`).toString()}async function resolveRemoteAgentRequestHeaders(e){let t={};return e.headers!==void 0&&Object.assign(t,typeof e.headers==`function`?await e.headers():e.headers),e.auth!==void 0&&Object.assign(t,(await e.auth()).headers),t}function formatRemoteAgentCallInputMessage(e){let t=typeof e.input.message==`string`?e.input.message:``;return formatSubagentInvocation({description:e.description,message:t,name:e.remoteAgentName}).message}function trimTrailingSlash(e){return e.endsWith(`/`)?e.slice(0,-1):e}export{resolveRemoteAgentForAction,startRemoteAgentSession};

package/dist/src/execution/runtime-context.d.ts

@@ -0,0 +1,10 @@
+import type { RunInput } from "#channel/types.js";
+import { ContextContainer } from "#context/container.js";
+import { type CompiledBundle } from "#runtime/sessions/runtime-context-keys.js";
+/**
+ * Builds the bootstrap {@link ContextContainer} for one run.
+ */
+export declare function buildRunContext(input: {
+    readonly bundle: CompiledBundle;
+    readonly run: RunInput;
+}): ContextContainer;