eve 0.5.4 → 0.6.0-beta.1

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

@@ -0,0 +1,229 @@
+import type { LanguageModel, ModelMessage, UserContent } from "ai";
+import type { SessionCapabilities } from "#channel/types.js";
+import type { HandleMessageStreamEvent, RuntimeIdentity } from "#protocol/message.js";
+import type { RunMode } from "#shared/run-mode.js";
+import type { RuntimeActionResult } from "#runtime/actions/types.js";
+import type { RuntimeModelReference } from "#runtime/agent/bootstrap.js";
+import type { InputResponse } from "#runtime/input/types.js";
+import type { SandboxState } from "#sandbox/state.js";
+import type { JsonObject } from "#shared/json.js";
+import type { InternalToolDefinition } from "#shared/tool-definition.js";
+import type { HarnessToolDefinition } from "#harness/execute-tool.js";
+/**
+ * Serializable tool definition stored on the session.
+ *
+ * Carries schema but no execute function so the session stays serializable
+ * across workflow step boundaries.
+ */
+export type SessionToolDefinition = Readonly<InternalToolDefinition>;
+/** Authored-key → opaque-value map stored on `session.state`. */
+export type SessionStateMap = Readonly<Record<string, unknown>>;
+/**
+ * Compaction configuration stored on the session.
+ */
+export interface CompactionConfig {
+    readonly lastKnownInputTokens?: number;
+    readonly lastKnownPromptMessageCount?: number;
+    readonly recentWindowSize: number;
+    readonly threshold: number;
+}
+/**
+ * Serializable agent configuration stored on the session.
+ */
+export interface SessionAgent {
+    /**
+     * Optional model used only for compaction summaries.
+     *
+     * When omitted, the harness uses the active turn model for compaction.
+     */
+    readonly compactionModelReference?: RuntimeModelReference;
+    readonly modelReference: RuntimeModelReference;
+    readonly system: string;
+    readonly tools: readonly SessionToolDefinition[];
+}
+/**
+ * Serializable session state passed between harness and runtime.
+ *
+ * Only contains plain data -- no resolved model instances or tool execute
+ * functions. The harness resolves those at step time via injected config.
+ */
+export interface HarnessSession {
+    readonly agent: SessionAgent;
+    readonly compaction: CompactionConfig;
+    readonly continuationToken: string;
+    readonly history: ModelMessage[];
+    readonly outputSchema?: JsonObject;
+    /**
+     * Stable identifier of the top user-facing session in the dispatch
+     * chain. For a top-level session this field is `undefined` and
+     * `sessionId` itself is the root. For any delegated subagent session,
+     * `rootSessionId` carries the original root sessionId so descendant
+     * dispatch sites (and observability tags) can attribute work back to
+     * the user-facing session without walking the chain.
+     */
+    readonly rootSessionId?: string;
+    readonly sessionId: string;
+    readonly sandboxState?: SandboxState;
+    readonly state?: SessionStateMap;
+}
+/**
+ * Result returned by the compaction callback.
+ *
+ * `session` carries any state resets (e.g. clearing active skills).
+ * `messages` carries context to append to the compacted history
+ * (e.g. the current todo list as a user message).
+ */
+export interface CompactionCallbackResult {
+    readonly messages: readonly ModelMessage[];
+    readonly session: HarnessSession;
+}
+/**
+ * Input payload for a harness turn.
+ *
+ * Carries an optional message and/or structured input responses from the
+ * channel emitter's `onDeliver`. The message may be a plain text string or
+ * a structured AI SDK {@link UserContent} array (mixing `text`, `image`,
+ * and `file` parts) to support multimodal attachments delivered by
+ * channels. The harness resolves any pending input batch at the start of
+ * `runStep` before the model call.
+ */
+export interface StepInput {
+    readonly inputResponses?: readonly InputResponse[];
+    readonly message?: string | UserContent;
+    /**
+     * Context strings from the channel delivery. Each entry is appended
+     * as a `role: "user"` message to `session.history` before the
+     * delivery message. Populated by channels via `SendPayload.context`.
+     */
+    readonly context?: readonly string[];
+    /**
+     * Run-scoped schema that replaces the session's current output schema when
+     * present. Omitted continuations keep the existing schema.
+     */
+    readonly outputSchema?: JsonObject;
+    /**
+     * Runtime-owned action results being resumed into the current turn.
+     *
+     * This field is internal to the execution/harness boundary and is never
+     * produced by channels.
+     */
+    readonly runtimeActionResults?: readonly RuntimeActionResult[];
+}
+/**
+ * Terminal result indicating the conversation is finished.
+ */
+export interface StepDone {
+    readonly done: true;
+    readonly output: unknown;
+    /**
+     * Marks a terminal turn that failed (e.g. a task-mode turn that could not
+     * fulfil its output schema). For a delegated subagent this routes the result
+     * to the parent as an error tool-result rather than an empty success.
+     */
+    readonly isError?: boolean;
+}
+/**
+ * The harness's instruction to the runtime about what to do next.
+ *
+ * - A `StepFn` reference means "call this step immediately" (tool loop continuation).
+ * - `null` means "park and wait for the next user message."
+ * - `StepDone` means "the conversation is finished."
+ */
+export type StepNext = StepDone | StepFn | null;
+/**
+ * Result returned by one harness step invocation.
+ */
+export interface StepResult {
+    readonly next: StepNext;
+    readonly session: HarnessSession;
+}
+/**
+ * A single step of AI work. Takes the current session and optional user input,
+ * returns the updated session and an instruction for the runtime.
+ */
+export type StepFn = (session: HarnessSession, input?: StepInput) => Promise<StepResult>;
+/**
+ * Map from tool name to its harness-owned definition.
+ *
+ * The harness uses these definitions for schema extraction, tool execution
+ * (via {@link buildToolSet}), approval gates, and compaction hooks.
+ */
+export type HarnessToolMap = ReadonlyMap<string, HarnessToolDefinition>;
+/**
+ * Callback that writes one event to the event stream.
+ *
+ * Composed by the runtime from the underlying writable and the channel's
+ * event handler, then injected into the harness so it can emit lifecycle
+ * events without knowing about writables or handlers.
+ */
+export type HarnessEmitFn = (event: HandleMessageStreamEvent, messages?: readonly import("ai").ModelMessage[]) => Promise<void>;
+/**
+ * Unified event handler: emits the event to the stream, then
+ * dispatches to hook subscribers and dynamic tool resolvers.
+ *
+ * Same signature as {@link HarnessEmitFn} but semantically broader —
+ * every event goes through channel adapter, stream write, hooks,
+ * and dynamic tool dispatch in one call.
+ */
+export type HandleEventFn = (event: HandleMessageStreamEvent, messages?: readonly import("ai").ModelMessage[]) => Promise<void>;
+/**
+ * Dependencies injected into the tool-loop harness at construction time.
+ */
+export interface ToolLoopHarnessConfig {
+    /**
+     * Session-level capabilities. The harness reads
+     * {@link SessionCapabilities.requestInput} when assembling the
+     * per-step toolset to decide whether `ask_question` is available.
+     */
+    readonly capabilities?: SessionCapabilities;
+    /**
+     * Routes executable tools through the sandboxed code-execution wrapper
+     * instead of exposing them directly to the model. Resolved by the
+     * runtime from the agent's `experimental.codeMode` flag (with the
+     * `EVE_EXPERIMENTAL_CODE_MODE` env backstop). Defaults to `false`.
+     */
+    readonly codeMode?: boolean;
+    /**
+     * Exposes the `Workflow` orchestration tool — a code-mode-style sandbox
+     * whose only callable operations are this agent's subagents and remote
+     * agents. Resolved by the runtime from the agent's `workflowEnabled` flag
+     * (set when `agent/tools/workflow.ts` re-exports the `Workflow` marker).
+     * Independent of {@link ToolLoopHarnessConfig.codeMode} — both may be on at
+     * once. Defaults to `false`.
+     */
+    readonly workflow?: boolean;
+    readonly handleEvent?: HandleEventFn;
+    /**
+     * Execution mode for the current harness.
+     *
+     * Conversation mode parks after a final assistant reply so the runtime can
+     * await the next user message. Task mode must return `{ done: true, output }`
+     * for terminal assistant text inside the current invocation.
+     */
+    readonly mode: RunMode;
+    /**
+     * Called after compaction to let the execution layer run session
+     * lifecycle hooks (e.g. tool compaction hooks). The harness applies
+     * the returned session and appends the returned messages to the
+     * compacted history.
+     */
+    readonly onCompaction?: (session: HarnessSession) => CompactionCallbackResult | Promise<CompactionCallbackResult>;
+    readonly resolveModel: (reference: RuntimeModelReference) => Promise<LanguageModel>;
+    /**
+     * Runtime identity metadata attached to the `session.started` event.
+     *
+     * When provided, the harness includes this in the first `session.started`
+     * event so remote consumers (eval runners, reporters) receive
+     * authoritative server-side metadata.
+     */
+    readonly runtimeIdentity?: RuntimeIdentity;
+    /**
+     * Unified tool definitions for this harness step.
+     *
+     * Each entry carries schema, execution, and approval gates. The
+     * harness derives AI SDK tool definitions, runs
+     * {@link buildToolSet}, and checks approval gates from these
+     * definitions directly.
+     */
+    readonly tools: HarnessToolMap;
+}

