experimental-ash 0.26.0 → 0.28.0

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

@@ -1,157 +1 @@
-import { normalizeAgentDefinition } from "#internal/authored-definition/core.js";
-import { formatLanguageModelGatewayId } from "#internal/runtime-model.js";
-import { toErrorMessage } from "#shared/errors.js";
-import { parseJsonObject } from "#shared/json.js";
-import { loadModuleBackedDefinition, } 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. `ash info`)
- * can degrade gracefully when invoked outside a real Ash application.
- */
-export class MissingAgentConfigModuleError extends Error {
-    agentId;
-    constructor(agentId) {
-        super(`Agent "${agentId}" does not have an agent.ts config module. The "model" field is required.`);
-        this.name = "MissingAgentConfigModuleError";
-        this.agentId = agentId;
-    }
-}
-/**
- * Compiles the agent-level configuration (model, compaction, metadata,
- * build, workspace) for one authored agent node.
- */
-export async function compileAgentConfig(manifest, context) {
-    if (manifest.configModule === undefined) {
-        throw new MissingAgentConfigModuleError(manifest.agentId);
-    }
-    const definition = normalizeAgentDefinition(await loadModuleBackedDefinition({
-        agentRoot: manifest.agentRoot,
-        kind: "agent config",
-        source: manifest.configModule,
-    }), `Expected the agent config export "${manifest.configModule.exportName ?? "default"}" from "${manifest.configModule.logicalPath}" to match the public Ash shape.`);
-    const model = await normalizeAuthoredModelReference({
-        modelCatalog: context.modelCatalog,
-        purpose: "the primary compaction trigger model",
-        contextWindowTokens: definition.modelContextWindowTokens,
-        providerOptions: definition.modelOptions?.providerOptions,
-        source: manifest.configModule,
-        value: definition.model,
-    });
-    const compaction = {};
-    const compiledConfig = {
-        compaction,
-        metadata: definition.metadata ?? {},
-        model,
-        name: manifest.agentId,
-    };
-    if (definition.description !== undefined) {
-        compiledConfig.description = definition.description;
-    }
-    if (definition.build !== undefined) {
-        compiledConfig.build = {
-            externalDependencies: definition.build.externalDependencies === undefined
-                ? undefined
-                : [...definition.build.externalDependencies],
-        };
-    }
-    compiledConfig.source = {
-        exportName: manifest.configModule.exportName,
-        sourceKind: "module",
-        logicalPath: manifest.configModule.logicalPath,
-        sourceId: manifest.configModule.sourceId,
-    };
-    if (definition.compaction?.model !== undefined) {
-        compaction.model = await normalizeAuthoredModelReference({
-            modelCatalog: context.modelCatalog,
-            purpose: "the compaction summary model",
-            contextWindowTokens: definition.compaction.modelContextWindowTokens,
-            providerOptions: definition.modelOptions?.providerOptions,
-            source: manifest.configModule,
-            value: definition.compaction.model,
-        });
-    }
-    if (definition.compaction?.thresholdPercent !== undefined) {
-        compaction.thresholdPercent = definition.compaction.thresholdPercent;
-    }
-    return compiledConfig;
-}
-async function normalizeAuthoredModelReference(input) {
-    if (typeof input.value === "string") {
-        return await withCompiledRuntimeModelLimits({
-            id: formatLanguageModelGatewayId(input.value),
-            providerOptions: parseProviderOptionsRecord(input.providerOptions),
-        }, input);
-    }
-    const source = input.source;
-    if (source === undefined) {
-        throw new Error(`Expected ${input.purpose} to provide a valid AI SDK language model reference.`);
-    }
-    // While in TypeScript `input.value` is safe to use, we still validate below against runtime input.
-    const languageModel = input.value;
-    const specificationVersion = languageModel.specificationVersion;
-    if (specificationVersion !== "v2" &&
-        specificationVersion !== "v3" &&
-        specificationVersion !== "v4") {
-        throw new Error(`Expected the authored agent config export "${source.exportName ?? "default"}" from "${source.logicalPath}" to provide a valid AI SDK language model.`);
-    }
-    if (typeof languageModel.provider !== "string" ||
-        typeof languageModel.modelId !== "string" ||
-        typeof languageModel.doGenerate !== "function" ||
-        typeof languageModel.doStream !== "function") {
-        throw new Error(`Expected the authored agent config export "${source.exportName ?? "default"}" from "${source.logicalPath}" to provide a valid AI SDK language model.`);
-    }
-    const sourceBackedModel = {
-        id: formatLanguageModelGatewayId(languageModel),
-        source: {
-            exportName: source.exportName,
-            sourceKind: "module",
-            logicalPath: source.logicalPath,
-            sourceId: source.sourceId,
-        },
-        providerOptions: parseProviderOptionsRecord(input.providerOptions),
-    };
-    if (input.contextWindowTokens === undefined) {
-        const providerResult = await input.modelCatalog.getByProviderModelId(languageModel.provider, languageModel.modelId);
-        if (providerResult) {
-            return {
-                ...sourceBackedModel,
-                id: providerResult.slug,
-                contextWindowTokens: providerResult.limits.contextWindowTokens,
-            };
-        }
-    }
-    return await withCompiledRuntimeModelLimits(sourceBackedModel, input);
-}
-async function withCompiledRuntimeModelLimits(model, input) {
-    if (input.contextWindowTokens !== undefined) {
-        return {
-            ...model,
-            contextWindowTokens: input.contextWindowTokens,
-        };
-    }
-    let limits;
-    try {
-        limits = await input.modelCatalog.getModelLimits(model.id);
-    }
-    catch (error) {
-        throw new Error(`Failed to load AI Gateway model metadata for ${input.purpose} "${model.id}". ${toErrorMessage(error)}`);
-    }
-    if (limits === null) {
-        throw new Error(`Cannot compile agent compaction because ${input.purpose} "${model.id}" does not have known AI Gateway context window metadata.`);
-    }
-    return {
-        ...model,
-        contextWindowTokens: limits.contextWindowTokens,
-    };
-}
-function parseProviderOptionsRecord(value) {
-    if (value === undefined) {
-        return undefined;
-    }
-    const normalized = {};
-    for (const [provider, entry] of Object.entries(value)) {
-        normalized[provider] = parseJsonObject(entry);
-    }
-    return normalized;
-}
+import{toErrorMessage}from"#shared/errors.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,n){if(e.configModule===void 0)throw new MissingAgentConfigModuleError(e.agentId);let r=normalizeAgentDefinition(await loadModuleBackedDefinition({agentRoot:e.agentRoot,kind:`agent config`,source:e.configModule}),`Expected the agent config export "${e.configModule.exportName??`default`}" from "${e.configModule.logicalPath}" to match the public Ash shape.`),a=await normalizeAuthoredModelReference({modelCatalog:n.modelCatalog,purpose:`the primary compaction trigger model`,contextWindowTokens:r.modelContextWindowTokens,providerOptions:r.modelOptions?.providerOptions,source:e.configModule,value:r.model}),o={},s={compaction:o,metadata:r.metadata??{},model:a,name:e.agentId};return r.description!==void 0&&(s.description=r.description),r.build!==void 0&&(s.build={externalDependencies:r.build.externalDependencies===void 0?void 0:[...r.build.externalDependencies]}),s.source={exportName:e.configModule.exportName,sourceKind:`module`,logicalPath:e.configModule.logicalPath,sourceId:e.configModule.sourceId},r.compaction?.model!==void 0&&(o.model=await normalizeAuthoredModelReference({modelCatalog:n.modelCatalog,purpose:`the compaction summary model`,contextWindowTokens:r.compaction.modelContextWindowTokens,providerOptions:r.modelOptions?.providerOptions,source:e.configModule,value:r.compaction.model})),r.compaction?.thresholdPercent!==void 0&&(o.thresholdPercent=r.compaction.thresholdPercent),s}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 r=e.value,i=r.specificationVersion;if(i!==`v2`&&i!==`v3`&&i!==`v4`||typeof r.provider!=`string`||typeof r.modelId!=`string`||typeof r.doGenerate!=`function`||typeof r.doStream!=`function`)throw Error(`Expected the authored agent config export "${t.exportName??`default`}" from "${t.logicalPath}" to provide a valid AI SDK language model.`);let a={id:formatLanguageModelGatewayId(r),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(r.provider,r.modelId);if(t)return{...a,id:t.slug,contextWindowTokens:t.limits.contextWindowTokens}}return await withCompiledRuntimeModelLimits(a,e)}async function withCompiledRuntimeModelLimits(t,n){if(n.contextWindowTokens!==void 0)return{...t,contextWindowTokens:n.contextWindowTokens};let r;try{r=await n.modelCatalog.getModelLimits(t.id)}catch(r){throw Error(`Failed to load AI Gateway model metadata for ${n.purpose} "${t.id}". ${toErrorMessage(r)}`)}if(r===null)throw Error(`Cannot compile agent compaction because ${n.purpose} "${t.id}" does not have known AI Gateway context window metadata.`);return{...t,contextWindowTokens:r.contextWindowTokens}}function parseProviderOptionsRecord(e){if(e===void 0)return;let t={};for(let[n,i]of Object.entries(e))t[n]=parseJsonObject(i);return t}export{MissingAgentConfigModuleError,compileAgentConfig};

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

