eve 0.5.4 → 0.6.0-beta.3

package/dist/src/execution/subagent-invocation.d.ts

@@ -0,0 +1,16 @@
+import type { StepInput } from "#harness/types.js";
+/**
+ * Narrowed form of {@link StepInput} whose `message` is always a plain string.
+ * Delegated child runs receive a synthesized text-only prompt.
+ */
+export interface FormattedSubagentInvocation extends StepInput {
+    readonly message: string;
+}
+/**
+ * Formats the stable delegated input handed to one child agent invocation.
+ */
+export declare function formatSubagentInvocation(input: {
+    readonly description: string;
+    readonly message: string;
+    readonly name: string;
+}): FormattedSubagentInvocation;

package/dist/src/execution/subagent-invocation.js

@@ -0,0 +1,2 @@
+function formatSubagentInvocation(e){return{message:[`You are the subagent "${e.name}".`,`Description: ${e.description}`,``,`The caller delegated the following task to you. Complete it and return the final result directly.`,``,`Caller message:`,e.message].join(`
+`)}}export{formatSubagentInvocation};

package/dist/src/execution/subagent-tool.d.ts

@@ -0,0 +1,39 @@
+import type { ChannelInstrumentationProjection, RunInput, SessionAuthContext, SessionCapabilities } from "#channel/types.js";
+import type { HarnessSession } from "#harness/types.js";
+import type { RuntimeSubagentCallActionRequest } from "#runtime/actions/types.js";
+/**
+ * Pending runtime-action batch event metadata needed for child run lineage.
+ */
+interface BatchEventMetadata {
+    readonly sequence: number;
+    readonly turnId: string;
+}
+/**
+ * Result of {@link buildSubagentRunInput}.
+ *
+ * Exposes the derived `childContinuationToken` alongside the
+ * {@link RunInput} so dispatch sites never re-derive the token from
+ * `(callId, parentSessionId)` on their own.
+ */
+export interface SubagentRunInputBuild {
+    readonly childContinuationToken: string;
+    readonly runInput: RunInput;
+}
+/**
+ * Builds the {@link RunInput} for one delegated subagent child run.
+ */
+export declare function buildSubagentRunInput(input: {
+    readonly action: RuntimeSubagentCallActionRequest;
+    readonly auth: SessionAuthContext | null;
+    readonly batchEvent: BatchEventMetadata;
+    /**
+     * Parent's session capabilities. Forwarded verbatim so HITL
+     * readiness flows transparently down through a subagent chain. Undefined
+     * parent capabilities produce an undefined child capability set.
+     */
+    readonly capabilities?: SessionCapabilities;
+    readonly channelMetadata?: ChannelInstrumentationProjection;
+    readonly initiatorAuth: SessionAuthContext | null;
+    readonly session: HarnessSession;
+}): SubagentRunInputBuild;
+export {};

package/dist/src/execution/subagent-tool.js

@@ -0,0 +1 @@
+import{mintSubagentContinuationToken}from"#execution/session.js";import{SUBAGENT_ADAPTER_KIND}from"#execution/subagent-adapter.js";import{formatSubagentInvocation}from"#execution/subagent-invocation.js";function buildSubagentRunInput(n){let{action:r,auth:i,batchEvent:a,capabilities:o,channelMetadata:s,initiatorAuth:c,session:l}=n,u=mintSubagentContinuationToken(`${l.sessionId}:${r.callId}`),d=l.rootSessionId??l.sessionId;return{childContinuationToken:u,runInput:{adapter:{kind:SUBAGENT_ADAPTER_KIND,state:{callId:r.callId,parentContinuationToken:l.continuationToken,parentSessionId:l.sessionId,subagentName:r.subagentName,...r.subagentName===`agent`&&l.sandboxState?{parentSandboxState:l.sandboxState,sandboxSessionId:l.sessionId}:{}}},auth:i,capabilities:o,channelMetadata:s,continuationToken:u,initiatorAuth:c,input:{message:formatSubagentCallInputMessage(r),outputSchema:r.input.outputSchema},mode:`task`,parent:{callId:r.callId,rootSessionId:d,sessionId:l.sessionId,turn:{id:a.turnId,sequence:a.sequence}}}}}function formatSubagentCallInputMessage(e){let{message:t}=e.input;return formatSubagentInvocation({description:e.description,message:t,name:e.subagentName}).message}export{buildSubagentRunInput};

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

