eve 0.5.4 → 0.6.0-beta.1

package/dist/src/internal/nitro/routes/runtime-artifacts.d.ts

@@ -0,0 +1,17 @@
+import { type RuntimeCompiledArtifactsSource } from "#runtime/compiled-artifacts-source.js";
+/**
+ * Configuration values needed to resolve the compiled-artifact source for
+ * package-owned Nitro routes. Passed explicitly from virtual handlers
+ * rather than read from a global runtime configuration store.
+ */
+export interface NitroArtifactsConfig {
+    readonly appRoot?: string;
+    readonly dev?: boolean;
+    readonly devRuntimeArtifactsPointerPath?: string;
+    readonly moduleMapLoaderPath?: string;
+}
+/**
+ * Resolves the compiled-artifact source available to package-owned Nitro
+ * routes.
+ */
+export declare function resolveNitroCompiledArtifactsSource(config: NitroArtifactsConfig): RuntimeCompiledArtifactsSource;

package/dist/src/internal/nitro/routes/runtime-artifacts.js

@@ -0,0 +1 @@
+import{createBundledRuntimeCompiledArtifactsSource,createDiskRuntimeCompiledArtifactsSource}from"#runtime/compiled-artifacts-source.js";import{readBundledCompiledArtifacts}from"#runtime/loaders/bundled-artifacts.js";import{readDevelopmentRuntimeArtifactsSnapshotRoot}from"#internal/nitro/dev-runtime-artifacts.js";function resolveNitroCompiledArtifactsSource(e){let{appRoot:t,dev:n}=e;if(n&&t!==void 0){if(e.moduleMapLoaderPath===void 0)throw Error(`Eve Nitro development routes require "moduleMapLoaderPath" in the artifacts config.`);return createDiskRuntimeCompiledArtifactsSource(readDevelopmentRuntimeArtifactsSnapshotRoot(e.devRuntimeArtifactsPointerPath)??t,{moduleMapLoaderPath:e.moduleMapLoaderPath})}if(readBundledCompiledArtifacts()!==null)return createBundledRuntimeCompiledArtifactsSource();if(t!==void 0)return createDiskRuntimeCompiledArtifactsSource(t);throw Error(`Eve Nitro route requires bundled artifacts or an Eve Nitro runtime configuration app root.`)}export{resolveNitroCompiledArtifactsSource};

package/dist/src/internal/nitro/routes/runtime-stack.d.ts

@@ -0,0 +1,26 @@
+import type { Runtime } from "#channel/types.js";
+import type { ResolvedChannelDefinition } from "#runtime/types.js";
+import { type NitroArtifactsConfig } from "#internal/nitro/routes/runtime-artifacts.js";
+/**
+ * Bundle returned to the per-channel Nitro dispatch handler.
+ *
+ * Carries the resolved channel set (framework defaults + authored
+ * overrides minus authored disables) and the per-request workflow runtime.
+ * The dispatch handler walks `channels` to match the inbound request
+ * against a registered URL pattern, then calls the matched channel's
+ * `fetch` with a `RouteContext` built from `runtime`.
+ */
+export interface NitroChannelRuntimeBundle {
+    readonly channels: readonly ResolvedChannelDefinition[];
+    readonly runtime: Runtime;
+}
+/**
+ * Resolves the per-request channel bundle: the agent's resolved channels
+ * (already merged with framework defaults by `resolve-agent-graph.ts`)
+ * and a fresh workflow runtime.
+ *
+ * No singleton caching is needed — session state lives inside the
+ * workflow's durable execution and the channel set is recomputed from the
+ * compiled bundle on each request.
+ */
+export declare function resolveNitroChannelRuntimeBundle(config: NitroArtifactsConfig): Promise<NitroChannelRuntimeBundle>;

package/dist/src/internal/nitro/routes/runtime-stack.js

@@ -0,0 +1 @@
+import{getCompiledRuntimeAgentBundle}from"#runtime/sessions/compiled-agent-cache.js";import{createWorkflowRuntime}from"#execution/workflow-runtime.js";import{resolveNitroCompiledArtifactsSource}from"#internal/nitro/routes/runtime-artifacts.js";async function resolveNitroChannelRuntimeBundle(e){let t=resolveNitroCompiledArtifactsSource(e),n=await getCompiledRuntimeAgentBundle({compiledArtifactsSource:t}),r=createWorkflowRuntime({compiledArtifactsSource:t});return{channels:n.graph.root.channels,runtime:r}}export{resolveNitroChannelRuntimeBundle};

package/dist/src/internal/nitro/routes/schedule-task.d.ts

@@ -0,0 +1,12 @@
+import type { NitroArtifactsConfig } from "#internal/nitro/routes/runtime-artifacts.js";
+/**
+ * Dispatches one Eve authored schedule via the execution engine.
+ *
+ * Fire-and-forget: the workflow runtime owns terminal completion and
+ * its own failure observability. The task return value reports which
+ * session ids the handler started so Nitro / dev tools can correlate.
+ */
+export declare function dispatchScheduleTask(taskName: string, config: NitroArtifactsConfig): Promise<{
+    scheduleId: string;
+    sessionIds: readonly string[];
+}>;

package/dist/src/internal/nitro/routes/schedule-task.js

@@ -0,0 +1 @@
+import{getCompiledRuntimeAgentBundle}from"#runtime/sessions/compiled-agent-cache.js";import{createWorkflowRuntime}from"#execution/workflow-runtime.js";import{resolveNitroCompiledArtifactsSource}from"#internal/nitro/routes/runtime-artifacts.js";import{loadResolvedCompiledScheduleByTaskName}from"#runtime/schedules/resolve-schedule.js";import{ScheduleDispatcher,expectScheduleRun}from"#channel/schedule.js";import{loadResolvedModuleExport}from"#runtime/resolve-helpers.js";async function dispatchScheduleTask(r,i){let a=resolveNitroCompiledArtifactsSource(i),o=await loadResolvedCompiledScheduleByTaskName(r,{compiledArtifactsSource:a}),s=await getCompiledRuntimeAgentBundle({compiledArtifactsSource:a}),c=new ScheduleDispatcher({runtime:createWorkflowRuntime({compiledArtifactsSource:a}),channels:s.graph.root.channels}),l={scheduleId:o.name};o.hasRun&&(l.run=await loadScheduleRun(o,s.moduleMap)),o.markdown!==void 0&&(l.markdown=o.markdown);let u=await c.trigger(l);return u.waitUntilTasks.length>0&&await Promise.allSettled(u.waitUntilTasks),{scheduleId:o.name,sessionIds:u.sessions.map(e=>e.id)}}async function loadScheduleRun(e,t){if(e.sourceKind!==`module`)throw Error(`Schedule "${e.name}" claims hasRun but is not a module-backed schedule.`);let n=e;return expectScheduleRun(await loadResolvedModuleExport({definition:{exportName:n.exportName,logicalPath:n.logicalPath,sourceId:n.sourceId},kindLabel:`schedule`,moduleMap:t,nodeId:void 0}),n.logicalPath,n.exportName)}export{dispatchScheduleTask};

