eve 0.5.4 → 0.6.0-beta.3

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.3`}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};

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

@@ -0,0 +1,46 @@
+/**
+ * Sandbox-resident attachment references.
+ *
+ * Refs are the compact wire format used after inbound attachment bytes
+ * have been written into the sandbox:
+ *
+ * ```
+ * eve-sandbox:?path=<urlencoded-resolved-path>&size=<bytes>&type=<mediaType>
+ * ```
+ */
+/**
+ * Custom URL scheme used by every sandbox-resident attachment ref. The
+ * trailing colon is part of the scheme per WHATWG URL semantics.
+ */
+export declare const SANDBOX_URL_SCHEME = "eve-sandbox:";
+/**
+ * Serializable description of one sandbox-resident file attachment.
+ *
+ * `path` is the backend-native absolute path returned by
+ * {@link SandboxSession.resolvePath}; `size` and `mediaType` are
+ * snapshotted so hydration can decide whether to inline without
+ * re-reading the file.
+ */
+export interface SandboxRef {
+    readonly path: string;
+    readonly size: number;
+    readonly mediaType: string;
+}
+/**
+ * Encodes a {@link SandboxRef} as a URL suitable for use as
+ * `FilePart.data`.
+ */
+export declare function encodeSandboxRef(ref: SandboxRef): URL;
+/**
+ * Parses a {@link SandboxRef} from its URL form.
+ */
+export declare function decodeSandboxRef(value: URL | string): SandboxRef;
+/**
+ * Cheap runtime check: does this value look like a sandbox-ref URL?
+ *
+ * Accepts `URL` instances with the `eve-sandbox:` scheme. Strings are
+ * NOT accepted — the staging and hydration layers only inspect
+ * URL-instance `FilePart.data` values, matching the existing
+ * `data instanceof URL` branch in `fileDataToBytes`.
+ */
+export declare function isSandboxRefUrl(value: unknown): value is URL;

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

@@ -0,0 +1 @@
+const SANDBOX_URL_SCHEME=`eve-sandbox:`,PATH_QUERY_KEY=`path`,SIZE_QUERY_KEY=`size`,TYPE_QUERY_KEY=`type`;function isValidSize(e){return Number.isFinite(e)&&Number.isInteger(e)&&e>=0}function encodeSandboxRef(t){if(typeof t.path!=`string`||t.path.length===0)throw RangeError(`SandboxRef.path must be a non-empty string.`);if(!isValidSize(t.size))throw RangeError(`SandboxRef.size must be a non-negative integer. Received: ${String(t.size)}.`);if(typeof t.mediaType!=`string`||t.mediaType.length===0)throw RangeError(`SandboxRef.mediaType must be a non-empty string.`);let n=new URL(SANDBOX_URL_SCHEME);return n.searchParams.set(PATH_QUERY_KEY,t.path),n.searchParams.set(SIZE_QUERY_KEY,String(t.size)),n.searchParams.set(TYPE_QUERY_KEY,t.mediaType),n}function decodeSandboxRef(t){let n=t instanceof URL?t:new URL(t);if(n.protocol!==`eve-sandbox:`)throw Error(`SandboxRef URL must use scheme "${SANDBOX_URL_SCHEME}". Got: "${n.protocol}".`);let r=n.searchParams.get(PATH_QUERY_KEY);if(r===null||r===``)throw Error(`SandboxRef URL is missing the required "path" query param.`);let i=n.searchParams.get(SIZE_QUERY_KEY);if(i===null||i===``)throw Error(`SandboxRef URL is missing the required "size" query param.`);let a=Number(i);if(!isValidSize(a))throw Error(`SandboxRef URL "size" must be a non-negative integer. Got: ${JSON.stringify(i)}.`);let o=n.searchParams.get(TYPE_QUERY_KEY);if(o===null||o===``)throw Error(`SandboxRef URL is missing the required "type" query param.`);return{mediaType:o,path:r,size:a}}function isSandboxRefUrl(e){return e instanceof URL&&e.protocol===`eve-sandbox:`}export{SANDBOX_URL_SCHEME,decodeSandboxRef,encodeSandboxRef,isSandboxRefUrl};

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

@@ -0,0 +1,17 @@
+/**
+ * Custom URL scheme for serializing `URL` objects in `FilePart.data`
+ * across the queue boundary.
+ *
+ * Route handlers place `new URL("https://...")` on `FilePart.data`.
+ * Before the message crosses the queue, `send()` rewrites these as
+ * `eve-url:https://...` strings. After the queue, the staging pipeline
+ * reconstitutes them back to `URL` objects so `instanceof URL` checks
+ * work reliably.
+ */
+export declare function serializeUrlFilePart(url: URL): string;
+export declare function isSerializedUrlFilePart(data: unknown): data is string;
+export declare function deserializeUrlFilePart(data: string): URL;
+/**
+ * Whether a `FilePart.data` string carries a framework-internal ref scheme.
+ */
+export declare function hasInternalRefScheme(data: string): boolean;

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

@@ -0,0 +1 @@
+import{SANDBOX_URL_SCHEME}from"#internal/attachments/sandbox-refs.js";import{ATTACHMENT_REF_SCHEME}from"#internal/attachments/refs.js";const EVE_URL_SCHEME=`eve-url:`;function serializeUrlFilePart(e){return`${EVE_URL_SCHEME}${e.href}`}function isSerializedUrlFilePart(e){return typeof e==`string`&&e.startsWith(EVE_URL_SCHEME)}function deserializeUrlFilePart(e){return new URL(e.slice(8))}const INTERNAL_REF_SCHEMES=[EVE_URL_SCHEME,SANDBOX_URL_SCHEME,ATTACHMENT_REF_SCHEME];function hasInternalRefScheme(e){return INTERNAL_REF_SCHEMES.some(t=>e.startsWith(t))}export{deserializeUrlFilePart,hasInternalRefScheme,isSerializedUrlFilePart,serializeUrlFilePart};

