@botbotgo/agent-harness 0.0.134 → 0.0.136

package/dist/workspace/tool-hydration.js

@@ -20,6 +20,18 @@ function toMcpServerConfig(server) {
 function readStringArray(value) {
     return Array.isArray(value) ? value.filter((item) => typeof item === "string" && item.trim().length > 0) : [];
 }
+function readStringRecord(value) {
+    if (typeof value !== "object" || !value || Array.isArray(value)) {
+        return undefined;
+    }
+    const entries = Object.entries(value).filter((entry) => typeof entry[1] === "string");
+    return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+function asObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
 function compileRegexList(value, label) {
     return readStringArray(value).map((pattern) => {
         try {
@@ -53,6 +65,52 @@ function shouldIncludeRemoteMcpTool(filter, toolName) {
     }
     return true;
 }
+function normalizeAgentMcpServerUsage(item) {
+    const config = asObject(item.config);
+    if (!config) {
+        return item;
+    }
+    return {
+        ...config,
+        ...item,
+    };
+}
+function hasMcpServerUsageOverrides(item) {
+    return [
+        "transport",
+        "command",
+        "args",
+        "env",
+        "cwd",
+        "url",
+        "token",
+        "headers",
+    ].some((key) => item[key] !== undefined);
+}
+function mergeReferencedMcpServer(referencedServer, item, agentId, name, sourcePath) {
+    return {
+        id: `${agentId}.${name}`,
+        transport: item.transport === "stdio" || item.transport === "http" || item.transport === "sse" || item.transport === "websocket"
+            ? item.transport
+            : referencedServer.transport,
+        url: typeof item.url === "string" ? item.url : referencedServer.url,
+        command: typeof item.command === "string" ? item.command : referencedServer.command,
+        args: Array.isArray(item.args)
+            ? item.args.filter((entry) => typeof entry === "string")
+            : referencedServer.args,
+        env: {
+            ...(referencedServer.env ?? {}),
+            ...(readStringRecord(item.env) ?? {}),
+        },
+        cwd: typeof item.cwd === "string" ? item.cwd : referencedServer.cwd,
+        token: typeof item.token === "string" ? item.token : referencedServer.token,
+        headers: {
+            ...(referencedServer.headers ?? {}),
+            ...(readStringRecord(item.headers) ?? {}),
+        },
+        sourcePath,
+    };
+}
 async function hydrateExternalToolSource(tools, source, workspaceRoot) {
     const externalRoot = await ensureExternalResourceSource(source, workspaceRoot);
     const discoveredToolRefs = [];
@@ -102,35 +160,51 @@ export async function hydrateResourceAndExternalTools(tools, toolSourceRefs, wor
             name: existing?.name || resourceTool.name,
             description: existing?.description || resourceTool.description,
             config: existing?.config,
+            embeddingModelRef: existing?.embeddingModelRef,
             backendOperation: existing?.backendOperation ?? resourceTool.backendOperation,
             bundleRefs: existing?.bundleRefs ?? [],
             hitl: existing?.hitl ?? resourceTool.hitl,
             retryable: existing?.retryable ?? resourceTool.retryable,
-            sourcePath: existing?.sourcePath ?? resourceTool.toolPath,
+            sourcePath: resourceTool.toolPath,
         });
     }
 }
 export async function hydrateAgentMcpTools(agents, mcpServers, tools) {
     for (const agent of agents) {
         const discoveredRefs = new Set(agent.toolRefs);
-        for (const item of agent.mcpServers ?? []) {
+        for (const rawItem of agent.mcpServers ?? []) {
+            const item = normalizeAgentMcpServerUsage(rawItem);
+            const serverRef = typeof item.ref === "string" ? item.ref.trim() : "";
+            const referencedServerId = serverRef.startsWith("mcp/") ? serverRef.slice(4) : serverRef;
+            const referencedServer = referencedServerId ? mcpServers.get(referencedServerId) : undefined;
             const name = typeof item.name === "string" && item.name.trim()
                 ? item.name.trim()
-                : typeof item.id === "string" && item.id.trim()
-                    ? item.id.trim()
-                    : "";
+                : referencedServer?.id
+                    ? referencedServer.id
+                    : 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,
-            });
+            let serverId = referencedServer?.id;
+            let parsedServer = referencedServer;
+            if (!parsedServer) {
+                serverId = `${agent.id}.${name}`;
+                parsedServer = parseMcpServerObject({
+                    id: serverId,
+                    kind: "mcp",
+                    sourcePath: agent.sourcePath,
+                    value: item,
+                });
+                mcpServers.set(serverId, parsedServer);
+            }
+            else if (referencedServer && hasMcpServerUsageOverrides(item)) {
+                parsedServer = mergeReferencedMcpServer(referencedServer, item, agent.id, name, agent.sourcePath);
+                serverId = parsedServer.id;
+                mcpServers.set(serverId, parsedServer);
+            }
             const filter = compileMcpToolFilter(item);
-            mcpServers.set(serverId, parsedServer);
             const remoteTools = await listRemoteMcpTools(toMcpServerConfig(parsedServer));
             for (const remoteTool of remoteTools) {
                 if (!shouldIncludeRemoteMcpTool(filter, remoteTool.name)) {

package/dist/workspace/yaml-object-reader.js

@@ -3,9 +3,31 @@ import { readdir } from "node:fs/promises";
 import { parseAllDocuments } from "yaml";
 import { fileExists, listFilesRecursive, readYamlOrJson } from "../utils/fs.js";
 const MODEL_FILENAMES = ["models.yaml", "models.yml"];
+const ENV_PLACEHOLDER_PATTERN = /\$\{env:([A-Za-z_][A-Za-z0-9_]*)\}/g;
 function asObject(value) {
     return typeof value === "object" && value ? value : undefined;
 }
+function interpolateEnvString(value, sourcePath) {
+    return value.replaceAll(ENV_PLACEHOLDER_PATTERN, (_match, envName) => {
+        const resolved = process.env[envName];
+        if (typeof resolved !== "string" || resolved.length === 0) {
+            throw new Error(`YAML document ${sourcePath} references missing environment variable ${envName}`);
+        }
+        return resolved;
+    });
+}
+function interpolateEnvPlaceholders(value, sourcePath) {
+    if (typeof value === "string") {
+        return interpolateEnvString(value, sourcePath);
+    }
+    if (Array.isArray(value)) {
+        return value.map((entry) => interpolateEnvPlaceholders(entry, sourcePath));
+    }
+    if (typeof value === "object" && value !== null) {
+        return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, interpolateEnvPlaceholders(entry, sourcePath)]));
+    }
+    return value;
+}
 function normalizeCatalogSpec(document, options = {}) {
     const typed = asObject(document);
     const spec = typed?.spec;
@@ -82,7 +104,7 @@ function normalizeKind(kind) {
 }
 export function normalizeYamlItem(item) {
     if (item.kind === "DeepAgent" || item.kind === "LangChainAgent") {
-        throw new Error(`YAML object kind ${String(item.kind)} is no longer supported; use kind: Agent with spec.execution.backend instead`);
+        throw new Error(`YAML object kind ${String(item.kind)} is no longer supported; use kind: Agent with spec.backend instead`);
     }
     const metadata = asObject(item.metadata);
     const spec = asObject(item.spec);
@@ -116,15 +138,17 @@ async function objectItemsFromDocument(document, sourcePath) {
         : undefined;
     const catalogItems = catalogKind === "Models"
         ? normalizeCatalogSpec(document, { defaultKind: "Model" })
-        : catalogKind === "Stores"
-            ? normalizeCatalogSpec(document)
-            : catalogKind === "Backends"
-                ? normalizeCatalogSpec(document, { defaultKind: "Backend" })
-                : catalogKind === "Tools"
-                    ? normalizeCatalogSpec(document, { defaultKind: "Tool" })
-                    : catalogKind === "McpServers"
-                        ? normalizeCatalogSpec(document, { defaultKind: "McpServer" })
-                        : [];
+        : catalogKind === "EmbeddingModels"
+            ? normalizeCatalogSpec(document, { defaultKind: "EmbeddingModel" })
+            : catalogKind === "Stores"
+                ? normalizeCatalogSpec(document)
+                : catalogKind === "Backends"
+                    ? normalizeCatalogSpec(document, { defaultKind: "Backend" })
+                    : catalogKind === "Tools"
+                        ? normalizeCatalogSpec(document, { defaultKind: "Tool" })
+                        : catalogKind === "McpServers"
+                            ? normalizeCatalogSpec(document, { defaultKind: "McpServer" })
+                            : [];
     if (catalogItems.length > 0) {
         return catalogItems;
     }
@@ -148,7 +172,8 @@ export async function readYamlItems(root, relativeDir, options = {}) {
     for (const filePath of files) {
         const parsedDocuments = parseAllDocuments(await readYamlOrJson(filePath));
         for (const parsedDocument of parsedDocuments) {
-            for (const item of await objectItemsFromDocument(parsedDocument.toJSON(), filePath)) {
+            const resolvedDocument = interpolateEnvPlaceholders(parsedDocument.toJSON(), filePath);
+            for (const item of await objectItemsFromDocument(resolvedDocument, filePath)) {
                 records.push({ item: normalizeYamlItem(item), sourcePath: filePath });
             }
         }
@@ -164,7 +189,8 @@ export async function readNamedYamlItems(root, filenames) {
         }
         const parsedDocuments = parseAllDocuments(await readYamlOrJson(filePath));
         for (const parsedDocument of parsedDocuments) {
-            for (const item of await objectItemsFromDocument(parsedDocument.toJSON(), filePath)) {
+            const resolvedDocument = interpolateEnvPlaceholders(parsedDocument.toJSON(), filePath);
+            for (const item of await objectItemsFromDocument(resolvedDocument, filePath)) {
                 records.push({ item: normalizeYamlItem(item), sourcePath: filePath });
             }
         }
@@ -190,7 +216,8 @@ export async function readNamedModelItems(root) {
     for (const filePath of [...filePaths].sort()) {
         const parsedDocuments = parseAllDocuments(await readYamlOrJson(filePath));
         for (const parsedDocument of parsedDocuments) {
-            for (const item of await objectItemsFromDocument(parsedDocument.toJSON(), filePath)) {
+            const resolvedDocument = interpolateEnvPlaceholders(parsedDocument.toJSON(), filePath);
+            for (const item of await objectItemsFromDocument(resolvedDocument, filePath)) {
                 const normalized = normalizeYamlItem(item);
                 if (normalized.kind === "model" && typeof normalized.id === "string" && normalized.id.trim()) {
                     records.push({ item: normalized, sourcePath: filePath });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.134",
+  "version": "0.0.136",
   "description": "Workspace runtime for multi-agent applications",
   "type": "module",
   "packageManager": "npm@10.9.2",