eve 0.5.4 → 0.6.0-beta.3

package/dist/src/compiler/normalize-agent-config.d.ts

@@ -0,0 +1,18 @@
+import type { AgentSourceManifest } from "#discover/manifest.js";
+import type { CompiledAgentDefinition } from "#compiler/manifest.js";
+import { type ManifestCompileContext } from "#compiler/normalize-helpers.js";
+/**
+ * Error raised when an agent node has no authored `agent.ts` config module.
+ *
+ * Surfaced as a distinct type so inspection-style callers (e.g. `eve info`)
+ * can degrade gracefully when invoked outside a real Eve application.
+ */
+export declare class MissingAgentConfigModuleError extends Error {
+    readonly agentId: string;
+    constructor(agentId: string);
+}
+/**
+ * Compiles the agent-level configuration (model, compaction, build,
+ * workspace) for one authored agent node.
+ */
+export declare function compileAgentConfig(manifest: AgentSourceManifest, context: ManifestCompileContext): Promise<CompiledAgentDefinition>;

package/dist/src/compiler/normalize-agent-config.js

@@ -0,0 +1 @@
+import{isAbsolute,join,relative,resolve}from"node:path";import{toErrorMessage}from"#shared/errors.js";import{normalizeJsonSchemaDefinition}from"#shared/json-schema.js";import{normalizeLogicalPath}from"#discover/filesystem.js";import{normalizeAgentDefinition}from"#internal/authored-definition/core.js";import{formatLanguageModelGatewayId}from"#internal/runtime-model.js";import{parseJsonObject}from"#shared/json.js";import{loadModuleBackedDefinition}from"#compiler/normalize-helpers.js";var MissingAgentConfigModuleError=class extends Error{agentId;constructor(e){super(`Agent "${e}" does not have an agent.ts config module. The "model" field is required.`),this.name=`MissingAgentConfigModuleError`,this.agentId=e}};async function compileAgentConfig(e,t){if(e.configModule===void 0)throw new MissingAgentConfigModuleError(e.agentId);let n=formatAgentConfigModulePath(e,e.configModule),r=normalizeAgentDefinition(await loadModuleBackedDefinition({agentRoot:e.agentRoot,displayPath:n,kind:`agent config`,source:e.configModule}),`Expected the agent config export "${e.configModule.exportName??`default`}" from "${n}" to match the public Eve shape.`),i=await normalizeAuthoredModelReference({modelCatalog:t.modelCatalog,purpose:`the primary compaction trigger model`,contextWindowTokens:r.modelContextWindowTokens,providerOptions:r.modelOptions?.providerOptions,source:e.configModule,sourcePath:n,value:r.model}),a={},o={compaction:a,model:i,name:e.agentId};return r.description!==void 0&&(o.description=r.description),r.experimental?.codeMode!==void 0&&(o.experimental={codeMode:r.experimental.codeMode}),r.build!==void 0&&(o.build={externalDependencies:r.build.externalDependencies===void 0?void 0:[...r.build.externalDependencies]}),r.outputSchema!==void 0&&(o.outputSchema=normalizeJsonSchemaDefinition(r.outputSchema,`output`)),o.source={exportName:e.configModule.exportName,sourceKind:`module`,logicalPath:e.configModule.logicalPath,sourceId:e.configModule.sourceId},r.compaction?.model!==void 0&&(a.model=await normalizeAuthoredModelReference({modelCatalog:t.modelCatalog,purpose:`the compaction summary model`,contextWindowTokens:r.compaction.modelContextWindowTokens,providerOptions:r.modelOptions?.providerOptions,source:e.configModule,sourcePath:n,value:r.compaction.model})),r.compaction?.thresholdPercent!==void 0&&(a.thresholdPercent=r.compaction.thresholdPercent),o}async function normalizeAuthoredModelReference(e){if(typeof e.value==`string`)return await withCompiledRuntimeModelLimits({id:formatLanguageModelGatewayId(e.value),providerOptions:parseProviderOptionsRecord(e.providerOptions)},e);let t=e.source;if(t===void 0)throw Error(`Expected ${e.purpose} to provide a valid AI SDK language model reference.`);let n=e.value,r=n.specificationVersion;if(r!==`v2`&&r!==`v3`&&r!==`v4`||typeof n.provider!=`string`||typeof n.modelId!=`string`||typeof n.doGenerate!=`function`||typeof n.doStream!=`function`)throw Error(`Expected the authored agent config export "${t.exportName??`default`}" from "${e.sourcePath??t.logicalPath}" to provide a valid AI SDK language model.`);let i={id:formatLanguageModelGatewayId(n),source:{exportName:t.exportName,sourceKind:`module`,logicalPath:t.logicalPath,sourceId:t.sourceId},providerOptions:parseProviderOptionsRecord(e.providerOptions)};if(e.contextWindowTokens===void 0){let t=await e.modelCatalog.getByProviderModelId(n.provider,n.modelId);if(t)return{...i,id:t.slug,contextWindowTokens:t.limits.contextWindowTokens}}return await withCompiledRuntimeModelLimits(i,e)}function formatAgentConfigModulePath(e,r){let i=join(e.agentRoot,r.logicalPath);return normalizeLogicalPath(relative(resolveTopLevelAgentRoot(e),i))}function resolveTopLevelAgentRoot(e){let t=resolve(e.appRoot),n=resolve(t,`agent`);return isPathInsideOrEqual(n,resolve(e.agentRoot))?n:t}function isPathInsideOrEqual(t,r){let i=relative(t,r);return i===``||!i.startsWith(`..`)&&!isAbsolute(i)}async function withCompiledRuntimeModelLimits(e,t){if(t.contextWindowTokens!==void 0)return{...e,contextWindowTokens:t.contextWindowTokens};let n;try{n=await t.modelCatalog.getModelLimits(e.id)}catch(n){throw Error(`Failed to load AI Gateway model metadata for ${t.purpose} "${e.id}". ${toErrorMessage(n)}`)}if(n===null)throw Error(`Cannot compile agent compaction because ${t.purpose} "${e.id}" does not have known AI Gateway context window metadata.`);return{...e,contextWindowTokens:n.contextWindowTokens}}function parseProviderOptionsRecord(e){if(e===void 0)return;let t={};for(let[n,r]of Object.entries(e))t[n]=parseJsonObject(r);return t}export{MissingAgentConfigModuleError,compileAgentConfig};

package/dist/src/compiler/normalize-channel.d.ts

@@ -0,0 +1,16 @@
+import type { ChannelSourceRef } from "#discover/manifest.js";
+import type { CompiledChannelEntry } from "#compiler/manifest.js";
+/**
+ * Compiles one authored channel module into the normalized channel
+ * entries stored on the compiled agent manifest.
+ *
+ * Recognizes the `disableRoute()` sentinel and emits a `disabled`
+ * entry so the runtime can short-circuit channel registration without
+ * losing the source path for diagnostics.
+ *
+ * Authored channels are always `CompiledChannel` values (from
+ * `defineChannel`). Each route in the channel's `routes` array becomes
+ * a separate compiled channel entry. The channel name is derived from
+ * the filesystem path; the URL path comes from the route's `path` field.
+ */
+export declare function compileChannelDefinition(agentRoot: string, source: ChannelSourceRef): Promise<CompiledChannelEntry | readonly CompiledChannelEntry[]>;

package/dist/src/compiler/normalize-channel.js

