@botbotgo/agent-harness 0.0.18 → 0.0.19

package/dist/tool-modules.js

@@ -0,0 +1,143 @@
+import path from "node:path";
+import { z } from "zod";
+import { TOOL_DEFINITION_MARKER, normalizeToolSchema } from "./tools.js";
+const TOOL_MODULE_EXTENSIONS = new Set([".mjs", ".js", ".cjs"]);
+const ANNOTATED_TOOL_EXPORT_PATTERN = /(?:\/\*\*?[\s\S]*?@tool[\s\S]*?\*\/\s*|\/\/[^\n]*@tool[^\n]*\n\s*)export\s+(?:async\s+)?(?:function\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(|const\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(?:async\s*)?(?:function\b|\())/g;
+function asRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function isSchemaLike(value) {
+    return typeof value === "object" && value !== null && typeof value.parse === "function";
+}
+function isToolDefinitionObject(value) {
+    return typeof value === "object" && value !== null && value[TOOL_DEFINITION_MARKER] === true;
+}
+function buildSchemaFromShape(shape, description) {
+    const record = asRecord(shape);
+    if (!record) {
+        return null;
+    }
+    const schema = z.object(record);
+    return description ? schema.describe(description) : schema;
+}
+function readToolDescription(imported, implementationName, schema) {
+    const explicit = typeof imported[`${implementationName}Description`] === "string"
+        ? String(imported[`${implementationName}Description`])
+        : typeof imported.description === "string"
+            ? String(imported.description)
+            : undefined;
+    return explicit?.trim() || schema.description?.trim() || `Auto-discovered tool ${implementationName}`;
+}
+function resolveToolSchema(imported, implementationName, allowGenericExports) {
+    const namedSchema = imported[`${implementationName}Schema`];
+    if (isSchemaLike(namedSchema)) {
+        return namedSchema;
+    }
+    const namedShape = imported[`${implementationName}SchemaShape`];
+    const namedDescription = typeof imported[`${implementationName}Description`] === "string"
+        ? String(imported[`${implementationName}Description`])
+        : undefined;
+    const schemaFromNamedShape = buildSchemaFromShape(namedShape, namedDescription);
+    if (schemaFromNamedShape) {
+        return schemaFromNamedShape;
+    }
+    if (!allowGenericExports) {
+        return null;
+    }
+    const genericSchema = imported.schema;
+    if (isSchemaLike(genericSchema)) {
+        return genericSchema;
+    }
+    const genericShape = imported.schemaShape ?? imported.schema;
+    const genericDescription = typeof imported.description === "string" ? String(imported.description) : undefined;
+    return buildSchemaFromShape(genericShape, genericDescription);
+}
+function discoverExportedFunctionNames(imported) {
+    return Object.entries(imported)
+        .filter(([name, value]) => name !== "default" && typeof value === "function")
+        .map(([name]) => name)
+        .sort();
+}
+function discoverExportedToolObjectNames(imported) {
+    return Object.entries(imported)
+        .filter(([name, value]) => name !== "default" && isToolDefinitionObject(value))
+        .map(([name]) => name)
+        .sort();
+}
+function loadToolObjectDefinition(imported, exportName) {
+    const definition = imported[exportName];
+    if (!isToolDefinitionObject(definition)) {
+        return null;
+    }
+    return {
+        implementationName: definition.name?.trim() || exportName,
+        invoke: definition.invoke,
+        schema: normalizeToolSchema(definition.schema),
+        description: definition.description.trim(),
+    };
+}
+export function isSupportedToolModulePath(filePath) {
+    return TOOL_MODULE_EXTENSIONS.has(path.extname(filePath));
+}
+export function discoverAnnotatedFunctionNames(sourceText) {
+    const matches = sourceText.matchAll(ANNOTATED_TOOL_EXPORT_PATTERN);
+    return Array.from(matches, (match) => match[1] ?? match[2]).filter((name) => Boolean(name));
+}
+export function discoverToolModuleDefinitions(sourceText, imported) {
+    const objectDefinitions = discoverExportedToolObjectNames(imported)
+        .map((exportName) => loadToolObjectDefinition(imported, exportName))
+        .filter((definition) => Boolean(definition));
+    if (objectDefinitions.length > 0) {
+        return objectDefinitions;
+    }
+    const annotatedNames = new Set(discoverAnnotatedFunctionNames(sourceText));
+    const functionNames = discoverExportedFunctionNames(imported);
+    const allowGenericExports = functionNames.length === 1;
+    const discovered = [];
+    for (const implementationName of functionNames) {
+        const invoke = imported[implementationName];
+        if (typeof invoke !== "function") {
+            continue;
+        }
+        const schema = resolveToolSchema(imported, implementationName, allowGenericExports);
+        if (!schema && !annotatedNames.has(implementationName)) {
+            continue;
+        }
+        if (!schema) {
+            throw new Error(`Tool module must export ${implementationName}Schema, ${implementationName}SchemaShape, or generic schema/schemaShape metadata.`);
+        }
+        discovered.push({
+            implementationName,
+            invoke: invoke,
+            schema,
+            description: readToolDescription(imported, implementationName, schema),
+        });
+    }
+    return discovered;
+}
+export function loadToolModuleDefinition(imported, implementationName) {
+    for (const exportName of discoverExportedToolObjectNames(imported)) {
+        const loaded = loadToolObjectDefinition(imported, exportName);
+        if (loaded && loaded.implementationName === implementationName) {
+            return loaded;
+        }
+    }
+    const functionNames = discoverExportedFunctionNames(imported);
+    const allowGenericExports = functionNames.length === 1;
+    const invoke = imported[implementationName];
+    if (typeof invoke !== "function") {
+        throw new Error(`Tool module must export function ${implementationName}.`);
+    }
+    const schema = resolveToolSchema(imported, implementationName, allowGenericExports);
+    if (!schema) {
+        throw new Error(`Tool module must export ${implementationName}Schema, ${implementationName}SchemaShape, or generic schema/schemaShape metadata.`);
+    }
+    return {
+        implementationName,
+        invoke: invoke,
+        schema,
+        description: readToolDescription(imported, implementationName, schema),
+    };
+}

package/dist/tools.d.ts

@@ -0,0 +1,20 @@
+import type { ZodRawShape, ZodTypeAny } from "zod";
+export declare const TOOL_DEFINITION_MARKER = "__agent_harness_tool_definition__";
+type SchemaInput = ZodRawShape | ZodTypeAny;
+export type ToolDefinitionObject = {
+    name?: string;
+    description: string;
+    schema: SchemaInput;
+    invoke: (input: unknown, context?: Record<string, unknown>) => Promise<unknown> | unknown;
+    [TOOL_DEFINITION_MARKER]: true;
+};
+export declare function normalizeToolSchema(schema: SchemaInput): ZodTypeAny & {
+    shape?: ZodRawShape;
+};
+export declare function tool(definition: {
+    name?: string;
+    description: string;
+    schema: SchemaInput;
+    invoke: (input: unknown, context?: Record<string, unknown>) => Promise<unknown> | unknown;
+}): ToolDefinitionObject;
+export {};

package/dist/tools.js

@@ -0,0 +1,17 @@
+import { z } from "zod";
+export const TOOL_DEFINITION_MARKER = "__agent_harness_tool_definition__";
+function isZodSchema(value) {
+    return typeof value === "object" && value !== null && typeof value.parse === "function";
+}
+export function normalizeToolSchema(schema) {
+    if (isZodSchema(schema)) {
+        return schema;
+    }
+    return z.object(schema);
+}
+export function tool(definition) {
+    return {
+        ...definition,
+        [TOOL_DEFINITION_MARKER]: true,
+    };
+}

package/dist/workspace/compile.js

@@ -1,9 +1,10 @@
 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 { parseEmbeddingModelObject, parseModelObject, parseToolObject, parseVectorStoreObject, validateEmbeddingModelObject, validateModelObject, validateToolObject, validateVectorStoreObject, } from "./resource-compilers.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";
@@ -11,6 +12,7 @@ import { collectAgentDiscoverySourceRefs, collectToolSourceRefs } from "./suppor
 import { resolveRefId } from "./support/workspace-ref-utils.js";
 function collectParsedResources(refs) {
     const embeddings = new Map();
+    const mcpServers = new Map();
     const models = new Map();
     const vectorStores = new Map();
     const tools = new Map();
@@ -22,6 +24,9 @@ function collectParsedResources(refs) {
         if (ref.startsWith("embedding-model/")) {
             embeddings.set(typed.id, parseEmbeddingModelObject(object));
         }
+        else if (ref.startsWith("mcp/")) {
+            mcpServers.set(typed.id, parseMcpServerObject(object));
+        }
         else if (ref.startsWith("vector-store/")) {
             vectorStores.set(typed.id, parseVectorStoreObject(object));
         }
@@ -32,7 +37,7 @@ function collectParsedResources(refs) {
             tools.set(typed.id, parseToolObject(object));
         }
     }
-    return { embeddings, models, vectorStores, tools };
+    return { embeddings, mcpServers, models, vectorStores, tools };
 }
 async function hydrateResourceAndExternalTools(tools, toolSourceRefs, workspaceRoot) {
     for (const source of toolSourceRefs) {
@@ -87,13 +92,125 @@ async function hydrateResourceAndExternalTools(tools, toolSourceRefs, workspaceR
         });
     }
 }
-function validateWorkspaceResources(embeddings, models, vectorStores, tools, agents) {
+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));
     models.forEach((model) => validateModelObject(model, models));
     vectorStores.forEach((vectorStore) => validateVectorStoreObject(vectorStore));
     tools.forEach((tool) => validateToolObject(tool, tools));
     agents.forEach(validateAgent);
     validateTopology(agents);