package/dist/src/internal/node-esm-compat-banner.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Options for {@link buildNodeEsmCompatBanner} and
+ * {@link createNodeEsmCompatBannerPlugin}.
+ *
+ * Bundle output that re-declares one of the CJS path globals at the top
+ * level would otherwise collide with the banner, producing
+ * `SyntaxError: Identifier '__dirname' has already been declared` at load
+ * time. The banner builder omits any line whose binding the chunk already
+ * provides.
+ */
+interface NodeEsmCompatBannerOptions {
+    /** Whether to expose a CommonJS `require` shim alongside the path globals. */
+    readonly includeRequire?: boolean;
+}
+/**
+ * Builds the ESM CommonJS-compatibility banner appropriate for a single
+ * bundle chunk's code. Identifiers the chunk already binds at the top
+ * level (e.g. `const __dirname = ...` emitted by an inlined module) are
+ * skipped so the prepended banner never re-declares them.
+ *
+ * Returns an empty string when the chunk already provides every binding.
+ */
+export declare function buildNodeEsmCompatBanner(code: string, options?: NodeEsmCompatBannerOptions): string;
+interface BannerPlugin {
+    readonly name: string;
+    renderChunk(code: string, chunk?: {
+        readonly fileName?: string;
+    }): {
+        code: string;
+        map: SourceMap;
+    } | null;
+}
+interface SourceMap {
+    readonly version: 3;
+    readonly sources: readonly string[];
+    readonly sourcesContent: readonly string[];
+    readonly names: readonly string[];
+    readonly mappings: string;
+}
+/**
+ * Creates a bundler plugin that prepends the Node ESM compatibility
+ * banner to each output chunk, skipping any banner line whose binding
+ * the chunk already provides. Compatible with both Rollup and Rolldown.
+ */
+export declare function createNodeEsmCompatBannerPlugin(options?: NodeEsmCompatBannerOptions): BannerPlugin;
+export {};

package/dist/src/internal/node-esm-compat-banner.js

@@ -0,0 +1,4 @@
+const BANNER_LINES=[{importLine:`import { fileURLToPath as __eveFileURLToPath } from "node:url";`,declarationLine:`const __filename = __eveFileURLToPath(import.meta.url);`,bindingPattern:/^(?:const|let|var)\s+__filename\b/m},{importLine:`import { dirname as __eveDirname } from "node:path";`,declarationLine:`const __dirname = __eveDirname(__filename);`,bindingPattern:/^(?:const|let|var)\s+__dirname\b/m}],REQUIRE_LINE={importLine:`import { createRequire as __eveCreateRequire } from "node:module";`,declarationLine:`const require = __eveCreateRequire(import.meta.url);`,bindingPattern:/^(?:const|let|var)\s+require\b/m};function buildNodeEsmCompatBanner(n,r={}){let i=[...BANNER_LINES];r.includeRequire===!0&&i.push(REQUIRE_LINE);let a=[],o=[];for(let e of i)e.bindingPattern.test(n)||(a.push(e.importLine),o.push(e.declarationLine));return o.length===0?``:[...a,...o].join(`
+`)}function createNodeEsmCompatBannerPlugin(e={}){return{name:`eve-node-esm-compat-banner`,renderChunk(t,n){let r=buildNodeEsmCompatBanner(t,e);return r===``?null:{code:`${r}\n${t}`,map:createPrependedLineSourceMap({insertedLineCount:r.split(`
+`).length,source:n?.fileName??`eve-node-esm-compat-banner-input`,sourceContent:t})}}}}function createPrependedLineSourceMap({insertedLineCount:e,source:t,sourceContent:n}){let r=n.split(`
+`).length,i=Array.from({length:r},(e,t)=>encodeVlqFields(t===0?[0,0,0,0]:[0,0,1,0]));return{version:3,sources:[t],sourcesContent:[n],names:[],mappings:`${`;`.repeat(e)}${i.join(`;`)}`}}function encodeVlqFields(e){return e.map(e=>encodeVlqInteger(e)).join(``)}function encodeVlqInteger(e){let t=e<0?(-e<<1)+1:e<<1,n=``;do{let e=t&31;t>>>=5,t>0&&(e|=32),n+=`ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/`[e]}while(t>0);return n}export{buildNodeEsmCompatBanner,createNodeEsmCompatBannerPlugin};

package/dist/src/internal/package-name.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The published npm package name for the Eve framework.
+ *
+ * This module is intentionally free of side effects and heavy imports so that
+ * any layer can reference the package identity without pulling in filesystem
+ * or module-resolution code.
+ */
+export declare const EVE_PACKAGE_NAME = "eve";

package/dist/src/internal/package-name.js

@@ -0,0 +1 @@
+const EVE_PACKAGE_NAME=`eve`;export{EVE_PACKAGE_NAME};