package/dist/src/internal/authored-asset-import-plugin.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Creates the Rollup-compatible plugin that gives authored modules a small
+ * asset-module surface for non-code relative imports.
+ */
+export declare function createAuthoredAssetImportPlugin(): Record<string, unknown>;

package/dist/src/internal/authored-asset-import-plugin.js

@@ -0,0 +1 @@
+import{dirname,extname,isAbsolute,resolve}from"node:path";import{readFile}from"node:fs/promises";const AUTHORED_ASSET_CODE_EXTENSIONS=[`.ts`,`.tsx`,`.mts`,`.cts`,`.js`,`.jsx`,`.mjs`,`.cjs`,`.json`];function createAuthoredAssetImportPlugin(){return{name:`eve-authored-asset-import`,resolveId(t,i){if(!isPotentialAuthoredAssetImport(t)||i===void 0)return;let{path:a,suffix:o}=splitImportSuffix(t);return`${isAbsolute(a)?a:resolve(dirname(i),a)}${o}`},async load(e){let{path:t,suffix:n}=splitImportSuffix(e);if(!isPotentialAuthoredAssetImport(t))return;if(n===`?raw`){let e=await readAssetText(t);return e===void 0?void 0:{code:`export default ${JSON.stringify(e)};`,moduleType:`js`}}let r=await readAssetDataUrl(t);if(r!==void 0)return{code:`export default ${JSON.stringify(r)};`,moduleType:`js`}}}}async function readAssetText(e){try{return await readFile(e,`utf8`)}catch(e){if(isPathNotFoundError(e))return;throw e}}function isPotentialAuthoredAssetImport(e){if(e.startsWith(`\0`)||e.startsWith(`node:`)||e.startsWith(`data:`)||e.startsWith(`file:`))return!1;let{path:n}=splitImportSuffix(e);if(!n.startsWith(`.`)&&!n.startsWith(`/`)&&!/^[A-Za-z]:[\\/]/.test(n))return!1;let r=extname(n);return r.length>0&&r!==`.node`&&!AUTHORED_ASSET_CODE_EXTENSIONS.includes(r)}function splitImportSuffix(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)}}async function readAssetDataUrl(e){try{let t=await readFile(e);return`data:${getAssetMimeType(e)};base64,${t.toString(`base64`)}`}catch(e){if(isPathNotFoundError(e))return;throw e}}function isPathNotFoundError(e){return typeof e==`object`&&!!e&&`code`in e&&(e.code===`ENOENT`||e.code===`ENOTDIR`)}function getAssetMimeType(e){switch(extname(e).toLowerCase()){case`.css`:return`text/css`;case`.csv`:return`text/csv`;case`.gif`:return`image/gif`;case`.html`:return`text/html`;case`.jpg`:case`.jpeg`:return`image/jpeg`;case`.png`:return`image/png`;case`.svg`:return`image/svg+xml`;case`.txt`:return`text/plain`;case`.wasm`:return`application/wasm`;case`.webp`:return`image/webp`;default:return`application/octet-stream`}}export{createAuthoredAssetImportPlugin};

package/dist/src/internal/authored-definition/channel.d.ts

@@ -0,0 +1,16 @@
+import { type CompiledChannel } from "#channel/compiled-channel.js";
+/**
+ * Normalizes one authored channel definition into the canonical internal
+ * shape consumed by the compiler.
+ *
+ * Authored channels must go through {@link defineChannel} (or a wrapper
+ * like `slackChannel` / `eveChannel`) and therefore must be
+ * {@link CompiledChannel} values. The legacy plain-`{ fetch, receive? }`
+ * Route shape is no longer supported — drop a clear error for it so
+ * users on old patterns get a useful migration hint instead of a silent
+ * runtime crash deeper in dispatch.
+ *
+ * Disable sentinels are handled by the compiler before this function is
+ * called.
+ */
+export declare function normalizeChannelDefinition(value: unknown, message: string): CompiledChannel;

package/dist/src/internal/authored-definition/channel.js

@@ -0,0 +1 @@
+import{isCompiledChannel}from"#channel/compiled-channel.js";function normalizeChannelDefinition(e,t){if(!isCompiledChannel(e))throw Error(`${t} Use \`defineChannel({ routes, ... })\` (or a wrapper like \`slackChannel\` / \`eveChannel\`) — bare \`{ fetch, receive? }\` channel objects are no longer supported.`);return e}export{normalizeChannelDefinition};

package/dist/src/internal/authored-definition/connection.d.ts

@@ -0,0 +1,18 @@
+import type { McpClientConnectionDefinition } from "#public/definitions/connections/mcp.js";
+import type { OpenAPIConnectionDefinition } from "#public/definitions/connections/openapi.js";
+/**
+ * Validates one authored MCP client connection module export at build time
+ * and returns the public definition type. The module export is `unknown`
+ * because it comes from a dynamically-loaded authored file; this function
+ * bridges the gap with runtime checks so authoring errors surface during
+ * `eve build`.
+ */
+export declare function normalizeMcpClientConnectionDefinition(value: unknown, message: string): McpClientConnectionDefinition;
+/**
+ * Validates one authored OpenAPI connection module export at build time
+ * and returns the public definition type. Mirrors
+ * {@link normalizeMcpClientConnectionDefinition} but validates the
+ * OpenAPI-specific `spec`/`baseUrl`/`operations` fields and reuses the
+ * shared auth and headers validation.
+ */
+export declare function normalizeOpenApiConnectionDefinition(value: unknown, message: string): OpenAPIConnectionDefinition;

