experimental-ash 0.26.0 → 0.28.0

package/dist/src/runtime/governance/network/ip-allow-list.js

@@ -1,66 +1 @@
-import { BlockList, isIP } from "node:net";
-/**
- * Parses exact IP and CIDR entries into a reusable runtime-owned allowlist.
- */
-export function createRuntimeIpAllowList(entries) {
-    const blockList = new BlockList();
-    for (const rawEntry of entries) {
-        const entry = rawEntry.trim();
-        if (entry.length === 0) {
-            throw new Error("Expected every network.ipAllowList entry to be non-empty.");
-        }
-        if (entry.includes("*")) {
-            throw new Error(`Expected "${entry}" to use exact IP or CIDR syntax instead of "*".`);
-        }
-        const slashIndex = entry.indexOf("/");
-        if (slashIndex === -1) {
-            const normalizedAddress = normalizeIpAddress(entry);
-            const family = getIpFamily(normalizedAddress);
-            blockList.addAddress(normalizedAddress, family);
-            continue;
-        }
-        const address = normalizeIpAddress(entry.slice(0, slashIndex));
-        const prefix = Number.parseInt(entry.slice(slashIndex + 1), 10);
-        const family = getIpFamily(address);
-        const maxPrefix = family === "ipv4" ? 32 : 128;
-        if (!Number.isInteger(prefix) || prefix < 0 || prefix > maxPrefix) {
-            throw new Error(`Expected "${entry}" to use a valid ${family} CIDR prefix length.`);
-        }
-        blockList.addSubnet(address, prefix, family);
-    }
-    return {
-        blockList,
-        entries: [...entries],
-    };
-}
-/**
- * Returns whether the normalized request IP matches at least one allowlist
- * entry.
- */
-export function isRuntimeIpAllowed(address, allowList) {
-    const normalizedAddress = normalizeIpAddress(address);
-    const family = getIpFamily(normalizedAddress);
-    return allowList.blockList.check(normalizedAddress, family);
-}
-function normalizeIpAddress(value) {
-    const trimmed = value.trim().replace(/^\[(.*)\]$/, "$1");
-    const percentIndex = trimmed.indexOf("%");
-    const withoutZone = percentIndex === -1 ? trimmed : trimmed.slice(0, percentIndex);
-    if (withoutZone.startsWith("::ffff:")) {
-        const candidate = withoutZone.slice("::ffff:".length);
-        if (isIP(candidate) === 4) {
-            return candidate;
-        }
-    }
-    return withoutZone;
-}
-function getIpFamily(address) {
-    switch (isIP(address)) {
-        case 4:
-            return "ipv4";
-        case 6:
-            return "ipv6";
-        default:
-            throw new Error(`Expected "${address}" to be a valid IP address.`);
-    }
-}
+import{BlockList,isIP}from"node:net";function createRuntimeIpAllowList(t){let n=new BlockList;for(let e of t){let t=e.trim();if(t.length===0)throw Error(`Expected every network.ipAllowList entry to be non-empty.`);if(t.includes(`*`))throw Error(`Expected "${t}" to use exact IP or CIDR syntax instead of "*".`);let r=t.indexOf(`/`);if(r===-1){let e=normalizeIpAddress(t),r=getIpFamily(e);n.addAddress(e,r);continue}let i=normalizeIpAddress(t.slice(0,r)),a=Number.parseInt(t.slice(r+1),10),o=getIpFamily(i),s=o===`ipv4`?32:128;if(!Number.isInteger(a)||a<0||a>s)throw Error(`Expected "${t}" to use a valid ${o} CIDR prefix length.`);n.addSubnet(i,a,o)}return{blockList:n,entries:[...t]}}function isRuntimeIpAllowed(e,t){let n=normalizeIpAddress(e),r=getIpFamily(n);return t.blockList.check(n,r)}function normalizeIpAddress(e){let n=e.trim().replace(/^\[(.*)\]$/,`$1`),r=n.indexOf(`%`),i=r===-1?n:n.slice(0,r);if(i.startsWith(`::ffff:`)){let e=i.slice(7);if(isIP(e)===4)return e}return i}function getIpFamily(e){switch(isIP(e)){case 4:return`ipv4`;case 6:return`ipv6`;default:throw Error(`Expected "${e}" to be a valid IP address.`)}}export{createRuntimeIpAllowList,isRuntimeIpAllowed};

