eve 0.5.4 → 0.6.0-beta.1

package/dist/src/runtime/sandbox/keys.d.ts

@@ -0,0 +1,38 @@
+import { type RuntimeCompiledArtifactsSource } from "#runtime/compiled-artifacts-source.js";
+import type { RuntimeSandboxTemplatePlan } from "#runtime/sandbox/template-plan.js";
+/**
+ * Input for deriving the stable runtime keys used for one sandbox definition.
+ */
+interface CreateRuntimeSandboxKeysInput {
+    readonly backendName: string;
+    readonly compiledArtifactsSource: RuntimeCompiledArtifactsSource;
+    readonly nodeId: string;
+    readonly sessionId: string;
+    readonly sourceId: string;
+    readonly templatePlan: RuntimeSandboxTemplatePlan;
+}
+/**
+ * Creates the stable runtime template and session keys for one sandbox
+ * definition under the current artifact source and backend.
+ */
+export declare function createRuntimeSandboxKeys(input: CreateRuntimeSandboxKeysInput): Promise<{
+    readonly sessionKey: string;
+    readonly templateKey: string | null;
+}>;
+/**
+ * Creates the stable reusable template key for one sandbox definition,
+ * or `null` when the sandbox should start from a fresh backend runtime.
+ *
+ * The template key factors in the graph `nodeId` so that two
+ * runtime agents (root and subagents) do not collide on the same
+ * template when they each own a sandbox authored at the same logical
+ * path.
+ */
+export declare function createRuntimeSandboxTemplateKey(input: {
+    readonly backendName: string;
+    readonly compiledArtifactsSource: RuntimeCompiledArtifactsSource;
+    readonly nodeId: string;
+    readonly sourceId: string;
+    readonly templatePlan: RuntimeSandboxTemplatePlan;
+}): Promise<string | null>;
+export {};

package/dist/src/runtime/sandbox/keys.js

@@ -0,0 +1 @@
+import{realpath}from"node:fs/promises";import{resolveInstalledPackageInfo}from"#internal/application/package.js";import{createHash}from"node:crypto";import{getRuntimeCompiledArtifactsAppRoot,getRuntimeCompiledArtifactsCacheKey}from"#runtime/compiled-artifacts-source.js";import{loadCompileMetadata}from"#runtime/loaders/compile-metadata.js";async function createRuntimeSandboxKeys(e){return{sessionKey:await createRuntimeSandboxSessionKey(e),templateKey:await createRuntimeSandboxTemplateKey(e)}}async function createRuntimeSandboxTemplateKey(e){if(e.templatePlan.kind===`none`)return null;let n=await resolveRuntimeSandboxScope({backendName:e.backendName,compiledArtifactsSource:e.compiledArtifactsSource,scopeKind:e.templatePlan.kind===`source-graph`?`deployment`:`stable`}),r=await resolveRuntimeSandboxVersionHash({compiledArtifactsSource:e.compiledArtifactsSource,nodeId:e.nodeId,sourceId:e.sourceId,templatePlan:e.templatePlan}),i=createStableHash(`${resolveInstalledPackageInfo().version}:5:${r}`).slice(0,20);return sanitizeRuntimeSandboxKey(`eve-sbx-tpl-${e.backendName}-${n}-${i}`)}async function createRuntimeSandboxSessionKey(e){let t=await resolveRuntimeSandboxScope({backendName:e.backendName,compiledArtifactsSource:e.compiledArtifactsSource,scopeKind:`deployment`}),n=sanitizeRuntimeSandboxKey(e.nodeId);return sanitizeRuntimeSandboxKey(`eve-sbx-ses-${e.backendName}-${t}-${e.sessionId}-${n}`)}async function resolveRuntimeSandboxScope(t){if(t.backendName===`vercel`){if(t.scopeKind===`stable`){let e=resolveVercelProjectScope();if(e!==void 0)return createStableHash(e).slice(0,16)}let e=process.env.VERCEL_DEPLOYMENT_ID?.trim();if(e!==void 0&&e.length>0)return createStableHash(e).slice(0,16)}let n=getRuntimeCompiledArtifactsAppRoot(t.compiledArtifactsSource);return n===void 0?createStableHash(getRuntimeCompiledArtifactsCacheKey(t.compiledArtifactsSource)).slice(0,16):createStableHash(await realpath(n)).slice(0,16)}async function resolveRuntimeSandboxVersionHash(e){if(e.templatePlan.kind===`bootstrap`){let t=e.templatePlan.contentHash??await resolveSourceGraphHash(e.compiledArtifactsSource);return createStableHash(`bootstrap:${e.templatePlan.revalidationKey??``}:${e.templatePlan.sourceHash}:${t}:${e.nodeId}:${e.sourceId}`)}return e.templatePlan.kind===`workspace-content`?createStableHash(`workspace-content:${e.templatePlan.contentHash??await resolveSourceGraphHash(e.compiledArtifactsSource)}:${e.nodeId}:${e.sourceId}`):createStableHash(`source-graph:${await resolveSourceGraphHash(e.compiledArtifactsSource)}:${e.nodeId}:${e.sourceId}`)}async function resolveSourceGraphHash(e){return(await loadCompileMetadata({compiledArtifactsSource:e}))?.discovery.sourceGraphHash??getRuntimeCompiledArtifactsCacheKey(e)}function resolveVercelProjectScope(){let e=process.env.VERCEL_PROJECT_ID?.trim();if(e===void 0||e.length===0)return;let t=process.env.VERCEL_TEAM_ID?.trim();return t===void 0||t.length===0?`vercel-project:${e}`:`vercel-project:${t}:${e}`}function createStableHash(e){return createHash(`sha256`).update(e).digest(`hex`)}function sanitizeRuntimeSandboxKey(e){return e.replaceAll(/[^a-zA-Z0-9._-]+/g,`-`).slice(0,120)}export{createRuntimeSandboxKeys,createRuntimeSandboxTemplateKey};