@@ -0,0 +1,42 @@
+/**
+ * Tool-hosted authorization wiring for authored tools that declare
+ * `auth` on {@link defineTool}.
+ *
+ * Mirrors the connection authorization flow (see
+ * `runtime/framework-tools/connection-search-dynamic.ts`) but scopes the
+ * per-step token cache and framework-owned callback URL by the tool's
+ * path-derived name instead of a connection name. All the shared
+ * machinery — principal resolution, cache reads/writes, the park/resume
+ * webhook dance, and the loop guard — lives in
+ * `runtime/connections/scoped-authorization.ts`; this module is the thin
+ * execution-layer adapter that wraps one tool's `execute`.
+ */
+import type { ToolContext } from "#public/definitions/tool.js";
+import type { AuthorizationDefinition } from "#runtime/connections/types.js";
+/**
+ * Wraps one authored tool's `execute` with the tool-hosted
+ * authorization flow.
+ *
+ * Each invocation:
+ * 1. Completes an authorization whose OAuth callback arrived this turn,
+ *    caching the freshly minted token (the loop-guard flag).
+ * 2. Runs the authored `execute` with a {@link ToolContext} whose
+ *    `getToken()` / `requireAuth()` are bound to this tool's scope.
+ * 3. On a thrown `ConnectionAuthorizationRequiredError` — implicit from
+ *    `getToken()` or explicit via `requireAuth()` — either fails
+ *    terminally (token rejected immediately after sign-in) or starts the
+ *    interactive flow and returns an `AuthorizationSignal` to park the
+ *    turn. Non-interactive strategies (no callback URL) rethrow the
+ *    original error so the model sees a normal failure.
+ */
+export declare function createAuthorizedToolExecute(input: {
+    readonly scope: string;
+    readonly auth: AuthorizationDefinition;
+    readonly execute: (toolInput: unknown, ctx: unknown) => unknown;
+}): (toolInput: unknown) => Promise<unknown>;
+/**
+ * Builds the {@link ToolContext} for an authored tool that does **not**
+ * declare `auth`. The token accessors are present (the type promises
+ * them) but throw, since there is no strategy to resolve a token from.
+ */
+export declare function buildUnauthorizedToolContext(scope: string): ToolContext;

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

@@ -0,0 +1 @@
+import{buildCallbackContext}from"#context/build-callback-context.js";import{ConnectionAuthorizationFailedError,ConnectionAuthorizationRequiredError,isConnectionAuthorizationRequiredError}from"#public/connections/errors.js";import{completeScopedAuthorization,resolveScopedToken,startScopedAuthorization}from"#runtime/connections/scoped-authorization.js";function createAuthorizedToolExecute(e){let{scope:n,auth:i,execute:a}=e,o={authorization:i,connection:{url:``},scope:n};return async e=>{let i=await completeScopedAuthorization(o);try{return await a(e,buildToolContext(o))}catch(e){if(!isConnectionAuthorizationRequiredError(e))throw e;if(i)throw new ConnectionAuthorizationFailedError(n,{message:`Tool "${n}" rejected the token immediately after authorization.`,reason:`token_rejected_after_authorization`,retryable:!1});let r=await startScopedAuthorization(o);if(r===void 0)throw e;return r}}}function buildUnauthorizedToolContext(t){return{...buildCallbackContext(),getToken(){throw noAuthError(t)},requireAuth(){throw noAuthError(t)}}}function buildToolContext(t){return{...buildCallbackContext(),getToken(){return resolveScopedToken(t)},requireAuth(){throw new ConnectionAuthorizationRequiredError(t.scope)}}}function noAuthError(e){return Error(`Tool "${e}" called ctx.getToken()/ctx.requireAuth() but does not declare an "auth" strategy. Add \`auth\` to the tool definition (e.g. \`connect("...")\` from "@vercel/connect/eve").`)}export{buildUnauthorizedToolContext,createAuthorizedToolExecute};

package/dist/src/execution/tool-compaction.d.ts

@@ -0,0 +1,9 @@
+import type { CompactionCallbackResult, HarnessSession } from "#harness/types.js";
+import type { ResolvedToolDefinition } from "#runtime/types.js";
+/**
+ * Builds the harness compaction callback for a list of resolved tools.
+ *
+ * Hooks run in registration order inside the active `AlsContext`; throws
+ * are logged so one buggy hook cannot block the rest.
+ */
+export declare function createToolCompactionHandler(tools: readonly ResolvedToolDefinition[]): (session: HarnessSession) => Promise<CompactionCallbackResult>;

package/dist/src/execution/tool-compaction.js

@@ -0,0 +1 @@
+import{createLogger}from"#internal/logging.js";import{buildCallbackContext}from"#context/build-callback-context.js";const log=createLogger(`execution.tool-compaction`);function createToolCompactionHandler(e){let n=e.filter(e=>e.onCompact!==void 0);return async e=>{if(n.length===0)return{messages:[],session:e};let r=buildCallbackContext(),i=new AbortController().signal,a=[],o=e.state??{},s=!1;for(let t of n){let n=t.onCompact;if(n===void 0)continue;let c;try{c=await n({history:e.history,signal:i},r)??{}}catch(e){log.warn(`compaction hook for tool "${t.name}" threw and was skipped`,{toolName:t.name,error:e});continue}c.messages!==void 0&&c.messages.length>0&&a.push(...c.messages),c.sessionPatch!==void 0&&(o={...o,...c.sessionPatch},s=!0)}return{messages:a,session:s?{...e,state:o}:e}}}export{createToolCompactionHandler};

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

