eve 0.5.3 → 0.6.0-beta.1

package/dist/src/execution/session.d.ts

@@ -0,0 +1,81 @@
+import type { DurableSession } from "#execution/durable-session-store.js";
+import type { HarnessSession } from "#harness/types.js";
+import type { RuntimeTurnAgent } from "#runtime/agent/bootstrap.js";
+/**
+ * Creates the durable compaction configuration used by one harness session.
+ */
+export declare function createCompactionConfig(input?: {
+    readonly contextWindowTokens?: number;
+    readonly lastKnownInputTokens?: number;
+    readonly lastKnownPromptMessageCount?: number;
+    readonly thresholdPercent?: number;
+}): {
+    recentWindowSize: number;
+    threshold: number;
+} | {
+    recentWindowSize: number;
+    threshold: number;
+    lastKnownInputTokens: number;
+    lastKnownPromptMessageCount: number | undefined;
+};
+export interface CreateSessionInput {
+    readonly continuationToken: string;
+    readonly compactionOverrides?: {
+        readonly thresholdPercent?: number;
+    };
+    /**
+     * Optional root session id passed in by the runtime when this
+     * session is a delegated subagent child. `undefined` for top-level
+     * sessions — `sessionId` is the root for those.
+     */
+    readonly rootSessionId?: string;
+    readonly sessionId: string;
+    readonly turnAgent: RuntimeTurnAgent;
+    readonly outputSchema?: HarnessSession["outputSchema"];
+}
+/**
+ * Creates a fresh {@link HarnessSession}. The only site that derives
+ * `session.agent.system` from a `turnAgent` — every subsequent turn
+ * preserves the prompt via {@link refreshSessionFromTurnAgent}.
+ */
+export declare function createSession(input: CreateSessionInput): HarnessSession;
+/**
+ * Refreshes a session with the latest `turnAgent` — replaces model/tool
+ * metadata and recalculates compaction thresholds; preserves history and
+ * state. Production callers keep the session-start `agent.system` prompt,
+ * while dev HMR callers can opt into refreshing it from authored source.
+ */
+export declare function refreshSessionFromTurnAgent(input: {
+    readonly session: HarnessSession;
+    readonly turnAgent: RuntimeTurnAgent;
+    readonly refreshSystemPrompt?: boolean;
+    readonly compactionOverrides?: {
+        readonly thresholdPercent?: number;
+    };
+}): HarnessSession;
+/**
+ * Mints a continuation token for a delegated subagent session.
+ * Deterministic when `suffix` is provided so retries address the same
+ * child hook.
+ */
+export declare function mintSubagentContinuationToken(suffix?: string): string;
+/**
+ * Projects a {@link HarnessSession} to {@link DurableSession}.
+ *
+ * Drops fields rebuilt every turn from `bundle.turnAgent`; keeps
+ * `agent.system` and `compaction.lastKnown*` so compaction stays
+ * informed after rehydration.
+ */
+export declare function projectToDurableSession(session: HarnessSession): DurableSession;
+/**
+ * Rehydrates a {@link HarnessSession} from a {@link DurableSession}
+ * plus the current `turnAgent`, rebuilding the runtime-only agent and
+ * compaction fields the durable shape omits.
+ */
+export declare function hydrateDurableSession(input: {
+    readonly durable: DurableSession;
+    readonly turnAgent: RuntimeTurnAgent;
+    readonly compactionOverrides?: {
+        readonly thresholdPercent?: number;
+    };
+}): HarnessSession;

package/dist/src/execution/session.js