package/dist/src/runtime/sandbox/registry.d.ts

@@ -0,0 +1,61 @@
+import type { CompiledWorkspaceResourceRoot } from "#compiler/manifest.js";
+import type { ResolvedSandboxDefinition } from "#runtime/types.js";
+/**
+ * Stable internal source id for the framework-owned default sandbox.
+ *
+ * Used by the runtime template/session key derivation and by prewarm
+ * to distinguish the shared framework sandbox from per-node authored
+ * overrides.
+ */
+export declare const DEFAULT_SANDBOX_SOURCE_ID = "eve:default-sandbox";
+/**
+ * Resolved sandbox tracked by the runtime-owned registry.
+ *
+ * The sandbox does not generate model-visible tools automatically. The
+ * framework `bash` tool targets it implicitly.
+ *
+ * `workspaceResourceRoot` carries the byte-free descriptor for the
+ * compiled workspace resource tree owned by this graph node. The
+ * prewarm orchestrator resolves the descriptor's logical path against
+ * the active compiled artifacts source and writes the contents into
+ * the sandbox template snapshot. Runtime `backend.create(...)` never
+ * reads these files.
+ */
+export interface RuntimeRegisteredSandbox {
+    readonly definition: ResolvedSandboxDefinition;
+    readonly workspaceResourceRoot: CompiledWorkspaceResourceRoot;
+}
+/**
+ * Runtime-owned registry that exposes the resolved sandbox to the harness
+ * startup path.
+ *
+ * Every agent owns exactly one sandbox, so the registry is just a
+ * single record. When the author provides a `sandbox.<ext>` (or
+ * `sandbox/sandbox.<ext>`) override, that authored definition replaces
+ * the framework default. Production always populates it; tests that
+ * need a `null` sandbox cast through `as RuntimeSandboxRegistry`.
+ */
+export interface RuntimeSandboxRegistry {
+    readonly sandbox: RuntimeRegisteredSandbox;
+}
+/**
+ * Builds the runtime-owned registry for one resolved authored agent's
+ * sandbox, preferring the authored override and falling back to the
+ * framework default.
+ */
+export declare function createRuntimeSandboxRegistry(input: {
+    readonly authoredSandbox: ResolvedSandboxDefinition | null;
+    readonly workspaceResourceRoot: CompiledWorkspaceResourceRoot;
+}): RuntimeSandboxRegistry;
+/**
+ * Builds the framework default sandbox definition used when no agent
+ * authored override is present.
+ *
+ * The `backend` is resolved through {@link defaultBackend} on each
+ * call so the framework default picks up the same environment-aware
+ * fallback as authored sandboxes that omit `backend` (`vercelBackend()`
+ * on hosted Vercel, `localBackend()` everywhere else). Implemented as
+ * a factory rather than a constant so the environment is read at
+ * graph-resolution time rather than at module-load time.
+ */
+export declare function createFrameworkSandboxDefinition(): ResolvedSandboxDefinition;

package/dist/src/runtime/sandbox/registry.js

@@ -0,0 +1 @@
+import{defaultBackend}from"#public/sandbox/backends/default.js";const DEFAULT_SANDBOX_SOURCE_ID=`eve:default-sandbox`;function createRuntimeSandboxRegistry(e){return{sandbox:{definition:e.authoredSandbox??createFrameworkSandboxDefinition(),workspaceResourceRoot:e.workspaceResourceRoot}}}function createFrameworkSandboxDefinition(){return{backend:defaultBackend(),logicalPath:`eve:framework/default-sandbox`,sourceId:DEFAULT_SANDBOX_SOURCE_ID,sourceKind:`module`}}export{DEFAULT_SANDBOX_SOURCE_ID,createFrameworkSandboxDefinition,createRuntimeSandboxRegistry};

package/dist/src/runtime/sandbox/template-plan.d.ts

@@ -0,0 +1,26 @@
+import type { CompiledWorkspaceResourceRoot } from "#compiler/manifest.js";
+import type { ResolvedSandboxDefinition } from "#runtime/types.js";
+/**
+ * Describes whether one sandbox needs a prewarmed template and, if so,
+ * which inputs must participate in the template key.
+ */
+export type RuntimeSandboxTemplatePlan = {
+    readonly kind: "none";
+} | {
+    readonly contentHash?: string;
+    readonly kind: "workspace-content";
+} | {
+    readonly contentHash?: string;
+    readonly kind: "bootstrap";
+    readonly revalidationKey?: string;
+    readonly sourceHash: string;
+} | {
+    readonly kind: "source-graph";
+};
+/**
+ * Chooses the template strategy for one resolved sandbox definition.
+ */
+export declare function createRuntimeSandboxTemplatePlan(input: {
+    readonly definition: ResolvedSandboxDefinition;
+    readonly workspaceResourceRoot: CompiledWorkspaceResourceRoot;
+}): RuntimeSandboxTemplatePlan;

package/dist/src/runtime/sandbox/template-plan.js

@@ -0,0 +1 @@
+function createRuntimeSandboxTemplatePlan(e){if(e.definition.bootstrap!==void 0){if(e.definition.sourceHash===void 0)throw Error(`Sandbox "${e.definition.logicalPath}" defines bootstrap() but has no compiled sourceHash.`);return{contentHash:e.workspaceResourceRoot.contentHash,kind:`bootstrap`,revalidationKey:e.definition.revalidationKey,sourceHash:e.definition.sourceHash}}return e.workspaceResourceRoot.rootEntries.length===0?{kind:`none`}:{contentHash:e.workspaceResourceRoot.contentHash,kind:`workspace-content`}}export{createRuntimeSandboxTemplatePlan};

package/dist/src/runtime/schedules/register.d.ts