package/dist/src/internal/authored-definition/connection.js

@@ -0,0 +1 @@
+import{expectObjectRecord,expectOnlyKnownKeys}from"#internal/authored-module.js";import{normalizeAuthorizationSpec}from"#runtime/connections/validate-authorization.js";const KNOWN_TOP_LEVEL_KEYS=[`approval`,`auth`,`description`,`headers`,`tools`,`url`],KNOWN_OPENAPI_TOP_LEVEL_KEYS=[`approval`,`auth`,`baseUrl`,`description`,`headers`,`operations`,`spec`],KNOWN_AUTHORIZATION_KEYS=[`completeAuthorization`,`getToken`,`principalType`,`startAuthorization`,`vercelConnect`];function normalizeMcpClientConnectionDefinition(n,i){let a=expectObjectRecord(n,i);expectOnlyKnownKeys(a,KNOWN_TOP_LEVEL_KEYS,i),validateUrl(a,i),validateDescription(a,i);let o=normalizeAuthorization(a,i),s=normalizeHeaders(a,i),c=normalizeToolFilter(a,i);if(o!==void 0&&s!==void 0&&typeof s!=`function`&&Object.keys(s).some(e=>e.toLowerCase()===`authorization`))throw Error(`${i} "headers" must not include an "Authorization" key when "auth" is also provided.`);let l={description:a.description,url:a.url};if(o!==void 0&&(l.auth=o),s!==void 0&&(l.headers=s),c!==void 0&&(l.tools=c),a.approval!==void 0){if(typeof a.approval!=`function`)throw Error(`${i} The "approval" field must be a function when provided.`);l.approval=a.approval}return l}function normalizeOpenApiConnectionDefinition(n,r){let a=expectObjectRecord(n,r);expectOnlyKnownKeys(a,KNOWN_OPENAPI_TOP_LEVEL_KEYS,r),validateSpec(a,r),validateBaseUrl(a,r),validateDescription(a,r);let o=normalizeAuthorization(a,r),s=normalizeHeaders(a,r),c=normalizeFilterField(a,`operations`,r);if(o!==void 0&&s!==void 0&&typeof s!=`function`&&Object.keys(s).some(e=>e.toLowerCase()===`authorization`))throw Error(`${r} "headers" must not include an "Authorization" key when "auth" is also provided.`);let l={description:a.description,spec:a.spec};if(a.baseUrl!==void 0&&(l.baseUrl=a.baseUrl),o!==void 0&&(l.auth=o),s!==void 0&&(l.headers=s),c!==void 0&&(l.operations=c),a.approval!==void 0){if(typeof a.approval!=`function`)throw Error(`${r} The "approval" field must be a function when provided.`);l.approval=a.approval}return l}function validateSpec(e,t){let n=e.spec;if(typeof n==`string`){if(!URL.canParse(n))throw Error(`${t} The "spec" field must be a valid URL when provided as a string.`);let e=new URL(n);if(e.protocol!==`https:`&&e.protocol!==`http:`)throw Error(`${t} The "spec" URL must use the http or https protocol, got "${e.protocol}".`);return}if(typeof n!=`object`||!n||Array.isArray(n))throw Error(`${t} The "spec" field must be a URL string or an inline OpenAPI document object.`)}function validateBaseUrl(e,t){if(e.baseUrl===void 0)return;if(typeof e.baseUrl!=`string`||!URL.canParse(e.baseUrl))throw Error(`${t} The "baseUrl" field must be a valid URL when provided.`);let n=new URL(e.baseUrl);if(n.protocol!==`https:`&&n.protocol!==`http:`)throw Error(`${t} The "baseUrl" field must use the http or https protocol, got "${n.protocol}".`)}function validateUrl(e,t){if(typeof e.url!=`string`||!URL.canParse(e.url))throw Error(`${t} The "url" field must be a valid URL.`);let n=new URL(e.url);if(n.protocol!==`https:`&&n.protocol!==`http:`)throw Error(`${t} The "url" field must use the http or https protocol, got "${n.protocol}".`)}function validateDescription(e,t){if(typeof e.description!=`string`||e.description.length===0)throw Error(`${t} The "description" field must be a non-empty string.`)}function normalizeAuthorization(r,i){if(r.auth===void 0)return;let o=expectObjectRecord(r.auth,`${i} The "auth" field must be an object with a "getToken" method.`);return expectOnlyKnownKeys(o,KNOWN_AUTHORIZATION_KEYS,`${i} The "auth" field`),normalizeAuthorizationSpec(o,i)}function normalizeHeaders(e,t){if(e.headers===void 0)return;if(typeof e.headers==`function`)return e.headers;if(typeof e.headers!=`object`||e.headers===null||Array.isArray(e.headers))throw Error(`${t} The "headers" field must be a plain object or a function.`);let n=e.headers;for(let[e,r]of Object.entries(n)){let n=typeof r;if(n!==`string`&&n!==`function`&&n!==`object`||n===`object`&&(r===null||typeof r.then!=`function`))throw Error(`${t} The "headers.${e}" value must be a string, Promise, or function.`)}return n}function normalizeToolFilter(e,t){return normalizeFilterField(e,`tools`,t)}function normalizeFilterField(e,t,n){let r=e[t];if(r===void 0)return;if(typeof r!=`object`||!r||Array.isArray(r))throw Error(`${n} The "${t}" field must specify either "allow" or "block".`);let i=r,a=`allow`in i,o=`block`in i;if(a&&o)throw Error(`${n} The "${t}" field must specify either "allow" or "block", not both.`);if(!a&&!o)throw Error(`${n} The "${t}" field must specify either "allow" or "block".`);return a?(validateStringArray(i.allow,`${n} The "${t}.allow"`),{allow:i.allow}):(validateStringArray(i.block,`${n} The "${t}.block"`),{block:i.block})}function validateStringArray(e,t){if(!Array.isArray(e))throw Error(`${t} field must be an array of strings.`);for(let n=0;n<e.length;n++)if(typeof e[n]!=`string`)throw Error(`${t}[${n}] must be a string.`)}export{normalizeMcpClientConnectionDefinition,normalizeOpenApiConnectionDefinition};

