eve 0.5.4 → 0.6.0-beta.3

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

@@ -0,0 +1,272 @@
+import type { LanguageModel } from "ai";
+import type { HandleMessageStreamEvent, RuntimeIdentity } from "#protocol/message.js";
+import type { AgentModelOptionsDefinition } from "#shared/agent-definition.js";
+import type { EvalReporter } from "#evals/runner/reporters/types.js";
+/**
+ * One normalized eval case. Suites produce these from raw data sources.
+ */
+export interface EveEvalCase {
+    /** Uniquely identifies the case within its suite. */
+    readonly id: string;
+    /**
+     * The case prompt, or a structured record the task derives messages from.
+     * A string is sent verbatim and a record is `JSON.stringify`d, unless the
+     * task's `messages`/`prompt` reads specific fields.
+     */
+    readonly input: string | Record<string, unknown>;
+    /**
+     * Reference value scorers compare against. The runner coerces this to a
+     * string for autoevals-compatible scorers; `args.case.expected` exposes it
+     * unmodified.
+     */
+    readonly expected?: unknown;
+    /** Passed through for filtering and reporting. */
+    readonly tags?: readonly string[];
+    /** Passed through for reporting and Braintrust span logging. */
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+/**
+ * Execution facts the runner extracts from a completed session's stream events.
+ */
+export interface EveEvalDerivedFacts {
+    readonly toolCalls: readonly string[];
+    readonly toolCallCount: number;
+    readonly subagentCalls: readonly string[];
+    readonly subagentCallCount: number;
+    readonly messageCount: number;
+    readonly reasoningBlockCount: number;
+    readonly failureCode?: string;
+}
+/**
+ * Full result of executing one eval case against an Eve agent.
+ */
+export interface EveEvalTaskResult {
+    /**
+     * The scored value. Defaults to `finalMessage` unless `task.parseOutput`
+     * overrides it. Mutable because the runner assigns it after parsing.
+     */
+    output: unknown;
+    /** The agent's last assistant message, or null when none was produced. */
+    readonly finalMessage: string | null;
+    readonly sessionId?: string;
+    /**
+     * How the run's final turn ended: `"completed"` (session finished),
+     * `"failed"` (terminal failure), or `"waiting"` (parked for the next
+     * user message).
+     */
+    readonly status: "completed" | "failed" | "waiting";
+    /** The captured stream events from the run. */
+    readonly events: readonly HandleMessageStreamEvent[];
+    /** Facts extracted from the stream (tool calls, message counts, etc.). */
+    readonly derived: EveEvalDerivedFacts;
+    /**
+     * Runtime identity metadata captured from the `session.started` stream event.
+     * Present when the Eve server populates the event with its runtime metadata.
+     */
+    readonly runtimeIdentity?: RuntimeIdentity;
+}
+/**
+ * Result returned by a single scorer invocation.
+ */
+export interface EveEvalScorerResult {
+    /** Scorer name. Used as the key in Braintrust score maps. */
+    readonly name: string;
+    /** Score between 0 and 1, or null if the scorer could not produce a score. */
+    readonly score: number | null;
+    /** Optional metadata for debugging or Braintrust span logging. */
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+/**
+ * Arguments passed to every scorer invocation.
+ *
+ * The flat `input`, `output`, and `expected` fields are coerced to `string`
+ * for compatibility with Braintrust autoevals scorers (e.g. `Factuality`,
+ * `Levenshtein`). For the original values, use `case.input`, `case.expected`,
+ * and `result.output`.
+ */
+export interface EveEvalScorerArgs {
+    /** The eval case input, coerced to string. Autoevals-compatible. */
+    readonly input: string;
+    /** The task output, coerced to string. Autoevals-compatible. */
+    readonly output: string;
+    /** The expected value, coerced to string. Autoevals-compatible. */
+    readonly expected?: string | undefined;
+    /** Suite-level scorer model. This does not change the target Eve agent model. */
+    readonly model: LanguageModel;
+    /** Suite-level provider options for model-backed scorers. */
+    readonly modelOptions?: AgentModelOptionsDefinition;
+    /** Full eval case. */
+    readonly case: EveEvalCase;
+    /** Full task result with events and derived facts. */
+    readonly result: EveEvalTaskResult;
+}
+/**
+ * Receives flattened input/output/expected fields (autoevals-compatible) plus
+ * the full Eve case and result. Return `null` to skip scoring a case (e.g. when
+ * expected is absent).
+ */
+export type EveEvalScorer = (args: EveEvalScorerArgs) => EveEvalScorerResult | Promise<EveEvalScorerResult | null> | null;
+export interface EveEvalTaskFields {
+    readonly messages?: (testCase: EveEvalCase) => string[];
+    /**
+     * Transform the raw task result into the scored output value. Available on
+     * every task variant. When omitted, `result.output` defaults to
+     * `result.finalMessage`.
+     */
+    readonly parseOutput?: (result: EveEvalTaskResult) => unknown;
+    readonly prompt?: (testCase: EveEvalCase) => string;
+}
+/**
+ * Declarative task configuration for a suite. The runner owns session
+ * lifecycle, stream capture, and derived metadata; suites only declare how to
+ * derive messages and parse outputs.
+ */
+export type EveEvalTask = (EveEvalTaskFields & {
+    /**
+     * Derive an ordered list of messages for a multi-turn eval.
+     * Mutually exclusive with `prompt`.
+     */
+    readonly messages: (testCase: EveEvalCase) => string[];
+    readonly prompt?: never;
+}) | (EveEvalTaskFields & {
+    readonly messages?: never;
+    /**
+     * Derive a single prompt string from one eval case.
+     * Mutually exclusive with `messages`.
+     */
+    readonly prompt: (testCase: EveEvalCase) => string;
+}) | {
+    readonly messages?: never;
+    /** See {@link EveEvalTaskFields.parseOutput}. */
+    readonly parseOutput?: (result: EveEvalTaskResult) => unknown;
+    readonly prompt?: never;
+};
+/**
+ * Describes the Eve server an eval suite runs against.
+ */
+export interface EveEvalTarget {
+    /**
+     * `"local"` for a dev server the runner starts in-process, `"remote"` for
+     * a deployed instance addressed by `--url`.
+     */
+    readonly kind: "local" | "remote";
+    /** Base HTTP URL the eval client connects to and sends message requests. */
+    readonly url: string;
+}
+/**
+ * Shared fields between the user-facing input and the validated suite.
+ *
+ * Suite identity (`id`) is derived from the `evals/<path>.eval.ts` file
+ * path by the discovery layer; it is not authored on the input.
+ */
+interface EveEvalSuiteBase {
+    readonly description?: string;
+    readonly task?: EveEvalTask;
+    readonly scores: readonly EveEvalScorer[];
+    /**
+     * Required model used by model-backed scorers in this suite.
+     *
+     * String model IDs route through the Vercel AI Gateway; the runner uses
+     * provider model instances directly. This model is only for scoring and
+     * never changes the Eve agent under test.
+     */
+    readonly model: LanguageModel;
+    /**
+     * Provider-specific options passed to model-backed scorers.
+     */
+    readonly modelOptions?: AgentModelOptionsDefinition;
+    /**
+     * Maximum number of cases the runner executes at once.
+     * Defaults to 8 when omitted.
+     */
+    readonly maxConcurrency?: number;
+    readonly timeoutMs?: number;
+    readonly tags?: readonly string[];
+    readonly metadata?: Readonly<Record<string, unknown>>;
+    readonly reporters?: readonly EvalReporter[];
+    /**
+     * Minimum score thresholds per scorer name. A case "passes" when every
+     * scorer meets or exceeds its threshold. Scorers not listed here
+     * default to a threshold of 1.0 (exact match).
+     *
+     * @example
+     * ```ts
+     * thresholds: {
+     *   "Factuality": 0.5,
+     *   "run.didNotFail": 1.0,
+     * }
+     * ```
+     */
+    readonly thresholds?: Readonly<Record<string, number>>;
+}
+/**
+ * Complete top-level key set accepted by {@link defineEvalSuite}, used to reject
+ * unknown authored keys. The stricter {@link EveEvalSuiteInput} union enforces
+ * `load`/`cases` exclusivity.
+ */
+export interface EveEvalSuiteInputFields extends Omit<EveEvalSuiteBase, "task"> {
+    readonly cases?: readonly EveEvalCase[];
+    readonly task?: EveEvalTaskFields;
+    load?(): Promise<EveEvalCase[]>;
+}
+/**
+ * Full suite input passed to `defineEvalSuite()`.
+ *
+ * Provide either `load` (async function) or `cases` (static array), not both;
+ * `cases` causes the runner to synthesize a `load` internally. Suite identity is
+ * derived from the file path, so authors do not specify an `id` or `name`.
+ */
+export type EveEvalSuiteInput = (EveEvalSuiteBase & {
+    readonly cases?: never;
+    /** Load cases dynamically. Mutually exclusive with `cases`. */
+    load(): Promise<EveEvalCase[]>;
+}) | (EveEvalSuiteBase & {
+    /** Static inline cases. Mutually exclusive with `load`. */
+    readonly cases: readonly EveEvalCase[];
+    load?: never;
+});
+/**
+ * Suite returned by `defineEvalSuite()`. Carries no `id` yet: discovery stamps
+ * the path-derived id at import time to produce a full {@link EveEvalSuite}. The
+ * `_tag` literal (`"EveEvalSuite"`) brands the value so discovery and the runner
+ * can recognize a defined suite.
+ */
+export interface EveEvalSuiteDefinition extends EveEvalSuiteBase {
+    readonly _tag: "EveEvalSuite";
+    /** Always present. Synthesized from `cases` when the input uses static cases. */
+    load(): Promise<EveEvalCase[]>;
+}
+/**
+ * Validated suite consumed by the runner and reporters. The `id` is the
+ * path-derived slug attached by discovery
+ * (e.g. `evals/weather.eval.ts` → `"weather"`).
+ */
+export interface EveEvalSuite extends EveEvalSuiteDefinition {
+    readonly id: string;
+}
+/**
+ * Result of scoring one eval case.
+ */
+export interface EveEvalCaseResult {
+    readonly case: EveEvalCase;
+    readonly result: EveEvalTaskResult;
+    readonly scores: readonly EveEvalScorerResult[];
+    readonly error?: string;
+}
+/**
+ * Aggregated result for one suite run.
+ *
+ * `suite` is the path-derived suite id
+ * (e.g. `evals/weather.eval.ts` → `"weather"`).
+ */
+export interface EveEvalSuiteResult {
+    readonly suite: string;
+    readonly target: EveEvalTarget;
+    readonly cases: readonly EveEvalCaseResult[];
+    readonly startedAt: string;
+    readonly completedAt: string;
+    readonly passed: number;
+    /** Cases that raised an execution error (timeout, connection failure, etc.). */
+    readonly errored: number;
+}
+export {};

package/dist/src/evals/types.js

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

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

@@ -0,0 +1,5 @@
+import type { ChannelAdapter } from "#channel/adapter.js";
+import type { ContextContainer } from "#context/container.js";
+export declare function setChannelContext(ctx: ContextContainer, adapter: ChannelAdapter, options?: {
+    readonly channelName?: string;
+}): void;

package/dist/src/execution/channel-context.js

@@ -0,0 +1 @@
+import{ChannelInstrumentationKey}from"#context/keys.js";import{ChannelKey}from"#runtime/sessions/runtime-context-keys.js";import{buildChannelInstrumentationProjection}from"#channel/instrumentation.js";function setChannelContext(e,t,n={}){e.set(ChannelKey,t),e.set(ChannelInstrumentationKey,buildChannelInstrumentationProjection({adapter:t,channelName:n.channelName,existingKind:e.get(ChannelInstrumentationKey)?.kind}))}export{setChannelContext};

package/dist/src/execution/connection-auth-tool-result.d.ts

@@ -0,0 +1,2 @@
+import type { JsonValue } from "#public/types/json.js";
+export declare function normalizeConnectionAuthToolResult(result: unknown): JsonValue;

package/dist/src/execution/connection-auth-tool-result.js

@@ -0,0 +1 @@
+function normalizeConnectionAuthToolResult(e){if(e===void 0)return null;try{return JSON.parse(JSON.stringify(e))}catch{return{error:`tool_result_not_serializable`,retryable:!1}}}export{normalizeConnectionAuthToolResult};

package/dist/src/execution/create-session-step.d.ts

@@ -0,0 +1,43 @@
+import type { RuntimeCompiledArtifactsSource } from "#runtime/compiled-artifacts-source.js";
+import { type DurableSessionState } from "#execution/durable-session-store.js";
+import type { JsonObject } from "#shared/json.js";
+/**
+ * Result returned by {@link createSessionStep}.
+ *
+ * Exposes the projected {@link DurableSessionState} the driver needs to
+ * drive the turn loop.
+ */
+export interface CreateSessionStepResult {
+    readonly state: DurableSessionState;
+}
+/**
+ * Creates the durable session and returns the initial snapshot-bearing
+ * state before the workflow enters its turn loop.
+ * `nodeId` targets a subagent node in the compiled graph; omitted for
+ * the root agent.
+ *
+ * Emits the session/subagent-root `$eve.*` tags from inside this step
+ * (so the attribute write folds into a step the session already runs)
+ * and returns the durable state value the driver consumes.
+ */
+export declare function createSessionStep(input: {
+    readonly compiledArtifactsSource: RuntimeCompiledArtifactsSource;
+    readonly continuationToken: string;
+    /**
+     * First user message of the run, used to derive `$eve.title` for
+     * top-level sessions. Threaded in so the session/subagent-root tags
+     * can be emitted from inside this step (see the tag write below)
+     * instead of the workflow body, where each `setEveAttributes` call
+     * spends a standalone `__builtin_set_attributes` step.
+     */
+    readonly inputMessage: unknown;
+    readonly outputSchema?: JsonObject;
+    readonly nodeId?: string;
+    readonly rootSessionId?: string;
+    /**
+     * Shared serialized context, read for `$eve.trigger` (channel kind)
+     * and to detect whether this run is a delegated subagent root.
+     */
+    readonly serializedContext: Record<string, unknown>;
+    readonly sessionId: string;
+}): Promise<CreateSessionStepResult>;

package/dist/src/execution/create-session-step.js

@@ -0,0 +1 @@
+import{ROOT_RUNTIME_AGENT_NODE_ID}from"#runtime/graph.js";import{getCompiledRuntimeAgentBundle}from"#runtime/sessions/compiled-agent-cache.js";import{createDurableSessionState}from"#execution/durable-session-store.js";import{createSession}from"#execution/session.js";import{buildSessionAttributes,buildSubagentRootAttributes,readParentLineage}from"#execution/eve-workflow-attributes.js";import{setEveAttributes}from"#runtime/attributes/emit.js";async function createSessionStep(e){"use step";let t=await getCompiledRuntimeAgentBundle({compiledArtifactsSource:e.compiledArtifactsSource,nodeId:e.nodeId}),n=createDurableSessionState({session:createSession({compactionOverrides:{thresholdPercent:t.resolvedAgent.config.compaction?.thresholdPercent},continuationToken:e.continuationToken,outputSchema:e.outputSchema,rootSessionId:e.rootSessionId,sessionId:e.sessionId,turnAgent:t.turnAgent})}),r={nodeId:t.nodeId??ROOT_RUNTIME_AGENT_NODE_ID},i=readParentLineage(e.serializedContext);return i.sessionId===void 0?await setEveAttributes(buildSessionAttributes({inputMessage:e.inputMessage,serializedContext:e.serializedContext})):await setEveAttributes(buildSubagentRootAttributes({identity:r,parentCallId:i.callId,parentSessionId:i.sessionId,parentTurnId:i.turnId,rootSessionId:e.rootSessionId??i.sessionId,serializedContext:e.serializedContext})),{state:n}}export{createSessionStep};

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