@@ -0,0 +1,30 @@
+import type { NextDriverAction } from "#execution/next-driver-action.js";
+import { type TurnWorkflowInput } from "#execution/durable-session-migrations/turn-workflow.js";
+/**
+ * Hook payload the turn child workflow delivers to the parent driver
+ * on completion. `turn-result` wraps a {@link NextDriverAction} the
+ * driver dispatches on; `turn-error` carries a normalized error the
+ * driver rethrows.
+ */
+export type TurnCompletionPayload = {
+    readonly kind: "turn-result";
+    readonly action: NextDriverAction;
+} | {
+    readonly kind: "turn-error";
+    readonly error: unknown;
+};
+export type { TurnWorkflowInput };
+/**
+ * Short-lived workflow that owns one runtime turn for the driver.
+ *
+ * `parentWritable` is threaded in from the driver run so event writes
+ * land on the driver's stream. Resolves the turn into a
+ * {@link NextDriverAction} and reports it back through
+ * {@link notifyDriverStep}.
+ */
+export declare function turnWorkflow(rawInput: unknown): Promise<void>;
+/** Resumes the driver's one-shot completion hook with the turn result. */
+export declare function notifyDriverStep(input: {
+    readonly completionToken: string;
+    readonly payload: TurnCompletionPayload;
+}): Promise<void>;

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

@@ -0,0 +1 @@
+import{normalizeSerializableError}from"#execution/workflow-errors.js";import{migrateTurnWorkflowInput}from"#execution/durable-session-migrations/turn-workflow.js";import{turnStep}from"#execution/workflow-steps.js";async function turnWorkflow(r){"use workflow";let i=migrateTurnWorkflowInput(r),a=i.stepInput;try{for(;;){let e=await turnStep(a);if(e.action===`done`){await notifyDriverStep({completionToken:i.completionToken,payload:{action:{kind:`done`,output:e.output??``,isError:e.isError,serializedContext:e.serializedContext,sessionState:e.sessionState},kind:`turn-result`}});return}if(e.action===`dispatch-code-mode-runtime-actions`){await notifyDriverStep({completionToken:i.completionToken,payload:{action:{kind:`dispatch-code-mode-runtime-actions`,pendingActionKeys:e.pendingRuntimeActionKeys,serializedContext:e.serializedContext,sessionState:e.sessionState},kind:`turn-result`}});return}if(e.action===`park`){let t=e.pendingRuntimeActionKeys;if(!(t!==void 0||e.hasPendingAuthorization||e.hasPendingInputBatch&&i.capabilities?.requestInput===!0||i.mode===`conversation`))throw Error("Task mode cannot wait for follow-up input (`next: null`).");let n=t===void 0?{kind:`park`,serializedContext:e.serializedContext,sessionState:e.sessionState,authorizationNames:e.authorizationNames}:{kind:`dispatch-runtime-actions`,pendingActionKeys:t,serializedContext:e.serializedContext,sessionState:e.sessionState};await notifyDriverStep({completionToken:i.completionToken,payload:{action:n,kind:`turn-result`}});return}a={input:void 0,parentWritable:a.parentWritable,serializedContext:e.serializedContext,sessionState:e.sessionState}}}catch(t){throw await notifyDriverStep({completionToken:i.completionToken,payload:{error:normalizeSerializableError(t),kind:`turn-error`}}),t}}async function notifyDriverStep(e){"use step";let{resumeHook:t}=await import(`#compiled/@workflow/core/runtime.js`);await t(e.completionToken,e.payload)}export{notifyDriverStep,turnWorkflow};

package/dist/src/execution/web-fetch/html.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Converts an HTML string to Markdown using Turndown.
+ *
+ * Removes `<script>`, `<style>`, `<meta>`, and `<link>` elements before
+ * conversion to keep the output focused on document content.
+ */
+export declare function convertHtmlToMarkdown(html: string): string;
+/**
+ * Strips HTML tags and extracts readable text content.
+ *
+ * Removes content inside `<script>`, `<style>`, and `<noscript>` elements,
+ * replaces block-level tags with newlines, decodes common HTML entities, and
+ * normalises whitespace.
+ */
+export declare function extractTextFromHtml(html: string): string;

package/dist/src/execution/web-fetch/html.js

@@ -0,0 +1,7 @@
+import TurndownService from"#compiled/turndown/index.js";function convertHtmlToMarkdown(t){let n=new TurndownService({bulletListMarker:`-`,codeBlockStyle:`fenced`,emDelimiter:`*`,headingStyle:`atx`,hr:`---`});return n.remove([`script`,`style`,`meta`,`link`]),n.turndown(t)}function extractTextFromHtml(e){let t=e;return t=t.replace(/<(script|style|noscript)\b[^>]*>[\s\S]*?<\/\1>/gi,``),t=t.replace(/<\/(p|div|br|h[1-6]|li|tr|blockquote|pre|section|article|header|footer|nav|aside|main|figure|figcaption|details|summary)>/gi,`
+`),t=t.replace(/<br\s*\/?>/gi,`
+`),t=t.replace(/<[^>]+>/g,``),t=decodeHtmlEntities(t),t=t.split(`
+`).map(e=>e.replace(/[ \t]+/g,` `).trim()).join(`
+`).replace(/\n{3,}/g,`
+
+`).trim(),t}const ENTITY_MAP={"&amp;":`&`,"&gt;":`>`,"&lt;":`<`,"&nbsp;":` `,"&quot;":`"`,"&#39;":`'`,"&#x27;":`'`,"&#x2F;":`/`},ENTITY_PATTERN=new RegExp(Object.keys(ENTITY_MAP).join(`|`),`gi`);function decodeHtmlEntities(e){return e.replace(ENTITY_PATTERN,e=>ENTITY_MAP[e.toLowerCase()]??e)}export{convertHtmlToMarkdown,extractTextFromHtml};