package/dist/src/harness/types.js

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

package/dist/src/harness/workflow-stream-error.d.ts

@@ -0,0 +1,29 @@
+import type { JsonObject } from "#shared/json.js";
+/**
+ * Parses a durable event-stream write failure raised by the workflow
+ * runtime's stream transport into structured diagnostics, or returns
+ * `null` when `error` is not such a failure.
+ *
+ * The harness emits every runtime event by writing to the workflow's
+ * durable `getWritable()` stream, and those writes are flushed to the
+ * workflow server over HTTP. Because the stream is consumed inside the
+ * harness's model-call try/catch, a failed flush (timeout, 5xx) would
+ * otherwise be misattributed to the model. This lets the harness label
+ * it as the workflow-infrastructure failure it is and attach the
+ * failing endpoint + platform error code as evidence.
+ *
+ * The returned object carries `operation` (`"write"`/`"close"`) and,
+ * when present in the message, `statusCode`, `url` (the `PUT` target),
+ * `vercelId` (`x-vercel-id`), and `vercelError` (`x-vercel-error`, e.g.
+ * `"FUNCTION_INVOCATION_TIMEOUT"`).
+ *
+ * Walks the cause chain so a wrapped transport error is still detected.
+ */
+export declare function extractWorkflowStreamWriteErrorDetails(error: unknown): JsonObject | null;
+/**
+ * Returns `true` when `error` is a durable event-stream write failure
+ * raised by the workflow runtime's stream transport, not by the model
+ * provider. Thin predicate over
+ * {@link extractWorkflowStreamWriteErrorDetails}.
+ */
+export declare function isWorkflowStreamWriteError(error: unknown): boolean;

package/dist/src/harness/workflow-stream-error.js

