@botbotgo/agent-harness 0.0.22 → 0.0.24

package/dist/workspace/compile.js

@@ -1,15 +1,12 @@
-import path from "node:path";
-import { createHash } from "node:crypto";
-import { ensureResourceSources, listResourceTools, listResourceToolsForSource } from "../resource/resource.js";
-import { listRemoteMcpTools } from "../resource/resource-impl.js";
-import { ensureExternalResourceSource, isExternalSourceLocator } from "../resource/sources.js";
-import { loadWorkspaceObjects, readToolModuleItems } from "./object-loader.js";
+import { ensureResourceSources } from "../resource/resource.js";
+import { loadWorkspaceObjects } from "./object-loader.js";
 import { parseEmbeddingModelObject, parseMcpServerObject, parseModelObject, parseToolObject, parseVectorStoreObject, validateEmbeddingModelObject, validateMcpServerObject, validateModelObject, validateToolObject, validateVectorStoreObject, } from "./resource-compilers.js";
 import { validateAgent, validateTopology } from "./validate.js";
 import { compileBinding } from "./agent-binding-compiler.js";
 import { discoverSubagents, ensureDiscoverySources } from "./support/discovery.js";
 import { collectAgentDiscoverySourceRefs, collectToolSourceRefs } from "./support/source-collectors.js";
 import { resolveRefId } from "./support/workspace-ref-utils.js";
+import { hydrateAgentMcpTools, hydrateResourceAndExternalTools } from "./tool-hydration.js";
 function collectParsedResources(refs) {
     const embeddings = new Map();
     const mcpServers = new Map();
@@ -39,154 +36,6 @@ function collectParsedResources(refs) {
     }
     return { embeddings, mcpServers, models, vectorStores, tools };
 }