@@ -0,0 +1,35 @@
+import type { ResolvedSchedule } from "#runtime/types.js";
+/**
+ * Stable Nitro task-name prefix for framework-owned authored schedules.
+ */
+export declare const EVE_SCHEDULE_TASK_NAME_PREFIX = "eve.schedule.";
+/**
+ * One compiled schedule registration consumed by the Nitro host wiring.
+ */
+export interface ScheduleRegistration {
+    readonly cron: string;
+    readonly description: string;
+    readonly logicalPath: string;
+    readonly scheduleId: string;
+    readonly sourceId: string;
+    readonly taskName: string;
+}
+/**
+ * Error raised when authored schedules cannot be converted into stable runtime
+ * registrations.
+ */
+export declare class ScheduleRegistrationError extends Error {
+    readonly scheduleId?: string;
+    readonly sourceId?: string;
+    readonly taskName?: string;
+    constructor(message: string, input?: {
+        scheduleId?: string;
+        sourceId?: string;
+        taskName?: string;
+    });
+}
+/**
+ * Creates stable registration inputs for Nitro's task and cron surfaces from
+ * resolved authored schedules.
+ */
+export declare function createScheduleRegistrations(schedules: readonly ResolvedSchedule[]): ScheduleRegistration[];

package/dist/src/runtime/schedules/register.js

@@ -0,0 +1 @@
+const EVE_SCHEDULE_TASK_NAME_PREFIX=`eve.schedule.`;var ScheduleRegistrationError=class extends Error{scheduleId;sourceId;taskName;constructor(e,t={}){super(e),this.name=`ScheduleRegistrationError`,t.scheduleId!==void 0&&(this.scheduleId=t.scheduleId),t.sourceId!==void 0&&(this.sourceId=t.sourceId),t.taskName!==void 0&&(this.taskName=t.taskName)}};function createScheduleRegistrations(e){let t=e.map(e=>({cron:e.cron,description:`Run Eve schedule "${e.name}" from "${e.logicalPath}".`,logicalPath:e.logicalPath,scheduleId:e.name,sourceId:e.sourceId,taskName:createScheduleTaskName(e.sourceId)})).sort((e,t)=>e.sourceId.localeCompare(t.sourceId));return assertUniqueScheduleIds(t),t}function assertUniqueScheduleIds(e){let t=new Map;for(let n of e){let e=t.get(n.scheduleId);if(e===void 0){t.set(n.scheduleId,n);continue}throw new ScheduleRegistrationError(`Duplicate authored schedule id "${n.scheduleId}" found in "${e.logicalPath}" and "${n.logicalPath}".`,{scheduleId:n.scheduleId,sourceId:n.sourceId,taskName:n.taskName})}}function createScheduleTaskName(t){return`${EVE_SCHEDULE_TASK_NAME_PREFIX}${Buffer.from(t,`utf8`).toString(`base64url`)}`}export{EVE_SCHEDULE_TASK_NAME_PREFIX,ScheduleRegistrationError,createScheduleRegistrations};

package/dist/src/runtime/schedules/resolve-schedule.d.ts

@@ -0,0 +1,31 @@
+import type { CompiledAgentManifest } from "#compiler/manifest.js";
+import type { RuntimeCompiledArtifactsSource } from "#runtime/compiled-artifacts-source.js";
+import type { ResolvedSchedule } from "#runtime/types.js";
+/**
+ * Input for resolving authored schedules from the compiled manifest.
+ */
+interface ResolveSchedulesInput {
+    manifest: CompiledAgentManifest;
+}
+/**
+ * Explicit compiled-artifact source used to resolve schedules from runtime
+ * artifacts.
+ */
+interface LoadResolvedCompiledSchedulesInput {
+    readonly compiledArtifactsSource: RuntimeCompiledArtifactsSource;
+}
+/**
+ * Resolves runtime-owned schedules from the compiled manifest.
+ */
+export declare function resolveSchedules(input: ResolveSchedulesInput): Promise<ResolvedSchedule[]>;
+/**
+ * Loads the compiled manifest, then resolves authored schedules into
+ * runtime-owned schedule models.
+ */
+export declare function loadResolvedCompiledSchedules(input: LoadResolvedCompiledSchedulesInput): Promise<ResolvedSchedule[]>;
+/**
+ * Loads and resolves one compiled authored schedule from its registered Nitro
+ * task name.
+ */
+export declare function loadResolvedCompiledScheduleByTaskName(taskName: string, input: LoadResolvedCompiledSchedulesInput): Promise<ResolvedSchedule>;
+export {};

package/dist/src/runtime/schedules/resolve-schedule.js

@@ -0,0 +1 @@
+import{loadCompiledManifest}from"#runtime/loaders/manifest.js";import{createScheduleRegistrations}from"#runtime/schedules/register.js";var ResolveScheduleError=class extends Error{taskName;constructor(e,t={}){super(e),this.name=`ResolveScheduleError`,t.taskName!==void 0&&(this.taskName=t.taskName)}};async function resolveSchedules(e){return[...e.manifest.schedules].map(e=>{let t={cron:e.cron,hasRun:e.hasRun,logicalPath:e.logicalPath,name:e.name,sourceId:e.sourceId,sourceKind:e.sourceKind};return e.markdown===void 0?t:{...t,markdown:e.markdown}})}async function loadResolvedCompiledSchedules(t){return await resolveSchedules({manifest:await loadCompiledManifest({compiledArtifactsSource:t.compiledArtifactsSource})})}async function loadResolvedCompiledScheduleByTaskName(e,n){let r=await loadResolvedCompiledSchedules(n),i=new Map(r.map(e=>[e.sourceId,e]));for(let n of createScheduleRegistrations(r))if(n.taskName===e){let e=i.get(n.sourceId);if(e!==void 0)return e}throw new ResolveScheduleError(`No compiled authored schedule is registered for Nitro task "${e}".`,{taskName:e})}export{loadResolvedCompiledScheduleByTaskName,loadResolvedCompiledSchedules,resolveSchedules};

package/dist/src/runtime/session-callback-route.d.ts