package/dist/src/internal/authored-definition/core.d.ts

@@ -0,0 +1,46 @@
+import type { AgentDefinition, AgentBuildDefinition } from "#public/definitions/agent.js";
+import type { ScheduleDefinition } from "#public/definitions/schedule.js";
+import type { SkillDefinition } from "#public/definitions/skill.js";
+import type { InstructionsDefinition } from "#public/definitions/instructions.js";
+type NormalizedAgentDefinition = Omit<AgentDefinition, "build"> & {
+    build?: {
+        externalDependencies?: Readonly<AgentBuildDefinition["externalDependencies"]>;
+    };
+};
+/**
+ * Normalizes one authored agent definition into the canonical internal shape.
+ *
+ * Authored `name` fields are rejected — agent identity is derived at compile
+ * time from `manifest.agentId` (package name or app-root basename).
+ */
+export declare function normalizeAgentDefinition(value: unknown, message: string): Readonly<NormalizedAgentDefinition>;
+/**
+ * Normalizes one authored instructions definition into the canonical
+ * internal shape.
+ *
+ * Authored `name` fields are rejected — instructions prompt identity is
+ * derived from the file path (`instructions.md` or
+ * `instructions.{ts,...}`).
+ */
+export declare function normalizeInstructionsDefinition(value: unknown, message: string): InstructionsDefinition & {
+    readonly markdown: string;
+};
+/**
+ * Normalizes one authored skill definition into the canonical internal
+ * shape.
+ *
+ * Authored `name` fields are rejected — skill identity is derived from
+ * the file path under `agent/skills/`.
+ */
+export declare function normalizeSkillDefinition(value: unknown, message: string): SkillDefinition;
+/**
+ * Normalizes one authored schedule definition into the canonical internal
+ * shape.
+ *
+ * Authored `name` fields are rejected — schedule identity is derived from
+ * the file path under `agent/schedules/`. Exactly one of `markdown` (the
+ * fire-and-forget agent prompt) or `run` (the cron handler function)
+ * must be provided.
+ */
+export declare function normalizeScheduleDefinition(value: unknown, message: string): ScheduleDefinition;
+export {};

package/dist/src/internal/authored-definition/core.js

@@ -0,0 +1 @@
+import{expectBoolean,expectFunction,expectObjectRecord,expectOnlyKnownKeys,expectProviderOptions,expectString,getOptionalStringRecordProperty}from"#internal/authored-module.js";function normalizeAgentDefinition(e,t){let i=expectObjectRecord(e,t);if(expectOnlyKnownKeys(i,[`build`,`compaction`,`description`,`experimental`,`model`,`modelContextWindowTokens`,`modelOptions`,`outputSchema`],t),i.model===void 0)throw Error(`${t} The "model" field is required.`);let o={model:i.model};return i.description!==void 0&&(o.description=expectString(i.description,t)),i.compaction!==void 0&&(o.compaction=normalizeAgentCompactionDefinition(i.compaction,t)),i.build!==void 0&&(o.build=normalizeAgentBuildDefinition(i.build,t)),i.experimental!==void 0&&(o.experimental=normalizeAgentExperimentalDefinition(i.experimental,t)),i.modelOptions!==void 0&&(o.modelOptions=normalizeAgentModelOptions(i.modelOptions,t)),i.modelContextWindowTokens!==void 0&&(o.modelContextWindowTokens=expectPositiveInteger(i.modelContextWindowTokens,t)),i.outputSchema!==void 0&&(o.outputSchema=i.outputSchema),o}function expectPositiveInteger(e,t){if(typeof e!=`number`||!Number.isInteger(e)||e<=0)throw Error(t);return e}function normalizeAgentBuildDefinition(e,t){let i=expectObjectRecord(e,t);expectOnlyKnownKeys(i,[`externalDependencies`],t);let o={};if(i.externalDependencies!==void 0){if(!Array.isArray(i.externalDependencies))throw Error(t);o.externalDependencies=Object.freeze(i.externalDependencies.map(e=>expectString(e,t)))}return o}function normalizeAgentExperimentalDefinition(t,i){let a=expectObjectRecord(t,i);expectOnlyKnownKeys(a,[`codeMode`],i);let o={};return a.codeMode!==void 0&&(o.codeMode=expectBoolean(a.codeMode,i)),o}function normalizeAgentModelOptions(e,t){let a=expectObjectRecord(e,t);expectOnlyKnownKeys(a,[`providerOptions`],t);let o=a.providerOptions;return o===void 0?{}:{providerOptions:expectProviderOptions(o,t)}}function normalizeAgentCompactionDefinition(e,t){let i=expectObjectRecord(e,t);expectOnlyKnownKeys(i,[`model`,`modelContextWindowTokens`,`thresholdPercent`],t);let a={};if(i.model!==void 0&&(a.model=i.model),i.modelContextWindowTokens!==void 0&&(a.modelContextWindowTokens=expectPositiveInteger(i.modelContextWindowTokens,t)),i.thresholdPercent!==void 0){let e=i.thresholdPercent;if(typeof e!=`number`||!Number.isFinite(e)||e<0||e>1)throw Error(t);a.thresholdPercent=e}return a}function normalizeInstructionsDefinition(e,t){let i=expectObjectRecord(e,t);return expectOnlyKnownKeys(i,[`markdown`],t),{markdown:expectString(i.markdown,t)}}function normalizeSkillDefinition(e,t){let i=expectObjectRecord(e,t);expectOnlyKnownKeys(i,[`description`,`files`,`license`,`markdown`,`metadata`],t);let s={description:expectString(i.description,t),markdown:expectString(i.markdown,t)},c=i.license,l=getOptionalStringRecordProperty(i,`metadata`,t);return c!==void 0&&(s.license=expectString(c,t)),l!==void 0&&(s.metadata=l),i.files!==void 0&&(s.files=normalizeSkillFiles(i.files,t)),s}function normalizeSkillFiles(e,t){let r=expectObjectRecord(e,t),i={};for(let[e,n]of Object.entries(r)){if(typeof n==`string`||n instanceof Uint8Array){i[e]=n;continue}throw Error(`${t} Expected skill file "${e}" to be a string or Uint8Array.`)}return i}function normalizeScheduleDefinition(e,i){let o=expectObjectRecord(e,i);expectOnlyKnownKeys(o,[`cron`,`markdown`,`run`],i);let s=expectString(o.cron,i),c=o.markdown!==void 0,l=o.run!==void 0;if(c&&l)throw Error(`${i} Pass either "markdown" (fire-and-forget) or "run" (handler) — not both.`);if(!c&&!l)throw Error(`${i} Must provide either "markdown" (fire-and-forget) or "run" (handler).`);let u={cron:s};return c?u.markdown=expectString(o.markdown,i):u.run=expectFunction(o.run,i),u}export{normalizeAgentDefinition,normalizeInstructionsDefinition,normalizeScheduleDefinition,normalizeSkillDefinition};