package/dist/src/execution/web-fetch/tool.d.ts

@@ -0,0 +1,34 @@
+type Format = "html" | "markdown" | "text";
+/**
+ * Typed input accepted by {@link executeWebFetchTool}.
+ */
+export interface WebFetchInput {
+    readonly format?: Format;
+    readonly timeout?: number;
+    readonly url: string;
+}
+/**
+ * Structured result returned from {@link executeWebFetchTool}.
+ */
+export interface WebFetchResult {
+    /** Response body, bounded to the shared tool-output limits. */
+    readonly content: string;
+    /** Response `Content-Type` header. */
+    readonly contentType: string;
+    /** Fetched URL. */
+    readonly url: string;
+    /** True when {@link content} was shortened to fit the output budget. */
+    readonly truncated: boolean;
+}
+/**
+ * Executes the `web_fetch` framework tool.
+ *
+ * Fetches the content at the given URL and returns it in the requested
+ * format. HTML responses are automatically converted to Markdown or
+ * plain text when the caller requests those formats. Responses up to
+ * 5 MB are accepted, and the returned {@link WebFetchResult.content}
+ * is capped at the shared tool-output budget (50 KB / 2000 lines) so
+ * large pages do not exhaust the model's context window.
+ */
+export declare function executeWebFetchTool(args: WebFetchInput): Promise<WebFetchResult>;
+export {};

package/dist/src/execution/web-fetch/tool.js

@@ -0,0 +1 @@
+import{truncateHead}from"#execution/sandbox/truncate-output.js";import{EVE_PACKAGE_NAME}from"#internal/package-name.js";import{convertHtmlToMarkdown,extractTextFromHtml}from"#execution/web-fetch/html.js";const MAX_RESPONSE_SIZE=5*1024*1024;async function executeWebFetchTool(n){let{url:r,format:i=`markdown`,timeout:a}=n;if(!r.startsWith(`http://`)&&!r.startsWith(`https://`))throw Error(`URL must start with http:// or https://`);let o=Math.min(a===void 0?3e4:a*1e3,12e4),s=AbortSignal.timeout(o),c=buildHeaders(i),l=await fetch(r,{headers:c,signal:s}),u=l.status===403&&l.headers.get(`cf-mitigated`)===`challenge`?await fetch(r,{headers:{...c,"User-Agent":EVE_PACKAGE_NAME},signal:s}):l;if(!u.ok)throw Error(`Request failed with status code: ${u.status}`);let d=u.headers.get(`content-length`);if(d!==null&&parseInt(d,10)>MAX_RESPONSE_SIZE)throw Error(`Response too large (exceeds 5 MB limit).`);let f=await u.arrayBuffer();if(f.byteLength>MAX_RESPONSE_SIZE)throw Error(`Response too large (exceeds 5 MB limit).`);let p=u.headers.get(`content-type`)??``,m=p.includes(`text/html`),h=new TextDecoder().decode(f),g;g=i===`markdown`&&m?convertHtmlToMarkdown(h):i===`text`&&m?extractTextFromHtml(h):h;let{output:_,truncated:v}=truncateHead(g);return{content:_,contentType:p,truncated:v,url:r}}function buildHeaders(e){let t;return t=e===`markdown`?`text/markdown;q=1.0, text/x-markdown;q=0.9, text/plain;q=0.8, text/html;q=0.7, */*;q=0.1`:e===`text`?`text/plain;q=1.0, text/markdown;q=0.9, text/html;q=0.8, */*;q=0.1`:`text/html;q=1.0, application/xhtml+xml;q=0.9, text/plain;q=0.8, text/markdown;q=0.7, */*;q=0.1`,{Accept:t,"Accept-Language":`en-US,en;q=0.9`,"User-Agent":`Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36`}}export{executeWebFetchTool};

package/dist/src/execution/workflow-callback-url.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Workflow metadata is deployment-specific, so on Vercel it can point at
+ * the generated deployment URL. Production callbacks need the stable
+ * project production URL instead so other services can post back through
+ * the same trusted source configuration users set up for the production
+ * agent.
+ */
+export declare function resolveVercelProductionCallbackBaseUrl(): string | null;
+/**
+ * Builds a framework-owned callback URL from a resolved callback origin.
+ */
+export declare function createWorkflowCallbackUrl(baseUrl: string, callbackPath: string): string;

package/dist/src/execution/workflow-callback-url.js