@@ -1,51 +1 @@
-import { stripLogicalPathExtension } from "#discover/filesystem.js";
-import { normalizeChannelDefinition } from "#internal/authored-definition/channel.js";
-import { isDisabledRouteSentinel } from "#public/definitions/channel.js";
-import { loadModuleBackedDefinition } from "#compiler/normalize-helpers.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 async function compileChannelDefinition(agentRoot, source) {
-    const rawValue = await loadModuleBackedDefinition({
-        agentRoot,
-        kind: "channel",
-        source,
-    });
-    const channelName = stripLogicalPathExtension(source.logicalPath).replace(/^channels\//, "");
-    if (isDisabledRouteSentinel(rawValue)) {
-        return {
-            kind: "disabled",
-            name: channelName,
-            logicalPath: source.logicalPath,
-        };
-    }
-    const definition = normalizeChannelDefinition(rawValue, `Expected the channel export "${source.exportName ?? "default"}" from "${source.logicalPath}" to match the public Ash shape.`);
-    return definition.routes.map((route) => ({
-        kind: "channel",
-        name: channelName,
-        logicalPath: source.logicalPath,
-        method: route.method.toUpperCase(),
-        urlPath: route.path,
-        sourceId: source.sourceId,
-        sourceKind: "module",
-        exportName: source.exportName,
-        adapterKind: extractAdapterKind(definition.adapter),
-    }));
-}
-function extractAdapterKind(adapter) {
-    if (adapter === null || typeof adapter !== "object") {
-        return undefined;
-    }
-    const kind = adapter.kind;
-    return typeof kind === "string" && kind.length > 0 ? kind : undefined;
-}
+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 Ash 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.js