package/dist/src/runtime/graph.js

@@ -1,17 +1 @@
-/**
- * Stable node id used by the runtime-owned graph bundle for the root agent.
- */
-export const ROOT_RUNTIME_AGENT_NODE_ID = "__root__";
-/**
- * Resolves one runtime-owned agent node from the compiled recursive graph.
- */
-export function getResolvedRuntimeAgentNode(bundle, nodeId) {
-    if (nodeId === undefined || nodeId === ROOT_RUNTIME_AGENT_NODE_ID) {
-        return bundle.root;
-    }
-    const node = bundle.nodesByNodeId.get(nodeId);
-    if (node === undefined) {
-        throw new Error(`Missing runtime agent node for node id "${nodeId}".`);
-    }
-    return node;
-}
+var ROOT_RUNTIME_AGENT_NODE_ID=`__root__`;function getResolvedRuntimeAgentNode(e,t){if(t===void 0||t===`__root__`)return e.root;let n=e.nodesByNodeId.get(t);if(n===void 0)throw Error(`Missing runtime agent node for node id "${t}".`);return n}export{ROOT_RUNTIME_AGENT_NODE_ID,getResolvedRuntimeAgentNode};

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

@@ -1,55 +1 @@
-/**
- * Returns an empty registry. Used by tests that build a runtime bundle
- * stub without authored hooks — production registries are constructed
- * via {@link createRuntimeHookRegistry} from the resolved authored
- * graph.
- */
-export function createEmptyHookRegistry() {
-    return {
-        session: [],
-        turn: [],
-        streamEventsByType: new Map(),
-        streamEventsWildcard: [],
-    };
-}
-/**
- * Builds the per-node runtime hook registry from an ordered list of
- * resolved hook definitions.
- *
- * The caller is responsible for sorting the input — discover-time
- * lexicographic ordering on full slug is preserved by the discovery
- * helper, so callers usually pass `resolvedHooks` directly.
- */
-export function createRuntimeHookRegistry(resolvedHooks) {
-    const session = [];
-    const turn = [];
-    const streamEventsByType = new Map();
-    const streamEventsWildcard = [];
-    for (const hook of resolvedHooks) {
-        const sessionFn = hook.lifecycle.session;
-        if (sessionFn !== undefined) {
-            session.push({ slug: hook.slug, handler: sessionFn });
-        }
-        const turnFn = hook.lifecycle.turn;
-        if (turnFn !== undefined) {
-            turn.push({ slug: hook.slug, handler: turnFn });
-        }
-        for (const [eventType, handler] of Object.entries(hook.events)) {
-            const entry = { slug: hook.slug, handler, eventType };
-            if (eventType === "*") {
-                streamEventsWildcard.push(entry);
-            }
-            else {
-                const bucket = streamEventsByType.get(eventType) ?? [];
-                bucket.push(entry);
-                streamEventsByType.set(eventType, bucket);
-            }
-        }
-    }
-    return {
-        session,
-        turn,
-        streamEventsByType,
-        streamEventsWildcard,
-    };
-}
+function createEmptyHookRegistry(){return{session:[],turn:[],streamEventsByType:new Map,streamEventsWildcard:[]}}function createRuntimeHookRegistry(e){let t=[],n=[],r=new Map,i=[];for(let a of e){let e=a.lifecycle.session;e!==void 0&&t.push({slug:a.slug,handler:e});let o=a.lifecycle.turn;o!==void 0&&n.push({slug:a.slug,handler:o});for(let[e,t]of Object.entries(a.events)){let n={slug:a.slug,handler:t,eventType:e};if(e===`*`)i.push(n);else{let t=r.get(e)??[];t.push(n),r.set(e,t)}}}return{session:t,turn:n,streamEventsByType:r,streamEventsWildcard:i}}export{createEmptyHookRegistry,createRuntimeHookRegistry};

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