@@ -0,0 +1 @@
+function resolveVercelProductionCallbackBaseUrl(){return process.env.VERCEL_ENV===`production`&&process.env.VERCEL_PROJECT_PRODUCTION_URL?`https://${process.env.VERCEL_PROJECT_PRODUCTION_URL}`:null}function createWorkflowCallbackUrl(e,t){let n=new URL(t,e),r=process.env.VERCEL_AUTOMATION_BYPASS_SECRET?.trim();return r&&n.searchParams.set(`x-vercel-protection-bypass`,r),n.toString()}export{createWorkflowCallbackUrl,resolveVercelProductionCallbackBaseUrl};

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

@@ -0,0 +1,26 @@
+import type { RunInput } from "#channel/types.js";
+/**
+ * Serializable workflow-entry input. All runtime state travels via
+ * `serializedContext`, which is produced by `serializeContext(ctx)`
+ * and deserialized at each `"use step"` boundary.
+ */
+export interface WorkflowEntryInput {
+    readonly input: RunInput["input"];
+    readonly serializedContext: Record<string, unknown>;
+}
+export interface WorkflowEntryResult {
+    readonly output: unknown;
+}
+/**
+ * Long-lived workflow entrypoint. Handles both root sessions and
+ * delegated child sessions: root sessions expose only parent
+ * control-plane events; delegated children publish their full progress
+ * on a child stream and resume the parked parent with a
+ * `subagent-result` on completion.
+ *
+ * Dispatches on the closed-contract {@link NextDriverAction} returned
+ * by each step. The only session-shape flag the driver reads (besides
+ * identity) is `hasProxyInputRequests`, the documented short-circuit
+ * for hook-payload routing.
+ */
+export declare function workflowEntry(input: WorkflowEntryInput): Promise<WorkflowEntryResult>;

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