@@ -1,58 +1 @@
-import { normalizeMcpClientConnectionDefinition } from "#internal/authored-definition/connection.js";
-import { loadModuleBackedDefinition } from "#compiler/normalize-helpers.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 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 `ash build`.
- */
-export async function compileConnectionDefinition(agentRoot, source) {
-    const normalized = normalizeMcpClientConnectionDefinition(await loadModuleBackedDefinition({
-        agentRoot,
-        kind: "connection",
-        source,
-    }), `Expected the connection export "${source.exportName ?? "default"}" from "${source.logicalPath}" to match the public Ash shape.`);
-    const compiled = {
-        connectionName: source.connectionName,
-        description: normalized.description,
-        exportName: source.exportName,
-        logicalPath: source.logicalPath,
-        sourceId: source.sourceId,
-        sourceKind: "module",
-        url: normalized.url,
-    };
-    const vercelConnect = extractVercelConnectMarker(normalized.auth);
-    if (vercelConnect !== undefined) {
-        compiled.vercelConnect = vercelConnect;
-    }
-    return compiled;
-}
-/**
- * Reads the optional `vercelConnect: { connector: string }` marker that
- * `@vercel/connect/ash`'s `connect()` helper attaches to its returned
- * authorization definition. Returns the parsed marker when present and
- * shaped correctly, otherwise `undefined`.
- *
- * The compiler does not import `@vercel/connect/ash` (it should not
- * depend on a specific auth provider). Detection is duck-typed against
- * the structural marker contract — any object with a non-empty
- * `vercelConnect.connector` string is recognized.
- */
-function extractVercelConnectMarker(auth) {
-    if (auth === null || typeof auth !== "object") {
-        return undefined;
-    }
-    const marker = auth.vercelConnect;
-    if (marker === null || typeof marker !== "object") {
-        return undefined;
-    }
-    const connector = marker.connector;
-    if (typeof connector !== "string" || connector.length === 0) {
-        return undefined;
-    }
-    return { connector };
-}
+import{loadModuleBackedDefinition}from"#compiler/normalize-helpers.js";import{normalizeMcpClientConnectionDefinition}from"#internal/authored-definition/connection.js";async function compileConnectionDefinition(n,r){let i=normalizeMcpClientConnectionDefinition(await loadModuleBackedDefinition({agentRoot:n,kind:`connection`,source:r}),`Expected the connection export "${r.exportName??`default`}" from "${r.logicalPath}" to match the public Ash shape.`),a={connectionName:r.connectionName,description:i.description,exportName:r.exportName,logicalPath:r.logicalPath,sourceId:r.sourceId,sourceKind:`module`,url:i.url},o=extractVercelConnectMarker(i.auth);return o!==void 0&&(a.vercelConnect=o),a}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.js