package/dist/src/internal/authored-definition/sandbox.d.ts

@@ -0,0 +1,17 @@
+import type { SandboxBackend } from "#public/definitions/sandbox-backend.js";
+import type { SandboxDefinition, SandboxRevalidationKeyFn } from "#public/definitions/sandbox.js";
+type NormalizedSandboxDefinition = Readonly<Omit<SandboxDefinition, "backend">> & {
+    readonly backend?: SandboxBackend;
+    readonly description?: string;
+    readonly revalidationKey?: SandboxRevalidationKeyFn;
+};
+/**
+ * Normalizes one authored sandbox definition into the canonical internal
+ * shape. If the author supplied a `backend` callback (e.g.
+ * `backend: () => vercelBackend({...})`), it is wrapped via
+ * {@link lazyBackend} so downstream consumers always see a plain
+ * `SandboxBackend` value — the callback fires exactly once on first
+ * access and the resulting backend is memoized.
+ */
+export declare function normalizeSandboxDefinition(value: unknown, message: string): NormalizedSandboxDefinition;
+export {};

package/dist/src/internal/authored-definition/sandbox.js

@@ -0,0 +1 @@
+import{expectFunction,expectObjectRecord,expectOnlyKnownKeys}from"#internal/authored-module.js";import{lazyBackend}from"#execution/sandbox/lazy-backend.js";function normalizeSandboxDefinition(n,r){let i=expectObjectRecord(n,r);expectOnlyKnownKeys(i,[`backend`,`bootstrap`,`description`,`onSession`,`revalidationKey`],r);let a={};if(i.backend!==void 0&&(a.backend=expectSandboxBackend(i.backend,r)),i.description!==void 0){if(typeof i.description!=`string`)throw Error(`${r} The "description" field must be a string when set.`);a.description=i.description}if(i.bootstrap!==void 0&&(a.bootstrap=expectFunction(i.bootstrap,r)),i.revalidationKey!==void 0&&(a.revalidationKey=expectFunction(i.revalidationKey,r)),a.bootstrap===void 0&&a.revalidationKey!==void 0)throw Error(`${r} The "revalidationKey" field can only be set when "bootstrap" is set.`);return i.onSession!==void 0&&(a.onSession=expectFunction(i.onSession,r)),a}function expectSandboxBackend(e,t){if(typeof e==`function`)return lazyBackend(e);let r=expectObjectRecord(e,`${t} The "backend" field must be a SandboxBackend value (use vercelBackend(), localBackend(), or your own factory) or a zero-arg function returning one.`);if(typeof r.name!=`string`||r.name.length===0)throw Error(`${t} The "backend" value must expose a non-empty string "name" identifier.`);if(typeof r.create!=`function`)throw Error(`${t} The "backend" value must expose a "create" function.`);if(r.prewarm!==void 0&&typeof r.prewarm!=`function`)throw Error(`${t} The "backend.prewarm" property must be a function when set.`);return r}export{normalizeSandboxDefinition};

package/dist/src/internal/authored-definition/schema-backed.d.ts