@@ -0,0 +1 @@
+import{readRootSessionId}from"#execution/eve-workflow-attributes.js";import{accumulateRuntimeActionResults}from"#harness/runtime-actions.js";import{dispatchRuntimeActionsStep}from"#execution/dispatch-runtime-actions-step.js";import{resolveVercelProductionCallbackBaseUrl}from"#execution/workflow-callback-url.js";import{normalizeSerializableError,rebuildSerializableError}from"#execution/workflow-errors.js";import{dispatchTurnStep,emitTerminalSessionFailureStep,routeProxiedDeliverStep,runProxyInputRequestStep}from"#execution/workflow-steps.js";import{createHook,getWorkflowMetadata,getWritable}from"#compiled/@workflow/core/index.js";import{coalesceDeliveries}from"#harness/messages.js";import{notifyDelegatedParentStep}from"#execution/delegated-parent-notification.js";import{createDelegatedSubagentErrorResult,createDelegatedSubagentSuccessResult}from"#execution/delegated-parent-result.js";import{createSessionStep}from"#execution/create-session-step.js";import{dispatchCodeModeRuntimeActionsStep}from"#execution/dispatch-code-mode-runtime-actions-step.js";import{fireSessionCallbackStep}from"#execution/session-callback-step.js";async function workflowEntry(t){"use workflow";let{workflowRunId:n}=getWorkflowMetadata(),r=t.serializedContext[`eve.continuationToken`]||``,a=t.serializedContext[`eve.mode`],o=t.serializedContext[`eve.capabilities`],c=t.serializedContext[`eve.bundle`];t.serializedContext[`eve.sessionId`]=n;let l=getWritable();try{let i=readRootSessionId(t.serializedContext),{state:s}=await createSessionStep({compiledArtifactsSource:c.source,continuationToken:r,inputMessage:t.input.message,nodeId:c.nodeId,outputSchema:t.input.outputSchema,rootSessionId:i,serializedContext:t.serializedContext,sessionId:n});return await runDriverLoop({capabilities:o,driverWritable:l,initialInput:{kind:`deliver`,payloads:[{message:t.input.message,context:t.input.context,outputSchema:t.input.outputSchema}]},mode:a,serializedContext:t.serializedContext,sessionState:s})}catch(e){throw await emitTerminalSessionFailureStep({error:normalizeSerializableError(e),parentWritable:l,serializedContext:t.serializedContext}),await fireSessionCallbackStep({error:normalizeSerializableError(e),serializedContext:t.serializedContext,status:`failed`}),await notifyDelegatedParentStep({result:createDelegatedSubagentErrorResult(t.serializedContext,e),serializedContext:t.serializedContext}),e}}async function runDriverLoop(e){let t=createHook({token:`${e.sessionState.sessionId}:auth`}),i=t[Symbol.asyncIterator](),a=0,nextTurnCompletionToken=()=>`${e.sessionState.sessionId}:turn-completion:${String(a++)}`,o=e.sessionState.continuationToken,s=createHook({token:o}),c=s[Symbol.asyncIterator](),l=null,u=[],getNextPromise=()=>(l??=c.next(),l),consumeNext=()=>{l=null},rekeyHook=async e=>{e===o||!e||(await closeHookIterator(c),await disposeHook(s),o=e,s=createHook({token:o}),c=s[Symbol.asyncIterator](),l=null)},d=await dispatchAndAwaitTurn({capabilities:e.capabilities,completionToken:nextTurnCompletionToken(),delivery:e.initialInput,mode:e.mode,parentWritable:e.driverWritable,serializedContext:e.serializedContext,sessionState:e.sessionState});if(d.kind===`done`)return await closeHookIterator(i),await disposeHook(t),await closeHookIterator(c),await disposeHook(s),await finalizeDone({action:d,driverWritable:e.driverWritable});if(!d.sessionState.continuationToken)throw Error("Cannot park: no continuation token available. The channel must post the first message during the initial turn (anchoring the session) or `send()` must be called with an explicit continuationToken.");await rekeyHook(d.sessionState.continuationToken);try{for(;;)switch(d.kind){case`done`:return await finalizeDone({action:d,driverWritable:e.driverWritable});case`dispatch-code-mode-runtime-actions`:case`dispatch-runtime-actions`:{let t=await(d.kind===`dispatch-code-mode-runtime-actions`?dispatchCodeModeRuntimeActionsStep:dispatchRuntimeActionsStep)({callbackBaseUrl:resolveVercelProductionCallbackBaseUrl()??getWorkflowMetadata().url,parentWritable:e.driverWritable,serializedContext:d.serializedContext,sessionState:d.sessionState}),i=await waitForPendingRuntimeActionResults({bufferedDeliveries:u,consumeNext,getNextPromise,initialResults:t.results,parentWritable:e.driverWritable,pendingActionKeys:d.pendingActionKeys,rekeyHook,serializedContext:d.serializedContext,sessionState:t.sessionState});if(i===null)return{output:``};d=await dispatchAndAwaitTurn({capabilities:e.capabilities,completionToken:nextTurnCompletionToken(),delivery:{kind:`runtime-action-result`,results:i.results},mode:e.mode,parentWritable:e.driverWritable,serializedContext:i.serializedContext,sessionState:i.sessionState}),await rekeyHook(d.sessionState.continuationToken);break}case`park`:{if(d.authorizationNames&&d.authorizationNames.length>0){let t=d.authorizationNames.length,n=[];for(;n.length<t;){let e=await i.next();if(e.done)break;e.value.kind===`deliver`&&n.push(...e.value.payloads)}d=await dispatchAndAwaitTurn({capabilities:e.capabilities,completionToken:nextTurnCompletionToken(),delivery:{kind:`deliver`,payloads:n},mode:e.mode,parentWritable:e.driverWritable,serializedContext:d.serializedContext,sessionState:d.sessionState}),await rekeyHook(d.sessionState.continuationToken);break}let t=await waitForNextDeliver({bufferedDeliveries:u,consumeNext,getNextPromise});if(t===null)return{output:``};let n=await routeDeliverForChildren({auth:t.auth,parentWritable:e.driverWritable,payloads:t.payloads,sessionState:d.sessionState});if(n===void 0)continue;d=await dispatchAndAwaitTurn({capabilities:e.capabilities,completionToken:nextTurnCompletionToken(),delivery:{auth:t.auth,kind:`deliver`,payloads:[n]},mode:e.mode,parentWritable:e.driverWritable,serializedContext:d.serializedContext,sessionState:d.sessionState}),await rekeyHook(d.sessionState.continuationToken);break}}}finally{await closeHookIterator(c),await disposeHook(s),await closeHookIterator(i),await disposeHook(t)}}async function finalizeDone(e){let{output:t,serializedContext:n}=e.action,r=e.action.isError===!0;return await fireSessionCallbackStep({error:r?t:void 0,output:r?void 0:t,serializedContext:n,status:r?`failed`:`completed`}),await notifyDelegatedParentStep({result:r?createDelegatedSubagentErrorResult(n,t):createDelegatedSubagentSuccessResult(n,t),serializedContext:n}),{output:t}}async function dispatchAndAwaitTurn(e){let t=createHook({token:e.completionToken}),n=t.token;try{await dispatchTurnStep({capabilities:e.capabilities,completionToken:n,delivery:e.delivery,mode:e.mode,parentWritable:e.parentWritable,serializedContext:e.serializedContext,sessionState:e.sessionState});let r=await awaitHookPayload(t);if(r.kind===`turn-error`)throw rebuildSerializableError(r.error);return r.action}finally{await disposeHook(t)}}async function awaitHookPayload(e){for await(let t of e)return t;throw Error(`Turn completion hook closed before delivering a result.`)}async function waitForPendingRuntimeActionResults(e){let n=e.sessionState,r=e.serializedContext,i=await accumulateRuntimeActionResults({bufferedDeliveries:e.bufferedDeliveries,async getNext(){for(;;){let t=await e.getNextPromise();if(e.consumeNext(),t.done)return null;let i=t.value;if(i.kind===`deliver`){let t=await routeDeliverForChildren({auth:i.auth,parentWritable:e.parentWritable,payloads:i.payloads,sessionState:n});if(t===void 0)continue;return{kind:`deliver`,value:{...i,payloads:[t]}}}if(i.kind===`runtime-action-result`)return{kind:`runtime-action-result`,results:i.results};let a=await runProxyInputRequestStep({hookPayload:i,parentWritable:e.parentWritable,serializedContext:r,sessionState:n});n=a.sessionState,r=a.serializedContext,await e.rekeyHook(n.continuationToken)}},initialResults:e.initialResults,pendingActionKeys:e.pendingActionKeys});return i===null?null:{results:i,serializedContext:r,sessionState:n}}async function routeDeliverForChildren(e){let t=coalescePayloads(e.payloads);return e.sessionState.hasProxyInputRequests?(await routeProxiedDeliverStep({auth:e.auth,parentWritable:e.parentWritable,payload:t,sessionState:e.sessionState})).remainder:t}async function waitForNextDeliver(e){if(e.bufferedDeliveries.length>0)return coalesceDeliveries(e.bufferedDeliveries.splice(0));for(;;){let t=await e.getNextPromise();if(e.consumeNext(),t.done)return null;if(t.value.kind!==`deliver`)continue;let n=t.value;for(;;){let t=await takeReadyPayload(e.getNextPromise());if(t===NO_READY_MESSAGE||(e.consumeNext(),t.done))break;t.value.kind===`deliver`&&(n=coalesceDeliveries([n,t.value]))}return n}}function coalescePayloads(e){if(e.length===0)return{};if(e.length===1)return e[0]??{};let t={},n=[];for(let r of e){for(let[e,n]of Object.entries(r))e!==`inputResponses`&&n!==void 0&&(t[e]=n);r.inputResponses!==void 0&&n.push(...r.inputResponses)}return n.length>0&&(t.inputResponses=n),t}const NO_READY_MESSAGE=Symbol(`no-ready-message`);async function takeReadyPayload(e){return await Promise.resolve(),await Promise.race([e,Promise.resolve(NO_READY_MESSAGE)])}async function closeHookIterator(e){typeof e.return==`function`&&await e.return(void 0)}async function disposeHook(e){let t=e.dispose;if(typeof t==`function`){await t.call(e);return}let n=e[Symbol.dispose];typeof n==`function`&&await n.call(e)}export{workflowEntry};

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