package/dist/src/internal/process/pnpm.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Resolved invocation for the host's pnpm executable. The shape carries
+ * everything `child_process.spawn` and `execFile` need to dispatch to the
+ * right binary across macOS/Linux PATH installs, Corepack-managed shims,
+ * and Windows runners that surface pnpm only through `PNPM_HOME`.
+ */
+export interface PnpmInvocation {
+    readonly args: readonly string[];
+    readonly command: string;
+    readonly shell?: boolean;
+}
+/**
+ * Picks the right pnpm executable for the current host. Resolution order:
+ *
+ *  1. `PNPM_HOME` — the standard install location used by Corepack and the
+ *     pnpm installers. On Windows, points at `pnpm.CMD` because the bare
+ *     `pnpm` shim is not directly invokable from a non-shell spawn.
+ *  2. `npm_execpath` — set when the current process was launched by an
+ *     npm-compatible package manager. Pointing at a `.cjs`/`.js` entry
+ *     means we have to run it through `node` (typical for Corepack
+ *     shims); otherwise treat it as a bare executable path.
+ *  3. Bare `pnpm` on PATH — the macOS/Linux happy path.
+ *
+ * Pure: no side effects, returns the invocation shape; the caller picks
+ * `spawn` vs. `execFile`. The test harness uses this to keep platform
+ * handling in one place.
+ */
+export declare function resolvePnpmInvocation(args: readonly string[]): PnpmInvocation;

package/dist/src/internal/process/pnpm.js

@@ -0,0 +1 @@
+import{extname,join}from"node:path";import{existsSync}from"node:fs";function resolvePnpmInvocation(n){let r=process.env.PNPM_HOME;if(r!==void 0){let e=join(r,process.platform===`win32`?`pnpm.CMD`:`pnpm`);if(existsSync(e))return{args:n,command:e,shell:process.platform===`win32`}}let i=process.env.npm_execpath;if(i!==void 0&&i.toLowerCase().includes(`pnpm`)){let t=extname(i).toLowerCase();return t===`.cjs`||t===`.js`?{args:[i,...n],command:process.execPath}:{args:n,command:i,shell:process.platform===`win32`}}return{args:n,command:`pnpm`}}export{resolvePnpmInvocation};

package/dist/src/internal/runtime-model.d.ts

@@ -0,0 +1,13 @@
+import type { LanguageModel } from "ai";
+/**
+ * Formats an authored agent model reference as an AI Gateway model id.
+ *
+ * Handles both authored shapes:
+ * - A `string` is treated as an already-formatted Gateway id.
+ * - A `LanguageModel` instance is formatted as `${provider}/${modelId}`.
+ *
+ * Some providers expose `provider` as a dotted sub-path (e.g. `anthropic.messages`,
+ * `openai.responses`) to disambiguate request shapes. The Gateway routes on the
+ * top-level provider only, so any segments after the first dot are dropped.
+ */
+export declare function formatLanguageModelGatewayId(model: LanguageModel): string;

package/dist/src/internal/runtime-model.js

@@ -0,0 +1 @@
+function formatLanguageModelGatewayId(e){return typeof e==`string`?e:`${e.provider.split(`.`)[0]}/${e.modelId.replace(/^(claude-[a-z]+-\d+)-(\d+)$/,`$1.$2`)}`}export{formatLanguageModelGatewayId};

package/dist/src/internal/runtime-registry.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Source location for one entry registered with a {@link RuntimeRegistry}.
+ *
+ * Carried on {@link RuntimeRegistryError} so callers (CLI diagnostics,
+ * IDE integrations) can point at the file that introduced the conflict.
+ */
+export interface RuntimeRegistryEntryLocation {
+    readonly logicalPath?: string;
+    readonly sourceId?: string;
+}
+/**
+ * Error raised when a runtime-owned subsystem rejects an entry — for
+ * example a duplicate authored sandbox name, a tool name reserved by the
+ * framework, or a subagent whose node id is already taken.
+ *
+ * The `registry` field identifies which subsystem produced the error
+ * (`"sandbox"`, `"tool"`, `"subagent"`, …) so consumers can branch on
+ * one error class instead of `instanceof`-ing one per primitive.
+ */
+export declare class RuntimeRegistryError extends Error {
+    readonly registry: string;
+    readonly entryName?: string;
+    readonly logicalPath?: string;
+    readonly sourceId?: string;
+    constructor(registry: string, message: string, context?: RuntimeRegistryEntryLocation & {
+        readonly entryName?: string;
+    });
+}
+/**
+ * Options accepted by {@link RuntimeRegistry.register}.
+ */
+interface RuntimeRegistryRegisterOptions {
+    /** Source location attached to the error if registration fails. */
+    readonly location?: RuntimeRegistryEntryLocation;
+    /** Override the default "duplicate name" error message. */
+    readonly duplicateMessage?: string;
+    /** Override the default "name reserved" error message. */
+    readonly reservedMessage?: string;
+}
+/**
+ * Map-backed primitive for runtime-owned subsystems that index entries
+ * by unique name and need to surface a consistent error shape on
+ * collision.
+ *
+ * The optional `reserved` set lets a registry detect collisions across
+ * multiple registration passes — for example the tool registry seeds
+ * reserved framework tool names so authored tools cannot shadow them.
+ * Once an entry is registered its name is automatically added to the
+ * reserved set.
+ */
+export declare class RuntimeRegistry<TEntry> {
+    private readonly registry;
+    private readonly _entries;
+    private readonly _reserved;
+    constructor(registry: string, reserved?: Iterable<string>);
+    get size(): number;
+    has(name: string): boolean;
+    get(name: string): TEntry | null;
+    /**
+     * Returns the underlying map. Callers must treat the returned value
+     * as read-only.
+     */
+    asMap(): ReadonlyMap<string, TEntry>;
+    /**
+     * Adds an entry to the registry. Throws {@link RuntimeRegistryError}
+     * if `name` is already registered or already reserved by a previous
+     * registration pass.
+     */
+    register(name: string, entry: TEntry, options?: RuntimeRegistryRegisterOptions): void;
+    /**
+     * Adds or replaces an entry without uniqueness or reservation checks.
+     * Use for framework-owned defaults that the caller has already
+     * validated.
+     */
+    set(name: string, entry: TEntry): void;
+}
+export {};

package/dist/src/internal/runtime-registry.js