@@ -0,0 +1,5 @@
+function createCompactionConfig(e={}){let t=e.thresholdPercent??.9,n={recentWindowSize:10,threshold:e.contextWindowTokens===void 0?1e5:Math.max(1,Math.floor(e.contextWindowTokens*t))};return e.lastKnownInputTokens===void 0?n:{...n,lastKnownInputTokens:e.lastKnownInputTokens,lastKnownPromptMessageCount:e.lastKnownPromptMessageCount}}function createSession(e){let{turnAgent:t}=e,n=createSessionToolDefinitions(t),r={agent:{compactionModelReference:t.compactionModel,modelReference:t.model,system:t.instructions.join(`
+
+`),tools:n},compaction:createCompactionConfig({contextWindowTokens:t.model.contextWindowTokens,thresholdPercent:e.compactionOverrides?.thresholdPercent}),continuationToken:e.continuationToken,history:[],sessionId:e.sessionId};return e.rootSessionId!==void 0&&(r.rootSessionId=e.rootSessionId),e.outputSchema!==void 0&&(r.outputSchema=e.outputSchema),r}function refreshSessionFromTurnAgent(e){return{...e.session,agent:{compactionModelReference:e.turnAgent.compactionModel,modelReference:e.turnAgent.model,system:e.refreshSystemPrompt===!0?e.turnAgent.instructions.join(`
+
+`):e.session.agent.system,tools:createSessionToolDefinitions(e.turnAgent)},compaction:createCompactionConfig({contextWindowTokens:e.turnAgent.model.contextWindowTokens,lastKnownInputTokens:e.session.compaction.lastKnownInputTokens,lastKnownPromptMessageCount:e.session.compaction.lastKnownPromptMessageCount,thresholdPercent:e.compactionOverrides?.thresholdPercent})}}function mintSubagentContinuationToken(e){return`subagent:${e??crypto.randomUUID()}`}function projectToDurableSession(e){let t={agent:{system:e.agent.system},continuationToken:e.continuationToken,history:e.history,sessionId:e.sessionId};return(e.compaction.lastKnownInputTokens!==void 0||e.compaction.lastKnownPromptMessageCount!==void 0)&&(t.compaction={lastKnownInputTokens:e.compaction.lastKnownInputTokens,lastKnownPromptMessageCount:e.compaction.lastKnownPromptMessageCount}),e.rootSessionId!==void 0&&(t.rootSessionId=e.rootSessionId),e.outputSchema!==void 0&&(t.outputSchema=e.outputSchema),e.sandboxState!==void 0&&(t.sandboxState=e.sandboxState),e.state!==void 0&&(t.state=e.state),t}function hydrateDurableSession(e){let{durable:t,turnAgent:n}=e,r=createSessionToolDefinitions(n),i={agent:{compactionModelReference:n.compactionModel,modelReference:n.model,system:t.agent.system,tools:r},compaction:createCompactionConfig({contextWindowTokens:n.model.contextWindowTokens,lastKnownInputTokens:t.compaction?.lastKnownInputTokens,lastKnownPromptMessageCount:t.compaction?.lastKnownPromptMessageCount,thresholdPercent:e.compactionOverrides?.thresholdPercent}),continuationToken:t.continuationToken,history:t.history,sessionId:t.sessionId};return t.rootSessionId!==void 0&&(i.rootSessionId=t.rootSessionId),t.outputSchema!==void 0&&(i.outputSchema=t.outputSchema),t.sandboxState!==void 0&&(i.sandboxState=t.sandboxState),t.state!==void 0&&(i.state=t.state),i}function createSessionToolDefinitions(e){return e.tools.map(e=>({description:e.description??``,inputSchema:e.inputSchema,name:e.name,outputSchema:e.outputSchema}))}export{createCompactionConfig,createSession,hydrateDurableSession,mintSubagentContinuationToken,projectToDurableSession,refreshSessionFromTurnAgent};

package/dist/src/execution/skills/instructions.d.ts

@@ -0,0 +1,19 @@
+interface AvailableSkillDescription {
+    readonly description: string;
+    readonly name: string;
+}
+/**
+ * Formats the "Available skills" system prompt section.
+ *
+ * All skills are always listed regardless of activation state. Active skill
+ * instructions are never injected into the system prompt — the model already
+ * has them from the `load_skill` tool result. This keeps the system
+ * prompt identical across the entire session, preserving prompt caching.
+ *
+ * Authored skills call this at graph resolution time so the section is
+ * part of the turn agent's static instructions. Dynamic skills
+ * (`defineDynamic` in `agent/skills/`) reuse the same formatter for
+ * durable context announcements.
+ */
+export declare function formatAvailableSkillsSection(skills: readonly AvailableSkillDescription[]): string | null;
+export {};

package/dist/src/execution/skills/instructions.js