@@ -0,0 +1,14 @@
+/**
+ * Serializes and rebuilds workflow errors across hook and step
+ * boundaries.
+ */
+/**
+ * Reduces an arbitrary throwable to a shape that survives the
+ * serialization the workflow devkit performs on step inputs.
+ */
+export declare function normalizeSerializableError(error: unknown): unknown;
+/**
+ * Rebuilds an {@link Error} from the normalized hook payload sent by a
+ * child workflow.
+ */
+export declare function rebuildSerializableError(error: unknown): Error;

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

@@ -0,0 +1 @@
+function normalizeSerializableError(e){return e instanceof Error?{...Object.fromEntries(Object.entries(e)),cause:e.cause===void 0?void 0:normalizeSerializableError(e.cause),message:e.message,name:e.name,stack:e.stack}:e}function rebuildSerializableError(e){if(!isRecord(e))return Error(String(e));let t=typeof e.message==`string`?e.message:String(e),n=Error(t);typeof e.name==`string`&&(n.name=e.name),typeof e.stack==`string`&&(n.stack=e.stack),`cause`in e&&(n.cause=isRecord(e.cause)?rebuildSerializableError(e.cause):e.cause);let r=n;for(let[t,n]of Object.entries(e))t===`message`||t===`name`||t===`stack`||t===`cause`||(r[t]=n);return n}function isRecord(e){return typeof e==`object`&&!!e}export{normalizeSerializableError,rebuildSerializableError};

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

@@ -0,0 +1,48 @@
+import type { Run } from "#compiled/@workflow/core/runtime.js";
+import type { WorkflowFunction, WorkflowMetadata } from "#compiled/@workflow/core/runtime/start.js";
+import type { Runtime } from "#channel/types.js";
+import type { RuntimeCompiledArtifactsSource } from "#runtime/compiled-artifacts-source.js";
+export declare const LATEST_DEPLOYMENT_UNSUPPORTED_MESSAGE = "deploymentId 'latest' requires a World that implements resolveLatestDeploymentId()";
+/**
+ * Workflow function names whose bundled id is stable across deployments
+ * (no `@<pkg.version>` stamp). The bundler reads this set when emitting
+ * the workflow id so cross-deployment routing — `start(ref, args, {
+ * deploymentId: "latest" })` — finds the same workflow on a newer
+ * deployment even when the eve version differs.
+ *
+ * Both halves of the contract (bundler output and runtime reference
+ * template) read this single set so they cannot drift.
+ */
+export declare const STABLE_WORKFLOW_NAMES: ReadonlySet<string>;
+/**
+ * Stable workflow reference used by `start()` to locate the workflow
+ * entrypoint registered by the Workflow DevKit builder. The id omits
+ * the package version stamp so the long-lived driver can rotate across
+ * deployments without rewriting the registry key.
+ */
+export declare const workflowEntryReference: {
+    workflowId: string;
+};
+/**
+ * Stable workflow reference used by the driver to dispatch per-turn
+ * child workflow runs. The id omits the package version stamp so
+ * `start(turnWorkflowReference, args, { deploymentId: "latest" })`
+ * routes to the latest deployment's turn workflow even when the eve
+ * version differs from the caller's deployment.
+ */
+export declare const turnWorkflowReference: {
+    workflowId: string;
+};
+/**
+ * Creates a workflow-backed runtime whose long-lived driver owns the
+ * event stream and dispatches each turn as a child workflow run.
+ */
+export declare function createWorkflowRuntime(config: {
+    readonly compiledArtifactsSource: RuntimeCompiledArtifactsSource;
+    readonly nodeId?: string;
+}): Runtime;
+/**
+ * Starts a workflow on the latest deployment when the active world supports
+ * it, while preserving local/dev worlds that do not implement latest routing.
+ */
+export declare function startWorkflowPreferLatest<TArgs extends unknown[], TResult>(workflow: WorkflowFunction<TArgs, TResult> | WorkflowMetadata, args: TArgs): Promise<Run<unknown> | Run<TResult>>;

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