@@ -1,23 +1 @@
-import { join } from "node:path";
-import { getAuthoredModuleExport, materializeAuthoredModuleExport, } from "#internal/authored-module.js";
-import { loadAuthoredModuleNamespace } from "#internal/authored-module-loader.js";
-import { toErrorMessage } from "#shared/errors.js";
-/**
- * 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 async function loadModuleBackedDefinition(input) {
-    const moduleNamespace = await loadAuthoredModuleNamespace(join(input.agentRoot, input.source.logicalPath));
-    const exportValue = getAuthoredModuleExport(moduleNamespace, input.source);
-    try {
-        return await materializeAuthoredModuleExport(exportValue);
-    }
-    catch (error) {
-        throw new Error(`Failed to execute the ${input.kind} export "${input.source.exportName ?? "default"}" from "${input.source.logicalPath}": ${toErrorMessage(error)}`);
-    }
-}
+import{getAuthoredModuleExport,materializeAuthoredModuleExport}from"#internal/authored-module.js";import{toErrorMessage}from"#shared/errors.js";import{join}from"node:path";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.source.logicalPath}": ${toErrorMessage(e)}`)}}export{loadModuleBackedDefinition};

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

@@ -1,19 +1 @@
-import { stripLogicalPathExtension } from "../discover/filesystem.js";
-/**
- * Compiles one authored hook module into the manifest entry stored on
- * the compiled agent node.
- *
- * Hook lifecycle 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 function compileHookEntry(source) {
-    return {
-        exportName: source.exportName,
-        logicalPath: source.logicalPath,
-        slug: stripLogicalPathExtension(source.logicalPath).replace(/^hooks\//, ""),
-        sourceId: source.sourceId,
-        sourceKind: "module",
-    };
-}
+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.js

@@ -1,28 +1 @@
-import { stripLogicalPathExtension } from "#discover/filesystem.js";
-import { normalizeInstructionsDefinition } from "#internal/authored-definition/core.js";
-import { loadModuleBackedDefinition } from "#compiler/normalize-helpers.js";
-/**
- * Compiles one authored instructions prompt source (markdown or
- * module-backed `defineInstructions`) into the normalized shape consumed
- * by the runtime.
- *
- * Module-backed 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.
- */
-export async function compileInstructions(agentRoot, source) {
-    const definition = source.sourceKind === "markdown"
-        ? normalizeInstructionsDefinition(source.definition, `Expected the compiled instructions definition at "${source.logicalPath}" to match the public Ash shape.`)
-        : normalizeInstructionsDefinition(await loadModuleBackedDefinition({
-            agentRoot,
-            kind: "instructions",
-            source,
-        }), `Expected the instructions export "${source.exportName ?? "default"}" from "${source.logicalPath}" to match the public Ash shape.`);
-    return {
-        name: stripLogicalPathExtension(source.logicalPath),
-        logicalPath: source.logicalPath,
-        markdown: definition.markdown,
-        sourceId: source.sourceId,
-        sourceKind: source.sourceKind,
-    };
-}
+import{stripLogicalPathExtension}from"#discover/filesystem.js";import{normalizeInstructionsDefinition}from"#internal/authored-definition/core.js";import{loadModuleBackedDefinition}from"#compiler/normalize-helpers.js";async function compileInstructions(e,t){let n=t.sourceKind===`markdown`?normalizeInstructionsDefinition(t.definition,`Expected the compiled instructions definition at "${t.logicalPath}" to match the public Ash shape.`):normalizeInstructionsDefinition(await loadModuleBackedDefinition({agentRoot:e,kind:`instructions`,source:t}),`Expected the instructions export "${t.exportName??`default`}" from "${t.logicalPath}" to match the public Ash shape.`);return{name:stripLogicalPathExtension(t.logicalPath),logicalPath:t.logicalPath,markdown:n.markdown,sourceId:t.sourceId,sourceKind:t.sourceKind}}export{compileInstructions};

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