@@ -0,0 +1,6 @@
+import type { RouteContext } from "#public/definitions/channel.js";
+import type { ResolvedChannelDefinition } from "#runtime/types.js";
+export declare const HTTP_SESSION_CALLBACK_CHANNEL_NAME_PREFIX = "eve/v1/callback";
+export declare function getSessionCallbackChannelDefinitions(): readonly ResolvedChannelDefinition[];
+export declare function getSessionCallbackChannelNames(): ReadonlySet<string>;
+export declare function handleSessionCallbackRequest(request: Request, ctx: RouteContext): Promise<Response>;

package/dist/src/runtime/session-callback-route.js

@@ -0,0 +1 @@
+import{EVE_CALLBACK_ROUTE_PATTERN}from"#protocol/routes.js";import{resumeHook}from"#compiled/@workflow/core/runtime.js";const HTTP_SESSION_CALLBACK_CHANNEL_NAME_PREFIX=`eve/v1/callback`,HANDLED_METHODS=[`POST`];function getSessionCallbackChannelDefinitions(){return HANDLED_METHODS.map(e=>buildCallbackChannelDefinition(e))}function getSessionCallbackChannelNames(){return new Set(HANDLED_METHODS.map(channelNameForMethod))}function buildCallbackChannelDefinition(t){let n=channelNameForMethod(t);return{name:n,method:t,urlPath:EVE_CALLBACK_ROUTE_PATTERN,fetch:handleSessionCallbackRequest,logicalPath:`framework://channels/${n}`,sourceId:`eve:framework:session-callback-${t.toLowerCase()}`,sourceKind:`module`}}function channelNameForMethod(e){return`${HTTP_SESSION_CALLBACK_CHANNEL_NAME_PREFIX}/${e.toLowerCase()}`}async function handleSessionCallbackRequest(e,n){let r=n.params.token;if(typeof r!=`string`||r.length===0)return Response.json({error:`Missing callback token.`,ok:!1},{status:400});let i;try{i=await e.json()}catch{return Response.json({error:`Invalid JSON body.`,ok:!1},{status:400})}let a=projectSessionCallbackResult(i);if(a instanceof Response)return a;try{await resumeHook(r,{kind:`runtime-action-result`,results:[a]})}catch{return Response.json({error:`Session callback not pending.`,ok:!1},{status:404})}return Response.json({ok:!0},{status:202})}function projectSessionCallbackResult(e){if(typeof e!=`object`||!e)return Response.json({error:`Expected a JSON object.`,ok:!1},{status:400});let t=e;return typeof t.callId!=`string`||t.callId.length===0?Response.json({error:`Missing callback callId.`,ok:!1},{status:400}):typeof t.subagentName!=`string`||t.subagentName.length===0?Response.json({error:`Missing callback subagentName.`,ok:!1},{status:400}):t.kind===`session.completed`?{callId:t.callId,kind:`subagent-result`,output:t.output??``,subagentName:t.subagentName}:t.kind===`session.failed`?{callId:t.callId,isError:!0,kind:`subagent-result`,output:t.error===void 0?{code:`REMOTE_AGENT_FAILED`,message:`Remote agent failed.`}:t.error,subagentName:t.subagentName}:Response.json({error:`Unsupported callback kind.`,ok:!1},{status:400})}export{HTTP_SESSION_CALLBACK_CHANNEL_NAME_PREFIX,getSessionCallbackChannelDefinitions,getSessionCallbackChannelNames,handleSessionCallbackRequest};

package/dist/src/runtime/sessions/auth.d.ts

@@ -0,0 +1,39 @@
+import { z } from "#compiled/zod/index.js";
+/**
+ * Runtime-owned authenticator kinds projected into Eve session auth metadata.
+ */
+export type RuntimeSessionAuthenticator = "http-basic" | "jwt-hmac" | "jwt-ecdsa" | "oidc";
+/**
+ * Normalized principal classifications projected into public session metadata.
+ */
+export type RuntimeSessionPrincipalType = "service" | "user" | "runtime" | "unknown";
+/**
+ * Serializable string-only auth attributes preserved on runtime sessions.
+ */
+export type RuntimeSessionAuthAttributes = Readonly<Record<string, string | readonly string[]>>;
+/**
+ * Serializable auth context projected onto one runtime session turn.
+ */
+export type RuntimeSessionAuthContext = z.infer<typeof runtimeSessionAuthContextSchema>;
+/**
+ * Zod schema for one serializable runtime session auth context.
+ */
+declare const runtimeSessionAuthContextSchema: z.ZodObject<{
+    attributes: z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodReadonly<z.ZodArray<z.ZodString>>]>>>;
+    authenticator: z.ZodEnum<{
+        "http-basic": "http-basic";
+        "jwt-ecdsa": "jwt-ecdsa";
+        "jwt-hmac": "jwt-hmac";
+        oidc: "oidc";
+    }>;
+    issuer: z.ZodOptional<z.ZodString>;
+    principalId: z.ZodString;
+    principalType: z.ZodEnum<{
+        runtime: "runtime";
+        service: "service";
+        unknown: "unknown";
+        user: "user";
+    }>;
+    subject: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export {};

package/dist/src/runtime/sessions/auth.js

@@ -0,0 +1 @@
+import{z}from"#compiled/zod/index.js";const runtimeSessionAuthAttributeValueSchema=z.union([z.string(),z.array(z.string()).readonly()]);z.object({attributes:z.record(z.string(),runtimeSessionAuthAttributeValueSchema).readonly(),authenticator:z.enum([`http-basic`,`jwt-hmac`,`jwt-ecdsa`,`oidc`]),issuer:z.string().optional(),principalId:z.string(),principalType:z.enum([`service`,`user`,`runtime`,`unknown`]),subject:z.string().optional()}).strict();export{};

package/dist/src/runtime/sessions/compiled-agent-cache.d.ts