@@ -0,0 +1 @@
+import{isObject}from"#shared/guards.js";const WORKFLOW_STREAM_WRITE_ERROR_PATTERN=/^Stream (write|close) failed: HTTP (\d+)(?: \(([^)]*)\))?/;function extractWorkflowStreamWriteErrorDetails(e){for(let t of causeChainMessages(e)){let e=parseStreamErrorMessage(t);if(e!==null)return e}return null}function isWorkflowStreamWriteError(e){return extractWorkflowStreamWriteErrorDetails(e)!==null}function parseStreamErrorMessage(e){let n=WORKFLOW_STREAM_WRITE_ERROR_PATTERN.exec(e);if(n===null)return null;let r=Number(n[2]),i={operation:n[1]??``};Number.isFinite(r)&&(i.statusCode=r);for(let e of(n[3]??``).split(`; `))e.startsWith(`PUT `)?i.url=e.slice(4):e.startsWith(`x-vercel-id=`)?i.vercelId=e.slice(12):e.startsWith(`x-vercel-error=`)&&(i.vercelError=e.slice(15));return i}function*causeChainMessages(t){let n=new Set,r=t;for(;r!=null&&!n.has(r);){if(n.add(r),r instanceof Error){yield r.message,r=r.cause;continue}if(isObject(r)&&typeof r.message==`string`){yield r.message,r=r.cause;continue}return}}export{extractWorkflowStreamWriteErrorDetails,isWorkflowStreamWriteError};

package/dist/src/harness/workflow-tool-description.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Builds the model-facing description for the `Workflow` orchestration tool.
+ *
+ * Dynamic in the agent's callable agents:
+ * - lists every callable agent by name (the built-in `agent` plus one per
+ *   declared subagent and remote agent);
+ * - the worked example uses only the built-in `agent`, so it is valid for any
+ *   agent;
+ * - a single simple subagent example is appended *only when* the agent has a
+ *   declared subagent or remote agent (i.e. an agent other than `agent`).
+ *
+ * The exact input signatures auto-generated by `createCodeModeTool` are appended
+ * after this framing.
+ *
+ * @param toolNames - Names of the agent functions callable inside the sandbox.
+ */
+export declare function workflowToolDescription(toolNames: readonly string[]): string;

package/dist/src/harness/workflow-tool-description.js