@@ -0,0 +1,36 @@
+import type { InternalToolDefinitionWithExecuteFn } from "#shared/tool-definition.js";
+import { type DynamicToolEventName } from "#shared/dynamic-tool-definition.js";
+/**
+ * Canonical normalized shape of one authored tool default export.
+ *
+ * Identity is path-derived — the compiler stamps the filename slug onto
+ * the compiled entry. This shape never carries an authored `name`.
+ */
+type NormalizedAuthoredTool = Readonly<Omit<InternalToolDefinitionWithExecuteFn, "name">>;
+/**
+ * Result of normalizing one authored tool default export. Either a real tool
+ * definition, a sentinel that disables a framework default, or a dynamic
+ * tool resolver. In all cases the disable target / runtime name is the
+ * authored file's slug, supplied by the compiler — this layer never sees
+ * a name.
+ */
+type NormalizedToolEntry = {
+    readonly kind: "tool";
+    readonly definition: NormalizedAuthoredTool;
+} | {
+    readonly kind: "disabled";
+} | {
+    readonly kind: "enable-workflow";
+} | {
+    readonly kind: "dynamic-tool";
+    readonly eventNames: readonly DynamicToolEventName[];
+};
+/**
+ * Normalizes one authored tool default export. Recognizes real tool
+ * definitions (`defineTool(...)`), disable sentinels (`disableTool()`), and the
+ * `Workflow` opt-in sentinel.
+ *
+ * Authored `name` fields are rejected — tool identity is path-derived.
+ */
+export declare function normalizeToolDefinition(value: unknown, message: string): NormalizedToolEntry;
+export {};

package/dist/src/internal/authored-definition/schema-backed.js

@@ -0,0 +1 @@
+import{expectFunction,expectObjectRecord,expectOnlyKnownKeys,expectString}from"#internal/authored-module.js";import{isDynamicSentinel}from"#shared/dynamic-tool-definition.js";import{normalizeJsonSchemaDefinition}from"#internal/json-schema.js";import{isDisabledToolSentinel,isEnableWorkflowToolSentinel}from"#public/definitions/tool.js";function normalizeToolDefinition(e,t){if(isDynamicSentinel(e))return{kind:`dynamic-tool`,eventNames:Object.keys(e.events)};if(isDisabledToolSentinel(e))return{kind:`disabled`};if(isEnableWorkflowToolSentinel(e))return{kind:`enable-workflow`};let n=expectObjectRecord(e,t);expectOnlyKnownKeys(n,[`auth`,`description`,`execute`,`inputSchema`,`needsApproval`,`onCompact`,`outputSchema`,`toModelOutput`],t);let r=n.inputSchema===void 0?null:normalizeJsonSchemaDefinition(n.inputSchema),i=n.outputSchema===void 0?void 0:normalizeJsonSchemaDefinition(n.outputSchema,`output`),a={description:expectString(n.description,t),execute:expectFunction(n.execute,t),inputSchema:r};return i!==void 0&&(a.outputSchema=i),n.onCompact!==void 0&&expectFunction(n.onCompact,t),n.needsApproval!==void 0&&expectFunction(n.needsApproval,t),n.toModelOutput!==void 0&&expectFunction(n.toModelOutput,t),n.auth!==void 0&&expectFunction(expectObjectRecord(n.auth,t).getToken,t),{kind:`tool`,definition:a}}export{normalizeToolDefinition};

package/dist/src/internal/authored-module-bundle.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Adds actionable context to lower-level authored module bundling failures.
+ */
+export declare function createAuthoredModuleBundleError(modulePath: string, error: unknown): Error;

package/dist/src/internal/authored-module-bundle.js