@@ -0,0 +1,47 @@
+import type { CompiledModuleMap } from "#compiler/module-map.js";
+import type { RuntimeTurnAgent } from "#runtime/agent/bootstrap.js";
+import type { RuntimeAdapterRegistry } from "#runtime/channels/registry.js";
+import { type RuntimeCompiledArtifactsSource } from "#runtime/compiled-artifacts-source.js";
+import { type ResolvedAgentGraphBundle } from "#runtime/graph.js";
+import type { RuntimeHookRegistry } from "#runtime/hooks/registry.js";
+import type { RuntimeSubagentRegistry } from "#runtime/subagents/registry.js";
+import type { RuntimeToolRegistry } from "#runtime/tools/registry.js";
+import type { ResolvedAgent } from "#runtime/types.js";
+export interface CompiledRuntimeAgentBundle {
+    readonly adapterRegistry: RuntimeAdapterRegistry;
+    readonly compiledArtifactsSource: RuntimeCompiledArtifactsSource;
+    readonly graph: ResolvedAgentGraphBundle;
+    readonly hookRegistry: RuntimeHookRegistry;
+    readonly moduleMap: CompiledModuleMap;
+    /**
+     * Id of the active node in the graph. `undefined` for root bundles.
+     * Persisted by the BundleKey codec so per-node bundles survive
+     * serialization across workflow step boundaries.
+     */
+    readonly nodeId?: string;
+    readonly resolvedAgent: ResolvedAgent;
+    readonly subagentRegistry: RuntimeSubagentRegistry;
+    readonly toolRegistry: RuntimeToolRegistry;
+    readonly turnAgent: RuntimeTurnAgent;
+}
+/**
+ * Returns a compiled runtime agent bundle for the given source and optional
+ * node id.
+ *
+ * The full graph is loaded and cached once per `compiledArtifactsSource`.
+ * When `nodeId` is provided, a cheap per-node bundle is derived from
+ * the cached graph with the node-level fields (turn agent, registries, etc.)
+ * pointing at the target node. When omitted the root bundle is returned.
+ */
+export declare function getCompiledRuntimeAgentBundle(input: {
+    readonly compiledArtifactsSource: RuntimeCompiledArtifactsSource;
+    readonly nodeId?: string;
+}): Promise<CompiledRuntimeAgentBundle>;
+/**
+ * Clears all cached compiled runtime agent bundles on the active runtime
+ * session. The dev-server file watcher uses this to invalidate cached
+ * bundles when authored source changes; tests rely on per-session isolation
+ * so the process default cache is untouched when called inside a scoped
+ * session.
+ */
+export declare function clearCompiledRuntimeAgentBundleCache(): void;

package/dist/src/runtime/sessions/compiled-agent-cache.js

@@ -0,0 +1 @@
+import{getResolvedRuntimeAgentNode}from"#runtime/graph.js";import{getRuntimeCompiledArtifactsCacheKey}from"#runtime/compiled-artifacts-source.js";import{loadCompiledManifest}from"#runtime/loaders/manifest.js";import{resolveRuntimeAgentGraph}from"#runtime/resolve-agent-graph.js";import{pathToFileURL}from"node:url";import{loadCompiledModuleMap}from"#runtime/loaders/module-map.js";import{getActiveRuntimeSession}from"#runtime/sessions/runtime-session.js";import{resolveRuntimeCompiledArtifactsVersionedCacheKey}from"#runtime/cache-key.js";import{createRuntimeAdapterRegistry}from"#runtime/channels/registry.js";const isCacheDisabled=process.env.EVE_DISABLE_AGENT_CACHE===`1`;async function loadFullBundle(e){let[t,i]=await Promise.all([loadCompiledManifest({compiledArtifactsSource:e}),loadRuntimeCompiledModuleMap(e)]),a=await resolveRuntimeAgentGraph({manifest:t,moduleMap:i}),o=a.root;return{adapterRegistry:createRuntimeAdapterRegistry({channels:collectResolvedChannels(a)}),compiledArtifactsSource:e,graph:a,hookRegistry:o.hookRegistry,moduleMap:i,resolvedAgent:o.agent,subagentRegistry:o.subagentRegistry,toolRegistry:o.toolRegistry,turnAgent:o.turnAgent}}async function loadRuntimeCompiledModuleMap(e){return e.kind===`disk`&&e.moduleMapLoaderPath!==void 0?await loadAuthoredSourceCompiledModuleMap(e):await loadCompiledModuleMap({compiledArtifactsSource:e})}async function loadAuthoredSourceCompiledModuleMap(e){if(e.moduleMapLoaderPath===void 0)throw Error(`Authored-source module map loading requires "moduleMapLoaderPath" in the compiled artifacts source.`);return await(await import(pathToFileURL(e.moduleMapLoaderPath).href)).loadCompiledModuleMapFromAuthoredSource({compiledArtifactsSource:e})}async function getOrLoadFullBundle(e){if(isCacheDisabled)return loadFullBundle(e);let n=getActiveRuntimeSession(),r=getRuntimeCompiledArtifactsCacheKey(e),i=await resolveRuntimeCompiledArtifactsVersionedCacheKey(e),a=n.bundleCacheKeyBySourceKey.get(r);a!==void 0&&a!==i&&n.bundleCache.delete(a),n.bundleCacheKeyBySourceKey.set(r,i);let s=n.bundleCache.get(i);if(s!==void 0)return s;let c=loadFullBundle(e).catch(e=>{throw n.bundleCache.delete(i),n.bundleCacheKeyBySourceKey.get(r)===i&&n.bundleCacheKeyBySourceKey.delete(r),e});return n.bundleCache.set(i,c),c}async function getCompiledRuntimeAgentBundle(t){let n=await getOrLoadFullBundle(t.compiledArtifactsSource);if(t.nodeId===void 0)return n;let r=getResolvedRuntimeAgentNode(n.graph,t.nodeId);return{adapterRegistry:n.adapterRegistry,compiledArtifactsSource:n.compiledArtifactsSource,graph:{nodesByNodeId:n.graph.nodesByNodeId,root:r},hookRegistry:r.hookRegistry,moduleMap:n.moduleMap,nodeId:t.nodeId,resolvedAgent:r.agent,subagentRegistry:r.subagentRegistry,toolRegistry:r.toolRegistry,turnAgent:r.turnAgent}}function clearCompiledRuntimeAgentBundleCache(){let e=getActiveRuntimeSession();e.bundleCache.clear(),e.bundleCacheKeyBySourceKey.clear()}function collectResolvedChannels(e){let t=new Map;for(let n of e.nodesByNodeId.values())for(let e of n.channels)t.set(`${e.sourceId}:${e.name}`,e);return[...t.values()]}export{clearCompiledRuntimeAgentBundleCache,getCompiledRuntimeAgentBundle};