@@ -0,0 +1,23 @@
+function workflowToolDescription(e){let t=e.length>0?e:[`agent`],n=t.map(e=>`\`${e}\``).join(`, `),r=t.filter(e=>e!==`agent`);return`Orchestrate this agent's subagents by writing a JavaScript program the runtime executes deterministically — fan out independent subtasks, run staged pipelines, and combine results in code, in a single step.
+
+The only callable operations are these agents — no filesystem, network, shell, or other tools: ${n}. Call each as \`await tools.<name>(input)\`; it resolves to the child's result, or a typed object when you pass an \`outputSchema\`. Sequence with \`await\`, run agents concurrently with \`Promise.all([...])\`, and use \`map\`/\`filter\`/\`flatMap\` to build calls and combine results. The program's return value becomes the tool result.
+
+Reach for this when work decomposes into independent or staged subtasks — map-reduce over a list, a plan-then-verify pipeline, or fan-out-and-gather. For a single delegation, call the agent directly.
+
+Example — fan out across areas with \`agent\`, then pipe the results into a synthesis step:
+\`\`\`js
+const areas = ["correctness", "security", "performance"];
+const reviews = await Promise.all(
+  areas.map((area) =>
+    tools.agent({
+      message: \`Review the change for \${area}.\`,
+      outputSchema: { type: "object", properties: { findings: { type: "array", items: { type: "string" } } } },
+    }),
+  ),
+);
+const verdict = await tools.agent({
+  message: \`Summarize these findings into a verdict: \${JSON.stringify(reviews)}\`,
+  outputSchema: { type: "object", properties: { verdict: { type: "string" }, blocking: { type: "boolean" } } },
+});
+return verdict;
+\`\`\`${r.length>0?`\n\nDeclared subagents are called the same way — e.g. \`const note = await tools.${r[0]}({ message: "..." });\`.`:``}`}export{workflowToolDescription};

package/dist/src/index.d.ts

@@ -0,0 +1 @@
+export * from "#public/index.js";

package/dist/src/index.js

@@ -0,0 +1 @@
+export*from"#public/index.js";export{};

package/dist/src/internal/application/cache-metadata.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Clears one Eve-owned cache directory when its recorded Eve version is missing
+ * or differs from the currently installed package version.
+ */
+export declare function prepareEveVersionedCacheDirectory(directoryPath: string): Promise<void>;
+/**
+ * Writes the current installed Eve version into one Eve-owned cache directory.
+ */
+export declare function writeEveVersionedCacheMetadata(directoryPath: string): Promise<void>;

package/dist/src/internal/application/cache-metadata.js

@@ -0,0 +1 @@
+import{join}from"node:path";import{mkdir,readFile,rm,writeFile}from"node:fs/promises";import{resolveInstalledPackageInfo}from"#internal/application/package.js";const EVE_CACHE_METADATA_FILE=`eve-cache.json`;async function prepareEveVersionedCacheDirectory(e){let t=await readEveCacheVersion(e),n=resolveInstalledPackageInfo().version;t!==null&&t===n||await rm(e,{force:!0,recursive:!0})}async function writeEveVersionedCacheMetadata(n){await mkdir(n,{recursive:!0}),await writeFile(join(n,EVE_CACHE_METADATA_FILE),`${JSON.stringify({eveVersion:resolveInstalledPackageInfo().version},null,2)}\n`)}async function readEveCacheVersion(t){try{let r=JSON.parse(await readFile(join(t,EVE_CACHE_METADATA_FILE),`utf8`));return typeof r.eveVersion==`string`?r.eveVersion:null}catch(e){return e instanceof Error&&`code`in e&&e.code,null}}export{prepareEveVersionedCacheDirectory,writeEveVersionedCacheMetadata};

package/dist/src/internal/application/compiled-artifacts.d.ts

@@ -0,0 +1,33 @@
+import type { CompileAgentResult } from "#compiler/compile-agent.js";
+/**
+ * Paths to the generated compiled-artifacts files shared by Nitro and the
+ * vendored workflow bundles for one application.
+ */
+export interface GeneratedCompiledArtifactsFiles {
+    /**
+     * Shared bundled-artifacts bootstrap installed by Nitro and vendored
+     * workflow handlers.
+     */
+    bootstrapPath: string;
+    /**
+     * Optional Nitro plugin that imports the authored instrumentation module
+     * from the application when present.
+     */
+    instrumentationPluginPath?: string;
+    /**
+     * Absolute path to the authored instrumentation module when present.
+     * Nitro uses this to preserve the module's side effects during bundling.
+     */
+    instrumentationSourcePath?: string;
+}
+/**
+ * Writes the generated compiled-artifacts bootstrap module.
+ *
+ * The bootstrap self-installs bundled artifacts on import and exports a
+ * default function so it can be used directly as a Nitro plugin — no
+ * separate plugin wrapper file is needed.
+ */
+export declare function writeCompiledArtifactsFiles(input: {
+    compileResult: CompileAgentResult;
+    outDir: string;
+}): Promise<GeneratedCompiledArtifactsFiles>;

package/dist/src/internal/application/compiled-artifacts.js

@@ -0,0 +1,4 @@
+import{join}from"node:path";import{mkdir,writeFile}from"node:fs/promises";import{existsSync}from"node:fs";import{resolvePackageSourceFilePath}from"#internal/application/package.js";import{createCompiledModuleMapSource}from"#compiler/module-map.js";import{stringifyEsmImportSpecifier}from"#internal/application/import-specifier.js";async function writeCompiledArtifactsFiles(r){let a=join(r.outDir,`compiled-artifacts-bootstrap.mjs`),o=join(r.outDir,`compiled-artifacts-instrumentation.mjs`),s=resolveInstrumentationModule(r.compileResult.manifest.agentRoot);await mkdir(r.outDir,{recursive:!0}),await writeFile(a,await createCompiledArtifactsBootstrapSource({compileResult:r.compileResult,installModulePath:resolvePackageSourceFilePath(`src/runtime/loaders/bundled-artifacts.ts`),moduleMapPath:a,metadata:r.compileResult.metadata})),s!==void 0&&await writeFile(o,createInstrumentationPluginSource({agentName:r.compileResult.manifest.config.name,instrumentationPath:s,registerConfigPath:resolvePackageSourceFilePath(`src/harness/instrumentation-config.ts`)}));let c={bootstrapPath:a};return s!==void 0&&(c.instrumentationPluginPath=o,c.instrumentationSourcePath=s),c}const INSTRUMENTATION_EXTENSIONS=[`.ts`,`.mts`,`.js`,`.mjs`];function resolveInstrumentationModule(t){for(let n of INSTRUMENTATION_EXTENSIONS){let i=join(t,`instrumentation${n}`);if(existsSync(i))return i}}function stripCompiledModuleMapExports(e){return e.replace(/^export const moduleMap = /m,`const moduleMap = `).replace(/\nexport default moduleMap;\n?$/,`
+`)}async function createCompiledArtifactsBootstrapSource(e){let t=stripCompiledModuleMapExports(createCompiledModuleMapSource({importSpecifierStyle:`absolute`,manifest:e.compileResult.manifest,moduleMapPath:e.moduleMapPath})).trim();return[`// Generated by Eve. Do not edit by hand.`,`import { installBundledCompiledArtifacts } from ${stringifyEsmImportSpecifier(e.installModulePath)};`,``,t,``,`const metadata = ${JSON.stringify(e.metadata,null,2)};`,``,`const manifest = ${JSON.stringify(e.compileResult.manifest,null,2)};`,``,`export function installCompiledArtifactsBootstrap() {`,`  installBundledCompiledArtifacts({`,`    manifest,`,`    metadata,`,`    moduleMap,`,`  });`,`}`,``,`installCompiledArtifactsBootstrap();`,``,`// Default export satisfies the Nitro plugin contract so this file`,`// can be used directly as a Nitro plugin without a separate wrapper.`,`export default function installCompiledArtifactsPlugin() {`,`  // Already installed on import above.`,`}`,``,`export async function __eveInstallCompiledArtifactsStep() {`,`  "use step";`,`  return null;`,`}`,``].join(`
+`)}function createInstrumentationPluginSource(e){return[`// Generated by Eve. Do not edit by hand.`,`import * as instrumentationModule from ${stringifyEsmImportSpecifier(e.instrumentationPath)};`,`import { registerInstrumentationConfig } from ${stringifyEsmImportSpecifier(e.registerConfigPath)};`,``,`if (instrumentationModule.default != null) {`,`  registerInstrumentationConfig(instrumentationModule.default, { agentName: ${JSON.stringify(e.agentName)} });`,`}`,``,`// Default export satisfies the Nitro plugin contract so this file`,`// can be used directly as a Nitro plugin without a separate wrapper.`,`export default function installInstrumentationPlugin() {}`,``].join(`
+`)}export{writeCompiledArtifactsFiles};

package/dist/src/internal/application/import-specifier.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Converts filesystem paths into ESM-safe import specifiers.
+ *
+ * Node's ESM loader rejects raw Windows absolute paths such as
+ * `G:\app\handler.js` because the drive letter is parsed as a URL scheme.
+ * Generated source should import filesystem targets through `file://` URLs
+ * while leaving virtual, package, and relative specifiers usable by bundlers.
+ */
+export declare function normalizeEsmImportSpecifier(specifier: string): string;
+/**
+ * Serializes an import specifier for direct insertion into generated ESM code.
+ */
+export declare function stringifyEsmImportSpecifier(specifier: string): string;
+/**
+ * Rewrites generated ESM source containing raw Windows absolute imports.
+ */
+export declare function normalizeGeneratedEsmImportSpecifiers(source: string): string;

package/dist/src/internal/application/import-specifier.js