@@ -0,0 +1 @@
+var RuntimeRegistryError=class extends Error{registry;entryName;logicalPath;sourceId;constructor(e,t,n={}){super(t),this.name=`RuntimeRegistryError`,this.registry=e,n.entryName!==void 0&&(this.entryName=n.entryName),n.logicalPath!==void 0&&(this.logicalPath=n.logicalPath),n.sourceId!==void 0&&(this.sourceId=n.sourceId)}},RuntimeRegistry=class{registry;_entries=new Map;_reserved;constructor(e,t=[]){this.registry=e,this._reserved=new Set(t)}get size(){return this._entries.size}has(e){return this._entries.has(e)}get(e){return this._entries.get(e)??null}asMap(){return this._entries}register(e,t,n={}){if(this._entries.has(e))throw new RuntimeRegistryError(this.registry,n.duplicateMessage??`Duplicate ${this.registry} name "${e}".`,{...n.location,entryName:e});if(this._reserved.has(e))throw new RuntimeRegistryError(this.registry,n.reservedMessage??`${capitalize(this.registry)} "${e}" collides with another runtime-visible name.`,{...n.location,entryName:e});this._entries.set(e,t),this._reserved.add(e)}set(e,t){this._entries.set(e,t),this._reserved.add(e)}};function capitalize(e){return e.length===0?e:e.charAt(0).toUpperCase()+e.slice(1)}export{RuntimeRegistry,RuntimeRegistryError};

package/dist/src/internal/vercel-agent-summary.d.ts

@@ -0,0 +1,210 @@
+/**
+ * Public, versioned summary of an Eve agent emitted by `eve`
+ * during `eve build`.
+ *
+ * This schema is the stable contract between Eve and Vercel platform
+ * surfaces (eg. the dashboard's project overview card). It is intentionally
+ * smaller and more conservative than the internal {@link CompiledAgentManifest}
+ * — only fields safe to render in product UI live here, and the schema is
+ * versioned independently of the internal compiler manifest.
+ *
+ * **Storage** — the file is written to {@link VERCEL_EVE_AGENT_SUMMARY_OUTPUT_PATH}
+ * (under the agent's `appRoot`, outside the Build Output API surface). On
+ * Vercel deployments, the build container uploads it to a top-level S3
+ * artifact at `<projectId>/<deploymentId>/eve_agent_summary.json` — the
+ * same tier as `deploy_metadata.json` and `turbo_summary.json`, never
+ * reachable from the public CDN. The dashboard reads it through the
+ * dedicated `/v6/deployments/:id/files/eve-agent-summary` endpoint with
+ * team-scoped authentication.
+ *
+ * **Privacy** — non-public by storage location. The summary contains
+ * user-authored business logic (tool descriptions, connection URLs,
+ * source paths, subagent prompts) and is never served on the deployment
+ * URL because the public proxy only resolves URLs against `basepath/`.
+ *
+ * **Self-hosted setups** — the file exists at the same path on disk
+ * (`<appRoot>/.eve/agent-summary.json`) and is consumed by whatever
+ * HTTP layer the operator wires up.
+ */
+/**
+ * Stable schema kind embedded in every emitted summary file.
+ */
+export declare const VERCEL_EVE_AGENT_SUMMARY_KIND: "vercel-eve-agent-summary";
+/**
+ * Current public schema version. Bump only when adding required fields or
+ * making semantic changes consumers must opt into. Adding optional fields
+ * does not require a version bump.
+ */
+export declare const VERCEL_EVE_AGENT_SUMMARY_VERSION = 3;
+/**
+ * Output path (relative to the agent's `appRoot`) where Eve writes the
+ * summary file at build time.
+ *
+ * Lives under `.eve/` — the existing Eve-internal cache namespace that
+ * already holds `nitro/`, `nitro-output/`, `sandbox-cache/`, etc. (see
+ * `packages/eve/src/internal/application/paths.ts`). Intentionally
+ * outside `.vercel/output/` so the file is not part of the Build Output
+ * API surface — the Vercel build container picks it up from this path
+ * and uploads it to a top-level deployment artifact, matching how the
+ * Turbo run summary works.
+ */
+export declare const VERCEL_EVE_AGENT_SUMMARY_OUTPUT_PATH = ".eve/agent-summary.json";
+/**
+ * Display category Eve exposes to the dashboard for one channel chip. Built
+ * from the channel's reported {@link CompiledChannelDefinition.adapterKind}.
+ */
+export type VercelEveChannelType = "slack" | "http" | "webhook" | "unknown";
+/**
+ * Top-level agent identity used to label the dashboard card.
+ */
+export interface VercelEveAgentEntry {
+    readonly name: string;
+    readonly description?: string;
+    readonly modelId: string;
+}
+/**
+ * Authored agent instructions resolved at build time from the agent's
+ * `instructions.md` or `instructions.{ts,cts,mts,js,cjs,mjs}` source.
+ * Agents without authored instructions fall back to the framework default
+ * and the summary's `instructions` field is `null`.
+ *
+ * The dashboard renders the markdown body verbatim, so the field carries
+ * the full resolved content rather than a preview. For module-backed
+ * sources the markdown is the result the module produced at build time,
+ * not the module's source code.
+ */
+export interface VercelEveInstructionsEntry {
+    /**
+     * Logical path of the discovered instructions source, relative to the
+     * agent root (eg. `instructions.md`).
+     */
+    readonly logicalPath: string;
+    /**
+     * How the instructions were authored. `markdown` is a literal markdown
+     * file at the agent root; `module` is a TypeScript / JavaScript module
+     * that produces the instructions at build time.
+     */
+    readonly sourceKind: "markdown" | "module";
+    /** Resolved markdown body of the instructions. */
+    readonly markdown: string;
+}
+export interface VercelEveScheduleEntry {
+    readonly name: string;
+    readonly cron: string;
+    readonly logicalPath: string;
+}
+export interface VercelEveToolEntry {
+    readonly name: string;
+    readonly description: string;
+    readonly logicalPath: string;
+}
+/**
+ * Wire protocol the authored connection speaks, mirrored from the
+ * compiled connection's `protocol` discriminator. `"mcp"` is a
+ * {@link defineMcpClientConnection} server; `"openapi"` is a
+ * {@link defineOpenAPIConnection} REST API. New primitives extend this
+ * union when they ship.
+ */
+export type VercelEveConnectionType = "mcp" | "openapi";
+export interface VercelEveConnectionEntry {
+    readonly name: string;
+    readonly description: string;
+    readonly url: string;
+    readonly logicalPath: string;
+    readonly type: VercelEveConnectionType;
+    /**
+     * When the connection's auth is built by `connect()` from
+     * `@vercel/connect/eve`, the connector identifier the author passed
+     * (UID like `"oauth/mcp-linear-app"` or opaque `"scl_..."` form).
+     * Dashboards use this to deep-link into the connector's settings page
+     * — typically resolving UID → `scl_...` against
+     * `GET /v6/connect/connectors` and building
+     * `/[teamSlug]/[project]/connect/<scl_...>`.
+     *
+     * Omitted for connections backed by a raw MCP server, a static
+     * token, or a custom `getToken` callback (anything not produced by
+     * the Vercel Connect helper).
+     */
+    readonly vercelConnect?: {
+        readonly connector: string;
+    };
+}
+export interface VercelEveChannelEntry {
+    readonly name: string;
+    readonly method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "WEBSOCKET";
+    readonly urlPath: string;
+    readonly type: VercelEveChannelType;
+    /**
+     * The raw `ChannelAdapter.kind` reported by the route, when present.
+     * Useful when `type` is `"unknown"` and a consumer wants to render a
+     * disambiguating label.
+     */
+    readonly adapterKind?: string;
+    readonly logicalPath: string;
+}
+export interface VercelEveSandboxEntry {
+    readonly logicalPath: string;
+}
+/**
+ * One authored skill exposed to the dashboard.
+ *
+ * Skills are markdown procedures the model loads on demand through the
+ * framework-owned `load_skill` tool. The summary lists the available
+ * skills by `name` + `description` so the dashboard can render the
+ * surface without pulling each skill's full markdown body. Consumers
+ * that need the full content can drill in through a dedicated endpoint
+ * later — this entry is intentionally an overview shape.
+ *
+ * `sourceKind` distinguishes flat markdown skills (`agent/skills/foo.md`),
+ * module-backed skills (`agent/skills/foo.ts`), and packaged skills
+ * (`agent/skills/foo/SKILL.md` with sibling `references/`, `assets/`,
+ * `scripts/` directories).
+ */
+export interface VercelEveSkillEntry {
+    readonly name: string;
+    readonly description: string;
+    readonly logicalPath: string;
+    readonly sourceKind: "markdown" | "module" | "skill-package";
+}
+export interface VercelEveSubagentEntry {
+    readonly name: string;
+    readonly description: string;
+    readonly logicalPath: string;
+}
+export interface VercelEveDiagnosticsSummary {
+    readonly errors: number;
+    readonly warnings: number;
+}
+/**
+ * Versioned public summary of one Eve agent, emitted into the Vercel Build
+ * Output during `eve build` and ingested by Vercel as deployment metadata.
+ */
+export interface VercelEveAgentSummary {
+    readonly kind: typeof VERCEL_EVE_AGENT_SUMMARY_KIND;
+    readonly schemaVersion: typeof VERCEL_EVE_AGENT_SUMMARY_VERSION;
+    /**
+     * Version of the `eve` package that produced this summary,
+     * for diagnostics. Format follows semver.
+     */
+    readonly generatorVersion: string;
+    readonly agent: VercelEveAgentEntry;
+    /**
+     * Authored agent instructions, when declared. `null` when the agent
+     * relies on the framework default.
+     */
+    readonly instructions: VercelEveInstructionsEntry | null;
+    readonly schedules: readonly VercelEveScheduleEntry[];
+    readonly tools: readonly VercelEveToolEntry[];
+    readonly skills: readonly VercelEveSkillEntry[];
+    readonly connections: readonly VercelEveConnectionEntry[];
+    readonly channels: readonly VercelEveChannelEntry[];
+    readonly sandbox: VercelEveSandboxEntry | null;
+    readonly subagents: readonly VercelEveSubagentEntry[];
+    readonly diagnostics: VercelEveDiagnosticsSummary;
+}
+/**
+ * Normalizes a channel adapter's reported `kind` string to the closed set
+ * the dashboard renders. Keeps the surface stable even when authors set a
+ * custom `kind` on their adapter (eg. `"weather-slack"`).
+ */
+export declare function normalizeChannelKindForDisplay(adapterKind: string | undefined): VercelEveChannelType;