@@ -1,63 +1 @@
-import { z } from "#compiled/zod/index.js";
-import { runtimeToolCallActionRequestSchema } from "#runtime/actions/types.js";
-/**
- * Zod schema for one input option.
- *
- * Descriptions are included as this schema is used in the `ask_question` tool
- * input, which is surfaced directly to the model.
- */
-export const inputOptionSchema = z
-    .object({
-    description: z.string().describe("Optional additional context for this option.").optional(),
-    id: z.string().describe("Stable identifier for the option."),
-    label: z.string().describe("User-facing label for the option."),
-    style: z
-        .enum(["primary", "danger", "default"])
-        .describe("Visual treatment hint for the option.")
-        .optional(),
-})
-    .strict();
-/**
- * Zod schema for one input request.
- */
-export const inputRequestSchema = z
-    .object({
-    action: runtimeToolCallActionRequestSchema,
-    allowFreeform: z
-        .boolean()
-        .describe("Whether the user may answer with freeform text instead of selecting one of the provided options.")
-        .optional(),
-    display: z
-        .enum(["confirmation", "select", "text"])
-        .describe("Rendering hint — the channel uses this to pick a UX treatment.")
-        .optional(),
-    options: z
-        .array(inputOptionSchema)
-        .describe("Selectable answer options to present to the user.")
-        .optional(),
-    prompt: z.string().describe("The prompt to present to the user."),
-    requestId: z.string().describe("Stable identifier for this request."),
-})
-    .strict();
-/**
- * Zod schema for one input response.
- */
-export const inputResponseSchema = z
-    .object({
-    optionId: z.string().optional(),
-    requestId: z.string(),
-    text: z.string().optional(),
-})
-    .strict();
-/**
- * Returns true when a value matches the input request contract.
- */
-export function isInputRequest(value) {
-    return inputRequestSchema.safeParse(value).success;
-}
-/**
- * Returns true when a value matches the input response contract.
- */
-export function isInputResponse(value) {
-    return inputResponseSchema.safeParse(value).success;
-}
+import{z}from"#compiled/zod/index.js";import{runtimeToolCallActionRequestSchema}from"#runtime/actions/types.js";var inputOptionSchema=z.object({description:z.string().describe(`Optional additional context for this option.`).optional(),id:z.string().describe(`Stable identifier for the option.`),label:z.string().describe(`User-facing label for the option.`),style:z.enum([`primary`,`danger`,`default`]).describe(`Visual treatment hint for the option.`).optional()}).strict(),inputRequestSchema=z.object({action:runtimeToolCallActionRequestSchema,allowFreeform:z.boolean().describe(`Whether the user may answer with freeform text instead of selecting one of the provided options.`).optional(),display:z.enum([`confirmation`,`select`,`text`]).describe(`Rendering hint — the channel uses this to pick a UX treatment.`).optional(),options:z.array(inputOptionSchema).describe(`Selectable answer options to present to the user.`).optional(),prompt:z.string().describe(`The prompt to present to the user.`),requestId:z.string().describe(`Stable identifier for this request.`)}).strict(),inputResponseSchema=z.object({optionId:z.string().optional(),requestId:z.string(),text:z.string().optional()}).strict();function isInputRequest(e){return inputRequestSchema.safeParse(e).success}function isInputResponse(e){return inputResponseSchema.safeParse(e).success}export{inputOptionSchema,inputRequestSchema,inputResponseSchema,isInputRequest,isInputResponse};

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