@@ -1,79 +1 @@
-import { createCompiledAgentManifest, createCompiledAgentNodeManifest, ROOT_COMPILED_AGENT_NODE_ID, } from "#compiler/manifest.js";
-import { createCompiledRuntimeModelCatalogLoader } from "#compiler/model-catalog.js";
-import { compileAgentConfig } from "#compiler/normalize-agent-config.js";
-import { compileChannelDefinition } from "#compiler/normalize-channel.js";
-import { compileConnectionDefinition } from "#compiler/normalize-connection.js";
-import { compileHookEntry } from "#compiler/normalize-hook.js";
-import { compileSandboxDefinition } from "#compiler/normalize-sandbox.js";
-import { compileInstructions } 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";
-/**
- * Compiles one discovery manifest into the normalized manifest loaded by the runtime.
- */
-export async function compileAgentManifest(manifest) {
-    const context = {
-        modelCatalog: createCompiledRuntimeModelCatalogLoader(manifest.appRoot),
-    };
-    const [compiledNode, subagentGraph] = await Promise.all([
-        compileAgentNodeManifest(manifest, context),
-        compileSubagentGraph({
-            appRoot: manifest.appRoot,
-            compileAgentNodeManifest,
-            context,
-            parentNodeId: ROOT_COMPILED_AGENT_NODE_ID,
-            subagents: manifest.subagents,
-        }),
-    ]);
-    return createCompiledAgentManifest({
-        ...compiledNode,
-        remoteAgents: subagentGraph.remoteAgents,
-        subagentEdges: subagentGraph.edges,
-        subagents: subagentGraph.nodes,
-    });
-}
-async function compileAgentNodeManifest(manifest, context) {
-    const compiledToolEntries = await Promise.all(manifest.tools.map((toolSource) => compileToolEntry(manifest.agentRoot, toolSource)));
-    const tools = [];
-    const disabledFrameworkTools = [];
-    for (const entry of compiledToolEntries) {
-        if (entry.kind === "tool") {
-            tools.push(entry.definition);
-        }
-        else {
-            disabledFrameworkTools.push(entry.name);
-        }
-    }
-    const compiledChannelResults = await Promise.all(manifest.channels.map((channelSource) => compileChannelDefinition(manifest.agentRoot, channelSource)));
-    // compileChannelDefinition returns one entry for a disabled-channel
-    // sentinel or an array of entries (one per route) for an authored
-    // CompiledChannel. Flatten so the manifest holds a single channel list.
-    const compiledChannels = compiledChannelResults.flat();
-    return createCompiledAgentNodeManifest({
-        agentRoot: manifest.agentRoot,
-        appRoot: manifest.appRoot,
-        channels: compiledChannels,
-        config: await compileAgentConfig(manifest, context),
-        connections: await Promise.all(manifest.connections.map((connectionSource) => compileConnectionDefinition(manifest.agentRoot, connectionSource))),
-        diagnosticsSummary: manifest.diagnosticsSummary,
-        disabledFrameworkTools,
-        hooks: manifest.hooks.map((hookSource) => compileHookEntry(hookSource)),
-        sandbox: manifest.sandbox === null
-            ? null
-            : await compileSandboxDefinition(manifest.agentRoot, manifest.sandbox),
-        sandboxWorkspaces: manifest.sandboxWorkspaces.map((workspace) => ({
-            logicalPath: workspace.logicalPath,
-            rootEntries: [...workspace.rootEntries],
-            sourceId: workspace.sourceId,
-            sourcePath: workspace.sourcePath,
-        })),
-        schedules: await Promise.all(manifest.schedules.map((scheduleSource) => compileScheduleDefinition(manifest.agentRoot, scheduleSource))),
-        skills: await Promise.all(manifest.skills.map((skillSource) => compileSkillSource(manifest.agentRoot, skillSource))),
-        instructions: manifest.instructions === undefined
-            ? undefined
-            : await compileInstructions(manifest.agentRoot, manifest.instructions),
-        tools,
-    });
-}
+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{compileChannelDefinition}from"#compiler/normalize-channel.js";import{compileConnectionDefinition}from"#compiler/normalize-connection.js";import{compileHookEntry}from"#compiler/normalize-hook.js";import{compileSandboxDefinition}from"#compiler/normalize-sandbox.js";import{compileInstructions}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(n){let i={modelCatalog:createCompiledRuntimeModelCatalogLoader(n.appRoot)},[a,o]=await Promise.all([compileAgentNodeManifest(n,i),compileSubagentGraph({appRoot:n.appRoot,compileAgentNodeManifest,context:i,parentNodeId:ROOT_COMPILED_AGENT_NODE_ID,subagents:n.subagents})]);return createCompiledAgentManifest({...a,remoteAgents:o.remoteAgents,subagentEdges:o.edges,subagents:o.nodes})}async function compileAgentNodeManifest(e,t){let r=await Promise.all(e.tools.map(t=>compileToolEntry(e.agentRoot,t))),s=[],c=[];for(let e of r)e.kind===`tool`?s.push(e.definition):c.push(e.name);let l=(await Promise.all(e.channels.map(t=>compileChannelDefinition(e.agentRoot,t)))).flat();return createCompiledAgentNodeManifest({agentRoot:e.agentRoot,appRoot:e.appRoot,channels:l,config:await compileAgentConfig(e,t),connections:await Promise.all(e.connections.map(t=>compileConnectionDefinition(e.agentRoot,t))),diagnosticsSummary:e.diagnosticsSummary,disabledFrameworkTools:c,hooks:e.hooks.map(e=>compileHookEntry(e)),sandbox:e.sandbox===null?null:await compileSandboxDefinition(e.agentRoot,e.sandbox),sandboxWorkspaces:e.sandboxWorkspaces.map(e=>({logicalPath:e.logicalPath,rootEntries:[...e.rootEntries],sourceId:e.sourceId,sourcePath:e.sourcePath})),schedules:await Promise.all(e.schedules.map(t=>compileScheduleDefinition(e.agentRoot,t))),skills:await Promise.all(e.skills.map(t=>compileSkillSource(e.agentRoot,t))),instructions:e.instructions===void 0?void 0:await compileInstructions(e.agentRoot,e.instructions),tools:s})}export{compileAgentManifest};

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

