experimental-ash 0.26.0 → 0.27.0

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};

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

@@ -1,287 +1 @@
-import { ROOT_COMPILED_AGENT_NODE_ID } from "#compiler/manifest.js";
-import { expectObjectRecord } from "#internal/authored-module.js";
-import { createResolvedRuntimeTurnAgent } from "#runtime/agent/bootstrap.js";
-import { getAllFrameworkChannelNames, getFrameworkChannelDefinitions, } from "#runtime/framework-channels/index.js";
-import { CONNECTION_SEARCH_TOOL_DEFINITION } from "#runtime/framework-tools/connection-search.js";
-import { getAllFrameworkToolNames, getFrameworkToolDefinitions, } from "#runtime/framework-tools/index.js";
-import { ROOT_RUNTIME_AGENT_NODE_ID } from "#runtime/graph.js";
-import { createRuntimeHookRegistry } from "#runtime/hooks/registry.js";
-import { resolveAgent } from "#runtime/resolve-agent.js";
-import { loadResolvedModuleExport } from "#runtime/resolve-helpers.js";
-import { createRuntimeSandboxRegistry } from "#runtime/sandbox/registry.js";
-import { LOAD_SKILL_TOOL_NAME } from "#runtime/skills/fragment-context.js";
-import { createRuntimeSubagentRegistry } from "#runtime/subagents/registry.js";
-import { createRuntimeToolRegistry } from "#runtime/tools/registry.js";
-/**
- * Error raised when the flattened compiled authored graph cannot be hydrated
- * into a runtime-owned agent graph.
- */
-class ResolveRuntimeAgentGraphError extends Error {
-    logicalPath;
-    nodeId;
-    sourceId;
-    constructor(message, input = {}) {
-        super(message);
-        this.name = "ResolveRuntimeAgentGraphError";
-        if (input.logicalPath !== undefined) {
-            this.logicalPath = input.logicalPath;
-        }
-        if (input.nodeId !== undefined) {
-            this.nodeId = input.nodeId;
-        }
-        if (input.sourceId !== undefined) {
-            this.sourceId = input.sourceId;
-        }
-    }
-}
-/**
- * Resolves the compiled authored manifest and flattened module graph into one
- * runtime-owned bundle of agent nodes.
- */
-export async function resolveRuntimeAgentGraph(input) {
-    const nodesByNodeId = new Map();
-    const childNodeIdsByParentNodeId = createChildNodeIdsByParentNodeId(input.manifest);
-    const subagentNodesById = new Map(input.manifest.subagents.map((subagentNode) => [subagentNode.nodeId, subagentNode]));
-    const root = await resolveRuntimeAgentNode({
-        childNodeIdsByParentNodeId,
-        manifest: input.manifest,
-        moduleMap: input.moduleMap,
-        nodeId: ROOT_COMPILED_AGENT_NODE_ID,
-        nodesByNodeId,
-        subagentNodesById,
-    });
-    return {
-        nodesByNodeId,
-        root,
-    };
-}
-async function resolveRuntimeAgentNode(input) {
-    const nodeId = toRuntimeNodeId(input.nodeId);
-    if (input.nodesByNodeId.has(nodeId)) {
-        throw new ResolveRuntimeAgentGraphError(`Found multiple runtime agent nodes for node id "${nodeId}".`, {
-            nodeId,
-            sourceId: input.sourceId,
-        });
-    }
-    const agent = await resolveAgent({
-        manifest: input.manifest,
-        moduleMap: input.moduleMap,
-        nodeId: input.nodeId,
-    });
-    const hasConnections = agent.connections.length > 0;
-    const baseFrameworkTools = getFrameworkToolDefinitions({
-        hasConnections,
-    });
-    const frameworkTools = hasConnections
-        ? enrichConnectionSearchDescription(baseFrameworkTools, agent.connections)
-        : baseFrameworkTools;
-    const frameworkToolNames = new Set(frameworkTools.map((t) => t.name));
-    const allFrameworkToolNames = getAllFrameworkToolNames();
-    // Authored tools whose filename slug matches a framework default replace
-    // it. Authored disable sentinels (whose target is also taken from the
-    // file's slug) remove a framework default. Both interactions happen here,
-    // before the registry is built, so the duplicate-name guard inside
-    // `createRuntimeToolRegistry` keeps doing its job for authored-vs-authored
-    // collisions.
-    const authoredToolNames = new Set(agent.tools.map((tool) => tool.name));
-    for (const disabledName of agent.disabledFrameworkTools) {
-        if (!allFrameworkToolNames.has(disabledName)) {
-            throw new ResolveRuntimeAgentGraphError(`agent/tools/${disabledName}.ts exports disableTool() but "${disabledName}" is not a framework tool. ` +
-                `Rename the file to one of: ${[...allFrameworkToolNames].sort().join(", ")}.`, {
-                nodeId,
-                sourceId: input.sourceId,
-            });
-        }
-    }
-    const disabledFrameworkTools = new Set(agent.disabledFrameworkTools);
-    const activeFrameworkTools = frameworkTools.filter((tool) => !authoredToolNames.has(tool.name) && !disabledFrameworkTools.has(tool.name));
-    const toolRegistry = await createRuntimeToolRegistry({
-        tools: [...activeFrameworkTools, ...agent.tools],
-    }, {
-        reservedToolNames: frameworkToolNames.has(LOAD_SKILL_TOOL_NAME) || authoredToolNames.has(LOAD_SKILL_TOOL_NAME)
-            ? []
-            : [LOAD_SKILL_TOOL_NAME],
-    });
-    // Authored channels override framework defaults by matching logical name;
-    // disable sentinels remove framework defaults with the same name.
-    const authoredChannelNames = new Set(agent.channels.map((channel) => channel.name));
-    const allFrameworkChannelNames = getAllFrameworkChannelNames();
-    for (const disabledName of agent.disabledFrameworkChannels) {
-        if (!allFrameworkChannelNames.has(disabledName)) {
-            throw new ResolveRuntimeAgentGraphError(`agent/channels/${disabledName}.ts exports disableRoute() but "${disabledName}" is not a framework channel. ` +
-                `Rename the file to one of: ${[...allFrameworkChannelNames].sort().join(", ")}.`, {
-                nodeId,
-                sourceId: input.sourceId,
-            });
-        }
-    }
-    const disabledFrameworkChannels = new Set(agent.disabledFrameworkChannels);
-    const activeFrameworkChannels = getFrameworkChannelDefinitions().filter((channel) => !authoredChannelNames.has(channel.name) && !disabledFrameworkChannels.has(channel.name));
-    const channels = [
-        ...activeFrameworkChannels,
-        ...agent.channels,
-    ];
-    const sandboxRegistry = createRuntimeSandboxRegistry({
-        authoredSandbox: agent.sandbox,
-        workspaceResourceRoot: agent.workspaceResourceRoot,
-    });
-    const subagentRegistry = createRuntimeSubagentRegistry({
-        reservedToolNames: [
-            LOAD_SKILL_TOOL_NAME,
-            ...toolRegistry.preparedTools.map((tool) => tool.name),
-        ],
-        subagents: await resolveRuntimeSubagents({
-            childNodeIdsByParentNodeId: input.childNodeIdsByParentNodeId,
-            manifest: input.manifest,
-            moduleMap: input.moduleMap,
-            nodesByNodeId: input.nodesByNodeId,
-            parentNodeId: input.nodeId,
-            subagentNodesById: input.subagentNodesById,
-        }),
-    });
-    const node = {
-        agent,
-        channels,
-        hookRegistry: createRuntimeHookRegistry(agent.hooks),
-        nodeId,
-        sandboxRegistry,
-        sourceId: input.sourceId,
-        subagentRegistry,
-        toolRegistry,
-        turnAgent: createResolvedRuntimeTurnAgent({
-            agent,
-            nodeId,
-            tools: [...toolRegistry.preparedTools, ...subagentRegistry.preparedTools],
-        }),
-    };
-    input.nodesByNodeId.set(nodeId, node);
-    return node;
-}
-async function resolveRuntimeSubagents(input) {
-    const resolvedSubagents = [];
-    const childNodeIds = input.childNodeIdsByParentNodeId.get(input.parentNodeId) ?? [];
-    for (const childNodeId of childNodeIds) {
-        const sourceRef = input.subagentNodesById.get(childNodeId);
-        if (sourceRef === undefined) {
-            throw new ResolveRuntimeAgentGraphError(`Missing compiled subagent node "${childNodeId}" while resolving runtime subagents.`, {
-                nodeId: toRuntimeNodeId(input.parentNodeId),
-                sourceId: childNodeId,
-            });
-        }
-        resolvedSubagents.push(await resolveRuntimeSubagent({
-            childNodeIdsByParentNodeId: input.childNodeIdsByParentNodeId,
-            moduleMap: input.moduleMap,
-            nodesByNodeId: input.nodesByNodeId,
-            sourceRef,
-            subagentNodesById: input.subagentNodesById,
-        }));
-    }
-    for (const remoteAgent of input.manifest.remoteAgents) {
-        resolvedSubagents.push(await resolveRuntimeRemoteAgent({
-            moduleMap: input.moduleMap,
-            nodeScopeId: input.parentNodeId,
-            sourceRef: remoteAgent,
-        }));
-    }
-    return resolvedSubagents;
-}
-async function resolveRuntimeSubagent(input) {
-    const resolvedSubagent = {
-        description: input.sourceRef.description,
-        kind: "subagent",
-        logicalPath: input.sourceRef.logicalPath,
-        name: input.sourceRef.name,
-        nodeId: toRuntimeNodeId(input.sourceRef.nodeId),
-        sourceId: input.sourceRef.sourceId,
-        sourceKind: "module",
-    };
-    await resolveRuntimeAgentNode({
-        childNodeIdsByParentNodeId: input.childNodeIdsByParentNodeId,
-        manifest: input.sourceRef.agent,
-        moduleMap: input.moduleMap,
-        nodeId: input.sourceRef.nodeId,
-        nodesByNodeId: input.nodesByNodeId,
-        sourceId: input.sourceRef.sourceId,
-        subagentNodesById: input.subagentNodesById,
-    });
-    return resolvedSubagent;
-}
-async function resolveRuntimeRemoteAgent(input) {
-    const resolvedExportValue = await loadResolvedModuleExport({
-        definition: input.sourceRef,
-        kindLabel: "remote agent",
-        moduleMap: input.moduleMap,
-        nodeId: input.nodeScopeId,
-    });
-    const resolvedRecord = expectObjectRecord(resolvedExportValue, `Expected remote agent source "${input.sourceRef.logicalPath}" to export an object.`);
-    const resolvedRemoteAgent = {
-        description: input.sourceRef.description,
-        kind: "remote",
-        logicalPath: input.sourceRef.logicalPath,
-        name: input.sourceRef.name,
-        nodeId: toRuntimeNodeId(input.sourceRef.nodeId),
-        path: input.sourceRef.path,
-        sourceId: input.sourceRef.sourceId,
-        sourceKind: "module",
-        url: input.sourceRef.url,
-    };
-    if (typeof resolvedRecord.auth === "function") {
-        resolvedRemoteAgent.auth = resolvedRecord.auth;
-    }
-    const headers = resolveRemoteAgentHeaders(resolvedRecord.headers);
-    if (headers !== undefined) {
-        resolvedRemoteAgent.headers = headers;
-    }
-    return resolvedRemoteAgent;
-}
-function resolveRemoteAgentHeaders(value) {
-    if (value === undefined) {
-        return undefined;
-    }
-    if (typeof value === "function") {
-        return value;
-    }
-    if (typeof value !== "object" || value === null || Array.isArray(value)) {
-        return undefined;
-    }
-    const headers = {};
-    for (const [headerName, headerValue] of Object.entries(value)) {
-        if (typeof headerValue === "string") {
-            headers[headerName] = headerValue;
-        }
-    }
-    return headers;
-}
-function createChildNodeIdsByParentNodeId(manifest) {
-    const childNodeIdsByParentNodeId = new Map();
-    for (const edge of manifest.subagentEdges) {
-        const existing = childNodeIdsByParentNodeId.get(edge.parentNodeId);
-        if (existing === undefined) {
-            childNodeIdsByParentNodeId.set(edge.parentNodeId, [edge.childNodeId]);
-            continue;
-        }
-        existing.push(edge.childNodeId);
-    }
-    return childNodeIdsByParentNodeId;
-}
-function toRuntimeNodeId(nodeId) {
-    return nodeId === ROOT_COMPILED_AGENT_NODE_ID ? ROOT_RUNTIME_AGENT_NODE_ID : nodeId;
-}
-const CONNECTION_SEARCH_NAME = CONNECTION_SEARCH_TOOL_DEFINITION.name;
-/**
- * Returns a copy of `tools` where the `connection_search` tool's description
- * is enriched with the list of available connection names so the model can
- * cross-reference them with the detailed Connections section in the system
- * prompt.
- */
-function enrichConnectionSearchDescription(tools, connections) {
-    const names = connections.map((c) => c.connectionName).join(", ");
-    return tools.map((tool) => {
-        if (tool.name !== CONNECTION_SEARCH_NAME)
-            return tool;
-        return {
-            ...tool,
-            description: `${tool.description} Available connections: ${names}.`,
-        };
-    });
-}
+import{expectObjectRecord}from"#internal/authored-module.js";import{ROOT_COMPILED_AGENT_NODE_ID}from"#compiler/manifest.js";import{CONNECTION_SEARCH_TOOL_DEFINITION}from"#runtime/framework-tools/connection-search.js";import{createRuntimeToolRegistry}from"#runtime/tools/registry.js";import{ROOT_RUNTIME_AGENT_NODE_ID}from"#runtime/graph.js";import{getAllFrameworkChannelNames,getFrameworkChannelDefinitions}from"#runtime/framework-channels/index.js";import{resolveAgent}from"#runtime/resolve-agent.js";import{loadResolvedModuleExport}from"#runtime/resolve-helpers.js";import{createResolvedRuntimeTurnAgent}from"#runtime/agent/bootstrap.js";import{LOAD_SKILL_TOOL_NAME}from"#runtime/skills/fragment-context.js";import{getAllFrameworkToolNames,getFrameworkToolDefinitions}from"#runtime/framework-tools/index.js";import{createRuntimeHookRegistry}from"#runtime/hooks/registry.js";import{createRuntimeSandboxRegistry}from"#runtime/sandbox/registry.js";import{createRuntimeSubagentRegistry}from"#runtime/subagents/registry.js";var ResolveRuntimeAgentGraphError=class extends Error{logicalPath;nodeId;sourceId;constructor(e,t={}){super(e),this.name=`ResolveRuntimeAgentGraphError`,t.logicalPath!==void 0&&(this.logicalPath=t.logicalPath),t.nodeId!==void 0&&(this.nodeId=t.nodeId),t.sourceId!==void 0&&(this.sourceId=t.sourceId)}};async function resolveRuntimeAgentGraph(e){let n=new Map,r=createChildNodeIdsByParentNodeId(e.manifest),i=new Map(e.manifest.subagents.map(e=>[e.nodeId,e]));return{nodesByNodeId:n,root:await resolveRuntimeAgentNode({childNodeIdsByParentNodeId:r,manifest:e.manifest,moduleMap:e.moduleMap,nodeId:ROOT_COMPILED_AGENT_NODE_ID,nodesByNodeId:n,subagentNodesById:i})}}async function resolveRuntimeAgentNode(e){let t=toRuntimeNodeId(e.nodeId);if(e.nodesByNodeId.has(t))throw new ResolveRuntimeAgentGraphError(`Found multiple runtime agent nodes for node id "${t}".`,{nodeId:t,sourceId:e.sourceId});let n=await resolveAgent({manifest:e.manifest,moduleMap:e.moduleMap,nodeId:e.nodeId}),i=n.connections.length>0,a=getFrameworkToolDefinitions({hasConnections:i}),o=i?enrichConnectionSearchDescription(a,n.connections):a,s=new Set(o.map(e=>e.name)),c=getAllFrameworkToolNames(),l=new Set(n.tools.map(e=>e.name));for(let r of n.disabledFrameworkTools)if(!c.has(r))throw new ResolveRuntimeAgentGraphError(`agent/tools/${r}.ts exports disableTool() but "${r}" is not a framework tool. Rename the file to one of: ${[...c].sort().join(`, `)}.`,{nodeId:t,sourceId:e.sourceId});let u=new Set(n.disabledFrameworkTools),d=await createRuntimeToolRegistry({tools:[...o.filter(e=>!l.has(e.name)&&!u.has(e.name)),...n.tools]},{reservedToolNames:s.has(LOAD_SKILL_TOOL_NAME)||l.has(LOAD_SKILL_TOOL_NAME)?[]:[LOAD_SKILL_TOOL_NAME]}),f=new Set(n.channels.map(e=>e.name)),p=getAllFrameworkChannelNames();for(let r of n.disabledFrameworkChannels)if(!p.has(r))throw new ResolveRuntimeAgentGraphError(`agent/channels/${r}.ts exports disableRoute() but "${r}" is not a framework channel. Rename the file to one of: ${[...p].sort().join(`, `)}.`,{nodeId:t,sourceId:e.sourceId});let m=new Set(n.disabledFrameworkChannels),h=[...getFrameworkChannelDefinitions().filter(e=>!f.has(e.name)&&!m.has(e.name)),...n.channels],g=createRuntimeSandboxRegistry({authoredSandbox:n.sandbox,workspaceResourceRoot:n.workspaceResourceRoot}),_=createRuntimeSubagentRegistry({reservedToolNames:[LOAD_SKILL_TOOL_NAME,...d.preparedTools.map(e=>e.name)],subagents:await resolveRuntimeSubagents({childNodeIdsByParentNodeId:e.childNodeIdsByParentNodeId,manifest:e.manifest,moduleMap:e.moduleMap,nodesByNodeId:e.nodesByNodeId,parentNodeId:e.nodeId,subagentNodesById:e.subagentNodesById})}),v={agent:n,channels:h,hookRegistry:createRuntimeHookRegistry(n.hooks),nodeId:t,sandboxRegistry:g,sourceId:e.sourceId,subagentRegistry:_,toolRegistry:d,turnAgent:createResolvedRuntimeTurnAgent({agent:n,nodeId:t,tools:[...d.preparedTools,..._.preparedTools]})};return e.nodesByNodeId.set(t,v),v}async function resolveRuntimeSubagents(e){let t=[],n=e.childNodeIdsByParentNodeId.get(e.parentNodeId)??[];for(let r of n){let n=e.subagentNodesById.get(r);if(n===void 0)throw new ResolveRuntimeAgentGraphError(`Missing compiled subagent node "${r}" while resolving runtime subagents.`,{nodeId:toRuntimeNodeId(e.parentNodeId),sourceId:r});t.push(await resolveRuntimeSubagent({childNodeIdsByParentNodeId:e.childNodeIdsByParentNodeId,moduleMap:e.moduleMap,nodesByNodeId:e.nodesByNodeId,sourceRef:n,subagentNodesById:e.subagentNodesById}))}for(let n of e.manifest.remoteAgents)t.push(await resolveRuntimeRemoteAgent({moduleMap:e.moduleMap,nodeScopeId:e.parentNodeId,sourceRef:n}));return t}async function resolveRuntimeSubagent(e){let t={description:e.sourceRef.description,kind:`subagent`,logicalPath:e.sourceRef.logicalPath,name:e.sourceRef.name,nodeId:toRuntimeNodeId(e.sourceRef.nodeId),sourceId:e.sourceRef.sourceId,sourceKind:`module`};return await resolveRuntimeAgentNode({childNodeIdsByParentNodeId:e.childNodeIdsByParentNodeId,manifest:e.sourceRef.agent,moduleMap:e.moduleMap,nodeId:e.sourceRef.nodeId,nodesByNodeId:e.nodesByNodeId,sourceId:e.sourceRef.sourceId,subagentNodesById:e.subagentNodesById}),t}async function resolveRuntimeRemoteAgent(t){let n=expectObjectRecord(await loadResolvedModuleExport({definition:t.sourceRef,kindLabel:`remote agent`,moduleMap:t.moduleMap,nodeId:t.nodeScopeId}),`Expected remote agent source "${t.sourceRef.logicalPath}" to export an object.`),r={description:t.sourceRef.description,kind:`remote`,logicalPath:t.sourceRef.logicalPath,name:t.sourceRef.name,nodeId:toRuntimeNodeId(t.sourceRef.nodeId),path:t.sourceRef.path,sourceId:t.sourceRef.sourceId,sourceKind:`module`,url:t.sourceRef.url};typeof n.auth==`function`&&(r.auth=n.auth);let i=resolveRemoteAgentHeaders(n.headers);return i!==void 0&&(r.headers=i),r}function resolveRemoteAgentHeaders(e){if(e===void 0)return;if(typeof e==`function`)return e;if(typeof e!=`object`||!e||Array.isArray(e))return;let t={};for(let[n,r]of Object.entries(e))typeof r==`string`&&(t[n]=r);return t}function createChildNodeIdsByParentNodeId(e){let t=new Map;for(let n of e.subagentEdges){let e=t.get(n.parentNodeId);if(e===void 0){t.set(n.parentNodeId,[n.childNodeId]);continue}e.push(n.childNodeId)}return t}function toRuntimeNodeId(e){return e===ROOT_COMPILED_AGENT_NODE_ID?ROOT_RUNTIME_AGENT_NODE_ID:e}var CONNECTION_SEARCH_NAME=CONNECTION_SEARCH_TOOL_DEFINITION.name;function enrichConnectionSearchDescription(e,t){let n=t.map(e=>e.connectionName).join(`, `);return e.map(e=>e.name===CONNECTION_SEARCH_NAME?{...e,description:`${e.description} Available connections: ${n}.`}:e)}export{resolveRuntimeAgentGraph};

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