@@ -0,0 +1,2 @@
+import{WORKSPACE_ROOT}from"#runtime/workspace/types.js";function formatAvailableSkillsSection(e){return e.length===0?null:[`Available skills`,`Listed skills are available in this run. Do not claim a listed skill is inaccessible unless activation or workspace inspection actually fails.`,`If the user names a skill or the request clearly matches one of the descriptions below, call load_skill before proceeding.`,`If multiple skills match, activate the minimal set that covers the task. After activation, follow the returned instructions instead of improvising around them.`,`If activation fails, say so briefly and continue with the best fallback. Packaged sibling files under a skill path can be inspected with bash or read_file when needed.`,...e.map(e=>formatAvailableSkillLine(e))].join(`
+`)}function formatAvailableSkillLine(t){return`- ${t.name}: ${t.description} (path: ${WORKSPACE_ROOT}/skills/${t.name}/SKILL.md)`}export{formatAvailableSkillsSection};

package/dist/src/execution/skills/types.d.ts

@@ -0,0 +1,22 @@
+/**
+ * A reference to one file inside a sandbox-backed skill directory.
+ */
+export interface SkillFile {
+    /** Reads the file content as bytes. */
+    bytes(): Promise<Uint8Array>;
+    /** Reads the file content as UTF-8 text. */
+    text(): Promise<string>;
+}
+/**
+ * Handle to one authored skill, returned by `ctx.getSkill()`.
+ *
+ * Exposes skill metadata and reads files from a skill package.
+ */
+export interface SkillHandle {
+    /** The skill identifier passed to `ctx.getSkill()`, used as the skill directory segment under the sandbox skills root. */
+    readonly name: string;
+    /**
+     * Returns a file accessor for a path relative to the skill root.
+     */
+    file(relativePath: string): SkillFile;
+}

package/dist/src/execution/skills/types.js

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

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

@@ -0,0 +1,43 @@
+import type { ChannelAdapter } from "#channel/adapter.js";
+/**
+ * Durable adapter kind used for delegated subagent child runs.
+ *
+ * Framework-owned — authored channel code never constructs a subagent
+ * adapter directly. Emitted by `buildSubagentRunInput`
+ * (`execution/subagent-tool.ts`) when a parent dispatches a child
+ * subagent.
+ */
+export declare const SUBAGENT_ADAPTER_KIND = "subagent";
+/**
+ * Durable state carried on a subagent adapter instance.
+ *
+ * Populated by `buildSubagentRunInput` at dispatch time so the child
+ * run retains the parent lineage metadata required to resume its parent
+ * when the child finishes and to forward HITL requests up the chain.
+ *
+ * The parent's turn identifier is not duplicated here — it lives on
+ * `RunInput.parent.turn.id` which is the single source of truth for the
+ * child's parent-turn lineage.
+ */
+export interface SubagentAdapterState extends Record<string, unknown> {
+    readonly callId: string;
+    readonly parentContinuationToken: string;
+    readonly parentSessionId: string;
+    readonly subagentName: string;
+}
+/**
+ * Narrow runtime guard for {@link SubagentAdapterState}.
+ *
+ * Framework adapters live through a JSON round-trip at every workflow
+ * step boundary, so consumers that want to treat the adapter state as
+ * a structured record must validate the shape explicitly.
+ */
+export declare function isSubagentAdapterState(value: unknown): value is SubagentAdapterState;
+/**
+ * Framework adapter that bridges a child subagent session to its
+ * parent.
+ *
+ * It proxies child `input.requested` events upward so the parent channel
+ * can render HITL prompts and route responses back down to the child.
+ */
+export declare const SUBAGENT_ADAPTER: ChannelAdapter;

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

@@ -0,0 +1 @@
+import{createErrorId,createLogger}from"#internal/logging.js";import{ContinuationTokenKey,SessionIdKey}from"#context/keys.js";import{resumeHook}from"#compiled/@workflow/core/runtime.js";const log=createLogger(`execution.subagent-adapter`),SUBAGENT_ADAPTER_KIND=`subagent`;function isSubagentAdapterState(e){if(typeof e!=`object`||!e)return!1;let t=e;return typeof t.callId==`string`&&t.callId.length>0&&typeof t.parentContinuationToken==`string`&&t.parentContinuationToken.length>0&&typeof t.parentSessionId==`string`&&typeof t.subagentName==`string`&&t.subagentName.length>0}const SUBAGENT_ADAPTER={kind:SUBAGENT_ADAPTER_KIND,async"input.requested"(e,t){let i=t.state;isSubagentAdapterState(i)&&await forwardSubagentInputRequestStep({hookPayload:{callId:i.callId,childContinuationToken:t.ctx.require(ContinuationTokenKey),childSessionId:t.ctx.require(SessionIdKey),event:{requests:e.requests,sequence:e.sequence,stepIndex:e.stepIndex,turnId:e.turnId},kind:`subagent-input-request`,subagentName:i.subagentName},parentContinuationToken:i.parentContinuationToken})}};async function forwardSubagentInputRequestStep(t){"use step";try{await resumeHook(t.parentContinuationToken,t.hookPayload)}catch(n){let r=createErrorId();throw log.warn(`failed to forward proxied HITL batch to parent`,{callId:t.hookPayload.callId,childContinuationToken:t.hookPayload.childContinuationToken,childSessionId:t.hookPayload.childSessionId,errorId:r,parentContinuationToken:t.parentContinuationToken,subagentName:t.hookPayload.subagentName,error:n}),n}}export{SUBAGENT_ADAPTER,SUBAGENT_ADAPTER_KIND,isSubagentAdapterState};