@@ -0,0 +1 @@
+const WINDOWS_DRIVE_ABSOLUTE_PATH_PATTERN=/^\/?[A-Za-z]:[\\/]/,WINDOWS_UNC_ABSOLUTE_PATH_PATTERN=/^\\\\[^\\]/,IMPORT_SPECIFIER_PATTERN=/(\b(?:from|import)\s*(?:\(\s*)?)(["'])([A-Za-z]:[\\/][^"'\n\r]*)\2/g;function isWindowsAbsolutePath(n){return WINDOWS_DRIVE_ABSOLUTE_PATH_PATTERN.test(n)||WINDOWS_UNC_ABSOLUTE_PATH_PATTERN.test(n)}function convertWindowsPathToFileUrl(e){let t=e.replaceAll(`\\`,`/`);return t.startsWith(`//`)?new URL(`file:${t}`).href:(/^\/[A-Za-z]:\//.test(t)&&(t=t.slice(1)),new URL(`file:///${t}`).href)}function splitPathSpecifierSuffix(e){let t=e.indexOf(`?`),n=e.indexOf(`#`),r=t===-1?n:n===-1?t:Math.min(t,n);return r===-1?{path:e,suffix:``}:{path:e.slice(0,r),suffix:e.slice(r)}}function normalizeEsmImportSpecifier(e){if(e.startsWith(`file://`))return e;let{path:t,suffix:n}=splitPathSpecifierSuffix(e);return isWindowsAbsolutePath(t)?`${convertWindowsPathToFileUrl(t)}${n}`:e.replaceAll(`\\`,`/`)}function stringifyEsmImportSpecifier(e){return JSON.stringify(normalizeEsmImportSpecifier(e))}function normalizeGeneratedEsmImportSpecifiers(e){return e.replace(IMPORT_SPECIFIER_PATTERN,(e,t,n,r)=>`${t}${n}${normalizeEsmImportSpecifier(r)}${n}`)}export{normalizeEsmImportSpecifier,normalizeGeneratedEsmImportSpecifiers,stringifyEsmImportSpecifier};

package/dist/src/internal/application/package.d.ts

@@ -0,0 +1,34 @@
+interface InstalledPackageInfo {
+    name: string;
+    version: string;
+}
+/**
+ * Resolves the installed Eve package root.
+ */
+export declare function resolvePackageRoot(): string;
+/**
+ * Resolves one package-owned source file from the currently executing Eve installation.
+ *
+ * Source checkouts use `src/...` paths so local tests exercise live source files.
+ * Installed or built package executions use `dist/src/...` so published builds do
+ * not depend on unpublished TypeScript sources.
+ */
+export declare function resolvePackageSourceFilePath(relativeSourcePath: string): string;
+/**
+ * Resolves one package-owned source directory from the currently executing Eve installation.
+ */
+export declare function resolvePackageSourceDirectoryPath(relativeSourcePath: string): string;
+export declare function resolvePackageDependencyPath(specifier: string): string;
+/**
+ * Resolves the installed Eve package identity from package.json.
+ */
+export declare function resolveInstalledPackageInfo(): InstalledPackageInfo;
+/**
+ * Resolves a Workflow runtime module from Eve's narrowed Workflow dependencies.
+ *
+ * Older Workflow builder output still uses `workflow/*` specifiers. Eve maps
+ * those historical specifiers to the smaller `@workflow/*` packages it actually
+ * needs, plus an Eve-owned builtins module for response body step helpers.
+ */
+export declare function resolveWorkflowModulePath(specifier: string): string;
+export {};

package/dist/src/internal/application/package.js

@@ -0,0 +1 @@
+import{createRequire}from"node:module";import{basename,dirname,join}from"node:path";import{existsSync,readFileSync,realpathSync}from"node:fs";import{EVE_PACKAGE_NAME}from"#internal/package-name.js";import{fileURLToPath}from"node:url";let cachedPackageInfo;const WORKFLOW_MODULE_ALIASES={"workflow/api":`src/compiled/@workflow/core/runtime.js`,"workflow/errors":`src/compiled/@workflow/errors/index.js`,"workflow/internal/private":`src/compiled/@workflow/core/private.js`,"workflow/runtime":`src/compiled/@workflow/core/runtime.js`};function resolveFallbackPackageVersion(){return`0.6.0-beta.1`}const FALLBACK_PACKAGE_INFO={name:EVE_PACKAGE_NAME,version:resolveFallbackPackageVersion()};function resolveCurrentModulePath(){return typeof __filename==`string`?__filename:resolveCurrentModulePathFromStack()}function resolveCurrentModulePathFromStack(){let e=Error.prepareStackTrace;try{Error.prepareStackTrace=(e,t)=>t;let e=Error().stack?.[0]?.getFileName();if(typeof e!=`string`||e.length===0)throw Error(`Failed to resolve the current module path from the stack trace.`);return e.startsWith(`file:`)?fileURLToPath(e):e}finally{Error.prepareStackTrace=e}}const require=createRequire(resolveCurrentModulePath());function isBuildOutputPackageRoot(e){return basename(e)===`dist`&&existsSync(join(dirname(e),`package.json`))}function resolvePackageBuildRoot(){let e=dirname(realpathSync(resolveCurrentModulePath()));for(;;){if(isBuildOutputPackageRoot(e))return e;let t=dirname(e);if(t===e)return null;e=t}}function findNearestPackageRoot(e){let t=e;for(;;){if(existsSync(join(t,`package.json`))&&!isBuildOutputPackageRoot(t))return t;let r=dirname(t);if(r===t)throw Error(`Failed to resolve package root from "${e}".`);t=r}}function resolvePackageRoot(){return findNearestPackageRoot(dirname(realpathSync(resolveCurrentModulePath())))}function tryResolvePackageRoot(){try{return resolvePackageRoot()}catch{return}}function rewriteSourceFilePathForBuild(e){return e.replace(/\.[cm]?tsx?$/,`.js`)}function resolvePackageSourceFilePath(e){let t=resolvePackageBuildRoot();return t===null?join(resolvePackageRoot(),e):join(t,rewriteSourceFilePathForBuild(e))}function resolvePackageSourceDirectoryPath(e){let t=resolvePackageBuildRoot();return join(t===null?resolvePackageRoot():t,e)}function resolvePackageDependencyPath(e){return require.resolve(e)}function resolvePackageCompiledFilePath(e){let t=resolvePackageBuildRoot();return t===null?join(resolvePackageRoot(),`.generated`,`compiled`,e.replace(/^src\/compiled\//,``)):join(t,e)}function normalizeInstalledPackageInfo(e){let t=e;if(!(typeof t.name!=`string`||typeof t.version!=`string`))return{name:t.name,version:t.version}}function tryReadInstalledPackageInfo(e,t){let n=normalizeInstalledPackageInfo(JSON.parse(readFileSync(e,`utf8`)));if(n?.name===t)return n}function resolveInstalledPackageInfo(){if(cachedPackageInfo)return cachedPackageInfo;let e=tryResolvePackageRoot(),t=e===void 0?void 0:tryReadInstalledPackageInfo(join(e,`package.json`),EVE_PACKAGE_NAME);if(t)return cachedPackageInfo=t,cachedPackageInfo;try{let e=tryReadInstalledPackageInfo(require.resolve(`${EVE_PACKAGE_NAME}/package.json`),EVE_PACKAGE_NAME);if(e)return cachedPackageInfo=e,cachedPackageInfo}catch{}return cachedPackageInfo={...FALLBACK_PACKAGE_INFO},cachedPackageInfo}function resolveWorkflowModulePath(e){if(e===`workflow`)return resolvePackageSourceFilePath(`src/internal/workflow/index.ts`);if(e===`workflow/internal/builtins`)return resolvePackageSourceFilePath(`src/internal/workflow/builtins.ts`);let t=WORKFLOW_MODULE_ALIASES[e];return t===void 0?require.resolve(e):resolvePackageCompiledFilePath(t)}export{resolveInstalledPackageInfo,resolvePackageDependencyPath,resolvePackageRoot,resolvePackageSourceDirectoryPath,resolvePackageSourceFilePath,resolveWorkflowModulePath};

package/dist/src/internal/application/paths.d.ts

@@ -0,0 +1,47 @@
+import type { NitroBuildSurface } from "#internal/nitro/host/types.js";
+export interface ApplicationInfo {
+    appRoot: string;
+    outputDir: string;
+    workflowId: string;
+    workflowBuildDir: string;
+    workflowSourceDir: string;
+}
+/**
+ * Resolves an application root from the current working directory.
+ */
+export declare function resolveApplicationRoot(cwd?: string): string;
+/**
+ * Resolves the programmatic Nitro build directory for an app.
+ */
+export declare function resolveNitroBuildDirectory(appRoot: string, surface?: NitroBuildSurface): string;
+/**
+ * Resolves the staged Nitro output directory for one isolated build surface.
+ */
+export declare function resolveNitroSurfaceOutputDirectory(appRoot: string, surface: Exclude<NitroBuildSurface, "all">): string;
+/**
+ * Resolves the package-owned Workflow DevKit bundle directory for a target app.
+ *
+ * This directory is intentionally placed under the package root rather than the
+ * application root so package-owned workflow caches are shared across generated
+ * app roots without relying on app-local installed dependencies.
+ *
+ * Each application root receives a unique hash-keyed subdirectory so parallel
+ * builds targeting different app roots never collide. The key is derived from
+ * `appRoot` alone — version-keyed dirs are intentionally avoided so every code
+ * path that resolves a cache directory converges on the same location and
+ * `prepareEveVersionedCacheDirectory` remains the single source of truth for
+ * version-based invalidation.
+ */
+export declare function resolveWorkflowBuildDirectory(appRoot: string): string;
+/**
+ * Resolves the cache directory used for durable local sandbox snapshots.
+ */
+export declare function resolveSandboxCacheDirectory(appRoot: string): string;
+/**
+ * Resolves the production Nitro output directory for an app.
+ */
+export declare function resolveOutputDirectory(appRoot: string): string;
+/**
+ * Returns structured app information for diagnostics and CLI output.
+ */
+export declare function getApplicationInfo(appRoot: string): ApplicationInfo;

package/dist/src/internal/application/paths.js

@@ -0,0 +1 @@
+import{join,resolve}from"node:path";import{existsSync,readFileSync,readdirSync,rmSync}from"node:fs";import{resolveInstalledPackageInfo,resolvePackageRoot,resolvePackageSourceDirectoryPath}from"#internal/application/package.js";import{createHash}from"node:crypto";import{workflowEntryReference}from"#execution/workflow-runtime.js";function resolveApplicationRoot(e=process.cwd()){return resolve(e)}function getWorkflowBuildCacheKey(e){return createHash(`sha256`).update(e).digest(`hex`).slice(0,12)}function isVercelBuildEnvironment(){return!!process.env.VERCEL}function resolveNitroBuildDirectory(t,n=`all`){let r=join(t,`.eve`,`nitro`);return n===`all`?r:join(r,n)}function resolveNitroSurfaceOutputDirectory(t,n){return join(t,`.eve`,`nitro-output`,n)}function resolveWorkflowBuildDirectory(t){let n=join(resolvePackageRoot(),`.eve`,`workflow-cache`);return pruneStaleWorkflowCacheSiblings(n),join(n,getWorkflowBuildCacheKey(t))}function pruneStaleWorkflowCacheSiblings(t){if(!existsSync(t))return;let o=resolveInstalledPackageInfo().version,s;try{s=readdirSync(t)}catch{return}for(let i of s){let a=join(t,i),s=join(a,`eve-cache.json`);if(existsSync(s))try{let e=JSON.parse(readFileSync(s,`utf8`));typeof e.eveVersion==`string`&&e.eveVersion!==o&&rmSync(a,{force:!0,recursive:!0})}catch{}}}function resolveSandboxCacheDirectory(t){return join(t,`.eve`,`sandbox-cache`)}function resolveOutputDirectory(t){return isVercelBuildEnvironment()?join(t,`.vercel`,`output`):join(t,`.output`)}function getApplicationInfo(e){return{appRoot:e,outputDir:resolveOutputDirectory(e),workflowId:workflowEntryReference.workflowId,workflowBuildDir:resolveWorkflowBuildDirectory(e),workflowSourceDir:resolvePackageSourceDirectoryPath(`src/execution`)}}export{getApplicationInfo,resolveApplicationRoot,resolveNitroBuildDirectory,resolveNitroSurfaceOutputDirectory,resolveOutputDirectory,resolveSandboxCacheDirectory,resolveWorkflowBuildDirectory};

package/dist/src/internal/application/runtime-compiled-artifacts-source.d.ts

@@ -0,0 +1,6 @@
+import { type RuntimeDiskCompiledArtifactsSource } from "#runtime/compiled-artifacts-source.js";
+/**
+ * Creates a disk-backed artifact source for dev/build flows that may need to
+ * hydrate authored modules directly from source files.
+ */
+export declare function createAuthoredSourceRuntimeCompiledArtifactsSource(appRoot: string): RuntimeDiskCompiledArtifactsSource;

package/dist/src/internal/application/runtime-compiled-artifacts-source.js

@@ -0,0 +1 @@
+import{resolvePackageSourceFilePath}from"#internal/application/package.js";import{createDiskRuntimeCompiledArtifactsSource}from"#runtime/compiled-artifacts-source.js";function createAuthoredSourceRuntimeCompiledArtifactsSource(e){return createDiskRuntimeCompiledArtifactsSource(e,{moduleMapLoaderPath:resolvePackageSourceFilePath(`src/internal/authored-module-map-loader.ts`)})}export{createAuthoredSourceRuntimeCompiledArtifactsSource};

package/dist/src/internal/attachments/data.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Shared helpers for decoding AI SDK `FilePart.data` values into raw
+ * bytes and inspecting their size without fetching remote resources.
+ *
+ * URL-shaped inputs that require IO return `null`; channel attachment
+ * refs are resolved explicitly by the staging layer.
+ */
+/**
+ * Converts any inline AI SDK `FilePart.data` value into raw bytes.
+ *
+ * Returns `null` for every URL-shaped input the caller is expected to
+ * handle out-of-band, including `eve-attachment:` refs and remote URLs.
+ */
+export declare function fileDataToBytes(data: unknown): Promise<Buffer | null>;
+/**
+ * Returns the byte length of `FilePart.data` without performing any IO.
+ */
+export declare function getKnownByteLength(data: unknown): number | null;

package/dist/src/internal/attachments/data.js

@@ -0,0 +1 @@
+import{isAttachmentRefUrl,parseAttachmentRef}from"#internal/attachments/refs.js";async function fileDataToBytes(e){return typeof Buffer<`u`&&Buffer.isBuffer(e)?e:e instanceof Uint8Array?Buffer.from(e):e instanceof ArrayBuffer?Buffer.from(new Uint8Array(e)):typeof e==`string`?decodeStringData(e):e instanceof URL&&e.protocol===`data:`?decodeStringData(e.href):null}function getKnownByteLength(n){return typeof Buffer<`u`&&Buffer.isBuffer(n)||n instanceof Uint8Array||n instanceof ArrayBuffer?n.byteLength:typeof n==`string`?computeStringByteLength(n):isAttachmentRefUrl(n)?parseAttachmentRef(n).size??null:n instanceof URL&&n.protocol===`data:`?computeStringByteLength(n.href):null}function decodeStringData(e){if(e.startsWith(`data:`)){let t=e.indexOf(`,`);if(t===-1)return null;let n=e.slice(5,t),r=e.slice(t+1);return n.endsWith(`;base64`)?Buffer.from(r,`base64`):Buffer.from(decodeURIComponent(r),`utf8`)}return/^https?:\/\//.test(e)?null:Buffer.from(e,`base64`)}function computeStringByteLength(e){if(e.startsWith(`data:`)){let t=e.indexOf(`,`);if(t===-1)return null;let n=e.slice(5,t),r=e.slice(t+1);if(n.endsWith(`;base64`))return estimateBase64ByteLength(r);try{return Buffer.byteLength(decodeURIComponent(r),`utf8`)}catch{return Buffer.byteLength(r,`utf8`)}}return/^https?:\/\//.test(e)?null:estimateBase64ByteLength(e)}function estimateBase64ByteLength(e){let t=e.trimEnd();if(t.length===0)return 0;let n=0;return t.endsWith(`==`)?n=2:t.endsWith(`=`)&&(n=1),Math.max(0,Math.floor(t.length*3/4)-n)}export{fileDataToBytes,getKnownByteLength};

package/dist/src/internal/attachments/errors.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Discriminator for {@link EveAttachmentError}.
+ *
+ * Today the only literal ever produced in the codebase is
+ * `"resolver-threw"`. The union remains a discriminated type so future
+ * producers can broaden it intentionally rather than as an accident of
+ * a string parameter that drifted.
+ */
+type EveAttachmentErrorKind = "resolver-threw";
+/**
+ * Input shape for {@link EveAttachmentError}. Separated from the class
+ * constructor so callers can build the options object inline and TS
+ * can check the `kind` / `message` pair without a positional
+ * constructor signature.
+ */
+interface EveAttachmentErrorInput {
+    readonly kind: EveAttachmentErrorKind;
+    readonly message: string;
+    readonly adapterKind?: string;
+    readonly cause?: unknown;
+}
+/**
+ * Error surfaced when an attachment resolver fails to produce bytes for
+ * an {@link AttachmentRef}.
+ *
+ * Channels can inspect the `.kind` discriminator to decide whether to
+ * drop the attachment and continue the turn (the default posture for
+ * every kind today) or fail the whole delivery (future strict mode).
+ * The original failure, when there is one, is preserved on `.cause` so
+ * observability can surface the upstream error without losing context.
+ */
+export declare class EveAttachmentError extends Error {
+    readonly kind: EveAttachmentErrorKind;
+    readonly adapterKind?: string;
+    readonly cause?: unknown;
+    constructor(input: EveAttachmentErrorInput);
+}
+export {};

package/dist/src/internal/attachments/errors.js

@@ -0,0 +1 @@
+var EveAttachmentError=class extends Error{kind;adapterKind;cause;constructor(e){super(e.message),this.name=`EveAttachmentError`,this.kind=e.kind,e.adapterKind!==void 0&&(this.adapterKind=e.adapterKind),e.cause!==void 0&&(this.cause=e.cause)}};export{EveAttachmentError};

package/dist/src/internal/attachments/refs.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Opaque attachment references: the wire format a channel uses to carry
+ * file identity across step boundaries without inlining the bytes.
+ *
+ * Refs are compact custom-scheme URLs:
+ *
+ * ```
+ * eve-attachment:?v=1&p=<base64url-encoded JSON of { params, size? }>
+ * ```
+ */
+/**
+ * Custom URL scheme used by every attachment ref. The trailing colon
+ * is part of the scheme per WHATWG URL semantics.
+ */
+export declare const ATTACHMENT_REF_SCHEME = "eve-attachment:";
+/**
+ * Current wire format version. Decoders reject any other value so a
+ * future format bump doesn't silently misparse.
+ */
+export declare const ATTACHMENT_REF_WIRE_VERSION = "1";
+/**
+ * Serializable description of one inbound file attachment.
+ *
+ * `params` is an adapter-defined, JSON-safe object typed by the generic
+ * parameter. It identifies the upstream file and must not carry
+ * credentials; resolvers read credentials from adapter context or closure.
+ *
+ * `size` is optional. Populating it when the upstream protocol exposes
+ * the byte length up front lets upload-policy size checks run without
+ * fetching the bytes.
+ */
+export interface AttachmentRef<TParams = unknown> {
+    readonly params: TParams;
+    readonly size?: number;
+}
+/**
+ * Encodes an {@link AttachmentRef} as a URL suitable for use as
+ * `FilePart.data`.
+ *
+ * `TParams` links the encoded payload shape to the channel resolver.
+ */
+export declare function encodeAttachmentRef<TParams>(ref: AttachmentRef<TParams>): URL;
+/**
+ * Parses an {@link AttachmentRef} back out of a URL.
+ */
+export declare function parseAttachmentRef<TParams = unknown>(url: URL): AttachmentRef<TParams>;
+/**
+ * Cheap runtime check: does this value look like an attachment-ref URL?
+ *
+ * Accepts `URL` instances with the `eve-attachment:` scheme. Strings
+ * are NOT accepted — the staging layer only checks URL-instance
+ * `FilePart.data` values, matching the existing `data instanceof URL`
+ * branch in `fileDataToBytes`.
+ */
+export declare function isAttachmentRefUrl(value: unknown): value is URL;

package/dist/src/internal/attachments/refs.js

@@ -0,0 +1 @@
+import{toErrorMessage}from"#shared/errors.js";const ATTACHMENT_REF_SCHEME=`eve-attachment:`,ATTACHMENT_REF_WIRE_VERSION=`1`;function isValidSize(e){return Number.isFinite(e)&&Number.isInteger(e)&&e>=0}function encodeAttachmentRef(e){if(e.size!==void 0&&!isValidSize(e.size))throw RangeError(`AttachmentRef.size must be a non-negative integer. Received: ${String(e.size)}.`);let n=e.size===void 0?{params:e.params}:{params:e.params,size:e.size},r=Buffer.from(JSON.stringify(n),`utf8`).toString(`base64url`),i=new URL(ATTACHMENT_REF_SCHEME);return i.searchParams.set(`v`,`1`),i.searchParams.set(`p`,r),i}function parseAttachmentRef(n){if(n.protocol!==`eve-attachment:`)throw Error(`AttachmentRef URL must use scheme "${ATTACHMENT_REF_SCHEME}". Got: "${n.protocol}".`);let r=n.searchParams.get(`v`);if(r!==`1`)throw Error(`AttachmentRef wire format version must be "1". Got: ${r===null?`missing`:JSON.stringify(r)}.`);let i=n.searchParams.get(`p`);if(i===null||i===``)throw Error(`AttachmentRef URL is missing the required "p" payload query param.`);let a;try{let e=Buffer.from(i,`base64url`).toString(`utf8`);a=JSON.parse(e)}catch(t){throw Error(`AttachmentRef payload is not valid base64url-encoded JSON: ${toErrorMessage(t)}`)}if(typeof a!=`object`||!a||Array.isArray(a))throw Error(`AttachmentRef payload must decode to a JSON object.`);let o=a;if(!(`params`in o))throw Error(`AttachmentRef payload is missing the required "params" field.`);let s=o.params;if(!(`size`in o))return{params:s};let c=o.size;if(typeof c!=`number`||!isValidSize(c))throw Error(`AttachmentRef payload "size" must be a non-negative integer. Got: ${JSON.stringify(c)}.`);return{params:s,size:c}}function isAttachmentRefUrl(e){return e instanceof URL&&e.protocol===`eve-attachment:`}export{ATTACHMENT_REF_SCHEME,ATTACHMENT_REF_WIRE_VERSION,encodeAttachmentRef,isAttachmentRefUrl,parseAttachmentRef};