package/dist/src/runtime/sessions/runtime-context-keys.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Runtime-tier context keys whose codecs call back into the runtime to
+ * materialize their values. Leaf keys (no codec) live in `#context/keys.ts`.
+ */
+import type { ChannelAdapter } from "#channel/adapter.js";
+import { ContextKey } from "#context/key.js";
+import { type CompiledRuntimeAgentBundle } from "#runtime/sessions/compiled-agent-cache.js";
+/** Compiled bundle on the durable context — re-exported under a stable name. */
+export type CompiledBundle = CompiledRuntimeAgentBundle;
+export declare const ChannelKey: ContextKey<ChannelAdapter>;
+export declare const BundleKey: ContextKey<CompiledRuntimeAgentBundle>;

package/dist/src/runtime/sessions/runtime-context-keys.js

@@ -0,0 +1 @@
+import{getAdapterKind}from"#channel/adapter.js";import{ContextKey}from"#context/key.js";import{getCompiledRuntimeAgentBundle}from"#runtime/sessions/compiled-agent-cache.js";import{deserializeRuntimeAdapter}from"#runtime/channels/registry.js";const ChannelKey=new ContextKey(`eve.channel`,{codec:{serialize(t){return{kind:getAdapterKind(t),state:t.state?{...t.state}:{}}},deserialize(e,t){let n=t.get(BundleKey);if(n===void 0)throw Error(`Cannot deserialize "eve.channel" before "eve.bundle". The runtime bundle must be present in context.`);return deserializeRuntimeAdapter(n.adapterRegistry,e)}}}),BundleKey=new ContextKey(`eve.bundle`,{codec:{serialize:e=>({nodeId:e.nodeId,source:e.compiledArtifactsSource}),deserialize:e=>{let{source:t,nodeId:r}=e;return getCompiledRuntimeAgentBundle({compiledArtifactsSource:t,nodeId:r})}}});export{BundleKey,ChannelKey};

package/dist/src/runtime/sessions/runtime-session.d.ts

@@ -0,0 +1,52 @@
+import type { BundledCompiledArtifacts } from "#runtime/loaders/bundled-artifacts.js";
+import type { CompiledRuntimeAgentBundle } from "#runtime/sessions/compiled-agent-cache.js";
+/**
+ * Process-scoped container for mutable runtime state owned by one Eve
+ * deployment.
+ *
+ * Holds installed compiled artifacts and compiled-agent bundle caches.
+ * Tests use {@link withRuntimeSession} to avoid mutating the process
+ * default session.
+ */
+export interface RuntimeSession {
+    /**
+     * Diagnostic identifier (e.g. `"process-default"` or a test-provided label).
+     * Used for logs and error messages; not relied on for dispatch.
+     */
+    readonly id: string;
+    /**
+     * The installed bundled compiled-artifact snapshot, or `null` when no
+     * snapshot has been installed in this session yet.
+     */
+    compiledArtifacts: BundledCompiledArtifacts | null;
+    /**
+     * Cache of resolved compiled-agent bundles, keyed by the versioned cache key
+     * derived from the compiled-artifact source.
+     */
+    readonly bundleCache: Map<string, Promise<CompiledRuntimeAgentBundle>>;
+    /**
+     * Reverse index from the stable source key to the currently active versioned
+     * cache key. Used to evict the previous entry when a source's version
+     * changes.
+     */
+    readonly bundleCacheKeyBySourceKey: Map<string, string>;
+}
+/**
+ * Creates a fresh, empty runtime session.
+ */
+export declare function createRuntimeSession(id?: string): RuntimeSession;
+/**
+ * Returns the runtime session that should be consulted for the current call.
+ *
+ * Returns the scoped session when {@link withRuntimeSession} is active in
+ * the current async context, otherwise the process-default session
+ * (lazily created on first access).
+ */
+export declare function getActiveRuntimeSession(): RuntimeSession;
+/**
+ * Executes `fn` with `session` installed as the active runtime session for
+ * the duration of the callback, including across every `await` boundary
+ * inside it. Concurrent callers each observe their own session. The
+ * process-default session is untouched.
+ */
+export declare function withRuntimeSession<T>(session: RuntimeSession, fn: () => Promise<T> | T): Promise<T>;

package/dist/src/runtime/sessions/runtime-session.js

@@ -0,0 +1 @@
+import{AsyncLocalStorage}from"node:async_hooks";function createRuntimeSession(e=`test-session`){return{bundleCache:new Map,bundleCacheKeyBySourceKey:new Map,compiledArtifacts:null,id:e}}const RUNTIME_SESSION_STORAGE_GLOBAL_KEY=Symbol.for(`eve.runtime-session-storage`),RUNTIME_SESSION_DEFAULT_GLOBAL_KEY=Symbol.for(`eve.runtime-session-default`),globalContainer=globalThis;globalContainer[RUNTIME_SESSION_STORAGE_GLOBAL_KEY]===void 0&&(globalContainer[RUNTIME_SESSION_STORAGE_GLOBAL_KEY]=new AsyncLocalStorage);const runtimeSessionStorage=globalContainer[RUNTIME_SESSION_STORAGE_GLOBAL_KEY];function resolveProcessDefaultSession(){return globalContainer[RUNTIME_SESSION_DEFAULT_GLOBAL_KEY]===void 0&&(globalContainer[RUNTIME_SESSION_DEFAULT_GLOBAL_KEY]=createRuntimeSession(`process-default`)),globalContainer[RUNTIME_SESSION_DEFAULT_GLOBAL_KEY]}function getActiveRuntimeSession(){return runtimeSessionStorage.getStore()??resolveProcessDefaultSession()}async function withRuntimeSession(e,t){return await runtimeSessionStorage.run(e,async()=>await t())}export{createRuntimeSession,getActiveRuntimeSession,withRuntimeSession};