-async function hydrateResourceAndExternalTools(tools, toolSourceRefs, workspaceRoot) {
-    for (const source of toolSourceRefs) {
-        if (isExternalSourceLocator(source)) {
-            const externalRoot = await ensureExternalResourceSource(source, workspaceRoot);
-            const discoveredToolRefs = [];
-            const sourcePrefix = `external.${createHash("sha256").update(source).digest("hex").slice(0, 12)}`;
-            for (const { item, sourcePath } of await readToolModuleItems(path.join(externalRoot, "tools"))) {
-                const toolId = typeof item.id === "string" ? item.id : undefined;
-                if (!toolId) {
-                    continue;
-                }
-                const namespacedId = `${sourcePrefix}.${toolId}`;
-                const parsed = parseToolObject({
-                    id: namespacedId,
-                    kind: "tool",
-                    sourcePath,
-                    value: {
-                        ...item,
-                        id: namespacedId,
-                    },
-                });
-                tools.set(parsed.id, parsed);
-                discoveredToolRefs.push(`tool/${parsed.id}`);
-            }
-            const sourceTools = await listResourceToolsForSource(source, workspaceRoot);
-            const bundleRefs = [...sourceTools.map((tool) => tool.toolPath), ...discoveredToolRefs];
-            if (bundleRefs.length > 0) {
-                tools.set(source, {
-                    id: source,
-                    type: "bundle",
-                    name: source,
-                    description: `External tool resource loaded from ${source}`,
-                    bundleRefs,
-                    sourcePath: source,
-                });
-            }
-        }
-    }
-    for (const resourceTool of await listResourceTools(toolSourceRefs, workspaceRoot)) {
-        const existing = tools.get(resourceTool.toolPath);
-        tools.set(resourceTool.toolPath, {
-            id: resourceTool.toolPath,
-            type: existing?.type ?? "backend",
-            name: existing?.name || resourceTool.name,
-            description: existing?.description || resourceTool.description,
-            config: existing?.config,
-            backendOperation: existing?.backendOperation ?? resourceTool.backendOperation,
-            bundleRefs: existing?.bundleRefs ?? [],
-            hitl: existing?.hitl ?? resourceTool.hitl,
-            sourcePath: existing?.sourcePath ?? resourceTool.toolPath,
-        });
-    }
-}
-function toMcpServerConfig(server) {
-    return {
-        transport: server.transport,
-        command: server.command,
-        args: server.args,
-        env: server.env,
-        cwd: server.cwd,
-        url: server.url,
-        token: server.token,
-        headers: server.headers,
-    };
-}
-function readStringArray(value) {
-    return Array.isArray(value) ? value.filter((item) => typeof item === "string" && item.trim().length > 0) : [];
-}
-function compileRegexList(value, label) {
-    return readStringArray(value).map((pattern) => {
-        try {
-            return new RegExp(pattern);
-        }
-        catch (error) {
-            throw new Error(`${label} contains invalid regex ${JSON.stringify(pattern)}: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    });
-}
-function compileMcpToolFilter(serverItem) {
-    return {
-        includeNames: new Set(readStringArray(serverItem.tools)),
-        excludeNames: new Set(readStringArray(serverItem.excludeTools)),
-        includePatterns: compileRegexList(serverItem.toolFilters ?? serverItem.toolFilter, "toolFilter"),
-        excludePatterns: compileRegexList(serverItem.excludeToolFilters ?? serverItem.excludeToolFilter, "excludeToolFilter"),
-    };
-}
-function shouldIncludeRemoteMcpTool(filter, toolName) {
-    const { includeNames, excludeNames, includePatterns, excludePatterns } = filter;
-    const includedByName = includeNames.size === 0 || includeNames.has(toolName);
-    const includedByPattern = includePatterns.length === 0 || includePatterns.some((pattern) => pattern.test(toolName));
-    if (!includedByName || !includedByPattern) {
-        return false;
-    }
-    if (excludeNames.has(toolName)) {
-        return false;
-    }
-    if (excludePatterns.some((pattern) => pattern.test(toolName))) {
-        return false;
-    }
-    return true;
-}
-async function hydrateAgentMcpTools(agents, mcpServers, tools) {
-    for (const agent of agents) {
-        const discoveredRefs = new Set(agent.toolRefs);
-        for (const item of agent.mcpServers ?? []) {
-            const name = typeof item.name === "string" && item.name.trim()
-                ? item.name.trim()
-                : typeof item.id === "string" && item.id.trim()
-                    ? item.id.trim()
-                    : "";
-            if (!name) {
-                throw new Error(`Agent ${agent.id} has an MCP server entry without a name`);
-            }
-            const serverId = `${agent.id}.${name}`;
-            const parsedServer = parseMcpServerObject({
-                id: serverId,
-                kind: "mcp",
-                sourcePath: agent.sourcePath,
-                value: item,
-            });
-            const filter = compileMcpToolFilter(item);
-            mcpServers.set(serverId, parsedServer);
-            const remoteTools = await listRemoteMcpTools(toMcpServerConfig(parsedServer));
-            for (const remoteTool of remoteTools) {
-                if (!shouldIncludeRemoteMcpTool(filter, remoteTool.name)) {
-                    continue;
-                }
-                const toolId = `mcp.${agent.id}.${name}.${remoteTool.name}`;
-                tools.set(toolId, {
-                    id: toolId,
-                    type: "mcp",
-                    name: remoteTool.name,
-                    description: remoteTool.description ?? remoteTool.name,
-                    config: {
-                        mcp: {
-                            serverRef: `mcp/${serverId}`,
-                        },
-                    },
-                    mcpRef: remoteTool.name,
-                    bundleRefs: [],
-                    sourcePath: agent.sourcePath,
-                });
-                discoveredRefs.add(`tool/${toolId}`);
-            }
-        }
-        agent.toolRefs = Array.from(discoveredRefs);
-    }
-}
 function validateWorkspaceResources(embeddings, mcpServers, models, vectorStores, tools, agents) {
     embeddings.forEach((embedding) => validateEmbeddingModelObject(embedding));
     mcpServers.forEach((server) => validateMcpServerObject(server));

package/dist/workspace/object-loader.js

@@ -7,18 +7,7 @@ import { resolveIsolatedResourceModulePath } from "../resource/isolation.js";
 import { resolveResourcePackageRoot } from "../resource/sources.js";
 import { discoverToolModuleDefinitions, isSupportedToolModulePath } from "../tool-modules.js";
 import { fileExists, listFilesRecursive, readYamlOrJson } from "../utils/fs.js";
-const ROOT_AGENT_FILENAMES = [
-    "agent.yaml",
-    "agent.yml",
-    "orchestra.yaml",
-    "orchestra.yml",
-    "direct.yaml",
-    "direct.yml",
-    "research.yaml",
-    "research.yml",
-];
 const MODEL_FILENAMES = ["models.yaml", "models.yml"];
-const LEGACY_GLOBAL_AGENT_FILENAMES = ["agent.yaml", "agent.yml"];
 const CONVENTIONAL_OBJECT_DIRECTORIES = ["tools"];
 function conventionalConfigRoot(root) {
     if (path.basename(root) === "config" && existsSync(root) && statSync(root).isDirectory()) {
@@ -220,6 +209,27 @@ function readObjectArray(items) {
         .map((item) => ({ ...item }));
     return records.length > 0 ? records : undefined;
 }
+function readSharedAgentConfig(item) {
+    const middleware = readMiddlewareArray(item.middleware);
+    return {
+        ...(typeof item.systemPrompt === "string" ? { systemPrompt: item.systemPrompt } : {}),
+        ...(typeof item.checkpointer === "object" && item.checkpointer ? { checkpointer: item.checkpointer } : {}),
+        ...(typeof item.interruptOn === "object" && item.interruptOn ? { interruptOn: item.interruptOn } : {}),
+        ...(item.responseFormat !== undefined ? { responseFormat: item.responseFormat } : {}),
+        ...(item.contextSchema !== undefined ? { contextSchema: item.contextSchema } : {}),
+        ...(middleware ? { middleware } : {}),
+    };
+}
+function readLangchainAgentConfig(item) {
+    return readSharedAgentConfig(item);
+}
+function readDeepAgentConfig(item) {
+    return {
+        ...readSharedAgentConfig(item),
+        ...(typeof item.backend === "object" && item.backend ? { backend: item.backend } : {}),
+        ...(typeof item.store === "object" && item.store ? { store: item.store } : {}),
+    };
+}
 export function parseAgentItem(item, sourcePath) {
     const subagentRefs = readRefArray(item.subagents);
     const subagentPathRefs = readPathArray(item.subagents);
@@ -239,44 +249,8 @@ export function parseAgentItem(item, sourcePath) {
         memorySources: readPathArray(item.memory),
         subagentRefs,
         subagentPathRefs,
-        langchainAgentConfig: {
-            ...(typeof item.systemPrompt === "string" ||
-                typeof item.interruptOn === "object" ||
-                typeof item.checkpointer === "object" ||
-                item.responseFormat !== undefined ||
-                item.contextSchema !== undefined ||
-                item.middleware !== undefined
-                ? {
-                    ...(typeof item.systemPrompt === "string" ? { systemPrompt: item.systemPrompt } : {}),
-                    ...(typeof item.interruptOn === "object" && item.interruptOn ? { interruptOn: item.interruptOn } : {}),
-                    ...(typeof item.checkpointer === "object" && item.checkpointer ? { checkpointer: item.checkpointer } : {}),
-                    ...(item.responseFormat !== undefined ? { responseFormat: item.responseFormat } : {}),
-                    ...(item.contextSchema !== undefined ? { contextSchema: item.contextSchema } : {}),
-                    ...(readMiddlewareArray(item.middleware) ? { middleware: readMiddlewareArray(item.middleware) } : {}),
-                }
-                : {}),
-        },
-        deepAgentConfig: {
-            ...(typeof item.systemPrompt === "string" ||
-                typeof item.backend === "object" ||
-                typeof item.store === "object" ||
-                typeof item.checkpointer === "object" ||
-                typeof item.interruptOn === "object" ||
-                item.responseFormat !== undefined ||
-                item.contextSchema !== undefined ||
-                item.middleware !== undefined
-                ? {
-                    ...(typeof item.systemPrompt === "string" ? { systemPrompt: item.systemPrompt } : {}),
-                    ...(typeof item.backend === "object" && item.backend ? { backend: item.backend } : {}),
-                    ...(typeof item.store === "object" && item.store ? { store: item.store } : {}),
-                    ...(typeof item.checkpointer === "object" && item.checkpointer ? { checkpointer: item.checkpointer } : {}),
-                    ...(typeof item.interruptOn === "object" && item.interruptOn ? { interruptOn: item.interruptOn } : {}),
-                    ...(item.responseFormat !== undefined ? { responseFormat: item.responseFormat } : {}),
-                    ...(item.contextSchema !== undefined ? { contextSchema: item.contextSchema } : {}),
-                    ...(readMiddlewareArray(item.middleware) ? { middleware: readMiddlewareArray(item.middleware) } : {}),
-                }
-                : {}),
-        },
+        langchainAgentConfig: readLangchainAgentConfig(item),
+        deepAgentConfig: readDeepAgentConfig(item),
         sourcePath,
     };
 }
@@ -346,6 +320,89 @@ function mergeValues(base, override) {
     }
     return override;
 }
+function mergeRawItemRecord(records, key, item, sourcePath) {
+    const current = records.get(key);
+    const mergedRecord = {
+        item: current ? mergeValues(current.item, item) : item,
+        sourcePath,
+    };
+    records.set(key, mergedRecord);
+    return mergedRecord;
+}
+function mergeAgentRecord(records, item, sourcePath) {
+    const id = typeof item.id === "string" ? item.id : undefined;
+    if (!id) {
+        return null;
+    }
+    return mergeRawItemRecord(records, id, item, sourcePath);
+}
+function mergeWorkspaceObjectRecord(records, workspaceObject, item, sourcePath) {
+    mergeRawItemRecord(records, `${workspaceObject.kind}/${workspaceObject.id}`, item, sourcePath);
+}
+async function loadNamedModelsForRoot(configRoot, mergedObjects) {
+    for (const { item, sourcePath } of await readNamedModelItems(configRoot)) {
+        const workspaceObject = parseWorkspaceObject(item, sourcePath);
+        if (!workspaceObject || workspaceObject.kind !== "model") {
+            continue;
+        }
+        mergeWorkspaceObjectRecord(mergedObjects, workspaceObject, item, sourcePath);
+    }
+}
+async function loadConfigAgentsForRoot(configRoot, mergedAgents) {
+    for (const { item, sourcePath } of await readConfigAgentItems(configRoot)) {
+        mergeAgentRecord(mergedAgents, item, sourcePath);
+    }
+}
+async function loadConventionalObjectsForRoot(root, mergedObjects) {
+    for (const directory of CONVENTIONAL_OBJECT_DIRECTORIES) {
+        for (const objectRoot of conventionalDirectoryRoots(root, directory)) {
+            for (const { item, sourcePath } of await readYamlItems(objectRoot, undefined, { recursive: true })) {
+                const workspaceObject = parseWorkspaceObject(item, sourcePath);
+                if (!workspaceObject || workspaceObject.kind === "tool") {
+                    continue;
+                }
+                mergeWorkspaceObjectRecord(mergedObjects, workspaceObject, item, sourcePath);
+            }
+            for (const { item, sourcePath } of await readToolModuleItems(objectRoot)) {
+                const workspaceObject = parseWorkspaceObject(item, sourcePath);
+                if (!workspaceObject) {
+                    continue;
+                }
+                mergeWorkspaceObjectRecord(mergedObjects, workspaceObject, item, sourcePath);
+            }
+        }
+    }
+}
+async function loadConfigObjectsForRoot(root, configRoot, mergedObjects) {
+    if (!conventionalConfigRoot(root)) {
+        return;
+    }
+    for (const { item, sourcePath } of await readYamlItems(configRoot, undefined, { recursive: true })) {
+        const workspaceObject = parseWorkspaceObject(item, sourcePath);
+        if (!workspaceObject) {
+            continue;
+        }
+        if (isAgentKind(workspaceObject.kind) || workspaceObject.kind === "model") {
+            continue;
+        }
+        mergeWorkspaceObjectRecord(mergedObjects, workspaceObject, item, sourcePath);
+    }
+}
+async function loadRootObjects(root, mergedObjects) {
+    for (const { item, sourcePath } of (await readYamlItems(root)).filter(({ sourcePath: fullPath }) => !fullPath.includes(`${path.sep}config${path.sep}`) &&
+        !fullPath.includes(`${path.sep}resources${path.sep}`) &&
+        !fullPath.includes(`${path.sep}agents${path.sep}`) &&
+        !CONVENTIONAL_OBJECT_DIRECTORIES.some((directory) => fullPath.includes(`${path.sep}${directory}${path.sep}`)))) {
+        const workspaceObject = parseWorkspaceObject(item, sourcePath);
+        if (!workspaceObject) {
+            continue;
+        }
+        if (workspaceObject.kind === "tool" || workspaceObject.kind === "mcp" || workspaceObject.kind === "model") {
+            continue;
+        }
+        mergeWorkspaceObjectRecord(mergedObjects, workspaceObject, item, sourcePath);
+    }
+}
 export async function readYamlItems(root, relativeDir, options = {}) {
     const targetRoot = relativeDir ? path.join(root, relativeDir) : root;
     if (!(await fileExists(targetRoot))) {
@@ -405,15 +462,13 @@ function isAgentKind(kind) {
     return kind === "deepagent" || kind === "langchain-agent";
 }
 async function readConfigAgentItems(configRoot) {
-    const records = await readYamlItems(configRoot, undefined, { recursive: true });
+    const records = await readYamlItems(configRoot, "agents", { recursive: true });
     return records.filter(({ item, sourcePath }) => {
         const kind = typeof item.kind === "string" ? item.kind : undefined;
         if (!isAgentKind(kind)) {
             return false;
         }
-        const parentDir = path.dirname(sourcePath);
-        const filename = path.basename(sourcePath).toLowerCase();
-        return !(parentDir === configRoot && ROOT_AGENT_FILENAMES.includes(filename));
+        return sourcePath.includes(`${path.sep}agents${path.sep}`);
     });
 }
 export async function readToolModuleItems(root) {
@@ -451,10 +506,6 @@ export async function readToolModuleItems(root) {
     }
     return records;
 }
-function isPrimaryAgentFile(sourcePath) {
-    const base = path.basename(sourcePath).toLowerCase();
-    return ROOT_AGENT_FILENAMES.includes(base);
-}
 function inferExecutionMode(item, current) {
     const kind = typeof item.kind === "string" ? item.kind : typeof current?.kind === "string" ? current.kind : undefined;
     if (kind === "langchain-agent") {
@@ -465,160 +516,18 @@ function inferExecutionMode(item, current) {
     }
     return undefined;
 }
-function extractSharedAgentDefaults(item) {
-    const defaults = {};
-    for (const key of ["modelRef", "runRoot", "checkpointer", "interruptOn"]) {
-        if (key in item) {
-            defaults[key] = item[key];
-        }
-    }
-    return defaults;
-}
-function applySharedAgentDefaults(globalDefaults, defaultsByMode, item, current) {
-    const executionMode = inferExecutionMode(item, current);
-    const defaults = {
-        ...globalDefaults,
-        ...(executionMode ? defaultsByMode[executionMode] : {}),
-    };
-    const merged = { ...item };
-    for (const [key, value] of Object.entries(defaults)) {
-        if (key in merged) {
-            continue;
-        }
-        if (current && key in current) {
-            continue;
-        }
-        merged[key] = value;
-    }
-    return merged;
-}
 export async function loadWorkspaceObjects(workspaceRoot, options = {}) {
     const refs = new Map();
     const mergedAgents = new Map();
     const mergedObjects = new Map();
     const roots = [frameworkWorkspaceRoot(), ...(options.overlayRoots ?? []), workspaceRoot];
-    let sharedAgentDefaults = {};
-    let sharedAgentDefaultsByMode = {};
     for (const root of roots) {
         const configRoot = conventionalConfigRoot(root) ?? root;
-        const namedAgentRoots = Array.from(new Set([root, configRoot]));
-        for (const namedAgentRoot of namedAgentRoots) {
-            for (const { item, sourcePath } of await readNamedYamlItems(namedAgentRoot, [...ROOT_AGENT_FILENAMES])) {
-                const id = typeof item.id === "string" ? item.id : undefined;
-                if (!id) {
-                    continue;
-                }
-                const current = mergedAgents.get(id);
-                mergedAgents.set(id, {
-                    item: current ? mergeValues(current.item, item) : item,
-                    sourcePath,
-                });
-                const filename = path.basename(sourcePath).toLowerCase();
-                if (LEGACY_GLOBAL_AGENT_FILENAMES.includes(filename)) {
-                    sharedAgentDefaults = mergeValues(sharedAgentDefaults, extractSharedAgentDefaults(item));
-                }
-                else {
-                    const executionMode = inferExecutionMode(item, current?.item);
-                    if (executionMode) {
-                        sharedAgentDefaultsByMode = {
-                            ...sharedAgentDefaultsByMode,
-                            [executionMode]: mergeValues(sharedAgentDefaultsByMode[executionMode] ?? {}, extractSharedAgentDefaults(item)),
-                        };
-                    }
-                }
-            }
-        }
-        for (const modelRoot of Array.from(new Set([configRoot]))) {
-            for (const { item, sourcePath } of await readNamedModelItems(modelRoot)) {
-                const workspaceObject = parseWorkspaceObject(item, sourcePath);
-                if (!workspaceObject || workspaceObject.kind !== "model") {
-                    continue;
-                }
-                const ref = `${workspaceObject.kind}/${workspaceObject.id}`;
-                const current = mergedObjects.get(ref);
-                mergedObjects.set(ref, {
-                    item: current ? mergeValues(current.item, item) : item,
-                    sourcePath,
-                });
-            }
-        }
-        for (const { item, sourcePath } of await readConfigAgentItems(configRoot)) {
-            const id = typeof item.id === "string" ? item.id : undefined;
-            if (!id) {
-                continue;
-            }
-            const current = mergedAgents.get(id);
-            const itemWithDefaults = applySharedAgentDefaults(sharedAgentDefaults, sharedAgentDefaultsByMode, item, current?.item);
-            mergedAgents.set(id, {
-                item: current ? mergeValues(current.item, itemWithDefaults) : itemWithDefaults,
-                sourcePath,
-            });
-        }
-        for (const directory of CONVENTIONAL_OBJECT_DIRECTORIES) {
-            for (const objectRoot of conventionalDirectoryRoots(root, directory)) {
-                for (const { item, sourcePath } of await readYamlItems(objectRoot, undefined, { recursive: true })) {
-                    const workspaceObject = parseWorkspaceObject(item, sourcePath);
-                    if (!workspaceObject || workspaceObject.kind === "tool") {
-                        continue;
-                    }
-                    const ref = `${workspaceObject.kind}/${workspaceObject.id}`;
-                    const current = mergedObjects.get(ref);
-                    mergedObjects.set(ref, {
-                        item: current ? mergeValues(current.item, item) : item,
-                        sourcePath,
-                    });
-                }
-                for (const { item, sourcePath } of await readToolModuleItems(objectRoot)) {
-                    const workspaceObject = parseWorkspaceObject(item, sourcePath);
-                    if (!workspaceObject) {
-                        continue;
-                    }
-                    const ref = `${workspaceObject.kind}/${workspaceObject.id}`;
-                    const current = mergedObjects.get(ref);
-                    mergedObjects.set(ref, {
-                        item: current ? mergeValues(current.item, item) : item,
-                        sourcePath,
-                    });
-                }
-            }
-        }
-        if (conventionalConfigRoot(root)) {
-            for (const { item, sourcePath } of await readYamlItems(configRoot, undefined, { recursive: true })) {
-                const workspaceObject = parseWorkspaceObject(item, sourcePath);
-                if (!workspaceObject) {
-                    continue;
-                }
-                if (isAgentKind(workspaceObject.kind) ||
-                    workspaceObject.kind === "model") {
-                    continue;
-                }
-                const ref = `${workspaceObject.kind}/${workspaceObject.id}`;
-                const current = mergedObjects.get(ref);
-                mergedObjects.set(ref, {
-                    item: current ? mergeValues(current.item, item) : item,
-                    sourcePath,
-                });
-            }
-        }
-        for (const { item, sourcePath } of (await readYamlItems(root)).filter(({ sourcePath: fullPath }) => !fullPath.includes(`${path.sep}config${path.sep}`) &&
-            !fullPath.includes(`${path.sep}resources${path.sep}`) &&
-            !fullPath.includes(`${path.sep}agents${path.sep}`) &&
-            !CONVENTIONAL_OBJECT_DIRECTORIES.some((directory) => fullPath.includes(`${path.sep}${directory}${path.sep}`)) &&
-            !isPrimaryAgentFile(fullPath))) {
-            const workspaceObject = parseWorkspaceObject(item, sourcePath);
-            if (!workspaceObject) {
-                continue;
-            }
-            if (workspaceObject.kind === "tool" || workspaceObject.kind === "mcp" || workspaceObject.kind === "model") {
-                continue;
-            }
-            const ref = `${workspaceObject.kind}/${workspaceObject.id}`;
-            const current = mergedObjects.get(ref);
-            mergedObjects.set(ref, {
-                item: current ? mergeValues(current.item, item) : item,
-                sourcePath,
-            });
-        }
+        await loadNamedModelsForRoot(configRoot, mergedObjects);
+        await loadConfigAgentsForRoot(configRoot, mergedAgents);
+        await loadConventionalObjectsForRoot(root, mergedObjects);
+        await loadConfigObjectsForRoot(root, configRoot, mergedObjects);
+        await loadRootObjects(root, mergedObjects);
     }
     const agents = Array.from(mergedAgents.values()).map(({ item, sourcePath }) => parseAgentItem(item, sourcePath));
     for (const [ref, { item, sourcePath }] of mergedObjects) {

package/dist/workspace/tool-hydration.d.ts

@@ -0,0 +1,3 @@
+import type { ParsedAgentObject, ParsedMcpServerObject, ParsedToolObject } from "../contracts/types.js";
+export declare function hydrateResourceAndExternalTools(tools: Map<string, ParsedToolObject>, toolSourceRefs: string[], workspaceRoot: string): Promise<void>;
+export declare function hydrateAgentMcpTools(agents: ParsedAgentObject[], mcpServers: Map<string, ParsedMcpServerObject>, tools: Map<string, ParsedToolObject>): Promise<void>;