@@ -1,26 +1 @@
-/**
- * Resolves the stable Ash artifact paths for one application root without
- * depending on Node path helpers.
- */
-export function resolveRuntimeCompilerArtifactPaths(appRoot) {
-    const normalizedAppRoot = normalizeFilesystemPath(appRoot);
-    const discoveryDirectoryPath = `${normalizedAppRoot}/.ash/discovery`;
-    const compileDirectoryPath = `${normalizedAppRoot}/.ash/compile`;
-    return {
-        appRoot: normalizedAppRoot,
-        compiledManifestPath: `${compileDirectoryPath}/compiled-agent-manifest.json`,
-        compileDirectoryPath,
-        compileMetadataPath: `${compileDirectoryPath}/compile-metadata.json`,
-        diagnosticsPath: `${discoveryDirectoryPath}/diagnostics.json`,
-        discoveryDirectoryPath,
-        discoveryManifestPath: `${discoveryDirectoryPath}/agent-discovery-manifest.json`,
-        moduleMapPath: `${compileDirectoryPath}/module-map.mjs`,
-    };
-}
-function normalizeFilesystemPath(path) {
-    const normalized = path.replaceAll("\\", "/");
-    if (normalized === "/") {
-        return normalized;
-    }
-    return normalized.replace(/\/+$/, "");
-}
+function resolveRuntimeCompilerArtifactPaths(e){let t=normalizeFilesystemPath(e),n=`${t}/.ash/discovery`,r=`${t}/.ash/compile`;return{appRoot:t,compiledManifestPath:`${r}/compiled-agent-manifest.json`,compileDirectoryPath:r,compileMetadataPath:`${r}/compile-metadata.json`,diagnosticsPath:`${n}/diagnostics.json`,discoveryDirectoryPath:n,discoveryManifestPath:`${n}/agent-discovery-manifest.json`,moduleMapPath:`${r}/module-map.mjs`}}function normalizeFilesystemPath(e){let t=e.replaceAll(`\\`,`/`);return t===`/`?t:t.replace(/\/+$/,``)}export{resolveRuntimeCompilerArtifactPaths};

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

@@ -1,21 +1 @@
-import { getActiveRuntimeSession } from "#runtime/sessions/runtime-session.js";
-/**
- * Installs one bundled compiled-artifact snapshot on the active runtime
- * session. In production this writes to the process-default session at
- * Nitro bootstrap time; inside a `withRuntimeSession` scope it targets the
- * scoped session so tests cannot leak installations across each other.
- */
-export function installBundledCompiledArtifacts(input) {
-    getActiveRuntimeSession().compiledArtifacts = {
-        manifest: input.manifest,
-        metadata: input.metadata,
-        moduleMap: input.moduleMap,
-    };
-}
-/**
- * Reads the bundled compiled-artifact snapshot for the active runtime
- * session, or `null` if none has been installed.
- */
-export function readBundledCompiledArtifacts() {
-    return getActiveRuntimeSession().compiledArtifacts;
-}
+import{getActiveRuntimeSession}from"#runtime/sessions/runtime-session.js";function installBundledCompiledArtifacts(e){getActiveRuntimeSession().compiledArtifacts={manifest:e.manifest,metadata:e.metadata,moduleMap:e.moduleMap}}function readBundledCompiledArtifacts(){return getActiveRuntimeSession().compiledArtifacts}export{installBundledCompiledArtifacts,readBundledCompiledArtifacts};

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

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

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

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

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

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

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

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

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

@@ -1,23 +1,2 @@
-import { CONNECTION_SEARCH_TOOL_DEFINITION } from "#runtime/framework-tools/connection-search.js";
-const SEARCH = CONNECTION_SEARCH_TOOL_DEFINITION.name;
-/**
- * Formats the "Connections" system prompt section listing all available
- * connections and their descriptions.
- *
- * Called at graph resolution time so the section is part of the turn
- * agent's static instructions rather than injected per-step.
- */
-export function formatConnectionsSection(connections) {
-    const connectionList = connections.map((c) => `- ${c.connectionName}: ${c.description}`);
-    return [
-        "## Connections",
-        "",
-        "You have direct access to the following external services through connected MCP servers.",
-        "When the user's request relates to any of these services, use them instead of web search or general knowledge.",
-        "",
-        "Available connections:",
-        ...connectionList,
-        "",
-        `Use ${SEARCH} to discover specific tools within a connection. Discovered tools become directly callable by their qualified name (e.g. linear__list_issues) in your next response.`,
-    ].join("\n");
-}
+import{CONNECTION_SEARCH_TOOL_DEFINITION}from"#runtime/framework-tools/connection-search.js";var SEARCH=CONNECTION_SEARCH_TOOL_DEFINITION.name;function formatConnectionsSection(e){return[`## Connections`,``,`You have direct access to the following external services through connected MCP servers.`,`When the user's request relates to any of these services, use them instead of web search or general knowledge.`,``,`Available connections:`,...e.map(e=>`- ${e.connectionName}: ${e.description}`),``,`Use ${SEARCH} to discover specific tools within a connection. Discovered tools become directly callable by their qualified name (e.g. linear__list_issues) in your next response.`].join(`
+`)}export{formatConnectionsSection};