experimental-ash 0.26.0 → 0.28.0

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

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

@@ -1,72 +1 @@
-import { expectObjectRecord } from "#internal/authored-module.js";
-import { registerDefinitionSource } from "#public/tool-result-narrowing.js";
-import { toErrorMessage } from "#shared/errors.js";
-import { normalizeAuthorizationSpec } from "#runtime/connections/validate-authorization.js";
-import { loadResolvedModuleExport, ResolveAgentError } from "#runtime/resolve-helpers.js";
-/**
- * Resolves one compiled connection entry into a runtime-owned definition
- * with the live `auth`, `headers`, and `tools` objects attached
- * from the authored module.
- *
- * The compiled manifest only stores serializable metadata (`url`,
- * `description`, `connectionName`). Live values (`auth`,
- * `headers`, `tools`) are resolved at runtime by re-importing the
- * authored module so they can reference ambient state (environment
- * variables, `AshContext`, etc.).
- */
-export async function resolveConnectionDefinition(definition, moduleMap, nodeId) {
-    try {
-        const resolvedExportValue = await loadResolvedModuleExport({
-            definition,
-            kindLabel: "connection",
-            moduleMap,
-            nodeId,
-        });
-        const resolvedRecord = expectObjectRecord(resolvedExportValue, `Expected the connection export "${definition.exportName ?? "default"}" from "${definition.logicalPath}" to return an object.`);
-        registerDefinitionSource(`connection:${resolvedRecord.url}`, {
-            kind: "connection",
-            name: definition.connectionName,
-        });
-        const hasAuth = resolvedRecord.auth !== undefined;
-        const hasHeaders = resolvedRecord.headers !== undefined;
-        const result = {
-            connectionName: definition.connectionName,
-            description: definition.description,
-            exportName: definition.exportName,
-            logicalPath: definition.logicalPath,
-            sourceId: definition.sourceId,
-            sourceKind: "module",
-            url: definition.url,
-        };
-        if (hasAuth) {
-            try {
-                result.authorization = normalizeAuthorizationSpec(resolvedRecord.auth, `Connection "${definition.connectionName}" at "${definition.logicalPath}":`);
-            }
-            catch (error) {
-                throw new ResolveAgentError(toErrorMessage(error), {
-                    logicalPath: definition.logicalPath,
-                    sourceId: definition.sourceId,
-                });
-            }
-        }
-        if (hasHeaders) {
-            result.headers = resolvedRecord.headers;
-        }
-        if (resolvedRecord.tools !== undefined) {
-            result.tools = resolvedRecord.tools;
-        }
-        if (typeof resolvedRecord.approval === "function") {
-            result.approval = resolvedRecord.approval;
-        }
-        return result;
-    }
-    catch (error) {
-        if (error instanceof ResolveAgentError) {
-            throw error;
-        }
-        throw new ResolveAgentError(`Failed to resolve connection "${definition.connectionName}" from "${definition.logicalPath}": ${toErrorMessage(error)}`, {
-            logicalPath: definition.logicalPath,
-            sourceId: definition.sourceId,
-        });
-    }
-}
+import{expectObjectRecord}from"#internal/authored-module.js";import{toErrorMessage}from"#shared/errors.js";import{normalizeAuthorizationSpec}from"#runtime/connections/validate-authorization.js";import{ResolveAgentError,loadResolvedModuleExport}from"#runtime/resolve-helpers.js";import{registerDefinitionSource}from"#public/tool-result-narrowing.js";async function resolveConnectionDefinition(t,n,r){try{let i=expectObjectRecord(await loadResolvedModuleExport({definition:t,kindLabel:`connection`,moduleMap:n,nodeId:r}),`Expected the connection export "${t.exportName??`default`}" from "${t.logicalPath}" to return an object.`);registerDefinitionSource(`connection:${i.url}`,{kind:`connection`,name:t.connectionName});let a=i.auth!==void 0,o=i.headers!==void 0,s={connectionName:t.connectionName,description:t.description,exportName:t.exportName,logicalPath:t.logicalPath,sourceId:t.sourceId,sourceKind:`module`,url:t.url};if(a)try{s.authorization=normalizeAuthorizationSpec(i.auth,`Connection "${t.connectionName}" at "${t.logicalPath}":`)}catch(e){throw new ResolveAgentError(toErrorMessage(e),{logicalPath:t.logicalPath,sourceId:t.sourceId})}return o&&(s.headers=i.headers),i.tools!==void 0&&(s.tools=i.tools),typeof i.approval==`function`&&(s.approval=i.approval),s}catch(e){throw e instanceof ResolveAgentError?e:new ResolveAgentError(`Failed to resolve connection "${t.connectionName}" from "${t.logicalPath}": ${toErrorMessage(e)}`,{logicalPath:t.logicalPath,sourceId:t.sourceId})}}export{resolveConnectionDefinition};

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