package/dist/src/execution/subagent-hitl-proxy.d.ts

@@ -0,0 +1,37 @@
+import type { DeliverPayload, SubagentInputRequestHookPayload } from "#channel/types.js";
+import type { HarnessEmitFn, HarnessSession, SessionStateMap } from "#harness/types.js";
+import type { RunMode } from "#shared/run-mode.js";
+import type { InputResponse } from "#runtime/input/types.js";
+/**
+ * Runs the parent-side work for a `subagent-input-request`. Conversation
+ * mode emits a waiting boundary on the parent stream; the returned proxy
+ * entries route the eventual response back down to the child.
+ */
+export declare function emitProxiedInputRequest(input: {
+    readonly emit: HarnessEmitFn;
+    readonly hookPayload: SubagentInputRequestHookPayload;
+    readonly mode: RunMode;
+    readonly session: HarnessSession;
+}): Promise<{
+    readonly entries: readonly (readonly [requestId: string, childContinuationToken: string])[];
+    readonly session: HarnessSession;
+}>;
+/**
+ * Outcome of splitting one deliver payload by the session's proxy map.
+ * `forSelf` is the parent-local remainder (or `undefined` when fully
+ * routed); `forChildren` carries one entry per descendant token.
+ */
+export interface RoutedDeliverPayload {
+    readonly forChildren: readonly {
+        readonly childContinuationToken: string;
+        readonly payload: {
+            readonly inputResponses: readonly InputResponse[];
+        };
+    }[];
+    readonly forSelf: DeliverPayload | undefined;
+}
+/** Splits a deliver payload into parent-local and proxied-child buckets. */
+export declare function routeDeliverPayload(input: {
+    readonly payload: DeliverPayload;
+    readonly state: SessionStateMap | undefined;
+}): RoutedDeliverPayload;

package/dist/src/execution/subagent-hitl-proxy.js

@@ -0,0 +1 @@
+import{createInputRequestedEvent}from"#protocol/message.js";import{emitTurnEpilogue,getHarnessEmissionState,setHarnessEmissionState}from"#harness/emission.js";import{getProxyInputRequests,toProxyInputRequestEntries}from"#harness/proxy-input-requests.js";async function emitProxiedInputRequest(i){await i.emit(createInputRequestedEvent({requests:i.hookPayload.event.requests,sequence:i.hookPayload.event.sequence,stepIndex:i.hookPayload.event.stepIndex,turnId:i.hookPayload.event.turnId}));let o=i.session;if(i.mode===`conversation`){let e=getHarnessEmissionState(i.session.state),a=await emitTurnEpilogue(i.emit,e,i.mode);o=setHarnessEmissionState(i.session,a)}return{entries:toProxyInputRequestEntries(i.hookPayload),session:o}}function routeDeliverPayload(e){let t=getProxyInputRequests(e.state),n=e.payload.inputResponses??[],r=new Map,a=[];for(let e of n){let n=t.get(e.requestId);if(n===void 0){a.push(e);continue}let i=r.get(n);i===void 0?r.set(n,[e]):i.push(e)}let o=[...r.entries()].map(([e,t])=>({childContinuationToken:e,payload:{inputResponses:t}})),s={};for(let[t,n]of Object.entries(e.payload))t===`inputResponses`||n===void 0||(s[t]=n);return a.length>0&&(s.inputResponses=a),{forChildren:o,forSelf:Object.keys(s).length>0?s:void 0}}export{emitProxiedInputRequest,routeDeliverPayload};

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