@@ -0,0 +1,2 @@
+function createAuthoredModuleBundleError(e,t){let n=t instanceof Error?t.message:String(t),r=[];return(/\.node(?:\b|["'?])/i.test(n)||/native addon|native module|invalid utf-?8|Could not load .*\.node/i.test(n))&&r.push(`If this comes from a native Node package, keep that package external with agent build.externalDependencies so Vercel/Nitro traces it instead of bundling it.`),/Unexpected character|No loader is configured|Could not load|Unknown file extension/i.test(n)&&r.push(`If this comes from an asset import, Eve only supports assets that Rolldown can emit for a Node ESM bundle; otherwise load the file through fs/import.meta.url or externalize the package.`),Error([`Failed to bundle authored module "${e}".`,n,...r.map(e=>`Hint: ${e}`)].join(`
+`))}export{createAuthoredModuleBundleError};

package/dist/src/internal/authored-module-loader.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Loads one authored module namespace from disk during compile-time
+ * discovery. Concurrent loads of the same `modulePath` share a single
+ * Promise so the underlying bundle/import pipeline runs once.
+ */
+export declare function loadAuthoredModuleNamespace(modulePath: string): Promise<Record<string, unknown>>;

package/dist/src/internal/authored-module-loader.js

@@ -0,0 +1,2 @@
+import{expectObjectRecord}from"#internal/authored-module.js";import{dirname,join,resolve,sep}from"node:path";import{existsSync,mkdirSync,writeFileSync}from"node:fs";import{createHash}from"node:crypto";import{createAuthoredAssetImportPlugin}from"#internal/authored-asset-import-plugin.js";import{createAuthoredModuleBundleError}from"#internal/authored-module-bundle.js";import{createAuthoredPackageTsConfigPathsPlugin}from"#internal/authored-package-tsconfig-paths.js";import{buildWithNitroRolldown,getSingleRolldownChunk}from"#internal/bundler/nitro-rolldown.js";import{createNodeEsmCompatBannerPlugin}from"#internal/node-esm-compat-banner.js";const AUTHORED_BUNDLED_MODULE_EXTENSION=/\.[cm]?[jt]sx?$/,AUTHORED_MODULE_BUNDLE_DIRECTORY_PATH=join(`node_modules`,`.cache`,`eve`,`authored-modules`),RESOLVE_EXTENSIONS=[`.ts`,`.tsx`,`.mts`,`.cts`,`.js`,`.jsx`,`.mjs`,`.cjs`,`.json`],CHANNEL_MODULE_CACHE_KEY=`__eveChannelModuleCache__`,CACHED_CHANNEL_PREFIX=`eve-cached-channel:`;function getChannelModuleCache(){return globalThis[CHANNEL_MODULE_CACHE_KEY]}const inFlightModuleLoads=new Map;function loadAuthoredModuleNamespace(e){let t=resolve(e),n=inFlightModuleLoads.get(t);if(n!==void 0)return n;let i=(async()=>{try{return await doLoadAuthoredModuleNamespace(e)}finally{inFlightModuleLoads.delete(t)}})();return inFlightModuleLoads.set(t,i),i}async function doLoadAuthoredModuleNamespace(t){return expectObjectRecord(AUTHORED_BUNDLED_MODULE_EXTENSION.test(t)?await loadBundledAuthoredModule(t):await import(createFileImportSpecifier(t)),`Expected "${t}" to export a module namespace object.`)}function createFileImportSpecifier(e){let t=e.replaceAll(`\\`,`/`);return/^[A-Za-z]:\//.test(t)?`file:///${encodeURI(t)}`:t.startsWith(`/`)?`file://${encodeURI(t)}`:t}async function loadBundledAuthoredModule(e){let t=getChannelModuleCache(),i=resolveAuthoredPackageRoot(e),s=resolveAuthoredTsConfigPath(i),c=t&&t.size>0?{name:`eve-channel-identity`,async resolveId(e,n,i){if(!/channels[/\\]/.test(e)||i.kind!==`import-statement`)return;let a=await this.resolve(e,n,{kind:i.kind,skipSelf:!0});if(a===null||typeof a.id!=`string`)return;let o=resolve(a.id);if(t.has(o))return{id:`${CACHED_CHANNEL_PREFIX}${o}`}},load(e){if(!e.startsWith(CACHED_CHANNEL_PREFIX))return;let t=e.slice(19);return{code:[`const cache = globalThis["${CHANNEL_MODULE_CACHE_KEY}"];`,`export default cache.get(${JSON.stringify(t)});`].join(`
+`),moduleType:`js`}}}:null,l=[createAuthoredAssetImportPlugin(),createAuthoredPackageTsConfigPathsPlugin({appPackageRoot:i,extensions:RESOLVE_EXTENSIONS}),createNodeEsmCompatBannerPlugin({includeRequire:!0}),createPackageBoundaryPlugin(i),c].filter(e=>e!==null),u;try{u=getSingleRolldownChunk(await buildWithNitroRolldown({cwd:i,input:e,platform:`node`,plugins:l,resolve:{extensions:[...RESOLVE_EXTENSIONS]},tsconfig:s,write:!1,output:{comments:!1,format:`esm`,sourcemap:`inline`}}),`authored module for "${e}"`)}catch(t){throw createAuthoredModuleBundleError(e,t)}let d=createHash(`sha1`).update(e).update(`\0`).update(u.code).digest(`hex`),f=join(i,AUTHORED_MODULE_BUNDLE_DIRECTORY_PATH),p=join(f,`${d}.mjs`);return existsSync(p)||(mkdirSync(f,{recursive:!0}),writeFileSync(p,u.code)),await import(`${createFileImportSpecifier(p)}?v=${d}`)}function createPackageBoundaryPlugin(e){return{name:`eve-package-boundary`,async resolveId(t,n,i){if(!isPackageImport(t))return;if(isEveFrameworkImport(t))return{external:!0,id:t};let a=n===void 0||n.startsWith(`\0`)||n.startsWith(CACHED_CHANNEL_PREFIX)?void 0:resolve(n);if(a!==void 0&&isPathInsideOrEqual(a,e)){let e=await this.resolve(t,n,{kind:i.kind,skipSelf:!0});if(e===null||typeof e.id!=`string`||isNodeModulesPath(e.id))return{external:!0,id:t}}}}}function isPackageImport(e){return e.startsWith(`.`)||e.startsWith(`/`)||/^[A-Za-z]:[\\/]/.test(e)||/^(?:node|data|file):/.test(e)||e.startsWith(`@/`)?!1:!e.startsWith(CACHED_CHANNEL_PREFIX)}function isEveFrameworkImport(e){return e===`eve`||e.startsWith(`eve/`)}function isNodeModulesPath(e){return e.replaceAll(`\\`,`/`).includes(`/node_modules/`)}function isPathInsideOrEqual(e,t){let n=resolve(e),a=resolve(t);return n===a||n.startsWith(`${a}${sep}`)}function resolveAuthoredTsConfigPath(e){for(let t of[`tsconfig.json`,`jsconfig.json`]){let r=join(e,t);if(existsSync(r))return r}return!1}function resolveAuthoredPackageRoot(e){let r=dirname(e);for(;;){if(existsSync(join(r,`package.json`)))return r;let i=dirname(r);if(i===r)throw Error(`Failed to resolve the authored package root for "${e}".`);r=i}}export{loadAuthoredModuleNamespace};

package/dist/src/internal/authored-module-map-loader.d.ts

@@ -0,0 +1,10 @@
+import { type CompiledModuleMap } from "#compiler/module-map.js";
+import type { RuntimeDiskCompiledArtifactsSource } from "#runtime/compiled-artifacts-source.js";
+/**
+ * Loads a disk-backed module map by hydrating authored modules directly from
+ * source. This is for dev/build flows that need tsconfig alias support and
+ * source reloads without relying on Node's module cache for module-map.mjs.
+ */
+export declare function loadCompiledModuleMapFromAuthoredSource(input: {
+    readonly compiledArtifactsSource: RuntimeDiskCompiledArtifactsSource;
+}): Promise<CompiledModuleMap>;

package/dist/src/internal/authored-module-map-loader.js

@@ -0,0 +1 @@
+import{join}from"node:path";import{collectModuleRefsForManifest}from"#compiler/module-map.js";import{ROOT_COMPILED_AGENT_NODE_ID}from"#compiler/manifest.js";import{loadAuthoredModuleNamespace}from"#internal/authored-module-loader.js";import{loadCompiledManifest}from"#runtime/loaders/manifest.js";async function loadCompiledModuleMapFromAuthoredSource(e){return await hydrateCompiledModuleMapFromManifest(await loadCompiledManifest({compiledArtifactsSource:e.compiledArtifactsSource}))}async function hydrateCompiledModuleMapFromManifest(e){let t={},r=[{agentRoot:e.agentRoot,manifest:e,nodeId:ROOT_COMPILED_AGENT_NODE_ID},...[...e.subagents].sort((e,t)=>e.nodeId.localeCompare(t.nodeId)).map(e=>({agentRoot:e.agent.agentRoot,manifest:e.agent,nodeId:e.nodeId}))];for(let e of r)t[e.nodeId]={modules:await hydrateCompiledNodeScope({agentRoot:e.agentRoot,manifest:e.manifest})};return{nodes:t}}async function hydrateCompiledNodeScope(n){let i=collectModuleRefsForManifest(n.manifest).sort((e,t)=>e.sourceId.localeCompare(t.sourceId)),a={};for(let t of i){let i=join(n.agentRoot,t.logicalPath);a[t.sourceId]=await loadAuthoredModuleNamespace(i)}return a}export{loadCompiledModuleMapFromAuthoredSource};

package/dist/src/internal/authored-module.d.ts

@@ -0,0 +1,42 @@
+import type { ModuleDefinitionExport } from "#public/definitions/source.js";
+import type { ModuleSourceRef } from "#shared/source-ref.js";
+import type { AgentModelOptionsDefinition } from "#shared/agent-definition.js";
+/**
+ * Returns the selected authored module export from one namespace.
+ */
+export declare function getAuthoredModuleExport(moduleNamespace: Record<string, unknown>, source: ModuleSourceRef | {
+    readonly exportName?: string;
+    readonly logicalPath: string;
+}): unknown;
+/**
+ * Materializes one authored module export that may be a definition factory.
+ */
+export declare function materializeAuthoredModuleExport<TDefinition>(exportValue: ModuleDefinitionExport<TDefinition>): Promise<TDefinition>;
+/**
+ * Returns the value as a plain object or throws.
+ */
+export declare function expectObjectRecord(value: unknown, message: string): Record<string, unknown>;
+/**
+ * Returns the value as a string or throws.
+ */
+export declare function expectString(value: unknown, message: string): string;
+/**
+ * Returns the value as a boolean or throws.
+ */
+export declare function expectBoolean(value: unknown, message: string): boolean;
+/**
+ * Returns the value as a function or throws.
+ */
+export declare function expectFunction<TFunction extends (...args: never[]) => unknown>(value: unknown, message: string): TFunction;
+/**
+ * Returns the value as a provider options object or throws.
+ */
+export declare function expectProviderOptions(value: unknown, message: string): Required<AgentModelOptionsDefinition>["providerOptions"];
+/**
+ * Rejects unexpected keys on one plain object.
+ */
+export declare function expectOnlyKnownKeys(record: Record<string, unknown>, knownKeys: readonly string[], message: string): void;
+/**
+ * Returns one optional string-record property when present.
+ */
+export declare function getOptionalStringRecordProperty(record: Record<string, unknown>, key: string, message: string): Record<string, string> | undefined;

package/dist/src/internal/authored-module.js

@@ -0,0 +1 @@
+function getAuthoredModuleExport(e,t){return e[t.exportName??`default`]}async function materializeAuthoredModuleExport(e){return typeof e==`function`?await e():e}function expectObjectRecord(e,t){if(typeof e!=`object`||!e||Array.isArray(e))throw Error(t);return e}function expectString(e,t){if(typeof e!=`string`)throw Error(t);return e}function expectBoolean(e,t){if(typeof e!=`boolean`)throw Error(t);return e}function expectFunction(e,t){if(typeof e!=`function`)throw Error(t);return e}function expectProviderOptions(e,t){let n=expectObjectRecord(e,t),r={};for(let[e,i]of Object.entries(n))r[e]=expectObjectRecord(i,t);return r}function expectOnlyKnownKeys(e,t,n){let r=new Set(t);for(let t of Object.keys(e))if(!r.has(t))throw Error(`${n} Unknown key "${t}".`)}function getOptionalStringRecordProperty(e,t,n){let r=e[t];if(r===void 0)return;let i=expectObjectRecord(r,n),a={};for(let[e,t]of Object.entries(i))a[e]=expectString(t,n);return a}export{expectBoolean,expectFunction,expectObjectRecord,expectOnlyKnownKeys,expectProviderOptions,expectString,getAuthoredModuleExport,getOptionalStringRecordProperty,materializeAuthoredModuleExport};

package/dist/src/internal/authored-package-tsconfig-paths.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Resolves tsconfig `paths` for authored source imported from linked
+ * workspace packages. Rolldown handles the root app tsconfig; this only
+ * fills the package-local config gap for sources outside the app root.
+ */
+export declare function createAuthoredPackageTsConfigPathsPlugin(input: {
+    appPackageRoot: string;
+    extensions: readonly string[];
+}): Record<string, unknown>;