package/dist/src/internal/vercel-agent-summary.js

@@ -0,0 +1 @@
+const VERCEL_EVE_AGENT_SUMMARY_KIND=`vercel-eve-agent-summary`,VERCEL_EVE_AGENT_SUMMARY_VERSION=3,VERCEL_EVE_AGENT_SUMMARY_OUTPUT_PATH=`.eve/agent-summary.json`;function normalizeChannelKindForDisplay(e){if(typeof e!=`string`||e.length===0)return`unknown`;let t=e.toLowerCase();return t===`slack`||t.includes(`slack`)?`slack`:t===`http`?`http`:t.includes(`webhook`)?`webhook`:`unknown`}export{VERCEL_EVE_AGENT_SUMMARY_KIND,VERCEL_EVE_AGENT_SUMMARY_OUTPUT_PATH,VERCEL_EVE_AGENT_SUMMARY_VERSION,normalizeChannelKindForDisplay};

package/dist/src/internal/workflow/builtins.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Built-in Workflow response body steps used by Eve-owned workflow bundles.
+ *
+ * These mirror Workflow's tiny `workflow/internal/builtins` module without
+ * requiring Eve to depend on Workflow's umbrella package.
+ */
+export declare function __builtin_response_array_buffer(this: Request | Response): Promise<ArrayBuffer>;
+export declare function __builtin_response_json(this: Request | Response): Promise<unknown>;
+export declare function __builtin_response_text(this: Request | Response): Promise<string>;
+/**
+ * Step bridge for `experimental_setAttributes`.
+ *
+ * Mirrors the `__builtin_set_attributes` step from
+ * `@workflow/workflow/internal/builtins`. The workflow-body shim's
+ * `experimental_setAttributes` (in `internal/workflow-bundle/workflow-core-shim.ts`)
+ * dispatches into the workflow runtime with the step id
+ * `"__builtin_set_attributes"`; the runtime walks the deployment's step
+ * registry to resolve it, so the step has to live inside an
+ * Eve-vendored builtins module that the registry visits. The Eve bundler
+ * already pulls this file in via `resolveWorkflowModulePath("workflow/internal/builtins")`,
+ * so adding the function here is sufficient to register it.
+ *
+ * Implementation notes — kept intentionally close to the upstream:
+ * - Reads world and run id directly from the runtime's `globalThis`
+ *   symbols rather than importing `@workflow/core`. Importing the
+ *   compiled core from a step file would re-introduce the bundling
+ *   chain we want to keep out of step bodies.
+ * - Treats missing world support as a silent best-effort no-op with a
+ *   single process-wide warning, matching upstream behaviour and the
+ *   contract on `setEveAttributes`.
+ * - On any other error, retries up to `EVE_INTERNAL_ATTRIBUTES_MAX_ATTEMPTS - 1`
+ *   times via the runtime's normal step retry path, then degrades to a
+ *   `console.error` so failed attribute writes never escalate into a
+ *   `FatalError` and tear down the user's agent run.
+ */
+export declare function __builtin_set_attributes(changes: Array<{
+    key: string;
+    value: string | null;
+}>, options?: {
+    allowReservedAttributes?: boolean;
+}): Promise<void>;

