eve 0.5.4 → 0.6.0-beta.3

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

@@ -0,0 +1,40 @@
+import type { StreamEventHook } from "../../public/definitions/hook.js";
+import type { ResolvedHookDefinition } from "../types.js";
+/**
+ * One ordered stream-event subscriber paired with its source slug.
+ *
+ * `eventType` is `"*"` for wildcard subscribers, otherwise the typed
+ * event name.
+ */
+interface RuntimeStreamEventHookEntry {
+    readonly slug: string;
+    readonly handler: StreamEventHook<unknown>;
+    readonly eventType: string;
+}
+/**
+ * Per-node runtime hook registry. Stream-event subscribers are split
+ * into typed buckets (keyed by event type) and a flat wildcard bucket
+ * so dispatch can iterate one typed bucket plus the wildcard bucket
+ * without scanning every entry.
+ */
+export interface RuntimeHookRegistry {
+    readonly streamEventsByType: ReadonlyMap<string, readonly RuntimeStreamEventHookEntry[]>;
+    readonly streamEventsWildcard: readonly RuntimeStreamEventHookEntry[];
+}
+/**
+ * Returns an empty registry. Used by tests that build a runtime bundle
+ * stub without authored hooks — production registries are constructed
+ * via {@link createRuntimeHookRegistry} from the resolved authored
+ * graph.
+ */
+export declare function createEmptyHookRegistry(): RuntimeHookRegistry;
+/**
+ * Builds the per-node runtime hook registry from an ordered list of
+ * resolved hook definitions.
+ *
+ * The caller is responsible for sorting the input — discover-time
+ * lexicographic ordering on full slug is preserved by the discovery
+ * helper, so callers usually pass `resolvedHooks` directly.
+ */
+export declare function createRuntimeHookRegistry(resolvedHooks: readonly ResolvedHookDefinition[]): RuntimeHookRegistry;
+export {};

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

@@ -0,0 +1 @@
+function createEmptyHookRegistry(){return{streamEventsByType:new Map,streamEventsWildcard:[]}}function createRuntimeHookRegistry(e){let t=new Map,n=[];for(let r of e)for(let[e,i]of Object.entries(r.events)){let a={slug:r.slug,handler:i,eventType:e};if(e===`*`)n.push(a);else{let n=t.get(e)??[];n.push(a),t.set(e,n)}}return{streamEventsByType:t,streamEventsWildcard:n}}export{createEmptyHookRegistry,createRuntimeHookRegistry};

package/dist/src/runtime/input/types.d.ts