@@ -0,0 +1,3 @@
+import{createLogger,logError}from"#internal/logging.js";import{RuntimeNoActiveSessionError}from"#execution/runtime-errors.js";import{resolveInstalledPackageInfo}from"#internal/application/package.js";import{getCompiledRuntimeAgentBundle}from"#runtime/sessions/compiled-agent-cache.js";import{serializeContext}from"#context/serialize.js";import{getHookByToken,getRun,resumeHook,start}from"#compiled/@workflow/core/runtime.js";import{HookNotFoundError}from"#compiled/@workflow/errors/index.js";import{buildRunContext}from"#execution/runtime-context.js";const WORKFLOW_ENTRY_NAME=`workflowEntry`,TURN_WORKFLOW_NAME=`turnWorkflow`,EVE_PACKAGE_INFO=resolveInstalledPackageInfo(),LATEST_DEPLOYMENT_UNSUPPORTED_MESSAGE=`deploymentId 'latest' requires a World that implements resolveLatestDeploymentId()`,STABLE_WORKFLOW_NAMES=new Set([WORKFLOW_ENTRY_NAME,TURN_WORKFLOW_NAME]),STABLE_ID_BASE=EVE_PACKAGE_INFO.name,log=createLogger(`execution.workflow-runtime`),workflowEntryReference={workflowId:`workflow//${STABLE_ID_BASE}//${WORKFLOW_ENTRY_NAME}`},turnWorkflowReference={workflowId:`workflow//${STABLE_ID_BASE}//${TURN_WORKFLOW_NAME}`};function createWorkflowRuntime(e){return{async run(n){let r=serializeContext(buildRunContext({bundle:await getCompiledRuntimeAgentBundle({compiledArtifactsSource:e.compiledArtifactsSource,nodeId:e.nodeId}),run:n})),o;try{o=await startWorkflowPreferLatest(workflowEntryReference,[{input:n.input,serializedContext:r}])}catch(e){throw logError(log,`failed to start workflow run`,e,{continuationToken:n.continuationToken}),e}let s,getEvents=()=>(s??=parseNdjsonStream(()=>getRun(o.runId).getReadable()),s);return{continuationToken:n.continuationToken??o.runId,get events(){return getEvents()},sessionId:o.runId}},async deliver(e){let r={auth:e.auth,kind:`deliver`,payloads:[e.payload]};try{let t=normalizeWorkflowHook(await getHookByToken(e.continuationToken));return await resumeHook(e.continuationToken,r),{sessionId:t.runId}}catch(r){throw HookNotFoundError.is(r)?new RuntimeNoActiveSessionError(e.continuationToken):(logError(log,`failed to deliver to active session`,r,{continuationToken:e.continuationToken}),r)}},async getEventStream(e,t){return parseNdjsonStream(()=>getRun(e).getReadable({startIndex:t?.startIndex}))}}}async function startWorkflowPreferLatest(e,t){try{return await start(e,t,{deploymentId:`latest`})}catch(n){if(!isLatestDeploymentUnsupportedError(n))throw n;return await start(e,t)}}function isLatestDeploymentUnsupportedError(e){return e instanceof Error&&e.message.includes(`deploymentId 'latest' requires a World that implements resolveLatestDeploymentId()`)}function normalizeWorkflowHook(e){if(typeof e!=`object`||!e||!(`runId`in e))throw Error(`Workflow hook did not include a run id.`);let t=e.runId;if(typeof t!=`string`||t.length===0)throw Error(`Workflow hook did not include a run id.`);return{runId:t}}function parseNdjsonStream(e){let t=new TextDecoder,n=``;return new ReadableStream({async start(r){let i=e().getReader();try{for(;;){let{value:e,done:a}=await i.read();if(a)break;n+=t.decode(e,{stream:!0});for(let e=n.indexOf(`
+`);e!==-1;e=n.indexOf(`
+`)){let t=n.slice(0,e).trim();n=n.slice(e+1),t.length>0&&r.enqueue(JSON.parse(t))}}n+=t.decode();let e=n.trim();e.length>0&&r.enqueue(JSON.parse(e)),r.close()}catch(e){r.error(e)}finally{i.releaseLock()}}})}export{LATEST_DEPLOYMENT_UNSUPPORTED_MESSAGE,STABLE_WORKFLOW_NAMES,createWorkflowRuntime,startWorkflowPreferLatest,turnWorkflowReference,workflowEntryReference};

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