@@ -1,58 +1 @@
-import { ROOT_COMPILED_AGENT_NODE_ID } from "#compiler/manifest.js";
-import { expectObjectRecord, getAuthoredModuleExport, materializeAuthoredModuleExport, } from "#internal/authored-module.js";
-/**
- * Error raised when compiled artifacts cannot be hydrated into a runtime-owned
- * authored agent model.
- */
-export class ResolveAgentError extends Error {
-    logicalPath;
-    sourceId;
-    constructor(message, input = {}) {
-        super(message);
-        this.name = "ResolveAgentError";
-        if (input.logicalPath !== undefined) {
-            this.logicalPath = input.logicalPath;
-        }
-        if (input.sourceId !== undefined) {
-            this.sourceId = input.sourceId;
-        }
-    }
-}
-/**
- * Builds the resolved source ref block shared by every per-primitive
- * resolver that targets a `module` source.
- */
-export function createResolvedModuleSourceRef(sourceRef) {
-    return {
-        exportName: sourceRef.exportName,
-        logicalPath: sourceRef.logicalPath,
-        sourceId: sourceRef.sourceId,
-        sourceKind: "module",
-    };
-}
-/**
- * Looks up a compiled module namespace for one resolved agent node and
- * returns the materialized exported value referenced by the given
- * compiled definition.
- *
- * Throws {@link ResolveAgentError} when the module map does not contain
- * the expected source — every per-primitive resolver shares this
- * lookup, so the helper centralizes the error message and avoids
- * duplicating ~25 lines of boilerplate per resolver.
- */
-export async function loadResolvedModuleExport(input) {
-    const resolvedNodeId = input.nodeId ?? ROOT_COMPILED_AGENT_NODE_ID;
-    const moduleNamespace = input.moduleMap.nodes[resolvedNodeId]?.modules[input.definition.sourceId];
-    if (moduleNamespace === undefined) {
-        throw new ResolveAgentError(`Missing compiled module namespace for ${input.kindLabel} source "${input.definition.sourceId}" in node "${resolvedNodeId}".`, {
-            logicalPath: input.definition.logicalPath,
-            sourceId: input.definition.sourceId,
-        });
-    }
-    const moduleRecord = expectObjectRecord(moduleNamespace, `Missing compiled module namespace for ${input.kindLabel} source "${input.definition.sourceId}" in node "${resolvedNodeId}".`);
-    const exportValue = getAuthoredModuleExport(moduleRecord, {
-        exportName: input.definition.exportName,
-        logicalPath: input.definition.logicalPath,
-    });
-    return await materializeAuthoredModuleExport(exportValue);
-}
+import{expectObjectRecord,getAuthoredModuleExport,materializeAuthoredModuleExport}from"#internal/authored-module.js";import{ROOT_COMPILED_AGENT_NODE_ID}from"#compiler/manifest.js";var ResolveAgentError=class extends Error{logicalPath;sourceId;constructor(e,t={}){super(e),this.name=`ResolveAgentError`,t.logicalPath!==void 0&&(this.logicalPath=t.logicalPath),t.sourceId!==void 0&&(this.sourceId=t.sourceId)}};function createResolvedModuleSourceRef(e){return{exportName:e.exportName,logicalPath:e.logicalPath,sourceId:e.sourceId,sourceKind:`module`}}async function loadResolvedModuleExport(n){let r=n.nodeId??ROOT_COMPILED_AGENT_NODE_ID,i=n.moduleMap.nodes[r]?.modules[n.definition.sourceId];if(i===void 0)throw new ResolveAgentError(`Missing compiled module namespace for ${n.kindLabel} source "${n.definition.sourceId}" in node "${r}".`,{logicalPath:n.definition.logicalPath,sourceId:n.definition.sourceId});return await materializeAuthoredModuleExport(getAuthoredModuleExport(expectObjectRecord(i,`Missing compiled module namespace for ${n.kindLabel} source "${n.definition.sourceId}" in node "${r}".`),{exportName:n.definition.exportName,logicalPath:n.definition.logicalPath}))}export{ResolveAgentError,createResolvedModuleSourceRef,loadResolvedModuleExport};