package/dist/src/internal/workflow/builtins.js

@@ -0,0 +1 @@
+async function __builtin_response_array_buffer(){"use step";return await this.arrayBuffer()}async function __builtin_response_json(){"use step";return await this.json()}async function __builtin_response_text(){"use step";return await this.text()}const EVE_UNSUPPORTED_WORLD_WARNED=Symbol.for(`@workflow/setAttributes//unsupportedWorldWarned`);function formatUnknownError(e){return e instanceof Error?e.stack??`${e.name}: ${e.message}`:String(e)}async function __builtin_set_attributes(t,n){"use step";if(t.length===0)return;let r=globalThis,i=r[Symbol.for(`WORKFLOW_STEP_CONTEXT_STORAGE`)]?.getStore?.(),a=typeof i?.stepMetadata?.attempt==`number`?i.stepMetadata.attempt:3,o=r[Symbol.for(`@workflow/world//cache`)];if(typeof o?.runs?.experimentalSetAttributes!=`function`){if(r[EVE_UNSUPPORTED_WORLD_WARNED]!==!0){r[EVE_UNSUPPORTED_WORLD_WARNED]=!0;let t=o?.name===void 0?``:` (${o.name})`;console.warn(`[eve] setAttributes: the current world implementation${t} does not implement experimentalSetAttributes; this call (and any subsequent setAttributes calls in this process) is a no-op. Attributes will become available once the world adapter adds support.`)}return}try{let e=i?.workflowMetadata?.workflowRunId;if(e===void 0)throw Error(`__builtin_set_attributes: no workflow run id available in step context`);await o.runs.experimentalSetAttributes(e,t,n)}catch(e){if(a<3)throw e;console.error(`[eve] setAttributes: failed to post tags after 3 attempts; dropping the internal attribute write. ${formatUnknownError(e)}`)}}__builtin_set_attributes.maxRetries=2;export{__builtin_response_array_buffer,__builtin_response_json,__builtin_response_text,__builtin_set_attributes};

package/dist/src/internal/workflow/index.d.ts

@@ -0,0 +1,6 @@
+export * from "#compiled/@workflow/core/index.js";
+/**
+ * Workflow-safe fetch helper retained for generated or authored workflow code
+ * that imports `fetch` from the historical `workflow` package surface.
+ */
+export declare function fetch(...args: Parameters<typeof globalThis.fetch>): Promise<Response>;

package/dist/src/internal/workflow/index.js

@@ -0,0 +1 @@
+export*from"#compiled/@workflow/core/index.js";async function fetch(...e){"use step";return await globalThis.fetch(...e)}export{fetch};

package/dist/src/internal/workflow-bundle/builder-support.d.ts

@@ -0,0 +1,71 @@
+import { type WorkflowManifest } from "#internal/workflow-bundle/workflow-builders.js";
+export declare const WORKFLOW_VIRTUAL_ENTRY_ID = "\0eve-workflow-entry";
+export interface WorkflowBundleBuilderConfig {
+    readonly buildTarget: "standalone";
+    readonly dirs: readonly string[];
+    readonly externalPackages: readonly string[];
+    readonly projectRoot: string;
+    readonly watch: boolean;
+    readonly workingDir: string;
+}
+export interface WorkflowBundleDiscoveredEntries {
+    readonly discoveredSerdeFiles: string[];
+    readonly discoveredSteps: string[];
+    readonly discoveredWorkflows: string[];
+}
+export interface WorkflowBundleCreateWorkflowsBundleOptions {
+    readonly bundleFinalOutput?: boolean;
+    readonly discoveredEntries?: WorkflowBundleDiscoveredEntries;
+    readonly format?: "cjs" | "esm";
+    readonly inputFiles: readonly string[];
+    readonly keepInterimBundleContext?: boolean;
+    readonly outfile: string;
+    readonly tsconfigPath?: string;
+}
+export interface WorkflowBundleCreateWorkflowsBundleResult {
+    readonly bundleFinal?: (interimBundleResult: string) => Promise<void>;
+    readonly interimBundleCtx?: undefined;
+    readonly manifest: WorkflowManifest;
+}
+interface WorkflowRolldownPlugin {
+    readonly name: string;
+    readonly resolveId?: (source: string, importer?: string) => unknown;
+    readonly load?: (id: string) => unknown;
+    readonly transform?: (code: string, id: string) => unknown;
+}
+export declare function collectWorkflowInputFiles(root: string): Promise<string[]>;
+export declare function createWorkflowImport(filePath: string, workingDir: string): string;
+export declare function createWorkflowVirtualEntryPlugin(source: string): WorkflowRolldownPlugin;
+export declare function createWorkflowPseudoPackagePlugin(): WorkflowRolldownPlugin;
+export declare function createWorkflowRuntimeAliasPlugin(): WorkflowRolldownPlugin;
+export declare function createEvePackageImportsPlugin(workingDir: string, options?: {
+    workflowCondition?: boolean;
+}): WorkflowRolldownPlugin;
+export declare function createWorkflowTransformPlugin(input: {
+    manifest: WorkflowManifest;
+    mode?: "step" | "workflow";
+    projectRoot: string;
+    sideEffectFiles?: readonly string[];
+    workingDir: string;
+}): WorkflowRolldownPlugin;
+export declare function bundleWorkflowStepRegistrations(input: {
+    builtinsPath: string;
+    discoveredEntries: WorkflowBundleDiscoveredEntries;
+    outfile: string;
+    projectRoot: string;
+    tsconfigPath?: string;
+    workingDir: string;
+}): Promise<void>;
+export declare function createWorkflowNodeBuiltinGuardPlugin(): WorkflowRolldownPlugin;
+export declare function bundleFinalWorkflowOutput(input: {
+    bundleFinalOutput: boolean;
+    code: string;
+    format: "cjs" | "esm";
+    outfile: string;
+    workingDir: string;
+}): Promise<void>;
+export declare function convertStepsManifest(steps: WorkflowManifest["steps"]): Record<string, unknown>;
+export declare function convertWorkflowsManifest(workflows: WorkflowManifest["workflows"]): Record<string, unknown>;
+export declare function convertClassesManifest(classes: WorkflowManifest["classes"]): Record<string, unknown>;
+export declare function atomicWriteFile(targetPath: string, contents: string | Buffer | Uint8Array): Promise<void>;
+export {};