@@ -1,20 +1 @@
-import { normalizeSandboxDefinition } from "#internal/authored-definition/sandbox.js";
-import { loadModuleBackedDefinition } from "#compiler/normalize-helpers.js";
-/**
- * Compiles one authored sandbox module into the normalized sandbox
- * definition stored on the compiled agent manifest.
- */
-export async function compileSandboxDefinition(agentRoot, source) {
-    const normalized = normalizeSandboxDefinition(await loadModuleBackedDefinition({
-        agentRoot,
-        kind: "sandbox",
-        source,
-    }), `Expected the sandbox export "${source.exportName ?? "default"}" from "${source.logicalPath}" to match the public Ash shape.`);
-    return {
-        description: normalized.description,
-        exportName: source.exportName,
-        logicalPath: source.logicalPath,
-        sourceId: source.sourceId,
-        sourceKind: "module",
-    };
-}
+import{loadModuleBackedDefinition}from"#compiler/normalize-helpers.js";import{normalizeSandboxDefinition}from"#internal/authored-definition/sandbox.js";async function compileSandboxDefinition(e,t){return{description:normalizeSandboxDefinition(await loadModuleBackedDefinition({agentRoot:e,kind:`sandbox`,source:t}),`Expected the sandbox export "${t.exportName??`default`}" from "${t.logicalPath}" to match the public Ash shape.`).description,exportName:t.exportName,logicalPath:t.logicalPath,sourceId:t.sourceId,sourceKind:`module`}}export{compileSandboxDefinition};

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

