npm - eve - Versions diffs - 0.5.4 → 0.6.0-beta.3 - Mend

eve 0.5.4 → 0.6.0-beta.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1743) hide show

package/dist/src/internal/nitro/routes/index.js ADDED Viewed

@@ -0,0 +1,151 @@
+const DEPLOYMENT_URL_PLACEHOLDER=`{{DEPLOYMENT_URL}}`,HOME_PAGE_HTML_TEMPLATE=`<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<meta name="robots" content="noindex">
+<meta name="referrer" content="no-referrer">
+<title>eve</title>
+<style>
+  :root {
+    color-scheme: light dark;
+    --bg: #fff;
+    --fg: #0a0a0a;
+    --muted: #6b6b6b;
+    --faint: #999;
+    --border: rgba(0, 0, 0, 0.09);
+    --surface: rgba(0, 0, 0, 0.025);
+    --accent: #00c46a;
+    --accent-glow: rgba(0, 196, 106, 0.18);
+    --button-bg: #0a0a0a;
+    --button-fg: #fff;
+  }
+  @media (prefers-color-scheme: dark) {
+    :root {
+      --bg: #000;
+      --fg: #ededed;
+      --muted: #8f8f8f;
+      --faint: #666;
+      --border: rgba(255, 255, 255, 0.1);
+      --surface: rgba(255, 255, 255, 0.035);
+      --accent: #46d4a4;
+      --accent-glow: rgba(70, 212, 164, 0.22);
+      --button-bg: #fff;
+      --button-fg: #000;
+    }
+  }
+  * { box-sizing: border-box; }
+  html, body { height: 100%; margin: 0; }
+  body {
+    background: var(--bg);
+    color: var(--fg);
+    font-family: ui-sans-serif, -apple-system, BlinkMacSystemFont, "Segoe UI",
+      Roboto, "Helvetica Neue", Arial, sans-serif;
+    font-feature-settings: "cv11", "ss01";
+    font-size: 15px;
+    line-height: 1.55;
+    -webkit-font-smoothing: antialiased;
+    -moz-osx-font-smoothing: grayscale;
+    text-rendering: optimizeLegibility;
+    display: grid;
+    place-items: center;
+    padding: 2rem;
+  }
+  .mono {
+    font-family: ui-monospace, "SF Mono", "Menlo", "JetBrains Mono",
+      "Cascadia Code", Consolas, "Liberation Mono", monospace;
+    font-feature-settings: "zero", "ss01";
+  }
+  main {
+    width: 100%;
+    max-width: 32rem;
+    text-align: center;
+  }
+  .status {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.5rem;
+    padding: 0.3125rem 0.75rem;
+    background: var(--surface);
+    border: 1px solid var(--border);
+    border-radius: 9999px;
+    font-size: 0.75rem;
+    color: var(--muted);
+    margin: 0 0 2rem;
+  }
+  .status-dot {
+    width: 6px;
+    height: 6px;
+    border-radius: 50%;
+    background: var(--accent);
+    box-shadow: 0 0 0 3px var(--accent-glow);
+    flex-shrink: 0;
+  }
+  h1 {
+    margin: 0 0 0.875rem;
+    font-size: clamp(2.5rem, 9vw, 3.25rem);
+    font-weight: 500;
+    letter-spacing: -0.05em;
+    line-height: 1;
+  }
+  .lede {
+    margin: 0 0 1.5rem;
+    color: var(--muted);
+    font-size: 0.9375rem;
+  }
+  .lede a {
+    color: var(--fg);
+    text-decoration: underline;
+    text-decoration-thickness: 1px;
+    text-underline-offset: 3px;
+    text-decoration-color: var(--border);
+    transition: text-decoration-color 0.15s ease;
+    white-space: nowrap;
+  }
+  .lede a:hover { text-decoration-color: var(--fg); }
+  .lede-arrow {
+    display: inline-block;
+    margin-left: 0.125rem;
+    transition: transform 0.15s ease;
+  }
+  .lede a:hover .lede-arrow { transform: translateX(2px); }
+  .terminal {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.625rem;
+    width: 100%;
+    max-width: 28rem;
+    padding: 0.75rem 1rem;
+    background: var(--surface);
+    border: 1px solid var(--border);
+    border-radius: 0.5rem;
+    text-align: left;
+    font-size: 0.8125rem;
+    margin: 0 auto;
+    overflow-x: auto;
+    white-space: nowrap;
+  }
+  .terminal-prompt {
+    color: var(--faint);
+    user-select: none;
+    flex-shrink: 0;
+  }
+  .terminal-cmd { color: var(--fg); }
+</style>
+</head>
+<body>
+<main>
+  <span class="status mono">
+    <span class="status-dot" aria-hidden="true"></span>
+    running
+  </span>
+  <h1 class="mono">eve</h1>
+  <p class="lede">The agent is up and accepting messages. <a href="https://beta.eve.dev/docs">Read the docs<span class="lede-arrow" aria-hidden="true">&nbsp;&rarr;</span></a></p>
+  <div class="terminal mono" role="group" aria-label="Send a message from your terminal">
+    <span class="terminal-prompt" aria-hidden="true">$</span>
+    <span class="terminal-cmd">eve dev ${DEPLOYMENT_URL_PLACEHOLDER}</span>
+  </div>
+</main>
+</body>
+</html>
+`;function escapeHtml(e){return e.replaceAll(`&`,`&amp;`).replaceAll(`<`,`&lt;`).replaceAll(`>`,`&gt;`).replaceAll(`"`,`&quot;`).replaceAll(`'`,`&#39;`)}function pickFirstForwardedValue(e){if(e===null)return;let t=e.split(`,`)[0]?.trim();if(!(t===void 0||t.length===0))return t}function resolveDeploymentUrl(e){let t=e.headers,n=new URL(e.url),r=pickFirstForwardedValue(t.get(`x-forwarded-host`)),i=pickFirstForwardedValue(t.get(`x-forwarded-proto`)),a=r??t.get(`host`)??n.host;return`${i??n.protocol.replace(/:$/,``)}://${a}`}function buildHomePageResponse(n){let r=resolveDeploymentUrl(n),i=HOME_PAGE_HTML_TEMPLATE.replace(DEPLOYMENT_URL_PLACEHOLDER,escapeHtml(r));return new Response(i,{headers:{"cache-control":`no-store`,"content-type":`text/html; charset=utf-8`}})}function handleHomePageRequest(e){return buildHomePageResponse(e.req)}export{buildHomePageResponse,handleHomePageRequest as default};