package/dist/src/internal/workflow-bundle/builder-support.js

@@ -0,0 +1,9 @@
+import{builtinModules}from"node:module";import{dirname,join,relative,resolve}from"node:path";import{mkdir,readFile,readdir,rename,writeFile}from"node:fs/promises";import{existsSync}from"node:fs";import{resolveWorkflowModulePath}from"#internal/application/package.js";import{buildWithNitroRolldown,getSingleRolldownChunk}from"#internal/bundler/nitro-rolldown.js";import{applyWorkflowTransform,getImportPath}from"#internal/workflow-bundle/workflow-builders.js";const WORKFLOW_VIRTUAL_ENTRY_ID=`\0eve-workflow-entry`,PSEUDO_PACKAGES=new Set([`server-only`,`client-only`,`next/dist/compiled/server-only`,`next/dist/compiled/client-only`]),NODE_BUILTIN_MODULES=new Set([...builtinModules,...builtinModules.map(e=>`node:${e}`)]),WORKFLOW_INPUT_EXTENSIONS=new Set([`.ts`,`.tsx`,`.mts`,`.cts`,`.js`,`.jsx`,`.mjs`,`.cjs`]),IGNORED_INPUT_DIRECTORIES=new Set([`node_modules`,`.git`,`.next`,`.nuxt`,`.output`,`.vercel`,`.workflow-data`,`.workflow-vitest`,`.well-known`,`.svelte-kit`,`.turbo`,`.cache`,`.yarn`,`.pnpm-store`]);async function collectWorkflowInputFiles(e){let t=[];async function visit(e){let r;try{r=await readdir(e,{withFileTypes:!0})}catch(e){if(e instanceof Error&&`code`in e&&e.code===`ENOENT`)return;throw e}for(let i of r){if(i.isDirectory()){IGNORED_INPUT_DIRECTORIES.has(i.name)||await visit(join(e,i.name));continue}if(!i.isFile())continue;let r=i.name.match(/\.[^.]+$/)?.[0];r!==void 0&&WORKFLOW_INPUT_EXTENSIONS.has(r)&&t.push(join(e,i.name))}}return await visit(e),t}function createWorkflowImport(e,t){let{importPath:n,isPackage:r}=getImportPath(e,t);return r?`import ${JSON.stringify(n)};`:`import ${JSON.stringify(toRelativeImportSpecifier(t,e))};`}function createWorkflowVirtualEntryPlugin(e){return{name:`eve-workflow-virtual-entry`,resolveId(e){if(e===`\0eve-workflow-entry`)return{id:e}},load(t){if(t===`\0eve-workflow-entry`)return{code:e,moduleSideEffects:!0,moduleType:`js`}}}}function createWorkflowPseudoPackagePlugin(){return{name:`eve-workflow-pseudo-packages`,resolveId(e){if(PSEUDO_PACKAGES.has(e))return{id:`\0eve-workflow-pseudo-package:${e}`}},load(e){if(e.startsWith(`\0eve-workflow-pseudo-package:`))return{code:``,moduleType:`js`}}}}function createWorkflowRuntimeAliasPlugin(){return{name:`eve-workflow-runtime-aliases`,resolveId(e){if(!(e!==`workflow`&&!e.startsWith(`workflow/`)))return resolveWorkflowModulePath(e)}}}function createEvePackageImportsPlugin(e,t={}){return{name:`eve-package-imports`,resolveId(r){let i=r.match(/^#compiled\/(.+)$/)?.[1];if(i!==void 0)return t.workflowCondition===!0&&i===`@workflow/core/index.js`?resolveFirstExistingPath([join(e,`src`,`internal`,`workflow-bundle`,`workflow-core-shim.ts`),join(e,`dist`,`src`,`internal`,`workflow-bundle`,`workflow-core-shim.js`)]):resolveFirstExistingPath([join(e,`.generated`,`compiled`,i),join(e,`dist`,`src`,`compiled`,i)]);let a=r.match(/^#(.+)\.js$/)?.[1];if(a!==void 0)return resolveFirstExistingPath([`.ts`,`.tsx`,`.mts`,`.cts`,`.js`,`.jsx`,`.mjs`,`.cjs`].flatMap(t=>[join(e,`src`,`${a}${t}`),join(e,`dist`,`src`,`${a}${t}`)]))}}}function createWorkflowTransformPlugin(e){let t=new Set(e.sideEffectFiles?.map(e=>e.replaceAll(`\\`,`/`))??[]);return{name:`eve-workflow-transform`,async load(n){if(!isJavaScriptLikePath(n))return;let r=await readFile(n,`utf8`),i=await applyWorkflowTransform(createManifestRelativeFilepath(e.workingDir,n),r.replace(/require\(\s*(['"])server-only\1\s*\)/g,`void 0`).replace(/require\(\s*(['"])client-only\1\s*\)/g,`void 0`),e.mode??`workflow`,n,e.projectRoot);return mergeWorkflowManifest(e.manifest,i.workflowManifest),{code:i.code,map:null,moduleSideEffects:t.has(n.replaceAll(`\\`,`/`))||void 0}}}}async function bundleWorkflowStepRegistrations(e){let t=[...e.discoveredEntries.discoveredSteps].sort(),n=new Set(t),r=[...e.discoveredEntries.discoveredSerdeFiles].sort().filter(e=>!n.has(e)),i={},a=[createWorkflowImport(e.builtinsPath,e.workingDir),...t.map(t=>createWorkflowImport(t,e.workingDir)),...r.map(t=>createWorkflowImport(t,e.workingDir)),`export const __steps_registered = true;`].join(`
+`),o=getSingleRolldownChunk(await buildWithNitroRolldown({cwd:e.workingDir,input:WORKFLOW_VIRTUAL_ENTRY_ID,platform:`node`,plugins:[createWorkflowVirtualEntryPlugin(a),createWorkflowPseudoPackagePlugin(),createWorkflowRuntimeAliasPlugin(),createEvePackageImportsPlugin(e.workingDir),createWorkflowTransformPlugin({manifest:i,mode:`step`,projectRoot:e.projectRoot,sideEffectFiles:[...t,...r],workingDir:e.workingDir})],resolve:{conditionNames:[`eve-source`,`node`,`import`,`default`],extensions:[`.ts`,`.tsx`,`.mts`,`.cts`,`.js`,`.jsx`,`.mjs`,`.cjs`],mainFields:[`module`,`main`]},tsconfig:e.tsconfigPath??!1,write:!1,output:{codeSplitting:!1,comments:!1,format:`esm`,sourcemap:`inline`}}),`step registrations bundle for "${e.outfile}"`);await writeWorkflowBundleAtomically(e.outfile,o.code)}function createWorkflowNodeBuiltinGuardPlugin(){return{name:`eve-workflow-node-builtins`,resolveId(e,t){let n=e.startsWith(`node:`)?e.slice(5):e;if(!NODE_BUILTIN_MODULES.has(e)&&!NODE_BUILTIN_MODULES.has(n))return;let r=t?` (imported by "${t}")`:``;throw Error(`Workflow bundle cannot import Node.js builtin "${e}"${r}. Move Node.js APIs behind a "use step" function, or keep the importing module out of the workflow driver body (only reachable through a "use step").`)}}}async function bundleFinalWorkflowOutput(e){let t=`// biome-ignore-all lint: generated file
+/* eslint-disable */
+import { workflowEntrypoint } from 'workflow/runtime';
+
+const workflowCode = \`${(e.code.endsWith(`
+`)?e.code:`${e.code}\n`).replace(/[\\`$]/g,`\\$&`)}\`;
+
+export const POST = workflowEntrypoint(workflowCode);`;if(!e.bundleFinalOutput){await writeWorkflowBundleAtomically(e.outfile,t);return}let n=getSingleRolldownChunk(await buildWithNitroRolldown({cwd:e.workingDir,input:WORKFLOW_VIRTUAL_ENTRY_ID,external:e=>e===`@aws-sdk/credential-provider-web-identity`,platform:`node`,plugins:[createWorkflowVirtualEntryPlugin(t)],write:!1,output:{comments:!1,format:e.format,sourcemap:!1}}),`final workflow bundle for "${e.outfile}"`);await writeWorkflowBundleAtomically(e.outfile,n.code)}function convertStepsManifest(e){let t={};for(let[n,r]of Object.entries(e??{})){t[n]={};for(let[e,i]of Object.entries(r))t[n][e]={stepId:i.stepId}}return t}function convertWorkflowsManifest(e){let t={};for(let[n,r]of Object.entries(e??{})){t[n]={};for(let[e,i]of Object.entries(r))t[n][e]={graph:{edges:[],nodes:[]},workflowId:i.workflowId}}return t}function convertClassesManifest(e){let t={};for(let[n,r]of Object.entries(e??{})){t[n]={};for(let[e,i]of Object.entries(r))t[n][e]={classId:i.classId}}return t}function toRelativeImportSpecifier(e,t){let n=relative(e,t).replaceAll(`\\`,`/`);return n.startsWith(`./`)||n.startsWith(`../`)?n:`./${n}`}function resolveFirstExistingPath(e){for(let t of e)if(existsSync(t))return{id:resolve(t)}}async function writeWorkflowBundleAtomically(e,n){await mkdir(dirname(e),{recursive:!0});let r=`${e}.${process.pid}.${Date.now()}.tmp`;await writeFile(r,n),await rename(r,e)}function mergeWorkflowManifest(e,t){e.steps=mergeWorkflowManifestSection(e.steps,t.steps),e.workflows=mergeWorkflowManifestSection(e.workflows,t.workflows),e.classes=mergeWorkflowManifestSection(e.classes,t.classes)}function mergeWorkflowManifestSection(e,t){if(t===void 0)return e;let n={...e};for(let[e,r]of Object.entries(t))n[e]={...n[e],...r};return n}function createManifestRelativeFilepath(e,t){let n=t.replaceAll(`\\`,`/`),i=relative(e.replaceAll(`\\`,`/`),n).replaceAll(`\\`,`/`);return i.startsWith(`../`)&&(i=i.split(`/`).filter(e=>e!==`..`).join(`/`)),i}function isJavaScriptLikePath(e){return/\.(?:[cm]?[jt]sx?)$/.test(e)}async function atomicWriteFile(e,t){let n=`${e}.tmp-${process.pid}-${Date.now().toString(36)}`;await writeFile(n,t),await rename(n,e)}export{WORKFLOW_VIRTUAL_ENTRY_ID,atomicWriteFile,bundleFinalWorkflowOutput,bundleWorkflowStepRegistrations,collectWorkflowInputFiles,convertClassesManifest,convertStepsManifest,convertWorkflowsManifest,createEvePackageImportsPlugin,createWorkflowImport,createWorkflowNodeBuiltinGuardPlugin,createWorkflowPseudoPackagePlugin,createWorkflowRuntimeAliasPlugin,createWorkflowTransformPlugin,createWorkflowVirtualEntryPlugin};