@@ -0,0 +1 @@
+import{stripLogicalPathExtension}from"#discover/filesystem.js";import{loadModuleBackedDefinition}from"#compiler/normalize-helpers.js";import{normalizeChannelDefinition}from"#internal/authored-definition/channel.js";import{isDisabledRouteSentinel}from"#public/definitions/channel.js";async function compileChannelDefinition(n,r){let i=await loadModuleBackedDefinition({agentRoot:n,kind:`channel`,source:r}),a=stripLogicalPathExtension(r.logicalPath).replace(/^channels\//,``);if(isDisabledRouteSentinel(i))return{kind:`disabled`,name:a,logicalPath:r.logicalPath};let o=normalizeChannelDefinition(i,`Expected the channel export "${r.exportName??`default`}" from "${r.logicalPath}" to match the public Eve shape.`);return o.routes.map(e=>({kind:`channel`,name:a,logicalPath:r.logicalPath,method:e.method.toUpperCase(),urlPath:e.path,sourceId:r.sourceId,sourceKind:`module`,exportName:r.exportName,adapterKind:extractAdapterKind(o.adapter)}))}function extractAdapterKind(e){if(typeof e!=`object`||!e)return;let t=e.kind;return typeof t==`string`&&t.length>0?t:void 0}export{compileChannelDefinition};

package/dist/src/compiler/normalize-connection.d.ts

@@ -0,0 +1,21 @@
+import type { ConnectionSourceRef } from "#discover/manifest.js";
+import type { CompiledConnectionDefinition } from "#compiler/manifest.js";
+/**
+ * Compiles one authored connection module into the serializable metadata
+ * stored on the compiled agent manifest.
+ *
+ * The compiled manifest holds only serializable data. The live authored
+ * `auth` callback (and, for OpenAPI connections, the `spec` and
+ * `operations` filter) is resolved at runtime by re-importing the
+ * authored module -- see `runtime/resolve-connection.ts`. Compile-time
+ * still imports and validates the module so authoring errors surface
+ * during `eve build`.
+ *
+ * The wire protocol is read from the marker stamped by the `define*`
+ * factory, defaulting to MCP, and selects which normalizer validates
+ * the authored shape. `url` carries the MCP server endpoint for MCP
+ * connections and the API base URL for OpenAPI connections, so the rest
+ * of the connection pipeline (auth context, tool-result narrowing,
+ * runtime resolution) stays protocol-agnostic.
+ */
+export declare function compileConnectionDefinition(agentRoot: string, source: ConnectionSourceRef): Promise<CompiledConnectionDefinition>;

package/dist/src/compiler/normalize-connection.js

@@ -0,0 +1 @@
+import{loadModuleBackedDefinition}from"#compiler/normalize-helpers.js";import{normalizeMcpClientConnectionDefinition,normalizeOpenApiConnectionDefinition}from"#internal/authored-definition/connection.js";import{readConnectionProtocol}from"#public/definitions/connections/protocol.js";async function compileConnectionDefinition(r,i){let a=await loadModuleBackedDefinition({agentRoot:r,kind:`connection`,source:i}),o=readConnectionProtocol(a),s=`Expected the connection export "${i.exportName??`default`}" from "${i.logicalPath}" to match the public Eve shape.`,c={connectionName:i.connectionName,exportName:i.exportName,logicalPath:i.logicalPath,sourceId:i.sourceId,sourceKind:`module`},l,u;if(o===`openapi`){let e=normalizeOpenApiConnectionDefinition(a,s);l={...c,description:e.description,protocol:`openapi`,url:e.baseUrl??``},u=e.auth}else{let e=normalizeMcpClientConnectionDefinition(a,s);l={...c,description:e.description,protocol:`mcp`,url:e.url},u=e.auth}let d=extractVercelConnectMarker(u);return d!==void 0&&(l.vercelConnect=d),l}function extractVercelConnectMarker(e){if(typeof e!=`object`||!e)return;let t=e.vercelConnect;if(typeof t!=`object`||!t)return;let n=t.connector;if(!(typeof n!=`string`||n.length===0))return{connector:n}}export{compileConnectionDefinition};

package/dist/src/compiler/normalize-helpers.d.ts

@@ -0,0 +1,28 @@
+import type { ModuleSourceRef } from "#shared/source-ref.js";
+import type { CompiledRuntimeModelCatalogLoader } from "#compiler/model-catalog.js";
+/**
+ * Shared compile-time context threaded through every per-primitive
+ * normalize step.
+ *
+ * Holds expensive lazily-loaded resources (currently the model catalog)
+ * so each `compileAgentManifest` invocation pays the load cost once and
+ * reuses the cache across all of its child compilations.
+ */
+export interface ManifestCompileContext {
+    readonly modelCatalog: CompiledRuntimeModelCatalogLoader;
+}
+/**
+ * Loads one authored module's value for a given source reference and
+ * resolves any value-returning factory it may export.
+ *
+ * Used by every per-primitive compiler that targets a `module` source
+ * (channels, sandboxes, tools, schedules, skills, prompt layers,
+ * subagents). Wraps execution errors so the message identifies which
+ * authored file failed.
+ */
+export declare function loadModuleBackedDefinition(input: {
+    readonly agentRoot: string;
+    readonly displayPath?: string;
+    readonly kind: string;
+    readonly source: ModuleSourceRef;
+}): Promise<unknown>;

package/dist/src/compiler/normalize-helpers.js

@@ -0,0 +1 @@
+import{getAuthoredModuleExport,materializeAuthoredModuleExport}from"#internal/authored-module.js";import{join}from"node:path";import{toErrorMessage}from"#shared/errors.js";import{loadAuthoredModuleNamespace}from"#internal/authored-module-loader.js";async function loadModuleBackedDefinition(t){let n=getAuthoredModuleExport(await loadAuthoredModuleNamespace(join(t.agentRoot,t.source.logicalPath)),t.source);try{return await materializeAuthoredModuleExport(n)}catch(e){throw Error(`Failed to execute the ${t.kind} export "${t.source.exportName??`default`}" from "${t.displayPath??t.source.logicalPath}": ${toErrorMessage(e)}`)}}export{loadModuleBackedDefinition};

package/dist/src/compiler/normalize-hook.d.ts

@@ -0,0 +1,12 @@
+import type { ModuleSourceRef } from "../shared/source-ref.js";
+import type { CompiledHookDefinition } from "./manifest.js";
+/**
+ * Compiles one authored hook module into the manifest entry stored on
+ * the compiled agent node.
+ *
+ * Hook event handlers are arbitrary functions and cannot be statically
+ * validated at compile time — the normalization step only derives the
+ * path-relative slug used for diagnostics and ordering. Per-handler
+ * validation lives in the runtime resolver.
+ */
+export declare function compileHookEntry(source: ModuleSourceRef): CompiledHookDefinition;

package/dist/src/compiler/normalize-hook.js

@@ -0,0 +1 @@
+import{stripLogicalPathExtension}from"../discover/filesystem.js";function compileHookEntry(e){return{exportName:e.exportName,logicalPath:e.logicalPath,slug:stripLogicalPathExtension(e.logicalPath).replace(/^hooks\//,``),sourceId:e.sourceId,sourceKind:`module`}}export{compileHookEntry};

package/dist/src/compiler/normalize-instructions.d.ts

@@ -0,0 +1,35 @@
+import type { InstructionsSourceRef } from "#discover/manifest.js";
+import type { CompiledDynamicInstructionsDefinition, CompiledInstructions } from "#compiler/manifest.js";
+/**
+ * Compiled instructions entry produced from one authored `instructions/*`
+ * file or flat `instructions.{md,ts,...}`.
+ *
+ * Either a static instructions definition or a dynamic resolver that
+ * produces model messages at runtime.
+ */
+export type CompiledInstructionsEntry = {
+    readonly kind: "instructions";
+    readonly definition: CompiledInstructions;
+} | {
+    readonly kind: "dynamic-instructions";
+    readonly definition: CompiledDynamicInstructionsDefinition;
+};
+/**
+ * Compiles one authored instructions prompt source (markdown or
+ * module-backed `defineInstructions`) into the normalized shape consumed
+ * by the runtime.
+ *
+ * Module-backed static instructions sources execute once at build time —
+ * the resulting markdown is captured into the compiled manifest. There is
+ * no per-session re-evaluation at runtime.
+ *
+ * Module-backed dynamic instructions (exporting `defineDynamic`) are
+ * classified and their event names recorded; the resolver runs at
+ * runtime.
+ */
+export declare function compileInstructionsEntry(agentRoot: string, source: InstructionsSourceRef): Promise<CompiledInstructionsEntry>;
+/**
+ * @deprecated Use {@link compileInstructionsEntry} instead. Kept for
+ * backwards compatibility with callers that pass a single source.
+ */
+export declare function compileInstructions(agentRoot: string, source: InstructionsSourceRef): Promise<CompiledInstructions>;

package/dist/src/compiler/normalize-instructions.js

@@ -0,0 +1 @@
+import{stripLogicalPathExtension}from"#discover/filesystem.js";import{normalizeInstructionsDefinition}from"#internal/authored-definition/core.js";import{loadModuleBackedDefinition}from"#compiler/normalize-helpers.js";import{isDynamicSentinel}from"#shared/dynamic-tool-definition.js";async function compileInstructionsEntry(r,i){if(i.sourceKind===`markdown`){let n=normalizeInstructionsDefinition(i.definition,`Expected the compiled instructions definition at "${i.logicalPath}" to match the public Eve shape.`);return{kind:`instructions`,definition:{name:stripLogicalPathExtension(i.logicalPath),logicalPath:i.logicalPath,markdown:n.markdown,sourceId:i.sourceId,sourceKind:i.sourceKind}}}let a=await loadModuleBackedDefinition({agentRoot:r,kind:`instructions`,source:i});if(isDynamicSentinel(a)){let t=stripLogicalPathExtension(i.logicalPath).replace(/^instructions\//,``);return{kind:`dynamic-instructions`,definition:{eventNames:Object.keys(a.events),exportName:i.exportName,logicalPath:i.logicalPath,slug:t,sourceId:i.sourceId,sourceKind:`module`}}}let o=normalizeInstructionsDefinition(a,`Expected the instructions export "${i.exportName??`default`}" from "${i.logicalPath}" to match the public Eve shape.`);return{kind:`instructions`,definition:{name:stripLogicalPathExtension(i.logicalPath),logicalPath:i.logicalPath,markdown:o.markdown,sourceId:i.sourceId,sourceKind:i.sourceKind}}}async function compileInstructions(e,t){let n=await compileInstructionsEntry(e,t);if(n.kind===`dynamic-instructions`)throw Error(`Expected static instructions from "${t.logicalPath}" but got a dynamic resolver. Use compileInstructionsEntry instead.`);return n.definition}export{compileInstructions,compileInstructionsEntry};

package/dist/src/compiler/normalize-manifest.d.ts

@@ -0,0 +1,6 @@
+import type { AgentSourceManifest } from "#discover/manifest.js";
+import { type CompiledAgentManifest } from "#compiler/manifest.js";
+/**
+ * Compiles one discovery manifest into the normalized manifest loaded by the runtime.
+ */
+export declare function compileAgentManifest(manifest: AgentSourceManifest): Promise<CompiledAgentManifest>;

package/dist/src/compiler/normalize-manifest.js

@@ -0,0 +1,3 @@
+import{compileChannelDefinition}from"#compiler/normalize-channel.js";import{ROOT_COMPILED_AGENT_NODE_ID,createCompiledAgentManifest,createCompiledAgentNodeManifest}from"#compiler/manifest.js";import{createCompiledRuntimeModelCatalogLoader}from"#compiler/model-catalog.js";import{compileAgentConfig}from"#compiler/normalize-agent-config.js";import{compileConnectionDefinition}from"#compiler/normalize-connection.js";import{compileHookEntry}from"#compiler/normalize-hook.js";import{compileSandboxDefinition}from"#compiler/normalize-sandbox.js";import{compileInstructionsEntry}from"#compiler/normalize-instructions.js";import{compileScheduleDefinition}from"#compiler/normalize-schedule.js";import{compileSkillSource}from"#compiler/normalize-skill.js";import{compileSubagentGraph}from"#compiler/normalize-subagent.js";import{compileToolEntry}from"#compiler/normalize-tool.js";async function compileAgentManifest(e){let r={modelCatalog:createCompiledRuntimeModelCatalogLoader(e.appRoot)},[a,o]=await Promise.all([compileAgentNodeManifest(e,r),compileSubagentGraph({appRoot:e.appRoot,compileAgentNodeManifest,context:r,parentNodeId:ROOT_COMPILED_AGENT_NODE_ID,subagents:e.subagents})]);return createCompiledAgentManifest({...a,remoteAgents:o.remoteAgents,subagentEdges:o.edges,subagents:o.nodes})}async function compileAgentNodeManifest(t,n){let i=await Promise.all(t.tools.map(e=>compileToolEntry(t.agentRoot,e))),s=[],c=[],l=[],u=!1;for(let e of i)e.kind===`tool`?s.push(e.definition):e.kind===`dynamic-tool`?c.push(e.definition):e.kind===`enable-workflow`?u=!0:l.push(e.name);let d=(await Promise.all(t.channels.map(n=>compileChannelDefinition(t.agentRoot,n)))).flat(),f=await Promise.all(t.skills.map(e=>compileSkillSource(t.agentRoot,e))),p=[],m=[];for(let e of f)e.kind===`skill`?p.push(e.definition):m.push(e.definition);let h=await Promise.all(t.instructions.map(e=>compileInstructionsEntry(t.agentRoot,e))),g=[],_=[];for(let e of h)e.kind===`instructions`?g.push(e.definition):_.push(e.definition);let v=g.length===0?void 0:g.length===1?g[0]:{name:`instructions`,logicalPath:`instructions`,markdown:g.map(e=>e.markdown).join(`
+
+`),sourceId:g[0].sourceId,sourceKind:`module`};return createCompiledAgentNodeManifest({agentRoot:t.agentRoot,appRoot:t.appRoot,channels:d,config:await compileAgentConfig(t,n),connections:await Promise.all(t.connections.map(e=>compileConnectionDefinition(t.agentRoot,e))),diagnosticsSummary:t.diagnosticsSummary,disabledFrameworkTools:l,workflowEnabled:u,dynamicSkills:m,dynamicTools:c,hooks:t.hooks.map(e=>compileHookEntry(e)),sandbox:t.sandbox===null?null:await compileSandboxDefinition(t.agentRoot,t.sandbox),sandboxWorkspaces:t.sandboxWorkspaces.map(e=>({logicalPath:e.logicalPath,rootEntries:[...e.rootEntries],sourceId:e.sourceId,sourcePath:e.sourcePath})),schedules:await Promise.all(t.schedules.map(e=>compileScheduleDefinition(t.agentRoot,e))),dynamicInstructions:_,skills:p,instructions:v,tools:s})}export{compileAgentManifest};

package/dist/src/compiler/normalize-sandbox.d.ts

@@ -0,0 +1,7 @@
+import type { SandboxSourceRef } from "#discover/manifest.js";
+import type { CompiledSandboxDefinition } from "#compiler/manifest.js";
+/**
+ * Compiles one authored sandbox module into the normalized sandbox
+ * definition stored on the compiled agent manifest.
+ */
+export declare function compileSandboxDefinition(agentRoot: string, source: SandboxSourceRef): Promise<CompiledSandboxDefinition>;

package/dist/src/compiler/normalize-sandbox.js

@@ -0,0 +1 @@
+import{join}from"node:path";import{readFile}from"node:fs/promises";import{toErrorMessage}from"#shared/errors.js";import{createHash}from"node:crypto";import{loadModuleBackedDefinition}from"#compiler/normalize-helpers.js";import{normalizeSandboxDefinition}from"#internal/authored-definition/sandbox.js";async function compileSandboxDefinition(e,t){let n=`Expected the sandbox export "${t.exportName??`default`}" from "${t.logicalPath}" to match the public Eve shape.`,r=normalizeSandboxDefinition(await loadModuleBackedDefinition({agentRoot:e,kind:`sandbox`,source:t}),n),o=r.revalidationKey===void 0?void 0:await resolveSandboxRevalidationKey({message:n,revalidationKey:r.revalidationKey,source:t});return{description:r.description,exportName:t.exportName,logicalPath:t.logicalPath,revalidationKey:o,sourceHash:await resolveSandboxSourceHash(e,t),sourceId:t.sourceId,sourceKind:`module`}}async function resolveSandboxRevalidationKey(e){let t;try{t=await e.revalidationKey()}catch(t){throw Error(`${e.message} Failed to execute the "revalidationKey" function from "${e.source.logicalPath}": ${toErrorMessage(t)}`)}if(typeof t!=`string`)throw Error(`${e.message} The "revalidationKey" function must return a string.`);if(t.trim().length===0)throw Error(`${e.message} The "revalidationKey" function must return a non-empty string.`);return t}async function resolveSandboxSourceHash(n,i){let a=await readFile(join(n,i.logicalPath));return createHash(`sha256`).update(a).digest(`hex`)}export{compileSandboxDefinition};

package/dist/src/compiler/normalize-schedule.d.ts

@@ -0,0 +1,14 @@
+import type { ScheduleSourceRef } from "#discover/manifest.js";
+import type { CompiledScheduleDefinition } from "#compiler/manifest.js";
+/**
+ * Compiles one authored schedule into the normalized shape consumed by
+ * the runtime scheduler.
+ *
+ * Schedules are single files: `schedules/<name>.{ts,md}`. The markdown
+ * form always produces a fire-and-forget schedule (`markdown` body, no
+ * `run`). The TypeScript form may declare either `markdown` or `run`
+ * (exactly one). The schedule name is derived from the relative file
+ * path under `schedules/` minus the extension
+ * (`schedules/billing/invoice-sweep.ts` → `"billing/invoice-sweep"`).
+ */
+export declare function compileScheduleDefinition(agentRoot: string, source: ScheduleSourceRef): Promise<CompiledScheduleDefinition>;

package/dist/src/compiler/normalize-schedule.js

@@ -0,0 +1 @@
+import{stripLogicalPathExtension}from"#discover/filesystem.js";import{normalizeScheduleDefinition}from"#internal/authored-definition/core.js";import{loadModuleBackedDefinition}from"#compiler/normalize-helpers.js";async function compileScheduleDefinition(e,n){let r=n.sourceKind===`markdown`?normalizeScheduleDefinition(n.definition,`Expected the compiled schedule definition at "${n.logicalPath}" to match the public Eve shape.`):normalizeScheduleDefinition(await loadModuleBackedDefinition({agentRoot:e,kind:`schedule`,source:n}),`Expected the schedule export "${n.exportName??`default`}" from "${n.logicalPath}" to match the public Eve shape.`),i={cron:r.cron,hasRun:r.run!==void 0,logicalPath:n.logicalPath,name:deriveScheduleName(n.logicalPath),sourceId:n.sourceId,sourceKind:n.sourceKind};return r.markdown===void 0?i:{...i,markdown:r.markdown.trim()}}function deriveScheduleName(t){return stripLogicalPathExtension(t).replace(/^schedules\//,``)}export{compileScheduleDefinition};

package/dist/src/compiler/normalize-skill.d.ts

@@ -0,0 +1,21 @@
+import type { SkillSourceRef } from "#discover/manifest.js";
+import type { CompiledDynamicSkillDefinition, CompiledSkillDefinition } from "#compiler/manifest.js";
+/**
+ * Compiled skill entry produced from one authored `skills/*` file.
+ *
+ * Either a real skill definition or a dynamic skill resolver that
+ * produces skills at runtime.
+ */
+export type CompiledSkillEntry = {
+    readonly kind: "skill";
+    readonly definition: CompiledSkillDefinition;
+} | {
+    readonly kind: "dynamic-skill";
+    readonly definition: CompiledDynamicSkillDefinition;
+};
+/**
+ * Compiles one authored skill source (markdown, module, or skill
+ * package directory) into the normalized shape stored on the compiled
+ * agent manifest.
+ */
+export declare function compileSkillSource(agentRoot: string, source: SkillSourceRef): Promise<CompiledSkillEntry>;

package/dist/src/compiler/normalize-skill.js

@@ -0,0 +1 @@
+import{stripLogicalPathExtension}from"#discover/filesystem.js";import{normalizeSkillDefinition}from"#internal/authored-definition/core.js";import{loadModuleBackedDefinition}from"#compiler/normalize-helpers.js";import{isDynamicSentinel}from"#shared/dynamic-tool-definition.js";async function compileSkillSource(r,i){if(i.sourceKind===`skill-package`)return{kind:`skill`,definition:compileSkillPackageSource(i)};if(i.sourceKind===`markdown`){let n=normalizeSkillDefinition(i.definition,`Expected the compiled skill definition at "${i.logicalPath}" to match the public Eve shape.`);return{kind:`skill`,definition:{description:n.description,files:n.files,license:n.license,logicalPath:i.logicalPath,markdown:n.markdown,metadata:n.metadata===void 0?void 0:{...n.metadata},name:stripLogicalPathExtension(i.logicalPath).replace(/^skills\//,``),sourceId:i.sourceId,sourceKind:i.sourceKind}}}let a=await loadModuleBackedDefinition({agentRoot:r,kind:`skill`,source:i});if(isDynamicSentinel(a)){let t=stripLogicalPathExtension(i.logicalPath).replace(/^skills\//,``);return{kind:`dynamic-skill`,definition:{eventNames:Object.keys(a.events),exportName:i.exportName,logicalPath:i.logicalPath,slug:t,sourceId:i.sourceId,sourceKind:`module`}}}let o=normalizeSkillDefinition(a,`Expected the skill export "${i.exportName??`default`}" from "${i.logicalPath}" to match the public Eve shape.`);return{kind:`skill`,definition:{description:o.description,files:o.files,license:o.license,logicalPath:i.logicalPath,markdown:o.markdown,metadata:o.metadata===void 0?void 0:{...o.metadata},name:stripLogicalPathExtension(i.logicalPath).replace(/^skills\//,``),sourceId:i.sourceId,sourceKind:i.sourceKind}}}function compileSkillPackageSource(e){return{assetsPath:e.assetsPath,description:e.description,license:e.license,logicalPath:e.logicalPath,markdown:e.markdown,metadata:e.metadata===void 0?void 0:{...e.metadata},name:e.name,referencesPath:e.referencesPath,rootPath:e.rootPath,scriptsPath:e.scriptsPath,skillId:e.skillId,skillFilePath:e.skillFilePath,sourceId:e.sourceId,sourceKind:`skill-package`}}export{compileSkillSource};

package/dist/src/compiler/normalize-subagent.d.ts

@@ -0,0 +1,29 @@
+import { type AgentSourceManifest, type LocalSubagentSourceRef } from "#discover/manifest.js";
+import { type CompiledAgentNodeManifest, type CompiledRemoteAgentNode, type CompiledSubagentEdge, type CompiledSubagentNode } from "#compiler/manifest.js";
+import { type ManifestCompileContext } from "#compiler/normalize-helpers.js";
+/**
+ * Callback the subagent compiler uses to recurse into the per-node
+ * manifest compiler. Injected by `normalize-manifest.ts` so this module
+ * does not have to import the orchestrator (which would create a
+ * circular dependency).
+ */
+export type CompileAgentNodeManifestFn = (manifest: AgentSourceManifest, context: ManifestCompileContext) => Promise<CompiledAgentNodeManifest>;
+/**
+ * Compiles every local subagent reachable from one parent node into a
+ * flat node list and the parent→child edges that connect them.
+ *
+ * Recursive: each subagent may itself declare further subagents, which
+ * are compiled depth-first via the injected `compileAgentNodeManifest`
+ * callback.
+ */
+export declare function compileSubagentGraph(input: {
+    readonly appRoot: string;
+    readonly compileAgentNodeManifest: CompileAgentNodeManifestFn;
+    readonly context: ManifestCompileContext;
+    readonly parentNodeId: string;
+    readonly subagents: readonly LocalSubagentSourceRef[];
+}): Promise<{
+    readonly edges: readonly CompiledSubagentEdge[];
+    readonly nodes: readonly CompiledSubagentNode[];
+    readonly remoteAgents: readonly CompiledRemoteAgentNode[];
+}>;

package/dist/src/compiler/normalize-subagent.js

@@ -0,0 +1 @@
+import{expectObjectRecord,expectOnlyKnownKeys,expectString}from"#internal/authored-module.js";import{EVE_CREATE_SESSION_ROUTE_PATH}from"#protocol/routes.js";import{normalizeJsonSchemaDefinition}from"#shared/json-schema.js";import{createCompiledSubagentNodeId}from"#compiler/manifest.js";import{loadModuleBackedDefinition}from"#compiler/normalize-helpers.js";import{createPathDerivedSourceId}from"#discover/manifest.js";async function compileSubagentGraph(e){let t=[],n=[],r=[];for(let i of e.subagents){let a=await compileSubagentDefinition({appRoot:e.appRoot,compileAgentNodeManifest:e.compileAgentNodeManifest,context:e.context,parentNodeId:e.parentNodeId,source:i});if(a.kind===`remote`){r.push(a.node);continue}t.push(a.node,...a.descendants.nodes),n.push({childNodeId:a.node.nodeId,parentNodeId:e.parentNodeId},...a.descendants.edges)}return{edges:n,nodes:t,remoteAgents:r}}async function compileSubagentDefinition(e){let t=e.source.manifest.configModule;if(t===void 0)throw Error(`Subagent "${e.source.logicalPath}" is missing an agent config module.`);let n=createSubagentConfigModuleSourceRef(e.source,t),r=await loadModuleBackedDefinition({agentRoot:e.source.manifest.agentRoot,displayPath:n.logicalPath,kind:`subagent config`,source:t});return readAgentDefinitionKind(r)===`remote`?{kind:`remote`,node:compileRemoteAgent({source:e.source,value:r})}:{kind:`local`,...await compileLocalSubagent(e)}}async function compileSubagent(e){let t=createCompiledSubagentNodeId(e.parentNodeId,e.source.sourceId),n=e.source.subagentId,r=await e.compileAgentNodeManifest({...e.source.manifest,appRoot:e.appRoot},e.context),i=r.config.description;if(!i)throw Error(`Local subagent "${e.source.logicalPath}" is missing a "description" field on its agent config. Add \`description\` to \`defineAgent({ ... })\` so the parent agent can decide when to delegate to this subagent.`);let o=await compileSubagentGraph({appRoot:e.appRoot,compileAgentNodeManifest:e.compileAgentNodeManifest,context:e.context,parentNodeId:t,subagents:e.source.manifest.subagents});return{descendants:o,node:{agent:{...r,remoteAgents:[...o.remoteAgents]},description:i,entryPath:e.source.entryPath,logicalPath:e.source.logicalPath,name:n,nodeId:t,rootPath:e.source.rootPath,sourceId:e.source.sourceId,sourceKind:`module`}}}const compileLocalSubagent=compileSubagent;function compileRemoteAgent(e){let t=e.source.manifest.configModule;if(t===void 0)throw Error(`Remote agent "${e.source.logicalPath}" is missing a config module.`);assertRemoteAgentDefinitionHasNoLocalPackageEntries(e.source);let n=createSubagentConfigModuleSourceRef(e.source,t),r=normalizeRemoteAgentDefinition(e.value,`Expected the remote agent config export "${t.exportName??`default`}" from "${n.logicalPath}" to match the public Eve shape.`);return{...n,description:r.description,entryPath:e.source.entryPath,name:e.source.subagentId,nodeId:e.source.sourceId,outputSchema:r.outputSchema,path:r.path,rootPath:e.source.rootPath,url:r.url}}function createSubagentConfigModuleSourceRef(e,t){let n=e.logicalPath===t.logicalPath?t.logicalPath:`${e.logicalPath}/${t.logicalPath}`,r={logicalPath:n,sourceId:createPathDerivedSourceId(n),sourceKind:`module`};return t.exportName!==void 0&&(r.exportName=t.exportName),r}function readAgentDefinitionKind(e){return typeof e!=`object`||!e?`local`:e.kind===`remote`?`remote`:`local`}function normalizeRemoteAgentDefinition(a,o){let s=expectObjectRecord(a,o);if(expectOnlyKnownKeys(s,[`auth`,`description`,`headers`,`kind`,`outputSchema`,`path`,`url`],o),s.kind!==`remote`)throw Error(`${o} Expected "kind" to be "remote".`);return{description:expectString(s.description,o),outputSchema:s.outputSchema===void 0?void 0:normalizeJsonSchemaDefinition(s.outputSchema,`output`),path:s.path===void 0?EVE_CREATE_SESSION_ROUTE_PATH:expectString(s.path,o),url:expectString(s.url,o)}}function assertRemoteAgentDefinitionHasNoLocalPackageEntries(e){let t=e.manifest,n=[t.connections.length>0?`connections/`:void 0,t.hooks.length>0?`hooks/`:void 0,t.instructions.length>0?`instructions`:void 0,t.lib.length>0?`lib/`:void 0,t.sandbox===null?void 0:`sandbox/`,t.sandboxWorkspaces.length>0?`sandbox/workspace/`:void 0,t.schedules.length>0?`schedules/`:void 0,t.skills.length>0?`skills/`:void 0,t.subagents.length>0?`subagents/`:void 0,t.tools.length>0?`tools/`:void 0].filter(e=>e!==void 0);if(n.length!==0)throw Error(`Remote subagent definition "${e.logicalPath}" cannot include local package entries. Remove unsupported entries: ${n.join(`, `)}.`)}export{compileSubagentGraph};

package/dist/src/compiler/normalize-tool.d.ts

@@ -0,0 +1,34 @@
+import type { ModuleSourceRef } from "#shared/source-ref.js";
+import type { CompiledToolDefinition, CompiledDynamicToolDefinition } from "#compiler/manifest.js";
+/**
+ * Compiled tool entry produced from one authored `tools/*.ts` file.
+ *
+ * Either a real tool definition, a `disabled` marker that removes the
+ * named framework default during graph resolution, or a dynamic tool
+ * resolver that produces tools at runtime.
+ */
+export type CompiledToolEntry = {
+    readonly kind: "tool";
+    readonly definition: CompiledToolDefinition;
+} | {
+    readonly kind: "disabled";
+    readonly name: string;
+} | {
+    readonly kind: "enable-workflow";
+} | {
+    readonly kind: "dynamic-tool";
+    readonly definition: CompiledDynamicToolDefinition;
+};
+/**
+ * Compiles one authored tool module into the normalized tool entry
+ * stored on the compiled agent manifest.
+ *
+ * The tool name is derived from the file path under `tools/` with the
+ * extension stripped and any path separators flattened to dashes
+ * (e.g. `tools/billing/refund.ts` → `"billing-refund"`). Path separators
+ * cannot reach the model — most providers reject `/` in tool names — so
+ * tools are the one path-derived primitive that flattens nested
+ * directories into a slug-safe single segment. Authored `name` fields
+ * are rejected by the normalizer.
+ */
+export declare function compileToolEntry(agentRoot: string, source: ModuleSourceRef): Promise<CompiledToolEntry>;

package/dist/src/compiler/normalize-tool.js

@@ -0,0 +1 @@
+import{stripLogicalPathExtension}from"#discover/filesystem.js";import{loadModuleBackedDefinition}from"#compiler/normalize-helpers.js";import{normalizeToolDefinition}from"#internal/authored-definition/schema-backed.js";async function compileToolEntry(e,t){let n=normalizeToolDefinition(await loadModuleBackedDefinition({agentRoot:e,kind:`tool`,source:t}),`Expected the tool export "${t.exportName??`default`}" from "${t.logicalPath}" to match the public Eve shape.`),r=stripLogicalPathExtension(t.logicalPath).replace(/^tools\//,``).replaceAll(`/`,`-`);return n.kind===`disabled`?{kind:`disabled`,name:r}:n.kind===`enable-workflow`?{kind:`enable-workflow`}:n.kind===`dynamic-tool`?{kind:`dynamic-tool`,definition:{eventNames:[...n.eventNames],exportName:t.exportName,logicalPath:t.logicalPath,slug:r,sourceId:t.sourceId,sourceKind:`module`}}:{kind:`tool`,definition:{description:n.definition.description,exportName:t.exportName,inputSchema:n.definition.inputSchema??null,logicalPath:t.logicalPath,name:r,outputSchema:n.definition.outputSchema,sourceId:t.sourceId,sourceKind:`module`}}}export{compileToolEntry};

package/dist/src/compiler/remote-agent-node.d.ts

@@ -0,0 +1,22 @@
+import { z } from "#compiled/zod/index.js";
+import type { JsonObject } from "#shared/json.js";
+import type { Node } from "#shared/node.js";
+import type { ModuleSourceRef } from "#shared/source-ref.js";
+/**
+ * Remote subagent entry owned by one compiled agent node manifest. Like
+ * channels, remote subagents are node-local manifest entries rather than a
+ * separate graph-level list.
+ */
+export type CompiledRemoteAgentNode = Readonly<ModuleSourceRef & Node & {
+    description: string;
+    entryPath: string;
+    name: string;
+    outputSchema?: JsonObject;
+    path: string;
+    rootPath: string;
+    url: string;
+}>;
+/**
+ * Zod schema for one compiled remote subagent entry.
+ */
+export declare const compiledRemoteAgentNodeSchema: z.ZodType<CompiledRemoteAgentNode>;

package/dist/src/compiler/remote-agent-node.js

@@ -0,0 +1 @@
+import{z}from"#compiled/zod/index.js";import{jsonObjectSchema}from"#shared/json-schemas.js";const compiledRemoteAgentNodeSchema=z.object({description:z.string(),entryPath:z.string(),exportName:z.string().optional(),logicalPath:z.string(),name:z.string(),nodeId:z.string(),outputSchema:jsonObjectSchema.optional(),path:z.string(),rootPath:z.string(),sourceId:z.string(),sourceKind:z.literal(`module`),url:z.string()}).strict();export{compiledRemoteAgentNodeSchema};

package/dist/src/compiler/workspace-resources.d.ts

@@ -0,0 +1,14 @@
+import type { CompiledAgentManifest } from "#compiler/manifest.js";
+/**
+ * Materializes the per-node workspace resource trees under
+ * `.eve/compile/workspace-resources/` and returns a manifest whose node
+ * descriptors point at the freshly-written directories.
+ *
+ * Idempotent against an existing compile run: the resources directory
+ * is removed before each invocation so a re-compile produces a clean
+ * tree.
+ */
+export declare function materializeWorkspaceResources(input: {
+    readonly compileDirectoryPath: string;
+    readonly manifest: CompiledAgentManifest;
+}): Promise<CompiledAgentManifest>;

package/dist/src/compiler/workspace-resources.js

@@ -0,0 +1 @@
+import{join,posix}from"node:path";import{cp,mkdir,readFile,readdir,rm}from"node:fs/promises";import{createHash}from"node:crypto";import{normalizeLogicalPath}from"#discover/filesystem.js";import{ROOT_COMPILED_AGENT_NODE_ID,deriveResourceRootEntries}from"#compiler/manifest.js";import{normalizeSkillPackage,writeSkillPackageDirectory}from"#shared/skill-package.js";const RESOURCES_DIRECTORY=`workspace-resources`;async function materializeWorkspaceResources(t){let n=join(t.compileDirectoryPath,RESOURCES_DIRECTORY);await rm(n,{force:!0,recursive:!0});let r=await materializeNode({nodeId:ROOT_COMPILED_AGENT_NODE_ID,resourcesRoot:n,manifest:t.manifest}),i=await Promise.all(t.manifest.subagents.map(async e=>({...e,agent:await materializeNode({nodeId:e.nodeId,resourcesRoot:n,manifest:e.agent})})));return{...r,kind:t.manifest.kind,subagentEdges:t.manifest.subagentEdges,subagents:i,version:t.manifest.version}}function createResourceRoot(t,n,r){return{contentHash:r,logicalPath:normalizeLogicalPath(join(RESOURCES_DIRECTORY,n)),rootEntries:deriveResourceRootEntries({sandboxWorkspaces:t.sandboxWorkspaces,skills:t.skills})}}async function materializeNode(t){for(let e of t.manifest.sandboxWorkspaces)if(e.rootEntries.some(e=>e===`skills/`||e===`skills`))throw Error(`Sandbox workspace "${e.logicalPath}" cannot define "skills" because Eve manages that workspace entry.`);let i=join(t.resourcesRoot,t.nodeId);await mkdir(i,{recursive:!0});for(let e of t.manifest.sandboxWorkspaces)await cp(e.sourcePath,i,{recursive:!0});for(let e of t.manifest.skills)await materializeSkill({nodeRoot:i,skill:e});let a=await heveWorkspaceResourceRoot(i);return{...t.manifest,skills:t.manifest.skills.map(stripSkillPackageFiles),workspaceResourceRoot:createResourceRoot(t.manifest,t.nodeId,a)}}async function materializeSkill(t){let r=join(t.nodeRoot,`skills`,t.skill.name);if(t.skill.sourceKind===`skill-package`){await cp(t.skill.rootPath,r,{recursive:!0});return}await writeSkillPackageDirectory({rootPath:t.nodeRoot,skill:normalizeSkillPackage(t.skill)})}function stripSkillPackageFiles(e){let{files:t,...n}=e;return n}async function heveWorkspaceResourceRoot(e){let t=await listWorkspaceResourceFiles({logicalDirectoryPath:`.`,sourceDirectoryPath:e});t.sort((e,t)=>e.logicalPath.localeCompare(t.logicalPath));let n=createHash(`sha256`);n.update(`eve-workspace-resource-root-v1\0`);for(let e of t){let t=await readFile(e.sourcePath);n.update(e.logicalPath),n.update(`\0`),n.update(String(t.byteLength)),n.update(`\0`),n.update(t),n.update(`\0`)}return n.digest(`hex`)}async function listWorkspaceResourceFiles(n){let r=[],i=await readdir(n.sourceDirectoryPath,{withFileTypes:!0});for(let a of i){if(!a.isDirectory()&&!a.isFile())continue;let i=join(n.sourceDirectoryPath,a.name),o=posix.join(n.logicalDirectoryPath,a.name);if(a.isDirectory()){r.push(...await listWorkspaceResourceFiles({logicalDirectoryPath:o,sourceDirectoryPath:i}));continue}r.push({logicalPath:o,sourcePath:i})}return r}export{materializeWorkspaceResources};

package/dist/src/context/accessors.d.ts

@@ -0,0 +1,40 @@
+import type { ContextKey } from "#context/key.js";
+export type { Session, SessionAuth, SessionAuthContext, SessionParent, SessionTurn, } from "#context/keys.js";
+/**
+ * Returns the current value of a context key, or `undefined` when unset.
+ *
+ * @throws When called outside of a managed step execution.
+ */
+export declare function getContext<T>(key: ContextKey<T>): T | undefined;
+/**
+ * Returns the current value of a context key, throwing when unset.
+ *
+ * @throws When the key is not set or when called outside of a managed
+ *   step execution.
+ */
+export declare function requireContext<T>(key: ContextKey<T>): T;
+/**
+ * Returns whether the key is currently set in the active context.
+ *
+ * @throws When called outside of a managed step execution.
+ */
+export declare function hasContext<T>(key: ContextKey<T>): boolean;
+/**
+ * Sets the durable value of a context key in the active context.
+ *
+ * Accepts either a direct value or an updater function that receives the
+ * current value (or `undefined` if unset) and returns the next value.
+ *
+ * The new durable value is serialized at the end of the step and survives
+ * future workflow steps and turns.
+ *
+ * @throws When called outside of a managed step execution.
+ */
+export declare function setContext<T>(key: ContextKey<T>, valueOrUpdater: T | ((current: T | undefined) => T)): T;
+/**
+ * Returns the current value of a context key or initializes and stores a
+ * durable value when the key is unset.
+ *
+ * @throws When called outside of a managed step execution.
+ */
+export declare function ensureContext<T>(key: ContextKey<T>, create: () => T): T;

package/dist/src/context/accessors.js

@@ -0,0 +1 @@
+import{loadContext}from"#context/container.js";function getContext(e){return loadContext().get(e)}function requireContext(e){return loadContext().require(e)}function hasContext(e){return loadContext().has(e)}function setContext(e,t){return loadContext().set(e,t)}function ensureContext(e,t){return loadContext().ensure(e,t)}export{ensureContext,getContext,hasContext,requireContext,setContext};

package/dist/src/context/build-callback-context.d.ts

@@ -0,0 +1,8 @@
+import type { SessionContext } from "#public/definitions/callback-context.js";
+/**
+ * Builds a {@link SessionContext} from the active ALS scope.
+ *
+ * Must be called inside a harness step (active `contextStorage.run`).
+ * Throws when called outside an ALS scope.
+ */
+export declare function buildCallbackContext(): SessionContext;

package/dist/src/context/build-callback-context.js

@@ -0,0 +1 @@
+import{SandboxKey,SessionKey}from"#context/keys.js";import{loadContext}from"#context/container.js";import{createSandboxSkillHandle}from"#runtime/skills/sandbox-access.js";function buildCallbackContext(){let r=loadContext(),i=r.require(SessionKey);return{session:{id:i.sessionId,auth:i.auth,turn:i.turn,parent:i.parent},getSandbox(){let t=r.get(SandboxKey);if(t===void 0)throw Error(`Eve sandbox runtime access is unavailable in the current async context. Call ctx.getSandbox() only from authored runtime functions such as tools, hooks, and channel events.`);return t.get().then(e=>{if(e===null)throw Error(`The sandbox is not available in the current authored runtime context.`);return e})},getSkill(t){let n=r.get(SandboxKey);if(n===void 0)throw Error(`Eve sandbox runtime access is unavailable in the current async context. Call ctx.getSkill() only from authored runtime functions such as tools, hooks, and channel events.`);return createSandboxSkillHandle(n,t)}}}export{buildCallbackContext};

package/dist/src/context/build-dynamic-tools.d.ts

@@ -0,0 +1,13 @@
+import type { HarnessToolDefinition } from "#harness/execute-tool.js";
+import type { ContextKey } from "#context/key.js";
+/**
+ * Builds live dynamic tool definitions. Narrower scopes appear first
+ * so they win on name collision (the tool-loop uses `??=` for dedup).
+ *
+ * Step tools are live closures (re-resolved every step via
+ * `LiveStepToolsKey`). Session/turn tools are replayed from durable
+ * metadata via the bundler's registered step functions.
+ */
+export declare function buildDynamicTools(ctx: {
+    get<T>(key: ContextKey<T>): T | undefined;
+}): readonly HarnessToolDefinition[];

package/dist/src/context/build-dynamic-tools.js

@@ -0,0 +1 @@
+import{createLogger}from"#internal/logging.js";import{LiveStepToolsKey,SessionDynamicToolMetadataKey,TurnDynamicToolMetadataKey}from"#context/keys.js";import{jsonSchema}from"ai";import{buildCallbackContext}from"#context/build-callback-context.js";const log=createLogger(`dynamic-tools`);function lookupStepFunction(e){try{let t=globalThis[Symbol.for(`@workflow/core//registeredSteps`)];return t===void 0?null:t.get(e)||null}catch{return null}}function replayTools(e){let t=[];for(let n of e){if(!n.executeStepFnName||!n.closureVars){log.warn(`Dynamic tool "${n.name}" has no registered step function — skipping on this step. The bundler transform may not have processed this tool file.`);continue}let e=lookupStepFunction(n.executeStepFnName);if(!e){log.warn(`Dynamic tool "${n.name}" references step function "${n.executeStepFnName}" which is not registered — skipping on this step.`);continue}t.push({description:n.description,execute:t=>e(n.closureVars,t,buildCallbackContext()),inputSchema:jsonSchema(n.inputSchema),name:n.name,outputSchema:n.outputSchema===void 0?void 0:jsonSchema(n.outputSchema)})}return t}function buildDynamicTools(e){let r=e.get(LiveStepToolsKey)??[],i=replayTools(e.get(TurnDynamicToolMetadataKey)??[]),a=replayTools(e.get(SessionDynamicToolMetadataKey)??[]);return[...r,...i,...a]}export{buildDynamicTools};

package/dist/src/context/container.d.ts

@@ -0,0 +1,60 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { type ContextAccessor, type ContextKey } from "#context/key.js";
+/**
+ * Keyed value container that backs one Eve execution scope.
+ *
+ * Durable values are serialized across workflow steps and turns. Virtual
+ * values are rebuilt each step by context providers and are never
+ * serialized.
+ *
+ * Extends {@link ContextAccessor} with the `entries()` iterator used by
+ * the serialization layer.
+ */
+export interface AlsContext extends ContextAccessor {
+    /**
+     * Iterates all durable key/value pairs currently stored in the context.
+     * Used by the serialization layer to persist context at step boundaries.
+     */
+    entries(): Iterable<readonly [ContextKey<unknown>, unknown]>;
+}
+/**
+ * Default mutable implementation of {@link AlsContext}.
+ */
+export declare class ContextContainer implements AlsContext {
+    private readonly _durableValues;
+    private readonly _virtualValues;
+    get<T>(key: ContextKey<T>): T | undefined;
+    require<T>(key: ContextKey<T>): T;
+    has<T>(key: ContextKey<T>): boolean;
+    set<T>(key: ContextKey<T>, valueOrUpdater: T | ((current: T | undefined) => T)): T;
+    ensure<T>(key: ContextKey<T>, create: () => T): T;
+    /**
+     * Clears all step-local provider values from the context.
+     *
+     * The runtime calls this before rebuilding context providers for a new
+     * step.
+     */
+    clearVirtualContext(): void;
+    /**
+     * Stores a step-local provider value for one key.
+     *
+     * Virtual values shadow durable values for the lifetime of the current
+     * step and are excluded from serialization.
+     */
+    setVirtualContext<T>(key: ContextKey<T>, value: T): void;
+    entries(): Generator<readonly [ContextKey<unknown>, unknown]>;
+}
+/**
+ * Process-wide AsyncLocalStorage used by every Eve module copy in the current
+ * runtime.
+ *
+ * Nitro step bundles can inline parts of Eve while authored modules still
+ * import `eve/*` from disk. Backing the storage with a global
+ * symbol keeps those copies on the same ALS instance so authored tools,
+ * model callbacks, and step code observe one unified Eve context.
+ */
+export declare const contextStorage: AsyncLocalStorage<AlsContext>;
+/**
+ * Returns the active context, throwing when called outside a managed scope.
+ */
+export declare function loadContext(): AlsContext;

package/dist/src/context/container.js

@@ -0,0 +1 @@
+import{AsyncLocalStorage}from"node:async_hooks";import{resolveKey}from"#context/key.js";const EVE_CONTEXT_STORAGE_KEY=Symbol.for(`eve.context-storage`);var ContextContainer=class{_durableValues=new Map;_virtualValues=new Map;get(e){return this._virtualValues.has(e.name)?this._virtualValues.get(e.name):this._durableValues.get(e.name)}require(e){if(!this.has(e))throw Error(`Context key "${e.name}" is not set.`);return this.get(e)}has(e){return this._virtualValues.has(e.name)||this._durableValues.has(e.name)}set(e,t){let n=typeof t==`function`?t(this.get(e)):t;return this._durableValues.set(e.name,n),n}ensure(e,t){return this.has(e)?this.require(e):this.set(e,t())}clearVirtualContext(){this._virtualValues.clear()}setVirtualContext(e,t){this._virtualValues.set(e.name,t)}*entries(){for(let[e,n]of this._durableValues){let r=resolveKey(e);r!==void 0&&(yield[r,n])}}};const globalContextStorage=globalThis;globalContextStorage[EVE_CONTEXT_STORAGE_KEY]===void 0&&(globalContextStorage[EVE_CONTEXT_STORAGE_KEY]=new AsyncLocalStorage);const contextStorage=globalContextStorage[EVE_CONTEXT_STORAGE_KEY];function loadContext(){let e=contextStorage.getStore();if(e===void 0)throw Error(`No active Eve context. Call this function only from authored runtime code such as tools, steps, and model callbacks.`);return e}export{ContextContainer,contextStorage,loadContext};

package/dist/src/context/dynamic-instruction-lifecycle.d.ts

@@ -0,0 +1,26 @@
+import type { ModelMessage, SystemModelMessage } from "ai";
+import type { HandleMessageStreamEvent } from "#protocol/message.js";
+import type { ResolvedDynamicInstructionsResolver } from "#runtime/types.js";
+import type { ContextContainer } from "#context/container.js";
+import type { ContextKey } from "#context/key.js";
+/**
+ * Builds the flattened system messages from session + turn durable keys.
+ * Session-scoped entries appear first.
+ */
+export declare function buildDynamicInstructionMessages(ctx: {
+    get<T>(key: ContextKey<T>): T | undefined;
+}): SystemModelMessage[];
+/**
+ * Dispatches a stream event to dynamic instruction resolvers.
+ *
+ * Each resolver's output replaces its own slot (keyed by slug) in the
+ * scope-appropriate durable key (session or turn). The tool-loop calls
+ * {@link buildDynamicInstructionMessages} to assemble the flattened
+ * result for the model call.
+ */
+export declare function dispatchDynamicInstructionEvent(input: {
+    readonly ctx: ContextContainer;
+    readonly resolvers: readonly ResolvedDynamicInstructionsResolver[];
+    readonly event: HandleMessageStreamEvent;
+    readonly messages: readonly ModelMessage[];
+}): Promise<void>;

package/dist/src/context/dynamic-instruction-lifecycle.js

@@ -0,0 +1 @@
+import{createLogger}from"#internal/logging.js";import{SessionDynamicInstructionsKey,TurnDynamicInstructionsKey}from"#context/keys.js";import{toErrorMessage}from"#shared/errors.js";import{ALLOWED_DYNAMIC_INSTRUCTION_EVENTS,isBrandedInstructionsEntry}from"#shared/dynamic-tool-definition.js";import{buildResolveContext}from"#context/dynamic-resolve-context.js";const log=createLogger(`dynamic-instructions`);function lowerToSystemMessage(e){let t=e.markdown.trim();if(t.length!==0)return{role:`system`,content:t}}function durableKeyForEvent(e){switch(e){case`session.started`:return SessionDynamicInstructionsKey;case`turn.started`:return TurnDynamicInstructionsKey;default:return}}function buildDynamicInstructionMessages(e){let r=e.get(SessionDynamicInstructionsKey)??{},i=e.get(TurnDynamicInstructionsKey)??{};return[...Object.values(r).flat(),...Object.values(i).flat()]}async function dispatchDynamicInstructionEvent(e){let{ctx:t,resolvers:n,event:a,messages:o}=e;if(!ALLOWED_DYNAMIC_INSTRUCTION_EVENTS.has(a.type))return;let s=n.filter(e=>e.eventNames.includes(a.type));if(s.length===0)return;let c=durableKeyForEvent(a.type);if(c===void 0)return;let l=buildResolveContext(t,o),u=await Promise.allSettled(s.map(async e=>{let t=e.events[a.type];if(t===void 0)return null;let n=await t(a,l);return n==null?{resolver:e,message:void 0}:isBrandedInstructionsEntry(n)?{resolver:e,message:lowerToSystemMessage(n)}:(log.error(`Dynamic instructions resolver "${e.slug}" returned an unbranded value — wrap with defineInstructions().`),null)})),d={...t.get(c)};for(let e of u){if(e.status===`rejected`){log.error(`Dynamic instructions resolver (${a.type}) threw — skipping.`,{error:toErrorMessage(e.reason)});continue}if(e.value===null)continue;let{resolver:t,message:n}=e.value;n===void 0?delete d[t.slug]:d[t.slug]=[n]}t.set(c,d)}export{buildDynamicInstructionMessages,dispatchDynamicInstructionEvent};

package/dist/src/context/dynamic-resolve-context.d.ts

@@ -0,0 +1,12 @@
+import type { ModelMessage } from "ai";
+import type { DynamicResolveContext } from "#shared/dynamic-tool-definition.js";
+import type { AlsContext } from "#context/container.js";
+type ReadableContext = Pick<AlsContext, "get">;
+/**
+ * Builds the {@link DynamicResolveContext} from the active ALS context.
+ *
+ * Shared by all three dynamic lifecycle dispatchers (tools, skills,
+ * instructions) so resolver handlers receive a consistent context shape.
+ */
+export declare function buildResolveContext(ctx: ReadableContext, messages: readonly ModelMessage[]): DynamicResolveContext;
+export {};

package/dist/src/context/dynamic-resolve-context.js

@@ -0,0 +1 @@
+import{getAdapterKind}from"#channel/adapter.js";import{AuthKey,ChannelInstrumentationKey,ContinuationTokenKey,InitiatorAuthKey,SessionIdKey}from"#context/keys.js";import{ChannelKey}from"#runtime/sessions/runtime-context-keys.js";function buildResolveContext(e,t){let n=e.get(SessionIdKey)??``,r=e.get(AuthKey)??null,i=e.get(InitiatorAuthKey)??null,a=e.get(ChannelKey),o=e.get(ContinuationTokenKey),s=e.get(ChannelInstrumentationKey);return{session:{id:n,auth:{current:r,initiator:i}},channel:{kind:a===void 0?void 0:getAdapterKind(a),continuationToken:o,metadata:s?.metadata},messages:t}}export{buildResolveContext};