@@ -1,38 +1 @@
-import { stripLogicalPathExtension } from "#discover/filesystem.js";
-import { normalizeScheduleDefinition } from "#internal/authored-definition/core.js";
-import { loadModuleBackedDefinition } from "#compiler/normalize-helpers.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 async function compileScheduleDefinition(agentRoot, source) {
-    const definition = source.sourceKind === "markdown"
-        ? normalizeScheduleDefinition(source.definition, `Expected the compiled schedule definition at "${source.logicalPath}" to match the public Ash shape.`)
-        : normalizeScheduleDefinition(await loadModuleBackedDefinition({
-            agentRoot,
-            kind: "schedule",
-            source,
-        }), `Expected the schedule export "${source.exportName ?? "default"}" from "${source.logicalPath}" to match the public Ash shape.`);
-    const compiled = {
-        cron: definition.cron,
-        hasRun: definition.run !== undefined,
-        logicalPath: source.logicalPath,
-        name: deriveScheduleName(source.logicalPath),
-        sourceId: source.sourceId,
-        sourceKind: source.sourceKind,
-    };
-    if (definition.markdown !== undefined) {
-        return { ...compiled, markdown: definition.markdown.trim() };
-    }
-    return compiled;
-}
-function deriveScheduleName(logicalPath) {
-    return stripLogicalPathExtension(logicalPath).replace(/^schedules\//, "");
-}
+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 Ash shape.`):normalizeScheduleDefinition(await loadModuleBackedDefinition({agentRoot:e,kind:`schedule`,source:n}),`Expected the schedule export "${n.exportName??`default`}" from "${n.logicalPath}" to match the public Ash 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.js

@@ -1,60 +1 @@
-import { stripLogicalPathExtension } from "#discover/filesystem.js";
-import { normalizeSkillDefinition } from "#internal/authored-definition/core.js";
-import { loadModuleBackedDefinition } from "#compiler/normalize-helpers.js";
-/**
- * Compiles one authored skill source (markdown, module, or skill
- * package directory) into the normalized shape stored on the compiled
- * agent manifest.
- */
-export async function compileSkillSource(agentRoot, source) {
-    if (source.sourceKind === "skill-package") {
-        return compileSkillPackageSource(source);
-    }
-    const definition = source.sourceKind === "markdown"
-        ? normalizeSkillDefinition(source.definition, `Expected the compiled skill definition at "${source.logicalPath}" to match the public Ash shape.`)
-        : normalizeSkillDefinition(await loadModuleBackedDefinition({
-            agentRoot,
-            kind: "skill",
-            source,
-        }), `Expected the skill export "${source.exportName ?? "default"}" from "${source.logicalPath}" to match the public Ash shape.`);
-    const compiled = {
-        description: definition.description,
-        license: definition.license,
-        logicalPath: source.logicalPath,
-        markdown: definition.markdown,
-        metadata: definition.metadata === undefined
-            ? undefined
-            : {
-                ...definition.metadata,
-            },
-        name: stripLogicalPathExtension(source.logicalPath).replace(/^skills\//, ""),
-        sourceId: source.sourceId,
-        sourceKind: source.sourceKind,
-    };
-    if (definition.files !== undefined) {
-        compiled.files = definition.files;
-    }
-    return compiled;
-}
-function compileSkillPackageSource(source) {
-    return {
-        assetsPath: source.assetsPath,
-        description: source.description,
-        license: source.license,
-        logicalPath: source.logicalPath,
-        markdown: source.markdown,
-        metadata: source.metadata === undefined
-            ? undefined
-            : {
-                ...source.metadata,
-            },
-        name: source.name,
-        referencesPath: source.referencesPath,
-        rootPath: source.rootPath,
-        scriptsPath: source.scriptsPath,
-        skillId: source.skillId,
-        skillFilePath: source.skillFilePath,
-        sourceId: source.sourceId,
-        sourceKind: "skill-package",
-    };
-}
+import{stripLogicalPathExtension}from"#discover/filesystem.js";import{normalizeSkillDefinition}from"#internal/authored-definition/core.js";import{loadModuleBackedDefinition}from"#compiler/normalize-helpers.js";async function compileSkillSource(t,n){if(n.sourceKind===`skill-package`)return compileSkillPackageSource(n);let r=n.sourceKind===`markdown`?normalizeSkillDefinition(n.definition,`Expected the compiled skill definition at "${n.logicalPath}" to match the public Ash shape.`):normalizeSkillDefinition(await loadModuleBackedDefinition({agentRoot:t,kind:`skill`,source:n}),`Expected the skill export "${n.exportName??`default`}" from "${n.logicalPath}" to match the public Ash shape.`),i={description:r.description,license:r.license,logicalPath:n.logicalPath,markdown:r.markdown,metadata:r.metadata===void 0?void 0:{...r.metadata},name:stripLogicalPathExtension(n.logicalPath).replace(/^skills\//,``),sourceId:n.sourceId,sourceKind:n.sourceKind};return r.files!==void 0&&(i.files=r.files),i}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};