@@ -1,134 +1 @@
-import { resolveChannelDefinition } from "#runtime/resolve-channel.js";
-// Re-exported so external consumers (tests, integrations) can keep
-// importing the error class from this path even though it now lives
-// in resolve-helpers.ts.
-export { ResolveAgentError } from "#runtime/resolve-helpers.js";
-import { resolveConnectionDefinition } from "#runtime/resolve-connection.js";
-import { resolveHookDefinition } from "#runtime/resolve-hook.js";
-import { createResolvedModuleSourceRef } from "#runtime/resolve-helpers.js";
-import { resolveSandboxDefinition } from "#runtime/resolve-sandbox.js";
-import { resolveToolDefinition } from "#runtime/resolve-tool.js";
-/**
- * Resolves the core authored agent path from compiled artifacts.
- */
-export async function resolveAgent(input) {
-    const resolvedSkills = input.manifest.skills.map((skill) => ({
-        ...skill,
-        metadata: skill.metadata === undefined
-            ? undefined
-            : {
-                ...skill.metadata,
-            },
-    }));
-    // Disabled channel entries (kind === "disabled") are filtered out here
-    // and surfaced separately on `ResolvedAgent.disabledFrameworkChannels`
-    // so the graph resolver can remove the corresponding framework defaults.
-    const resolvedChannels = [];
-    const disabledFrameworkChannels = [];
-    for (const channelEntry of input.manifest.channels) {
-        if (channelEntry.kind === "disabled") {
-            disabledFrameworkChannels.push(channelEntry.name);
-            continue;
-        }
-        resolvedChannels.push(await resolveChannelDefinition(channelEntry, input.moduleMap, input.nodeId));
-    }
-    const resolvedTools = await Promise.all(input.manifest.tools.map((toolDefinition) => resolveToolDefinition(toolDefinition, input.moduleMap, input.nodeId)));
-    // Hook resolution preserves the manifest's lexicographic-on-slug order
-    // produced by the discovery walker; the per-node registry inherits
-    // that order.
-    const resolvedHooks = await Promise.all(input.manifest.hooks.map((hookDefinition) => resolveHookDefinition(hookDefinition, input.moduleMap, input.nodeId)));
-    const resolvedConnections = await Promise.all(input.manifest.connections.map((connectionDefinition) => resolveConnectionDefinition(connectionDefinition, input.moduleMap, input.nodeId)));
-    const authoredSandbox = input.manifest.sandbox === null
-        ? null
-        : await resolveSandboxDefinition(input.manifest.sandbox, input.moduleMap, input.nodeId);
-    const instructions = createResolvedInstructions(input.manifest.instructions);
-    const workspaceResourceRoot = input.manifest.workspaceResourceRoot;
-    const resolvedAgent = {
-        channels: resolvedChannels,
-        config: createResolvedAgentConfig(input.manifest),
-        connections: resolvedConnections,
-        disabledFrameworkChannels,
-        disabledFrameworkTools: [...input.manifest.disabledFrameworkTools],
-        hooks: resolvedHooks,
-        metadata: {
-            agentRoot: input.manifest.agentRoot,
-            appRoot: input.manifest.appRoot,
-            diagnosticsSummary: input.manifest.diagnosticsSummary,
-        },
-        sandbox: authoredSandbox,
-        workspaceResourceRoot,
-        skills: resolvedSkills,
-        tools: resolvedTools,
-        workspaceSpec: { rootEntries: [...workspaceResourceRoot.rootEntries] },
-    };
-    if (instructions !== undefined) {
-        return { ...resolvedAgent, instructions };
-    }
-    return resolvedAgent;
-}
-function createResolvedInstructions(instructions) {
-    if (instructions === undefined) {
-        return undefined;
-    }
-    return {
-        name: instructions.name,
-        logicalPath: instructions.logicalPath,
-        markdown: instructions.markdown,
-        sourceId: instructions.sourceId,
-        sourceKind: instructions.sourceKind,
-    };
-}
-function createResolvedAgentConfig(manifest) {
-    const config = {
-        metadata: { ...manifest.config.metadata },
-        model: manifest.config.model.source === undefined
-            ? {
-                id: manifest.config.model.id,
-                contextWindowTokens: manifest.config.model.contextWindowTokens,
-                providerOptions: manifest.config.model.providerOptions,
-            }
-            : {
-                contextWindowTokens: manifest.config.model.contextWindowTokens,
-                id: manifest.config.model.id,
-                providerOptions: manifest.config.model.providerOptions,
-                source: {
-                    exportName: manifest.config.model.source.exportName,
-                    sourceKind: "module",
-                    logicalPath: manifest.config.model.source.logicalPath,
-                    sourceId: manifest.config.model.source.sourceId,
-                },
-            },
-        name: manifest.config.name,
-    };
-    if (manifest.config.compaction !== undefined) {
-        const compaction = {};
-        if (manifest.config.compaction.model !== undefined) {
-            compaction.model =
-                manifest.config.compaction.model.source === undefined
-                    ? {
-                        contextWindowTokens: manifest.config.compaction.model.contextWindowTokens,
-                        id: manifest.config.compaction.model.id,
-                        providerOptions: manifest.config.compaction.model.providerOptions,
-                    }
-                    : {
-                        contextWindowTokens: manifest.config.compaction.model.contextWindowTokens,
-                        id: manifest.config.compaction.model.id,
-                        providerOptions: manifest.config.compaction.model.providerOptions,
-                        source: {
-                            exportName: manifest.config.compaction.model.source.exportName,
-                            sourceKind: "module",
-                            logicalPath: manifest.config.compaction.model.source.logicalPath,
-                            sourceId: manifest.config.compaction.model.source.sourceId,
-                        },
-                    };
-        }
-        if (manifest.config.compaction.thresholdPercent !== undefined) {
-            compaction.thresholdPercent = manifest.config.compaction.thresholdPercent;
-        }
-        config.compaction = compaction;
-    }
-    if (manifest.config.source !== undefined) {
-        config.source = createResolvedModuleSourceRef(manifest.config.source);
-    }
-    return config;
-}
+import{ResolveAgentError,createResolvedModuleSourceRef}from"#runtime/resolve-helpers.js";import{resolveChannelDefinition}from"#runtime/resolve-channel.js";import{resolveConnectionDefinition}from"#runtime/resolve-connection.js";import{resolveHookDefinition}from"#runtime/resolve-hook.js";import{resolveSandboxDefinition}from"#runtime/resolve-sandbox.js";import{resolveToolDefinition}from"#runtime/resolve-tool.js";async function resolveAgent(e){let t=e.manifest.skills.map(e=>({...e,metadata:e.metadata===void 0?void 0:{...e.metadata}})),r=[],i=[];for(let t of e.manifest.channels){if(t.kind===`disabled`){i.push(t.name);continue}r.push(await resolveChannelDefinition(t,e.moduleMap,e.nodeId))}let a=await Promise.all(e.manifest.tools.map(t=>resolveToolDefinition(t,e.moduleMap,e.nodeId))),o=await Promise.all(e.manifest.hooks.map(t=>resolveHookDefinition(t,e.moduleMap,e.nodeId))),s=await Promise.all(e.manifest.connections.map(t=>resolveConnectionDefinition(t,e.moduleMap,e.nodeId))),c=e.manifest.sandbox===null?null:await resolveSandboxDefinition(e.manifest.sandbox,e.moduleMap,e.nodeId),l=createResolvedInstructions(e.manifest.instructions),u=e.manifest.workspaceResourceRoot,d={channels:r,config:createResolvedAgentConfig(e.manifest),connections:s,disabledFrameworkChannels:i,disabledFrameworkTools:[...e.manifest.disabledFrameworkTools],hooks:o,metadata:{agentRoot:e.manifest.agentRoot,appRoot:e.manifest.appRoot,diagnosticsSummary:e.manifest.diagnosticsSummary},sandbox:c,workspaceResourceRoot:u,skills:t,tools:a,workspaceSpec:{rootEntries:[...u.rootEntries]}};return l===void 0?d:{...d,instructions:l}}function createResolvedInstructions(e){if(e!==void 0)return{name:e.name,logicalPath:e.logicalPath,markdown:e.markdown,sourceId:e.sourceId,sourceKind:e.sourceKind}}function createResolvedAgentConfig(e){let n={metadata:{...e.config.metadata},model:e.config.model.source===void 0?{id:e.config.model.id,contextWindowTokens:e.config.model.contextWindowTokens,providerOptions:e.config.model.providerOptions}:{contextWindowTokens:e.config.model.contextWindowTokens,id:e.config.model.id,providerOptions:e.config.model.providerOptions,source:{exportName:e.config.model.source.exportName,sourceKind:`module`,logicalPath:e.config.model.source.logicalPath,sourceId:e.config.model.source.sourceId}},name:e.config.name};if(e.config.compaction!==void 0){let t={};e.config.compaction.model!==void 0&&(t.model=e.config.compaction.model.source===void 0?{contextWindowTokens:e.config.compaction.model.contextWindowTokens,id:e.config.compaction.model.id,providerOptions:e.config.compaction.model.providerOptions}:{contextWindowTokens:e.config.compaction.model.contextWindowTokens,id:e.config.compaction.model.id,providerOptions:e.config.compaction.model.providerOptions,source:{exportName:e.config.compaction.model.source.exportName,sourceKind:`module`,logicalPath:e.config.compaction.model.source.logicalPath,sourceId:e.config.compaction.model.source.sourceId}}),e.config.compaction.thresholdPercent!==void 0&&(t.thresholdPercent=e.config.compaction.thresholdPercent),n.compaction=t}return e.config.source!==void 0&&(n.source=createResolvedModuleSourceRef(e.config.source)),n}export{ResolveAgentError,resolveAgent};

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