+    tools.forEach((tool) => {
+        if (tool.type !== "mcp") {
+            return;
+        }
+        const mcpConfig = typeof tool.config?.mcp === "object" && tool.config.mcp
+            ? tool.config.mcp
+            : undefined;
+        const serverRef = typeof mcpConfig?.serverRef === "string" ? mcpConfig.serverRef : undefined;
+        if (!serverRef) {
+            throw new Error(`MCP tool ${tool.id} must define mcp.server or mcp.serverRef`);
+        }
+        const serverId = serverRef.startsWith("mcp/") ? serverRef.slice(4) : serverRef;
+        if (!mcpServers.has(serverId)) {
+            throw new Error(`MCP tool ${tool.id} references missing MCP server ${serverRef}`);
+        }
+    });
 }
 function compileBindings(workspaceRoot, refs, agentsList, models, tools) {
     const agents = new Map(agentsList.map((agent) => [agent.id, agent]));
@@ -112,17 +229,19 @@ export async function loadWorkspace(workspaceRoot, options = {}) {
     for (const agent of loaded.agents) {
         loaded.refs.set(`agent/${agent.id}`, agent);
     }
-    const { embeddings, models, vectorStores, tools } = collectParsedResources(loaded.refs);
+    const { embeddings, mcpServers, models, vectorStores, tools } = collectParsedResources(loaded.refs);
+    await hydrateAgentMcpTools(loaded.agents, mcpServers, tools);
     const toolSourceRefs = collectToolSourceRefs(tools, loaded.agents, options);
     await ensureResourceSources(toolSourceRefs, workspaceRoot);
     await hydrateResourceAndExternalTools(tools, toolSourceRefs, workspaceRoot);
-    validateWorkspaceResources(embeddings, models, vectorStores, tools, loaded.agents);
+    validateWorkspaceResources(embeddings, mcpServers, models, vectorStores, tools, loaded.agents);
     return {
         workspaceRoot,
         resourceSources: [...toolSourceRefs],
         builtinSources: [...toolSourceRefs],
         refs: loaded.refs,
         embeddings,
+        mcpServers,
         models,
         vectorStores,
         tools,

package/dist/workspace/object-loader.js

@@ -3,7 +3,9 @@ import { existsSync, statSync } from "node:fs";
 import { readdir, readFile } from "node:fs/promises";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { parseAllDocuments } from "yaml";
+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",
@@ -15,6 +17,7 @@ const ROOT_AGENT_FILENAMES = [
     "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) {
@@ -69,6 +72,31 @@ function toArray(value) {
 function asObject(value) {
     return typeof value === "object" && value ? value : undefined;
 }
+function normalizeNamedResourceSpec(document, kind) {
+    const typed = asObject(document);
+    const spec = typed?.spec;
+    if (!Array.isArray(spec)) {
+        return [];
+    }
+    const normalized = spec
+        .filter((item) => typeof item === "object" && item !== null && !Array.isArray(item))
+        .map((item) => {
+        const id = typeof item.id === "string" && item.id.trim()
+            ? item.id
+            : typeof item.name === "string" && item.name.trim()
+                ? item.name
+                : undefined;
+        if (!id) {
+            return null;
+        }
+        return {
+            ...item,
+            kind,
+            id,
+        };
+    });
+    return normalized.filter((item) => item !== null);
+}
 function normalizeKind(kind) {
     switch (kind) {
         case "LangChainAgent":
@@ -109,6 +137,8 @@ function normalizeKind(kind) {
             return "runtime";
         case "Prompt":
             return "prompt";
+        case "McpServer":
+            return "mcp";
         default:
             return kind;
     }
@@ -153,7 +183,11 @@ function normalizeResourceItem(item) {
 }
 function readRefArray(items) {
     return toArray(items)
-        .map((item) => (typeof item === "object" && item && "ref" in item ? item.ref : undefined))
+        .map((item) => typeof item === "string"
+        ? item
+        : typeof item === "object" && item && "ref" in item
+            ? item.ref
+            : undefined)
         .filter((item) => Boolean(item));
 }
 function readPathArray(items) {
@@ -180,6 +214,12 @@ function readMiddlewareArray(items) {
         .map((item) => ({ ...item }));
     return middleware.length > 0 ? middleware : undefined;
 }
+function readObjectArray(items) {
+    const records = toArray(items)
+        .filter((item) => typeof item === "object" && item !== null && !Array.isArray(item))
+        .map((item) => ({ ...item }));
+    return records.length > 0 ? records : undefined;
+}
 export function parseAgentItem(item, sourcePath) {
     const subagentRefs = readRefArray(item.subagents);
     const subagentPathRefs = readPathArray(item.subagents);
@@ -194,6 +234,7 @@ export function parseAgentItem(item, sourcePath) {
         modelRef: readSingleRef(item.modelRef) ?? "",
         runRoot: typeof item.runRoot === "string" ? item.runRoot : undefined,
         toolRefs: readRefArray(item.tools),
+        mcpServers: readObjectArray(item.mcpServers),
         skillPathRefs: readPathArray(item.skills),
         memorySources: readPathArray(item.memory),
         subagentRefs,
@@ -343,6 +384,23 @@ async function readNamedYamlItems(root, filenames) {
     }
     return records;
 }
+async function readNamedModelItems(root) {
+    const records = [];
+    for (const filename of MODEL_FILENAMES) {
+        const filePath = path.join(root, filename);
+        if (!(await fileExists(filePath))) {
+            continue;
+        }
+        const parsedDocuments = parseAllDocuments(await readYamlOrJson(filePath));
+        for (const parsedDocument of parsedDocuments) {
+            const items = normalizeNamedResourceSpec(parsedDocument.toJSON(), "model");
+            for (const item of items) {
+                records.push({ item: normalizeYamlItem(item), sourcePath: filePath });
+            }
+        }
+    }
+    return records;
+}
 function isAgentKind(kind) {
     return kind === "deepagent" || kind === "langchain-agent";
 }
@@ -358,44 +416,34 @@ async function readConfigAgentItems(configRoot) {
         return !(parentDir === configRoot && ROOT_AGENT_FILENAMES.includes(filename));
     });
 }
-function discoverAnnotatedFunctionNames(sourceText) {
-    const matches = sourceText.matchAll(/@tool[\s\S]*?export\s+(?:async\s+)?function\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(/g);
-    return Array.from(matches, (match) => match[1]);
-}
 export async function readToolModuleItems(root) {
     if (!(await fileExists(root))) {
         return [];
     }
     const entries = await readdir(root, { withFileTypes: true });
     const files = entries
-        .filter((entry) => entry.isFile() && entry.name.endsWith(".mjs"))
+        .filter((entry) => entry.isFile() && isSupportedToolModulePath(entry.name))
         .map((entry) => path.join(root, entry.name))
         .sort();
     const records = [];
     for (const filePath of files) {
         const sourceText = await readFile(filePath, "utf8");
-        const functionNames = discoverAnnotatedFunctionNames(sourceText);
-        if (functionNames.length === 0) {
+        const packageRoot = path.dirname(root);
+        const isolatedSourcePath = await resolveIsolatedResourceModulePath(packageRoot, filePath);
+        const imported = await import(pathToFileURL(isolatedSourcePath).href);
+        const definitions = discoverToolModuleDefinitions(sourceText, imported);
+        if (definitions.length === 0) {
             continue;
         }
-        const imported = await import(pathToFileURL(filePath).href);
-        for (const functionName of functionNames) {
-            const invoke = imported[functionName];
-            const schema = imported[`${functionName}Schema`];
-            if (typeof invoke !== "function") {
-                throw new Error(`Tool module ${filePath} must export function ${functionName}.`);
-            }
-            if (!schema?.parse) {
-                throw new Error(`Tool module ${filePath} must export ${functionName}Schema as a Zod schema.`);
-            }
+        for (const definition of definitions) {
             records.push({
                 item: {
                     kind: "tool",
-                    id: functionName,
+                    id: definition.implementationName,
                     type: "function",
-                    name: functionName,
-                    description: typeof schema.description === "string" ? schema.description : `Auto-discovered tool ${functionName}`,
-                    implementationName: functionName,
+                    name: definition.implementationName,
+                    description: definition.description,
+                    implementationName: definition.implementationName,
                 },
                 sourcePath: filePath,
             });
@@ -480,6 +528,20 @@ export async function loadWorkspaceObjects(workspaceRoot, options = {}) {
                 }
             }
         }
+        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) {
@@ -496,7 +558,7 @@ export async function loadWorkspaceObjects(workspaceRoot, options = {}) {
             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) {
+                    if (!workspaceObject || workspaceObject.kind === "tool") {
                         continue;
                     }
                     const ref = `${workspaceObject.kind}/${workspaceObject.id}`;
@@ -526,7 +588,8 @@ export async function loadWorkspaceObjects(workspaceRoot, options = {}) {
                 if (!workspaceObject) {
                     continue;
                 }
-                if (isAgentKind(workspaceObject.kind)) {
+                if (isAgentKind(workspaceObject.kind) ||
+                    workspaceObject.kind === "model") {
                     continue;
                 }
                 const ref = `${workspaceObject.kind}/${workspaceObject.id}`;
@@ -546,6 +609,9 @@ export async function loadWorkspaceObjects(workspaceRoot, options = {}) {
             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, {

package/dist/workspace/resource-compilers.d.ts

@@ -1,10 +1,12 @@
-import type { CompiledEmbeddingModel, CompiledModel, CompiledVectorStore, ParsedEmbeddingModelObject, ParsedVectorStoreObject, CompiledTool, ParsedModelObject, ParsedToolObject, WorkspaceObject } from "../contracts/types.js";
+import type { CompiledEmbeddingModel, ParsedMcpServerObject, CompiledModel, CompiledVectorStore, ParsedEmbeddingModelObject, ParsedVectorStoreObject, CompiledTool, ParsedModelObject, ParsedToolObject, WorkspaceObject } from "../contracts/types.js";
 export declare function parseModelObject(object: WorkspaceObject): ParsedModelObject;
 export declare function parseEmbeddingModelObject(object: WorkspaceObject): ParsedEmbeddingModelObject;
 export declare function parseVectorStoreObject(object: WorkspaceObject): ParsedVectorStoreObject;
+export declare function parseMcpServerObject(object: WorkspaceObject): ParsedMcpServerObject;
 export declare function validateModelObject(model: ParsedModelObject, models: Map<string, ParsedModelObject>): void;
 export declare function validateEmbeddingModelObject(model: ParsedEmbeddingModelObject): void;
 export declare function validateVectorStoreObject(vectorStore: ParsedVectorStoreObject): void;
+export declare function validateMcpServerObject(server: ParsedMcpServerObject): void;
 export declare function compileModel(model: ParsedModelObject): CompiledModel;
 export declare function compileVectorStore(vectorStore: ParsedVectorStoreObject): CompiledVectorStore;
 export declare function compileEmbeddingModel(model: ParsedEmbeddingModelObject): CompiledEmbeddingModel;