@@ -0,0 +1,78 @@
+import { z } from "#compiled/zod/index.js";
+/**
+ * One selectable option presented to the user in an input request.
+ */
+export type InputOption = z.infer<typeof inputOptionSchema>;
+/**
+ * Zod schema for one input option.
+ *
+ * Includes descriptions because the `ask_question` tool input embeds this
+ * schema and exposes it directly to the model.
+ */
+export declare const inputOptionSchema: z.ZodObject<{
+    description: z.ZodOptional<z.ZodString>;
+    id: z.ZodString;
+    label: z.ZodString;
+    style: z.ZodOptional<z.ZodEnum<{
+        danger: "danger";
+        default: "default";
+        primary: "primary";
+    }>>;
+}, z.core.$strict>;
+/**
+ * Unified input request surfaced to the client when the agent needs
+ * user input before continuing.
+ *
+ * Tool approvals and questions share this shape. Approvals are requests
+ * with two options (`"approve"` / `"deny"`) and `display: "confirmation"`.
+ */
+export type InputRequest = z.infer<typeof inputRequestSchema>;
+/**
+ * Zod schema for one input request.
+ */
+export declare const inputRequestSchema: z.ZodObject<{
+    action: z.ZodObject<{
+        callId: z.ZodString;
+        input: z.ZodType<import("../../shared/json.js").JsonObject, unknown, z.core.$ZodTypeInternals<import("../../shared/json.js").JsonObject, unknown>>;
+        kind: z.ZodLiteral<"tool-call">;
+        toolName: z.ZodString;
+    }, z.core.$strict>;
+    allowFreeform: z.ZodOptional<z.ZodBoolean>;
+    display: z.ZodOptional<z.ZodEnum<{
+        confirmation: "confirmation";
+        select: "select";
+        text: "text";
+    }>>;
+    options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
+        id: z.ZodString;
+        label: z.ZodString;
+        style: z.ZodOptional<z.ZodEnum<{
+            danger: "danger";
+            default: "default";
+            primary: "primary";
+        }>>;
+    }, z.core.$strict>>>;
+    prompt: z.ZodString;
+    requestId: z.ZodString;
+}, z.core.$strict>;
+/**
+ * Unified input response submitted by the client for a pending request.
+ */
+export type InputResponse = z.infer<typeof inputResponseSchema>;
+/**
+ * Zod schema for one input response.
+ */
+export declare const inputResponseSchema: z.ZodObject<{
+    optionId: z.ZodOptional<z.ZodString>;
+    requestId: z.ZodString;
+    text: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * Returns true when a value matches the input request contract.
+ */
+export declare function isInputRequest(value: unknown): value is InputRequest;
+/**
+ * Returns true when a value matches the input response contract.
+ */
+export declare function isInputResponse(value: unknown): value is InputResponse;

package/dist/src/runtime/input/types.js

@@ -0,0 +1 @@
+import{z}from"#compiled/zod/index.js";import{runtimeToolCallActionRequestSchema}from"#runtime/actions/types.js";const inputOptionSchema=z.object({description:z.string().describe(`Optional additional context for this option.`).optional(),id:z.string().describe(`Stable identifier for the option.`),label:z.string().describe(`User-facing label for the option.`),style:z.enum([`primary`,`danger`,`default`]).describe(`Visual treatment hint for the option.`).optional()}).strict(),inputRequestSchema=z.object({action:runtimeToolCallActionRequestSchema,allowFreeform:z.boolean().describe(`Whether the user may answer with freeform text instead of selecting one of the provided options.`).optional(),display:z.enum([`confirmation`,`select`,`text`]).describe(`Rendering hint: the channel uses this to pick a UX treatment.`).optional(),options:z.array(inputOptionSchema).describe(`Selectable answer options to present to the user.`).optional(),prompt:z.string().describe(`The prompt to present to the user.`),requestId:z.string().describe(`Stable identifier for this request.`)}).strict(),inputResponseSchema=z.object({optionId:z.string().optional(),requestId:z.string(),text:z.string().optional()}).strict();function isInputRequest(e){return inputRequestSchema.safeParse(e).success}function isInputResponse(e){return inputResponseSchema.safeParse(e).success}export{inputOptionSchema,inputRequestSchema,inputResponseSchema,isInputRequest,isInputResponse};

package/dist/src/runtime/loaders/artifact-paths.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Runtime-owned compiled artifact paths for one application root.
+ */
+export interface RuntimeCompilerArtifactPaths {
+    readonly appRoot: string;
+    readonly compiledManifestPath: string;
+    readonly compileDirectoryPath: string;
+    readonly compileMetadataPath: string;
+    readonly diagnosticsPath: string;
+    readonly discoveryManifestPath: string;
+    readonly discoveryDirectoryPath: string;
+    readonly moduleMapPath: string;
+}
+/**
+ * Resolves the stable Eve artifact paths for one application root without
+ * depending on Node path helpers.
+ */
+export declare function resolveRuntimeCompilerArtifactPaths(appRoot: string): RuntimeCompilerArtifactPaths;

package/dist/src/runtime/loaders/artifact-paths.js

@@ -0,0 +1 @@
+function resolveRuntimeCompilerArtifactPaths(e){let t=normalizeFilesystemPath(e),n=`${t}/.eve/discovery`,r=`${t}/.eve/compile`;return{appRoot:t,compiledManifestPath:`${r}/compiled-agent-manifest.json`,compileDirectoryPath:r,compileMetadataPath:`${r}/compile-metadata.json`,diagnosticsPath:`${n}/diagnostics.json`,discoveryDirectoryPath:n,discoveryManifestPath:`${n}/agent-discovery-manifest.json`,moduleMapPath:`${r}/module-map.mjs`}}function normalizeFilesystemPath(e){let t=e.replaceAll(`\\`,`/`);return t===`/`?t:t.replace(/\/+$/,``)}export{resolveRuntimeCompilerArtifactPaths};

package/dist/src/runtime/loaders/bundled-artifacts.d.ts

@@ -0,0 +1,36 @@
+import type { CompileMetadata } from "#compiler/artifacts.js";
+import type { CompiledAgentManifest } from "#compiler/manifest.js";
+import type { CompiledModuleMap } from "#compiler/module-map.js";
+/**
+ * Bundled compiled artifacts installed by Nitro when authored runtime state is
+ * embedded directly into the server bundle.
+ */
+export interface BundledCompiledArtifacts {
+    manifest: CompiledAgentManifest;
+    metadata?: CompileMetadata;
+    moduleMap: CompiledModuleMap;
+}
+/**
+ * Input for running code against one isolated bundled compiled-artifact
+ * snapshot.
+ */
+export interface WithBundledCompiledArtifactsInput extends BundledCompiledArtifacts {
+    readonly sessionId?: string;
+}
+/**
+ * Installs one bundled compiled-artifact snapshot on the active runtime
+ * session. In production this writes to the process-default session at
+ * Nitro bootstrap time; inside a `withRuntimeSession` scope it targets the
+ * scoped session so tests cannot leak installations across each other.
+ */
+export declare function installBundledCompiledArtifacts(input: BundledCompiledArtifacts): void;
+/**
+ * Runs `fn` with bundled compiled artifacts installed on a fresh scoped
+ * runtime session, leaving the process-default runtime session untouched.
+ */
+export declare function withBundledCompiledArtifacts<T>(input: WithBundledCompiledArtifactsInput, fn: () => Promise<T> | T): Promise<T>;
+/**
+ * Reads the bundled compiled-artifact snapshot for the active runtime
+ * session, or `null` if none has been installed.
+ */
+export declare function readBundledCompiledArtifacts(): BundledCompiledArtifacts | null;

package/dist/src/runtime/loaders/bundled-artifacts.js

@@ -0,0 +1 @@
+import{createRuntimeSession,getActiveRuntimeSession,withRuntimeSession}from"#runtime/sessions/runtime-session.js";function installBundledCompiledArtifacts(e){getActiveRuntimeSession().compiledArtifacts={manifest:e.manifest,metadata:e.metadata,moduleMap:e.moduleMap}}async function withBundledCompiledArtifacts(t,n){return await withRuntimeSession(createRuntimeSession(t.sessionId??`bundled-compiled-artifacts`),async()=>(installBundledCompiledArtifacts(t),await n()))}function readBundledCompiledArtifacts(){return getActiveRuntimeSession().compiledArtifacts}export{installBundledCompiledArtifacts,readBundledCompiledArtifacts,withBundledCompiledArtifacts};

package/dist/src/runtime/loaders/compile-metadata.d.ts

@@ -0,0 +1,14 @@
+import { type CompileMetadata } from "#compiler/artifacts.js";
+import type { RuntimeCompiledArtifactsSource } from "#runtime/compiled-artifacts-source.js";
+/**
+ * Input for loading compile metadata from disk or bundled artifacts.
+ */
+interface LoadCompileMetadataInput {
+    readonly compiledArtifactsSource: RuntimeCompiledArtifactsSource;
+}
+/**
+ * Loads and validates compile metadata when it is available for the current
+ * artifact source.
+ */
+export declare function loadCompileMetadata(input: LoadCompileMetadataInput): Promise<CompileMetadata | null>;
+export {};

package/dist/src/runtime/loaders/compile-metadata.js

@@ -0,0 +1 @@
+import{z}from"#compiled/zod/index.js";import{COMPILE_METADATA_KIND,COMPILE_METADATA_VERSION}from"#compiler/artifacts.js";import{readBundledCompiledArtifacts}from"#runtime/loaders/bundled-artifacts.js";import{resolveRuntimeCompilerArtifactPaths}from"#runtime/loaders/artifact-paths.js";import{formatValidationError}from"#runtime/validation.js";const compileArtifactDigestSchema=z.object({path:z.string(),sha256:z.string()}).strict(),compileMetadataSchema=z.object({compile:z.object({moduleMap:compileArtifactDigestSchema}).strict(),discovery:z.object({diagnostics:compileArtifactDigestSchema,manifest:compileArtifactDigestSchema,sourceGraphHash:z.string(),summary:z.object({errors:z.number().finite(),warnings:z.number().finite()}).strict()}).strict(),generator:z.object({name:z.string(),version:z.string()}).strict(),kind:z.literal(COMPILE_METADATA_KIND),status:z.union([z.literal(`failed`),z.literal(`ready`)]),version:z.literal(COMPILE_METADATA_VERSION)}).strict();var LoadCompileMetadataError=class extends Error{metadataPath;constructor(e,t){super(e),this.name=`LoadCompileMetadataError`,t!==void 0&&(this.metadataPath=t)}};async function loadCompileMetadata(e){let t=e.compiledArtifactsSource.kind===`disk`?resolveRuntimeCompilerArtifactPaths(e.compiledArtifactsSource.appRoot).compileMetadataPath:void 0;if(t!==void 0){let{readFile:e}=await import(`node:fs/promises`),n;try{n=JSON.parse(await e(t,`utf8`))}catch(e){throw new LoadCompileMetadataError(formatLoadErrorMessage(e),t)}return parseCompileMetadata(n,t)}let n=readBundledCompiledArtifacts()?.metadata;return n===void 0?null:parseCompileMetadata(n,`bundled compile metadata`)}function parseCompileMetadata(e,t){let n=compileMetadataSchema.safeParse(e);if(!n.success)throw new LoadCompileMetadataError(`Expected "${t}" to contain valid Eve compile metadata. ${formatValidationError(n.error)}`,t);return n.data}function formatLoadErrorMessage(e){return e instanceof Error?e.message:`Unknown compile metadata load failure.`}export{loadCompileMetadata};

package/dist/src/runtime/loaders/manifest.d.ts

@@ -0,0 +1,21 @@
+import { type CompiledAgentManifest } from "#compiler/manifest.js";
+import type { RuntimeCompiledArtifactsSource } from "#runtime/compiled-artifacts-source.js";
+/**
+ * Input for loading the compiled source manifest from disk or the bundled
+ * runtime alias.
+ */
+interface LoadCompiledManifestInput {
+    readonly compiledArtifactsSource: RuntimeCompiledArtifactsSource;
+}
+/**
+ * Error raised when the compiled manifest cannot be loaded or validated.
+ */
+export declare class LoadCompiledManifestError extends Error {
+    readonly manifestPath?: string;
+    constructor(message: string, manifestPath?: string);
+}
+/**
+ * Loads and validates the compiler-owned source manifest.
+ */
+export declare function loadCompiledManifest(input: LoadCompiledManifestInput): Promise<CompiledAgentManifest>;
+export {};

package/dist/src/runtime/loaders/manifest.js

@@ -0,0 +1 @@
+import{compiledAgentManifestSchema}from"#compiler/manifest.js";import{readBundledCompiledArtifacts}from"#runtime/loaders/bundled-artifacts.js";import{resolveRuntimeCompilerArtifactPaths}from"#runtime/loaders/artifact-paths.js";import{formatValidationError}from"#runtime/validation.js";const BUNDLED_MANIFEST_SOURCE=`bundled compiled manifest`;var LoadCompiledManifestError=class extends Error{manifestPath;constructor(e,t){super(e),this.name=`LoadCompiledManifestError`,t!==void 0&&(this.manifestPath=t)}};async function loadCompiledManifest(e){let r=e.compiledArtifactsSource.kind===`disk`?resolveRuntimeCompilerArtifactPaths(e.compiledArtifactsSource.appRoot).compiledManifestPath:void 0;if(r!==void 0){let{readFile:e}=await import(`node:fs/promises`),t;try{t=JSON.parse(await e(r,`utf8`))}catch(e){throw new LoadCompiledManifestError(formatLoadErrorMessage(e),r)}return parseCompiledManifest(t,r)}let a=readBundledCompiledArtifacts();if(a!==null)return parseCompiledManifest(a.manifest,BUNDLED_MANIFEST_SOURCE);throw new LoadCompiledManifestError(`Compiled manifest is unavailable without an app root or bundled compiled artifacts.`,BUNDLED_MANIFEST_SOURCE)}function parseCompiledManifest(t,n){let i=compiledAgentManifestSchema.safeParse(t);if(!i.success)throw new LoadCompiledManifestError(`Expected "${n}" to contain a valid compiled Eve agent manifest. ${formatValidationError(i.error)}`,n);return i.data}function formatLoadErrorMessage(e){return e instanceof Error?e.message:`Unknown manifest load failure.`}export{LoadCompiledManifestError,loadCompiledManifest};

package/dist/src/runtime/loaders/module-map.d.ts

@@ -0,0 +1,21 @@
+import { type CompiledModuleMap } from "#compiler/module-map.js";
+import type { RuntimeCompiledArtifactsSource } from "#runtime/compiled-artifacts-source.js";
+/**
+ * Input for loading the compiled module map from disk or the bundled runtime
+ * alias.
+ */
+interface LoadCompiledModuleMapInput {
+    readonly compiledArtifactsSource: RuntimeCompiledArtifactsSource;
+}
+/**
+ * Error raised when the compiled module map cannot be loaded or validated.
+ */
+export declare class LoadCompiledModuleMapError extends Error {
+    readonly moduleMapPath?: string;
+    constructor(message: string, moduleMapPath?: string);
+}
+/**
+ * Loads and validates the compiler-owned module map.
+ */
+export declare function loadCompiledModuleMap(input: LoadCompiledModuleMapInput): Promise<CompiledModuleMap>;
+export {};

package/dist/src/runtime/loaders/module-map.js

@@ -0,0 +1 @@
+import{compiledModuleMapSchema}from"#compiler/module-map.js";import{readBundledCompiledArtifacts}from"#runtime/loaders/bundled-artifacts.js";import{resolveRuntimeCompilerArtifactPaths}from"#runtime/loaders/artifact-paths.js";import{formatValidationError}from"#runtime/validation.js";const BUNDLED_MODULE_MAP_SOURCE=`bundled compiled module map`;var LoadCompiledModuleMapError=class extends Error{moduleMapPath;constructor(e,t){super(e),this.name=`LoadCompiledModuleMapError`,t!==void 0&&(this.moduleMapPath=t)}};async function loadCompiledModuleMap(e){let r=e.compiledArtifactsSource.kind===`disk`?resolveRuntimeCompilerArtifactPaths(e.compiledArtifactsSource.appRoot).moduleMapPath:void 0;if(r!==void 0){let e=createFileImportSpecifier(r);try{let t=await import(e);return parseCompiledModuleMap(t.moduleMap??t.default,r)}catch(e){throw new LoadCompiledModuleMapError(formatLoadErrorMessage(e),r)}}let a=readBundledCompiledArtifacts();if(a!==null)return parseCompiledModuleMap(a.moduleMap,BUNDLED_MODULE_MAP_SOURCE);throw new LoadCompiledModuleMapError(`Compiled module map is unavailable without an app root or bundled compiled artifacts.`,BUNDLED_MODULE_MAP_SOURCE)}function parseCompiledModuleMap(t,n){let i=compiledModuleMapSchema.safeParse(t);if(!i.success)throw new LoadCompiledModuleMapError(`Expected "${n}" to export a valid compiled Eve module map. ${formatValidationError(i.error)}`,n);return i.data}function formatLoadErrorMessage(e){return e instanceof Error?e.message:`Unknown module-map load failure.`}function createFileImportSpecifier(e){let t=e.replaceAll(`\\`,`/`);return/^[A-Za-z]:\//.test(t)?`file:///${encodeURI(t)}`:t.startsWith(`/`)?`file://${encodeURI(t)}`:t}export{LoadCompiledModuleMapError,loadCompiledModuleMap};

package/dist/src/runtime/prompt/compose.d.ts

@@ -0,0 +1,19 @@
+import type { ResolvedConnectionDefinition, ResolvedInstructions, ResolvedSkillDefinition } from "#runtime/types.js";
+import type { WorkspaceRuntimeSpec } from "#runtime/workspace/types.js";
+/**
+ * Input for composing the base authored instructions prompt for one
+ * resolved agent.
+ */
+interface ComposeRuntimeBasePromptInput {
+    connections?: readonly ResolvedConnectionDefinition[];
+    instructions?: ResolvedInstructions;
+    skills?: readonly ResolvedSkillDefinition[];
+    toolsAvailable?: boolean;
+    workspaceSpec?: WorkspaceRuntimeSpec;
+}
+/**
+ * Composes the authored base prompt from the resolved instructions source
+ * without flattening skills into always-on instructions.
+ */
+export declare function composeRuntimeBasePrompt(input: ComposeRuntimeBasePromptInput): readonly string[];
+export {};

package/dist/src/runtime/prompt/compose.js

@@ -0,0 +1,2 @@
+import{formatAvailableSkillsSection}from"#execution/skills/instructions.js";import{createWorkspacePromptSection}from"#runtime/workspace/spec.js";import{formatConnectionsSection}from"#runtime/prompt/connections.js";function composeRuntimeBasePrompt(e){return[...createInstructionsPromptBlocks(e.instructions),...createWorkspacePromptBlocks(e.workspaceSpec),...e.toolsAvailable?[`Tool execution
+A single tool or subagent call runs as one serial action. If you call multiple independent tools or subagents in one response, Eve treats that batch as parallel work. Only batch work that is independent and does not rely on another call in the same response.`]:[],...createConnectionsPromptBlocks(e.connections),...createSkillsPromptBlocks(e.skills)]}function createInstructionsPromptBlocks(e){if(e===void 0)return[];let t=e.markdown.trim();return t.length===0?[]:[`Instructions (${e.name})\n${t}`]}function createWorkspacePromptBlocks(e){if(e===void 0)return[];let n=createWorkspacePromptSection(e);return n===void 0?[]:[n]}function createConnectionsPromptBlocks(e){return!e||e.length===0?[]:[formatConnectionsSection(e)]}function createSkillsPromptBlocks(t){if(!t||t.length===0)return[];let n=formatAvailableSkillsSection(t);return n===null?[]:[n]}export{composeRuntimeBasePrompt};

package/dist/src/runtime/prompt/connections.d.ts

@@ -0,0 +1,9 @@
+import type { ResolvedConnectionDefinition } from "#runtime/types.js";
+/**
+ * Formats the "Connections" system prompt section listing all available
+ * connections and their descriptions.
+ *
+ * Called at graph resolution time so the section is part of the turn
+ * agent's static instructions rather than injected per-step.
+ */
+export declare function formatConnectionsSection(connections: readonly ResolvedConnectionDefinition[]): string;

package/dist/src/runtime/prompt/connections.js

@@ -0,0 +1,2 @@
+function formatConnectionsSection(e){return[`## Connections`,``,`You have direct access to the following external services through connected MCP servers.`,`When the user's request relates to any of these services, use them instead of web search or general knowledge.`,``,`Available connections:`,...e.map(e=>`- ${e.connectionName}: ${e.description}`),``,`Use connection__search to discover specific tools within a connection. Discovered tools become directly callable by their qualified name (e.g. connection__linear__list_issues) in your next response.`].join(`
+`)}export{formatConnectionsSection};

package/dist/src/runtime/resolve-agent-graph.d.ts

@@ -0,0 +1,17 @@
+import type { CompiledAgentManifest } from "#compiler/manifest.js";
+import type { CompiledModuleMap } from "#compiler/module-map.js";
+import { type ResolvedAgentGraphBundle } from "#runtime/graph.js";
+/**
+ * Input for resolving the compiled authored manifest and flattened module graph
+ * into a runtime-owned recursive agent graph.
+ */
+interface ResolveRuntimeAgentGraphInput {
+    manifest: CompiledAgentManifest;
+    moduleMap: CompiledModuleMap;
+}
+/**
+ * Resolves the compiled authored manifest and flattened module graph into one
+ * runtime-owned bundle of agent nodes.
+ */
+export declare function resolveRuntimeAgentGraph(input: ResolveRuntimeAgentGraphInput): Promise<ResolvedAgentGraphBundle>;
+export {};

package/dist/src/runtime/resolve-agent-graph.js

@@ -0,0 +1 @@
+import{expectObjectRecord}from"#internal/authored-module.js";import{ROOT_COMPILED_AGENT_NODE_ID}from"#compiler/manifest.js";import{ROOT_RUNTIME_AGENT_NODE_ID}from"#runtime/graph.js";import{CODE_MODE_TOOL_NAME,WORKFLOW_TOOL_NAME}from"#shared/code-mode.js";import{createRuntimeToolRegistry}from"#runtime/tools/registry.js";import{createRuntimeSubagentRegistry}from"#runtime/subagents/registry.js";import{LOAD_SKILL_TOOL_NAME}from"#runtime/skills/fragment-context.js";import{getAllFrameworkChannelNames,getFrameworkChannelDefinitions}from"#runtime/framework-channels/index.js";import{resolveAgent}from"#runtime/resolve-agent.js";import{loadResolvedModuleExport}from"#runtime/resolve-helpers.js";import{createResolvedRuntimeTurnAgent}from"#runtime/agent/bootstrap.js";import{createConnectionSearchResolver}from"#runtime/framework-tools/connection-search-dynamic.js";import{getAllFrameworkToolNames,getFrameworkToolDefinitions}from"#runtime/framework-tools/index.js";import{createRuntimeHookRegistry}from"#runtime/hooks/registry.js";import{createRuntimeSandboxRegistry}from"#runtime/sandbox/registry.js";var ResolveRuntimeAgentGraphError=class extends Error{logicalPath;nodeId;sourceId;constructor(e,t={}){super(e),this.name=`ResolveRuntimeAgentGraphError`,t.logicalPath!==void 0&&(this.logicalPath=t.logicalPath),t.nodeId!==void 0&&(this.nodeId=t.nodeId),t.sourceId!==void 0&&(this.sourceId=t.sourceId)}};async function resolveRuntimeAgentGraph(e){let n=new Map,r=createChildNodeIdsByParentNodeId(e.manifest),i=new Map(e.manifest.subagents.map(e=>[e.nodeId,e]));return{nodesByNodeId:n,root:await resolveRuntimeAgentNode({childNodeIdsByParentNodeId:r,manifest:e.manifest,moduleMap:e.moduleMap,nodeId:ROOT_COMPILED_AGENT_NODE_ID,nodesByNodeId:n,subagentNodesById:i})}}async function resolveRuntimeAgentNode(e){let t=toRuntimeNodeId(e.nodeId);if(e.nodesByNodeId.has(t))throw new ResolveRuntimeAgentGraphError(`Found multiple runtime agent nodes for node id "${t}".`,{nodeId:t,sourceId:e.sourceId});let n=await resolveAgent({manifest:e.manifest,moduleMap:e.moduleMap,nodeId:e.nodeId}),a=n.connections.length>0,o=getFrameworkToolDefinitions({hasConnections:a}),s=new Set(o.map(e=>e.name)),c=getAllFrameworkToolNames(),l=new Set(n.tools.map(e=>e.name));for(let r of n.disabledFrameworkTools)if(!c.has(r))throw new ResolveRuntimeAgentGraphError(`agent/tools/${r}.ts exports disableTool() but "${r}" is not a framework tool. Rename the file to one of: ${[...c].sort().join(`, `)}.`,{nodeId:t,sourceId:e.sourceId});let u=new Set(n.disabledFrameworkTools),d=await createRuntimeToolRegistry({tools:[...o.filter(e=>!l.has(e.name)&&!u.has(e.name)),...n.tools]},{reservedToolNames:[CODE_MODE_TOOL_NAME,WORKFLOW_TOOL_NAME,...s.has(LOAD_SKILL_TOOL_NAME)||l.has(LOAD_SKILL_TOOL_NAME)?[]:[LOAD_SKILL_TOOL_NAME]]}),f=new Set(n.channels.map(e=>e.name)),p=getAllFrameworkChannelNames();for(let r of n.disabledFrameworkChannels)if(!p.has(r))throw new ResolveRuntimeAgentGraphError(`agent/channels/${r}.ts exports disableRoute() but "${r}" is not a framework channel. Rename the file to one of: ${[...p].sort().join(`, `)}.`,{nodeId:t,sourceId:e.sourceId});let m=new Set(n.disabledFrameworkChannels),h=[...getFrameworkChannelDefinitions().filter(e=>!f.has(e.name)&&!m.has(e.name)),...n.channels],g=createRuntimeSandboxRegistry({authoredSandbox:n.sandbox,workspaceResourceRoot:n.workspaceResourceRoot}),_=createRuntimeSubagentRegistry({reservedToolNames:[LOAD_SKILL_TOOL_NAME,...d.preparedTools.map(e=>e.name)],subagents:await resolveRuntimeSubagents({childNodeIdsByParentNodeId:e.childNodeIdsByParentNodeId,manifest:e.manifest,moduleMap:e.moduleMap,nodesByNodeId:e.nodesByNodeId,parentNodeId:e.nodeId,subagentNodesById:e.subagentNodesById})}),v=a?{...n,dynamicToolResolvers:[...n.dynamicToolResolvers,createConnectionSearchResolver()]}:n,y={agent:v,channels:h,hookRegistry:createRuntimeHookRegistry(v.hooks),nodeId:t,sandboxRegistry:g,sourceId:e.sourceId,subagentRegistry:_,toolRegistry:d,turnAgent:createResolvedRuntimeTurnAgent({agent:v,nodeId:t,tools:[...d.preparedTools,..._.preparedTools]})};return e.nodesByNodeId.set(t,y),y}async function resolveRuntimeSubagents(e){let t=[],n=e.childNodeIdsByParentNodeId.get(e.parentNodeId)??[];for(let r of n){let n=e.subagentNodesById.get(r);if(n===void 0)throw new ResolveRuntimeAgentGraphError(`Missing compiled subagent node "${r}" while resolving runtime subagents.`,{nodeId:toRuntimeNodeId(e.parentNodeId),sourceId:r});t.push(await resolveRuntimeSubagent({childNodeIdsByParentNodeId:e.childNodeIdsByParentNodeId,moduleMap:e.moduleMap,nodesByNodeId:e.nodesByNodeId,sourceRef:n,subagentNodesById:e.subagentNodesById}))}for(let n of e.manifest.remoteAgents)t.push(await resolveRuntimeRemoteAgent({moduleMap:e.moduleMap,nodeScopeId:e.parentNodeId,sourceRef:n}));return t}async function resolveRuntimeSubagent(e){let t={description:e.sourceRef.description,kind:`subagent`,logicalPath:e.sourceRef.logicalPath,name:e.sourceRef.name,nodeId:toRuntimeNodeId(e.sourceRef.nodeId),sourceId:e.sourceRef.sourceId,sourceKind:`module`};return await resolveRuntimeAgentNode({childNodeIdsByParentNodeId:e.childNodeIdsByParentNodeId,manifest:e.sourceRef.agent,moduleMap:e.moduleMap,nodeId:e.sourceRef.nodeId,nodesByNodeId:e.nodesByNodeId,sourceId:e.sourceRef.sourceId,subagentNodesById:e.subagentNodesById}),t}async function resolveRuntimeRemoteAgent(t){let n=expectObjectRecord(await loadResolvedModuleExport({definition:t.sourceRef,kindLabel:`remote agent`,moduleMap:t.moduleMap,nodeId:t.nodeScopeId}),`Expected remote agent source "${t.sourceRef.logicalPath}" to export an object.`),r={description:t.sourceRef.description,kind:`remote`,logicalPath:t.sourceRef.logicalPath,name:t.sourceRef.name,nodeId:toRuntimeNodeId(t.sourceRef.nodeId),outputSchema:t.sourceRef.outputSchema,path:t.sourceRef.path,sourceId:t.sourceRef.sourceId,sourceKind:`module`,url:t.sourceRef.url};typeof n.auth==`function`&&(r.auth=n.auth);let i=resolveRemoteAgentHeaders(n.headers);return i!==void 0&&(r.headers=i),r}function resolveRemoteAgentHeaders(e){if(e===void 0)return;if(typeof e==`function`)return e;if(typeof e!=`object`||!e||Array.isArray(e))return;let t={};for(let[n,r]of Object.entries(e))typeof r==`string`&&(t[n]=r);return t}function createChildNodeIdsByParentNodeId(e){let t=new Map;for(let n of e.subagentEdges){let e=t.get(n.parentNodeId);if(e===void 0){t.set(n.parentNodeId,[n.childNodeId]);continue}e.push(n.childNodeId)}return t}function toRuntimeNodeId(e){return e===ROOT_COMPILED_AGENT_NODE_ID?ROOT_RUNTIME_AGENT_NODE_ID:e}export{resolveRuntimeAgentGraph};

package/dist/src/runtime/resolve-agent.d.ts

@@ -0,0 +1,16 @@
+import type { CompiledAgentNodeManifest } from "#compiler/manifest.js";
+import type { CompiledModuleMap } from "#compiler/module-map.js";
+export { ResolveAgentError } from "#runtime/resolve-helpers.js";
+import type { ResolvedAgent } from "#runtime/types.js";
+/**
+ * Input for resolving one compiled authored agent into a runtime-owned model.
+ */
+export interface ResolveAgentInput {
+    manifest: CompiledAgentNodeManifest;
+    moduleMap: CompiledModuleMap;
+    nodeId?: string;
+}
+/**
+ * Resolves the core authored agent path from compiled artifacts.
+ */
+export declare function resolveAgent(input: ResolveAgentInput): Promise<ResolvedAgent>;

package/dist/src/runtime/resolve-agent.js

@@ -0,0 +1 @@
+import{ResolveAgentError,createResolvedModuleSourceRef}from"#runtime/resolve-helpers.js";import{resolveChannelDefinition}from"#runtime/resolve-channel.js";import{resolveConnectionDefinition}from"#runtime/resolve-connection.js";import{resolveHookDefinition}from"#runtime/resolve-hook.js";import{resolveSandboxDefinition}from"#runtime/resolve-sandbox.js";import{resolveDynamicInstructionsDefinition}from"#runtime/resolve-dynamic-instructions.js";import{resolveDynamicSkillDefinition}from"#runtime/resolve-dynamic-skill.js";import{resolveDynamicToolDefinition}from"#runtime/resolve-dynamic-tool.js";import{resolveToolDefinition}from"#runtime/resolve-tool.js";async function resolveAgent(e){let t=e.manifest.skills.map(e=>({...e,metadata:e.metadata===void 0?void 0:{...e.metadata}})),r=[],i=[];for(let t of e.manifest.channels){if(t.kind===`disabled`){i.push(t.name);continue}r.push(await resolveChannelDefinition(t,e.moduleMap,e.nodeId))}let a=await Promise.all(e.manifest.tools.map(t=>resolveToolDefinition(t,e.moduleMap,e.nodeId))),o=await Promise.all((e.manifest.dynamicInstructions??[]).map(t=>resolveDynamicInstructionsDefinition(t,e.moduleMap,e.nodeId))),s=await Promise.all((e.manifest.dynamicSkills??[]).map(t=>resolveDynamicSkillDefinition(t,e.moduleMap,e.nodeId))),c=await Promise.all(e.manifest.dynamicTools.map(t=>resolveDynamicToolDefinition(t,e.moduleMap,e.nodeId))),l=await Promise.all(e.manifest.hooks.map(t=>resolveHookDefinition(t,e.moduleMap,e.nodeId))),u=await Promise.all(e.manifest.connections.map(t=>resolveConnectionDefinition(t,e.moduleMap,e.nodeId))),d=e.manifest.sandbox===null?null:await resolveSandboxDefinition(e.manifest.sandbox,e.moduleMap,e.nodeId),f=createResolvedInstructions(e.manifest.instructions),p=e.manifest.workspaceResourceRoot,m={channels:r,config:createResolvedAgentConfig(e.manifest),connections:u,disabledFrameworkChannels:i,disabledFrameworkTools:[...e.manifest.disabledFrameworkTools],workflowEnabled:e.manifest.workflowEnabled,dynamicInstructionsResolvers:o,dynamicSkillResolvers:s,dynamicToolResolvers:c,hooks:l,metadata:{agentRoot:e.manifest.agentRoot,appRoot:e.manifest.appRoot,diagnosticsSummary:e.manifest.diagnosticsSummary},sandbox:d,workspaceResourceRoot:p,skills:t,tools:a,workspaceSpec:{rootEntries:[...p.rootEntries]}};return f===void 0?m:{...m,instructions:f}}function createResolvedInstructions(e){if(e!==void 0)return{name:e.name,logicalPath:e.logicalPath,markdown:e.markdown,sourceId:e.sourceId,sourceKind:e.sourceKind}}function createResolvedAgentConfig(e){let n={model:e.config.model.source===void 0?{id:e.config.model.id,contextWindowTokens:e.config.model.contextWindowTokens,providerOptions:e.config.model.providerOptions}:{contextWindowTokens:e.config.model.contextWindowTokens,id:e.config.model.id,providerOptions:e.config.model.providerOptions,source:{exportName:e.config.model.source.exportName,sourceKind:`module`,logicalPath:e.config.model.source.logicalPath,sourceId:e.config.model.source.sourceId}},name:e.config.name};if(e.config.compaction!==void 0){let t={};e.config.compaction.model!==void 0&&(t.model=e.config.compaction.model.source===void 0?{contextWindowTokens:e.config.compaction.model.contextWindowTokens,id:e.config.compaction.model.id,providerOptions:e.config.compaction.model.providerOptions}:{contextWindowTokens:e.config.compaction.model.contextWindowTokens,id:e.config.compaction.model.id,providerOptions:e.config.compaction.model.providerOptions,source:{exportName:e.config.compaction.model.source.exportName,sourceKind:`module`,logicalPath:e.config.compaction.model.source.logicalPath,sourceId:e.config.compaction.model.source.sourceId}}),e.config.compaction.thresholdPercent!==void 0&&(t.thresholdPercent=e.config.compaction.thresholdPercent),n.compaction=t}return e.config.experimental!==void 0&&(n.experimental={codeMode:e.config.experimental.codeMode}),e.config.outputSchema!==void 0&&(n.outputSchema=e.config.outputSchema),e.config.source!==void 0&&(n.source=createResolvedModuleSourceRef(e.config.source)),n}export{ResolveAgentError,resolveAgent};

package/dist/src/runtime/resolve-channel.d.ts

@@ -0,0 +1,17 @@
+import type { CompiledChannelDefinition } from "#compiler/manifest.js";
+import type { CompiledModuleMap } from "#compiler/module-map.js";
+import type { ResolvedChannelDefinition } from "#runtime/types.js";
+/**
+ * Resolves one compiled channel entry into a runtime-owned definition
+ * with a live `handler` (the per-route handler authored via `POST` /
+ * `GET` / etc. inside `defineChannel`) and the channel's `receive` hook
+ * if the author declared one.
+ *
+ * Every authored channel is a `CompiledChannel` from `defineChannel` —
+ * the bare `{ fetch, receive? }` Route shape is rejected by
+ * {@link normalizeChannelDefinition}. Framework-internal channels
+ * (the connection callback route, the `eve` session channel) build
+ * `ResolvedChannelDefinition` values directly and do not flow through
+ * this resolver.
+ */
+export declare function resolveChannelDefinition(definition: CompiledChannelDefinition, moduleMap: CompiledModuleMap, nodeId: string | undefined): Promise<ResolvedChannelDefinition>;

package/dist/src/runtime/resolve-channel.js

@@ -0,0 +1 @@
+import{setChannelInstrumentationKind}from"#channel/compiled-channel.js";import{toErrorMessage}from"#shared/errors.js";import{normalizeChannelDefinition}from"#internal/authored-definition/channel.js";import{ResolveAgentError,createResolvedModuleSourceRef,loadResolvedModuleExport}from"#runtime/resolve-helpers.js";import{HTTP_ADAPTER_KIND}from"#channel/http.js";import{isHttpRouteDefinition,isWebSocketRouteDefinition}from"#channel/routes.js";async function resolveChannelDefinition(r,i,a){try{let t=normalizeChannelDefinition(await loadResolvedModuleExport({definition:r,kindLabel:`channel`,moduleMap:i,nodeId:a}),`Expected the channel export "${r.exportName??`default`}" from "${r.logicalPath}" to match the public Eve shape.`),n=createResolvedModuleSourceRef({exportName:r.exportName,logicalPath:r.logicalPath,sourceId:r.sourceId}),o=t.routes.find(e=>e.method.toUpperCase()===r.method.toUpperCase()&&e.path===r.urlPath),s=`channel:${r.name}`;setChannelInstrumentationKind(t,s);let c=t.adapter;c&&c.kind!==HTTP_ADAPTER_KIND&&(c.kind=s);let l=resolveHttpRoute(r,o),u=resolveWebSocketRoute(r,o);return{name:r.name,method:r.method,urlPath:r.urlPath,fetch:async(e,t)=>l?l.handler(e,t):Response.json({error:`No matching route handler.`,ok:!1},{status:404}),handler:l?.handler,websocket:u?.handler,receive:t.receive,definition:t,adapter:c,...n}}catch(e){throw e instanceof ResolveAgentError?e:new ResolveAgentError(`Failed to attach the channel definition from "${r.logicalPath}": ${toErrorMessage(e)}`,{logicalPath:r.logicalPath,sourceId:r.sourceId})}}function resolveHttpRoute(e,t){if(!(t===void 0||e.method===`WEBSOCKET`||!isHttpRouteDefinition(t)))return t}function resolveWebSocketRoute(e,t){if(!(t===void 0||e.method!==`WEBSOCKET`||!isWebSocketRouteDefinition(t)))return t}export{resolveChannelDefinition};

package/dist/src/runtime/resolve-connection.d.ts

@@ -0,0 +1,15 @@
+import type { CompiledConnectionDefinition } from "#compiler/manifest.js";
+import type { CompiledModuleMap } from "#compiler/module-map.js";
+import type { ResolvedConnectionDefinition } from "#runtime/types.js";
+/**
+ * Resolves one compiled connection entry into a runtime-owned definition
+ * with the live `auth`, `headers`, and `tools` objects attached
+ * from the authored module.
+ *
+ * The compiled manifest only stores serializable metadata (`url`,
+ * `description`, `connectionName`). Live values (`auth`,
+ * `headers`, `tools`) are resolved at runtime by re-importing the
+ * authored module so they can reference ambient state (environment
+ * variables, `AlsContext`, etc.).
+ */
+export declare function resolveConnectionDefinition(definition: CompiledConnectionDefinition, moduleMap: CompiledModuleMap, nodeId: string | undefined): Promise<ResolvedConnectionDefinition>;

package/dist/src/runtime/resolve-connection.js

@@ -0,0 +1 @@
+import{expectObjectRecord}from"#internal/authored-module.js";import{toErrorMessage}from"#shared/errors.js";import{normalizeAuthorizationSpec}from"#runtime/connections/validate-authorization.js";import{ResolveAgentError,loadResolvedModuleExport}from"#runtime/resolve-helpers.js";import{registerDefinitionSource,stampDefinitionKey}from"#public/tool-result-narrowing.js";async function resolveConnectionDefinition(t,n,r){try{let i=expectObjectRecord(await loadResolvedModuleExport({definition:t,kindLabel:`connection`,moduleMap:n,nodeId:r}),`Expected the connection export "${t.exportName??`default`}" from "${t.logicalPath}" to return an object.`),a={kind:`connection`,logicalPath:t.logicalPath,name:t.connectionName},o=`connection-source:${t.sourceId}`;stampDefinitionKey(i,o),registerDefinitionSource(o,a),registerDefinitionSource(`connection:${t.url}`,a);let s=i.auth!==void 0,c=i.headers!==void 0,l=t.protocol===`openapi`?i.operations:i.tools,u={connectionName:t.connectionName,description:t.description,exportName:t.exportName,logicalPath:t.logicalPath,protocol:t.protocol,sourceId:t.sourceId,sourceKind:`module`,url:t.url};if(s)try{u.authorization=normalizeAuthorizationSpec(i.auth,`Connection "${t.connectionName}" at "${t.logicalPath}":`)}catch(e){throw new ResolveAgentError(toErrorMessage(e),{logicalPath:t.logicalPath,sourceId:t.sourceId})}return c&&(u.headers=i.headers),l!==void 0&&(u.tools=l),t.protocol===`openapi`&&i.spec!==void 0&&(u.spec=i.spec),typeof i.approval==`function`&&(u.approval=i.approval),u}catch(e){throw e instanceof ResolveAgentError?e:new ResolveAgentError(`Failed to resolve connection "${t.connectionName}" from "${t.logicalPath}": ${toErrorMessage(e)}`,{logicalPath:t.logicalPath,sourceId:t.sourceId})}}export{resolveConnectionDefinition};

package/dist/src/runtime/resolve-dynamic-instructions.d.ts

@@ -0,0 +1,4 @@
+import type { CompiledDynamicInstructionsDefinition } from "#compiler/manifest.js";
+import type { CompiledModuleMap } from "#compiler/module-map.js";
+import type { ResolvedDynamicInstructionsResolver } from "#runtime/types.js";
+export declare function resolveDynamicInstructionsDefinition(definition: CompiledDynamicInstructionsDefinition, moduleMap: CompiledModuleMap, nodeId: string | undefined): Promise<ResolvedDynamicInstructionsResolver>;

package/dist/src/runtime/resolve-dynamic-instructions.js

@@ -0,0 +1 @@
+import{expectFunction,expectObjectRecord}from"#internal/authored-module.js";import{toErrorMessage}from"#shared/errors.js";import{ResolveAgentError,loadResolvedModuleExport}from"#runtime/resolve-helpers.js";async function resolveDynamicInstructionsDefinition(i,a,o){try{let n=expectObjectRecord(expectObjectRecord(await loadResolvedModuleExport({definition:i,kindLabel:`dynamic-instructions`,moduleMap:a,nodeId:o}),describe(i,`to return an object`)).events,describe(i,`to provide an events object`)),r={};for(let t of i.eventNames)r[t]=expectFunction(n[t],describe(i,`to provide a handler for event "${t}"`));return{eventNames:[...i.eventNames],events:r,exportName:i.exportName,logicalPath:i.logicalPath,slug:i.slug,sourceId:i.sourceId,sourceKind:`module`}}catch(e){throw e instanceof ResolveAgentError?e:new ResolveAgentError(`Failed to resolve dynamic instructions from "${i.logicalPath}": ${toErrorMessage(e)}`,{logicalPath:i.logicalPath,sourceId:i.sourceId})}}function describe(e,t){return`Expected the dynamic instructions export "${e.exportName??`default`}" from "${e.logicalPath}" ${t}.`}export{resolveDynamicInstructionsDefinition};

package/dist/src/runtime/resolve-dynamic-skill.d.ts

@@ -0,0 +1,8 @@
+import type { CompiledDynamicSkillDefinition } from "#compiler/manifest.js";
+import type { CompiledModuleMap } from "#compiler/module-map.js";
+import type { ResolvedDynamicSkillResolver } from "#runtime/types.js";
+/**
+ * Resolves one compiled dynamic skill entry into a runtime-owned resolver
+ * with live event handler functions reattached from the authored module.
+ */
+export declare function resolveDynamicSkillDefinition(definition: CompiledDynamicSkillDefinition, moduleMap: CompiledModuleMap, nodeId: string | undefined): Promise<ResolvedDynamicSkillResolver>;

package/dist/src/runtime/resolve-dynamic-skill.js

@@ -0,0 +1 @@
+import{expectFunction,expectObjectRecord}from"#internal/authored-module.js";import{toErrorMessage}from"#shared/errors.js";import{ResolveAgentError,loadResolvedModuleExport}from"#runtime/resolve-helpers.js";async function resolveDynamicSkillDefinition(i,a,o){try{let n=expectObjectRecord(expectObjectRecord(await loadResolvedModuleExport({definition:i,kindLabel:`dynamic-skill`,moduleMap:a,nodeId:o}),describe(i,`to return an object`)).events,describe(i,`to provide an events object`)),r={};for(let t of i.eventNames)r[t]=expectFunction(n[t],describe(i,`to provide a handler for event "${t}"`));return{eventNames:[...i.eventNames],events:r,exportName:i.exportName,logicalPath:i.logicalPath,slug:i.slug,sourceId:i.sourceId,sourceKind:`module`}}catch(e){throw e instanceof ResolveAgentError?e:new ResolveAgentError(`Failed to resolve dynamic skill from "${i.logicalPath}": ${toErrorMessage(e)}`,{logicalPath:i.logicalPath,sourceId:i.sourceId})}}function describe(e,t){return`Expected the dynamic skill export "${e.exportName??`default`}" from "${e.logicalPath}" ${t}.`}export{resolveDynamicSkillDefinition};

package/dist/src/runtime/resolve-dynamic-tool.d.ts

@@ -0,0 +1,12 @@
+import type { CompiledDynamicToolDefinition } from "#compiler/manifest.js";
+import type { CompiledModuleMap } from "#compiler/module-map.js";
+import type { ResolvedDynamicToolResolver } from "#runtime/types.js";
+/**
+ * Resolves one compiled dynamic tool entry into a runtime-owned resolver
+ * with live event handler functions reattached from the authored module.
+ *
+ * The resolver's `events` map is validated: each declared event name must
+ * map to a function. The handlers are not called here — they run later at
+ * the lifecycle point indicated by each event name.
+ */
+export declare function resolveDynamicToolDefinition(definition: CompiledDynamicToolDefinition, moduleMap: CompiledModuleMap, nodeId: string | undefined): Promise<ResolvedDynamicToolResolver>;

package/dist/src/runtime/resolve-dynamic-tool.js

@@ -0,0 +1 @@
+import{expectFunction,expectObjectRecord}from"#internal/authored-module.js";import{toErrorMessage}from"#shared/errors.js";import{ResolveAgentError,loadResolvedModuleExport}from"#runtime/resolve-helpers.js";import{registerDefinitionSource,stampDefinitionKey}from"#public/tool-result-narrowing.js";async function resolveDynamicToolDefinition(i,a,o){try{let n=expectObjectRecord(await loadResolvedModuleExport({definition:i,kindLabel:`dynamic-tool`,moduleMap:a,nodeId:o}),describe(i,`to return an object`)),r=expectObjectRecord(n.events,describe(i,`to provide an events object`)),s={};for(let t of i.eventNames)s[t]=expectFunction(r[t],describe(i,`to provide a handler for event "${t}"`));let c=`dynamic-tool-source:${i.sourceId}`;return stampDefinitionKey(n,c),registerDefinitionSource(c,{kind:`tool`,logicalPath:i.logicalPath,name:i.slug}),{eventNames:[...i.eventNames],events:s,exportName:i.exportName,logicalPath:i.logicalPath,slug:i.slug,sourceId:i.sourceId,sourceKind:`module`}}catch(e){throw e instanceof ResolveAgentError?e:new ResolveAgentError(`Failed to resolve dynamic tool from "${i.logicalPath}": ${toErrorMessage(e)}`,{logicalPath:i.logicalPath,sourceId:i.sourceId})}}function describe(e,t){return`Expected the dynamic tool export "${e.exportName??`default`}" from "${e.logicalPath}" ${t}.`}export{resolveDynamicToolDefinition};

package/dist/src/runtime/resolve-helpers.d.ts

@@ -0,0 +1,43 @@
+import type { CompiledModuleMap } from "#compiler/module-map.js";
+import type { ResolvedModuleSourceRef } from "#runtime/types.js";
+/**
+ * Error raised when compiled artifacts cannot be hydrated into a runtime-owned
+ * authored agent model.
+ */
+export declare class ResolveAgentError extends Error {
+    readonly logicalPath?: string;
+    readonly sourceId?: string;
+    constructor(message: string, input?: {
+        logicalPath?: string;
+        sourceId?: string;
+    });
+}
+/**
+ * Builds the resolved source ref block shared by every per-primitive
+ * resolver that targets a `module` source.
+ */
+export declare function createResolvedModuleSourceRef(sourceRef: {
+    readonly exportName?: string;
+    readonly logicalPath: string;
+    readonly sourceId: string;
+}): ResolvedModuleSourceRef;
+/**
+ * Looks up a compiled module namespace for one resolved agent node and
+ * returns the materialized exported value referenced by the given
+ * compiled definition.
+ *
+ * Throws {@link ResolveAgentError} when the module map does not contain
+ * the expected source — every per-primitive resolver shares this
+ * lookup, so the helper centralizes the error message and avoids
+ * duplicating ~25 lines of boilerplate per resolver.
+ */
+export declare function loadResolvedModuleExport(input: {
+    readonly definition: {
+        readonly exportName?: string;
+        readonly logicalPath: string;
+        readonly sourceId: string;
+    };
+    readonly kindLabel: string;
+    readonly moduleMap: CompiledModuleMap;
+    readonly nodeId: string | undefined;
+}): Promise<unknown>;

package/dist/src/runtime/resolve-helpers.js

@@ -0,0 +1 @@
+import{expectObjectRecord,getAuthoredModuleExport,materializeAuthoredModuleExport}from"#internal/authored-module.js";import{ROOT_COMPILED_AGENT_NODE_ID}from"#compiler/manifest.js";var ResolveAgentError=class extends Error{logicalPath;sourceId;constructor(e,t={}){super(e),this.name=`ResolveAgentError`,t.logicalPath!==void 0&&(this.logicalPath=t.logicalPath),t.sourceId!==void 0&&(this.sourceId=t.sourceId)}};function createResolvedModuleSourceRef(e){return{exportName:e.exportName,logicalPath:e.logicalPath,sourceId:e.sourceId,sourceKind:`module`}}async function loadResolvedModuleExport(n){let r=n.nodeId??ROOT_COMPILED_AGENT_NODE_ID,i=n.moduleMap.nodes[r]?.modules[n.definition.sourceId];if(i===void 0)throw new ResolveAgentError(`Missing compiled module namespace for ${n.kindLabel} source "${n.definition.sourceId}" in node "${r}".`,{logicalPath:n.definition.logicalPath,sourceId:n.definition.sourceId});return await materializeAuthoredModuleExport(getAuthoredModuleExport(expectObjectRecord(i,`Missing compiled module namespace for ${n.kindLabel} source "${n.definition.sourceId}" in node "${r}".`),{exportName:n.definition.exportName,logicalPath:n.definition.logicalPath}))}export{ResolveAgentError,createResolvedModuleSourceRef,loadResolvedModuleExport};

package/dist/src/runtime/resolve-hook.d.ts

@@ -0,0 +1,13 @@
+import type { CompiledHookDefinition } from "../compiler/manifest.js";
+import type { CompiledModuleMap } from "../compiler/module-map.js";
+import type { ResolvedHookDefinition } from "./types.js";
+/**
+ * Resolves one compiled authored hook into a runtime-owned definition
+ * with live handlers reattached from the authored module.
+ *
+ * The authored shape is `{ events?: { ... } }`.
+ * Each declared handler must be a function. Any other shape raises a
+ * {@link ResolveAgentError} so typos surface at resolve time instead of
+ * at first dispatch call.
+ */
+export declare function resolveHookDefinition(definition: CompiledHookDefinition, moduleMap: CompiledModuleMap, nodeId: string | undefined): Promise<ResolvedHookDefinition>;

package/dist/src/runtime/resolve-hook.js

@@ -0,0 +1 @@
+import{expectFunction,expectObjectRecord}from"../internal/authored-module.js";import{ResolveAgentError,loadResolvedModuleExport}from"./resolve-helpers.js";import{toErrorMessage}from"../shared/errors.js";async function resolveHookDefinition(a,o,s){try{let n=expectObjectRecord(await loadResolvedModuleExport({definition:a,kindLabel:`hook`,moduleMap:o,nodeId:s}),describe(a,`to return an object`)),i={},c=n.events;if(c!==void 0){let n=expectObjectRecord(c,describe(a,"to expose `events` as an object"));for(let[t,r]of Object.entries(n))r!==void 0&&(i[t]=expectFunction(r,describe(a,`to provide a function for "events.${t}"`)))}return{events:i,exportName:a.exportName,logicalPath:a.logicalPath,slug:a.slug,sourceId:a.sourceId,sourceKind:`module`}}catch(e){throw e instanceof ResolveAgentError?e:new ResolveAgentError(`Failed to attach hook handlers from "${a.logicalPath}": ${toErrorMessage(e)}`,{logicalPath:a.logicalPath,sourceId:a.sourceId})}}function describe(e,t){return`Expected the hook export "${e.exportName??`default`}" from "${e.logicalPath}" ${t}.`}export{resolveHookDefinition};

package/dist/src/runtime/resolve-sandbox.d.ts

@@ -0,0 +1,13 @@
+import type { CompiledSandboxDefinition } from "#compiler/manifest.js";
+import type { CompiledModuleMap } from "#compiler/module-map.js";
+import type { ResolvedSandboxDefinition } from "#runtime/types.js";
+/**
+ * Resolves one compiled sandbox entry into a runtime-owned definition
+ * with live `backend`, `bootstrap`, and `onSession` lifecycle handlers
+ * (when present) attached from the authored module.
+ *
+ * If the authored module omits `backend`, the resolver substitutes
+ * {@link defaultBackend} so the rest of the runtime can rely on a
+ * non-null backend value.
+ */
+export declare function resolveSandboxDefinition(definition: CompiledSandboxDefinition, moduleMap: CompiledModuleMap, nodeId: string | undefined): Promise<ResolvedSandboxDefinition>;

package/dist/src/runtime/resolve-sandbox.js

@@ -0,0 +1 @@
+import{expectObjectRecord}from"#internal/authored-module.js";import{toErrorMessage}from"#shared/errors.js";import{lazyBackend}from"#execution/sandbox/lazy-backend.js";import{ResolveAgentError,loadResolvedModuleExport}from"#runtime/resolve-helpers.js";import{defaultBackend}from"#public/sandbox/backends/default.js";async function resolveSandboxDefinition(n,i,a){try{let t=expectObjectRecord(await loadResolvedModuleExport({definition:n,kindLabel:`sandbox`,moduleMap:i,nodeId:a}),`Expected the sandbox export "${n.exportName??`default`}" from "${n.logicalPath}" to return an object.`);return{backend:resolveBackend(t.backend,n.logicalPath),bootstrap:t.bootstrap,description:n.description,exportName:n.exportName,logicalPath:n.logicalPath,onSession:t.onSession,revalidationKey:n.revalidationKey,sourceHash:n.sourceHash,sourceId:n.sourceId,sourceKind:`module`}}catch(e){throw e instanceof ResolveAgentError?e:new ResolveAgentError(`Failed to attach the sandbox lifecycle handlers from "${n.logicalPath}": ${toErrorMessage(e)}`,{logicalPath:n.logicalPath,sourceId:n.sourceId})}}function resolveBackend(e,t){if(e===void 0)return defaultBackend();if(typeof e==`function`)return lazyBackend(e);if(typeof e!=`object`||!e)throw new ResolveAgentError(`Sandbox "${t}" exposed a non-object "backend" field. Use vercelBackend(), localBackend(), another factory that returns a SandboxBackend value, or a zero-arg callback returning one.`,{logicalPath:t});let r=e;if(typeof r.name!=`string`||r.name.length===0)throw new ResolveAgentError(`Sandbox "${t}" backend is missing a non-empty string "name" identifier.`,{logicalPath:t});if(typeof r.create!=`function`)throw new ResolveAgentError(`Sandbox "${t}" backend is missing a "create" function.`,{logicalPath:t});return r}export{resolveSandboxDefinition};

package/dist/src/runtime/resolve-tool.d.ts

@@ -0,0 +1,14 @@
+import type { CompiledToolDefinition } from "#compiler/manifest.js";
+import type { CompiledModuleMap } from "#compiler/module-map.js";
+import type { ResolvedToolDefinition } from "#runtime/types.js";
+/**
+ * Resolves one compiled authored tool into a runtime-owned definition
+ * with live callbacks reattached from the authored module.
+ *
+ * Optional hooks (`onCompact`, `needsApproval`,
+ * plus an optional Standard Schema `inputSchema`) are extracted when
+ * declared and validated to have the expected shape; any type mismatch
+ * raises a {@link ResolveAgentError} so typos surface at resolve time
+ * instead of at first tool call.
+ */
+export declare function resolveToolDefinition(definition: CompiledToolDefinition, moduleMap: CompiledModuleMap, nodeId: string | undefined): Promise<ResolvedToolDefinition>;

package/dist/src/runtime/resolve-tool.js

@@ -0,0 +1 @@
+import{expectFunction,expectObjectRecord}from"#internal/authored-module.js";import{toErrorMessage}from"#shared/errors.js";import{normalizeAuthorizationSpec}from"#runtime/connections/validate-authorization.js";import{ResolveAgentError,loadResolvedModuleExport}from"#runtime/resolve-helpers.js";import{registerDefinitionSource,stampDefinitionKey}from"#public/tool-result-narrowing.js";async function resolveToolDefinition(r,a,o){try{let n=expectObjectRecord(await loadResolvedModuleExport({definition:r,kindLabel:`tool`,moduleMap:a,nodeId:o}),describe(r,`to return an object`)),i={kind:`tool`,logicalPath:r.logicalPath,name:r.name},s=`tool-source:${r.sourceId}`;stampDefinitionKey(n,s),registerDefinitionSource(s,i),registerDefinitionSource(`tool:${n.description}`,i);let c=expectFunction(n.execute,describe(r,`to provide an execute function`));return{description:r.description,execute:c,exportName:r.exportName,inputSchema:r.inputSchema,logicalPath:r.logicalPath,name:r.name,outputSchema:r.outputSchema,sourceId:r.sourceId,sourceKind:`module`,...extractOptionalHooks(n,r)}}catch(e){throw e instanceof ResolveAgentError?e:new ResolveAgentError(`Failed to attach the tool execute function from "${r.logicalPath}": ${toErrorMessage(e)}`,{logicalPath:r.logicalPath,sourceId:r.sourceId})}}function extractOptionalHooks(t,n){let i={};return t.onCompact!==void 0&&(i.onCompact=expectFunction(t.onCompact,describe(n,`to provide an onCompact function`))),t.needsApproval!==void 0&&(i.needsApproval=expectFunction(t.needsApproval,describe(n,`to provide a needsApproval function`))),t.toModelOutput!==void 0&&(i.toModelOutput=expectFunction(t.toModelOutput,describe(n,`to provide a toModelOutput function`))),t.inputSchema!==void 0&&isFlexibleSchema(t.inputSchema)&&(i.inputStandardSchema=t.inputSchema),t.outputSchema!==void 0&&isFlexibleSchema(t.outputSchema)&&(i.outputStandardSchema=t.outputSchema),t.auth!==void 0&&(i.auth=normalizeAuthorizationSpec(t.auth,`${describe(n,`to provide a valid auth object`)}:`)),i}function describe(e,t){return`Expected the tool export "${e.exportName??`default`}" from "${e.logicalPath}" ${t}.`}function isFlexibleSchema(e){return typeof e==`object`&&!!e&&`~standard`in e&&typeof e[`~standard`]==`object`}export{resolveToolDefinition};