package/dist/src/internal/nitro/routes/info.d.ts ADDED Viewed

@@ -0,0 +1,16 @@
+/**
+ * Builds the package-owned JSON inspection response for the current
+ * agent (model id, instructions preview, skills, schedules, subagents,
+ * tools, sandbox, endpoint catalog).
+ *
+ * The route is gated by the same default auth chain as the eve channel
+ * (`[localDev(), vercelOidc()]`) so the deployed URL does not expose
+ * agent metadata to anonymous callers, while local inspection tools
+ * and curl-based probes still work without setup. The same-project
+ * bypass on `vercelOidc()` keeps the route reachable to in-deployment
+ * callers (`apps/nextjs-eve`-style consumers) without any additional
+ * setup.
+ */
+export declare function handleAgentInfoRequest(input: {
+    appRoot?: string;
+}, request: Request): Promise<Response>;

package/dist/src/internal/nitro/routes/info.js ADDED Viewed

@@ -0,0 +1 @@

+ import{buildAgentInfoResponse}from"#internal/nitro/routes/agent-info/build-agent-info-response.js";import{loadAgentInfoData,resolveAgentInfoCompiledArtifactsSource}from"#internal/nitro/routes/agent-info/load-agent-info-data.js";import{localDev,routeAuth,vercelOidc}from"#public/channels/auth.js";async function createAgentInfoPayload(r){return buildAgentInfoResponse(await loadAgentInfoData({compiledArtifactsSource:resolveAgentInfoCompiledArtifactsSource({appRoot:r.appRoot})}))}async function handleAgentInfoRequest(e,t){let n=await routeAuth(t,[localDev(),vercelOidc()]);return n instanceof Response?n:new Response(JSON.stringify(await createAgentInfoPayload(e)),{headers:{"cache-control":`no-store`,"content-type":`application/json; charset=utf-8`}})}export{handleAgentInfoRequest};

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

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -0,0 +1 @@

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

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

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

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

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

	@@ -0,0 +1 @@
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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

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