package/dist/src/runtime/sessions/turn.d.ts

@@ -0,0 +1,33 @@
+import type { Node } from "#shared/node.js";
+import type { SourceRef } from "#shared/source-ref.js";
+import type { InternalToolDefinition } from "#shared/tool-definition.js";
+/**
+ * Serializable authored tool descriptor prepared by the runtime for one
+ * harness turn.
+ */
+export type PreparedRuntimeAuthoredTool = Readonly<InternalToolDefinition & SourceRef & {
+    kind: "authored-tool";
+}>;
+type PreparedRuntimeDelegationToolBase<TKind extends "remote" | "subagent"> = Readonly<InternalToolDefinition & SourceRef & Node & {
+    kind: TKind;
+}>;
+/**
+ * Serializable local subagent descriptor prepared by the runtime for one
+ * harness turn.
+ */
+type PreparedRuntimeSubagentTool = PreparedRuntimeDelegationToolBase<"subagent">;
+/**
+ * Serializable remote subagent descriptor prepared by the runtime for one
+ * harness turn.
+ */
+type PreparedRuntimeRemoteAgentTool = PreparedRuntimeDelegationToolBase<"remote">;
+/**
+ * Serializable delegation descriptor prepared by the runtime for one harness
+ * turn.
+ */
+export type PreparedRuntimeDelegationTool = PreparedRuntimeRemoteAgentTool | PreparedRuntimeSubagentTool;
+/**
+ * Serializable model-visible runtime tool prepared for one harness turn.
+ */
+export type PreparedRuntimeTool = PreparedRuntimeAuthoredTool | PreparedRuntimeDelegationTool;
+export {};

package/dist/src/runtime/sessions/turn.js

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

package/dist/src/runtime/skills/fragment-context.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Framework-owned tool name used to load one available compiled skill.
+ */
+export declare const LOAD_SKILL_TOOL_NAME = "load_skill";

package/dist/src/runtime/skills/fragment-context.js

@@ -0,0 +1 @@
+const LOAD_SKILL_TOOL_NAME=`load_skill`;export{LOAD_SKILL_TOOL_NAME};

package/dist/src/runtime/skills/sandbox-access.d.ts

@@ -0,0 +1,21 @@
+import type { SandboxAccess } from "#sandbox/state.js";
+import type { SkillHandle } from "#execution/skills/types.js";
+/**
+ * Validates a skill id before it is used as one path segment under
+ * `/workspace/skills`.
+ */
+export declare function assertSafeSkillId(id: string): asserts id is string;
+/**
+ * Reads one skill's instruction markdown from the current sandbox.
+ *
+ * Returns the SKILL.md body with any YAML frontmatter stripped, so the
+ * model receives plain markdown as the tool result. Throws when the id
+ * is unsafe or the file does not exist; the AI SDK forwards the error
+ * to the model as a tool-error result.
+ */
+export declare function loadSkillFromSandbox(access: SandboxAccess, id: string): Promise<string>;
+/**
+ * Creates the public runtime skill handle. Existence is checked lazily by
+ * each file read against the sandbox.
+ */
+export declare function createSandboxSkillHandle(access: SandboxAccess, id: string): SkillHandle;

package/dist/src/runtime/skills/sandbox-access.js

@@ -0,0 +1 @@
+import{WORKSPACE_ROOT}from"#runtime/workspace/types.js";const FRONTMATTER_PATTERN=/^---\r?\n[\s\S]*?\r?\n---\r?\n?/;function assertSafeSkillId(e){if(e.length===0||e.trim()!==e||e.startsWith(`.`)||e.includes(`/`)||e.includes(`\\`)||e.includes(`..`)||/^[A-Za-z]:/.test(e))throw Error(`Expected skill id to be a non-empty safe path segment without whitespace, separators, "." prefix, or "..".`)}async function loadSkillFromSandbox(e,n){assertSafeSkillId(n);let r=await requireSandboxSession(e),i=skillFilePath(n,`SKILL.md`),a=await r.readTextFile({path:i});if(a===null)throw Error(`No skill named "${n}" at ${i}.`);return a.replace(FRONTMATTER_PATTERN,``)}function createSandboxSkillHandle(e,t){return assertSafeSkillId(t),{name:t,file(n){assertSafeSkillRelativePath(n);let r=skillFilePath(t,n);return{async bytes(){let t=await(await requireSandboxSession(e)).readBinaryFile({path:r});if(t===null)throw Error(`Skill file not found: ${r}`);return t},async text(){let t=await(await requireSandboxSession(e)).readTextFile({path:r});if(t===null)throw Error(`Skill file not found: ${r}`);return t}}}}}function assertSafeSkillRelativePath(e){if(e.length===0||e.startsWith(`/`)||e.includes(`\\`)||e.split(`/`).some(e=>e.length===0||e===`.`||e===`..`))throw Error(`Expected skill file path to be a relative path inside the skill directory.`)}async function requireSandboxSession(e){let t=await e.get();if(t===null)throw Error(`The sandbox is not available in the current authored runtime context.`);return t}function skillFilePath(t,n){return`${WORKSPACE_ROOT}/skills/${t}/${n}`}export{assertSafeSkillId,createSandboxSkillHandle,loadSkillFromSandbox};

package/dist/src/runtime/subagents/registry.d.ts