@@ -1,62 +1 @@
-import { HTTP_ADAPTER_KIND } from "#channel/http.js";
-import { normalizeChannelDefinition } from "#internal/authored-definition/channel.js";
-import { toErrorMessage } from "#shared/errors.js";
-import { createResolvedModuleSourceRef, loadResolvedModuleExport, ResolveAgentError, } from "#runtime/resolve-helpers.js";
-/**
- * Resolves one compiled channel entry into a runtime-owned definition
- * with a live `handler` (the per-route handler authored via `POST` /
- * `GET` / etc. inside `defineChannel`) and the channel's `receive` hook
- * if the author declared one.
- *
- * Every authored channel is a `CompiledChannel` from `defineChannel` —
- * the bare `{ fetch, receive? }` Route shape is rejected by
- * {@link normalizeChannelDefinition}. Framework-internal channels
- * (the connection callback route, the `ash` session channel) build
- * `ResolvedChannelDefinition` values directly and do not flow through
- * this resolver.
- */
-export async function resolveChannelDefinition(definition, moduleMap, nodeId) {
-    try {
-        const resolvedExportValue = await loadResolvedModuleExport({
-            definition,
-            kindLabel: "channel",
-            moduleMap,
-            nodeId,
-        });
-        const channelDefinition = normalizeChannelDefinition(resolvedExportValue, `Expected the channel export "${definition.exportName ?? "default"}" from "${definition.logicalPath}" to match the public Ash shape.`);
-        const sourceRef = createResolvedModuleSourceRef({
-            exportName: definition.exportName,
-            logicalPath: definition.logicalPath,
-            sourceId: definition.sourceId,
-        });
-        const matchedRoute = channelDefinition.routes.find((r) => r.method.toUpperCase() === definition.method.toUpperCase() && r.path === definition.urlPath);
-        const adapter = channelDefinition.adapter;
-        if (adapter && adapter.kind !== HTTP_ADAPTER_KIND) {
-            adapter.kind = `channel:${definition.name}`;
-        }
-        return {
-            name: definition.name,
-            method: definition.method,
-            urlPath: definition.urlPath,
-            fetch: async (req, ctx) => {
-                if (matchedRoute)
-                    return matchedRoute.handler(req, ctx);
-                return Response.json({ error: "No matching route handler.", ok: false }, { status: 404 });
-            },
-            handler: matchedRoute?.handler,
-            receive: channelDefinition.receive,
-            definition: channelDefinition,
-            adapter,
-            ...sourceRef,
-        };
-    }
-    catch (error) {
-        if (error instanceof ResolveAgentError) {
-            throw error;
-        }
-        throw new ResolveAgentError(`Failed to attach the channel definition from "${definition.logicalPath}": ${toErrorMessage(error)}`, {
-            logicalPath: definition.logicalPath,
-            sourceId: definition.sourceId,
-        });
-    }
-}
+import{toErrorMessage}from"#shared/errors.js";import{normalizeChannelDefinition}from"#internal/authored-definition/channel.js";import{ResolveAgentError,createResolvedModuleSourceRef,loadResolvedModuleExport}from"#runtime/resolve-helpers.js";import{HTTP_ADAPTER_KIND}from"#channel/http.js";async function resolveChannelDefinition(r,i,a){try{let e=normalizeChannelDefinition(await loadResolvedModuleExport({definition:r,kindLabel:`channel`,moduleMap:i,nodeId:a}),`Expected the channel export "${r.exportName??`default`}" from "${r.logicalPath}" to match the public Ash shape.`),n=createResolvedModuleSourceRef({exportName:r.exportName,logicalPath:r.logicalPath,sourceId:r.sourceId}),o=e.routes.find(e=>e.method.toUpperCase()===r.method.toUpperCase()&&e.path===r.urlPath),s=e.adapter;return s&&s.kind!==HTTP_ADAPTER_KIND&&(s.kind=`channel:${r.name}`),{name:r.name,method:r.method,urlPath:r.urlPath,fetch:async(e,t)=>o?o.handler(e,t):Response.json({error:`No matching route handler.`,ok:!1},{status:404}),handler:o?.handler,receive:e.receive,definition:e,adapter:s,...n}}catch(t){throw t instanceof ResolveAgentError?t:new ResolveAgentError(`Failed to attach the channel definition from "${r.logicalPath}": ${toErrorMessage(t)}`,{logicalPath:r.logicalPath,sourceId:r.sourceId})}}export{resolveChannelDefinition};