@@ -0,0 +1,32 @@
+import type { JsonObject } from "#shared/json.js";
+import type { PreparedRuntimeDelegationTool } from "#runtime/sessions/turn.js";
+import type { ResolvedRuntimeDelegationNode } from "#runtime/types.js";
+/**
+ * One runtime-owned subagent tracked by the prepared registry.
+ */
+interface RuntimeRegisteredSubagent {
+    readonly definition: ResolvedRuntimeDelegationNode;
+    readonly prepared: PreparedRuntimeDelegationTool;
+}
+/**
+ * Runtime-owned registry that exposes resolved subagents as model-visible tools.
+ */
+export interface RuntimeSubagentRegistry {
+    readonly preparedTools: readonly PreparedRuntimeDelegationTool[];
+    readonly subagentsByName: ReadonlyMap<string, RuntimeRegisteredSubagent>;
+    readonly subagentsByNodeId: ReadonlyMap<string, RuntimeRegisteredSubagent>;
+}
+/**
+ * Stable JSON Schema lowered onto every subagent tool. Subagents always
+ * accept one free-form `message` string from the parent agent.
+ */
+export declare const SUBAGENT_TOOL_INPUT_SCHEMA: JsonObject;
+/**
+ * Builds the runtime-owned registry for the resolved subagents visible from one
+ * runtime agent node.
+ */
+export declare function createRuntimeSubagentRegistry(input: {
+    readonly reservedToolNames?: readonly string[];
+    readonly subagents: readonly ResolvedRuntimeDelegationNode[];
+}): RuntimeSubagentRegistry;
+export {};

package/dist/src/runtime/subagents/registry.js

@@ -0,0 +1 @@
+import{RuntimeRegistry,RuntimeRegistryError}from"#internal/runtime-registry.js";const SUBAGENT_TOOL_INPUT_SCHEMA=Object.freeze({type:`object`,properties:Object.freeze({message:Object.freeze({type:`string`,description:`The message to send to the subagent. Provide all context the subagent needs to complete the task; the subagent does not see the parent's history.`}),outputSchema:Object.freeze({type:`object`,description:`When provided, the subagent runs in task mode and must produce structured output matching this JSON Schema. The structured output becomes the tool result.`})}),required:Object.freeze([`message`]),additionalProperties:!1});function createRuntimeSubagentRegistry(t){let n=[],r=new RuntimeRegistry(`subagent`,t.reservedToolNames??[]),i=new Map;for(let e of t.subagents){let t={logicalPath:e.logicalPath,sourceId:e.sourceId};if(i.has(e.nodeId))throw new RuntimeRegistryError(`subagent`,`Found multiple runtime subagents mapped to node id "${e.nodeId}".`,{...t,entryName:e.name});let a=createPreparedRuntimeSubagentTool(e),o={definition:e,prepared:a};r.register(e.name,o,{location:t,duplicateMessage:`Found multiple subagents named "${e.name}". Subagent names must be unique at runtime.`,reservedMessage:`Subagent "${e.name}" collides with another runtime-visible tool name.`}),n.push(a),i.set(e.nodeId,o)}return{preparedTools:n,subagentsByName:r.asMap(),subagentsByNodeId:i}}function createPreparedRuntimeSubagentTool(e){return{description:e.description,inputSchema:SUBAGENT_TOOL_INPUT_SCHEMA,kind:e.kind,logicalPath:e.logicalPath,name:e.name,nodeId:e.nodeId,outputSchema:e.kind===`remote`?e.outputSchema:void 0,sourceId:e.sourceId}}export{SUBAGENT_TOOL_INPUT_SCHEMA,createRuntimeSubagentRegistry};

package/dist/src/runtime/tools/registry.d.ts

@@ -0,0 +1,30 @@
+import type { PreparedRuntimeAuthoredTool } from "#runtime/sessions/turn.js";
+import type { ResolvedToolDefinition } from "#runtime/types.js";
+/**
+ * One executable authored tool tracked by the runtime-owned registry.
+ */
+interface RuntimeRegisteredTool {
+    readonly definition: ResolvedToolDefinition;
+    readonly prepared: PreparedRuntimeAuthoredTool;
+}
+/**
+ * Runtime-owned tool registry used to expose authored tools to the harness and
+ * execute them later inside framework-owned steps.
+ */
+export interface RuntimeToolRegistry {
+    readonly preparedTools: readonly PreparedRuntimeAuthoredTool[];
+    readonly toolsByName: ReadonlyMap<string, RuntimeRegisteredTool>;
+}
+/**
+ * Builds the runtime-owned registry for one resolved authored agent.
+ */
+export declare function createRuntimeToolRegistry(definitions: {
+    readonly tools: readonly ResolvedToolDefinition[];
+}, input?: {
+    readonly reservedToolNames?: readonly string[];
+}): Promise<RuntimeToolRegistry>;
+/**
+ * Looks up one authored tool by name from the runtime-owned registry.
+ */
+export declare function findRegisteredRuntimeTool(registry: RuntimeToolRegistry, toolName: string): RuntimeRegisteredTool | null;
+export {};

package/dist/src/runtime/tools/registry.js

@@ -0,0 +1 @@
+import{RuntimeRegistry}from"#internal/runtime-registry.js";async function createRuntimeToolRegistry(t,n={}){let r=[],i=new RuntimeRegistry(`tool`,n.reservedToolNames??[]);for(let e of t.tools){let t=await createPreparedRuntimeTool(e);i.register(e.name,{definition:e,prepared:t},{location:{logicalPath:e.logicalPath,sourceId:e.sourceId},duplicateMessage:`Found multiple authored tools named "${e.name}". Tool names must be unique at runtime.`,reservedMessage:`Tool "${e.name}" collides with another runtime-visible tool name.`}),r.push(t)}return{preparedTools:r,toolsByName:i.asMap()}}function findRegisteredRuntimeTool(e,t){return e.toolsByName.get(t)??null}async function createPreparedRuntimeTool(e){return{description:e.description,inputSchema:e.inputSchema,kind:`authored-tool`,logicalPath:e.logicalPath,name:e.name,outputSchema:e.outputSchema,sourceId:e.sourceId}}export{createRuntimeToolRegistry,findRegisteredRuntimeTool};