@botbotgo/agent-harness 0.0.134 → 0.0.135

package/dist/workspace/object-loader.js

@@ -6,6 +6,7 @@ import { resolveIsolatedResourceModulePath } from "../resource/isolation.js";
 import { isExternalSourceLocator, resolveResourcePackageRoot } from "../resource/sources.js";
 import { discoverToolModuleDefinitions, isSupportedToolModulePath } from "../tool-modules.js";
 import { fileExists } from "../utils/fs.js";
+import { parseToolObject } from "./resource-compilers.js";
 import { readNamedModelItems, readNamedYamlItems, readYamlItems, } from "./yaml-object-reader.js";
 export { normalizeYamlItem, readYamlItems } from "./yaml-object-reader.js";
 const CONVENTIONAL_OBJECT_DIRECTORIES = ["tools"];
@@ -93,6 +94,89 @@ function readRefArray(items) {
             : undefined)
         .filter((item) => Boolean(item));
 }
+function readToolBindingArray(items) {
+    return toArray(items)
+        .map((item) => {
+        if (typeof item === "string") {
+            return { ref: item };
+        }
+        if (typeof item !== "object" || !item || !("ref" in item) || typeof item.ref !== "string") {
+            return undefined;
+        }
+        const { ref, ...rest } = item;
+        const overrides = Object.keys(rest).length > 0
+            ? cloneConfigValue(rest)
+            : undefined;
+        return {
+            ref,
+            ...(overrides ? { overrides } : {}),
+        };
+    })
+        .filter((item) => Boolean(item));
+}
+function readInlineToolObjects(items, sourcePath, agentId) {
+    const sourceDir = path.dirname(sourcePath);
+    const bindings = [];
+    const inlineTools = [];
+    toArray(items).forEach((item, index) => {
+        if (typeof item === "string") {
+            bindings.push({ ref: item });
+            return;
+        }
+        if (typeof item !== "object" || !item) {
+            return;
+        }
+        if ("ref" in item && typeof item.ref === "string") {
+            const { ref, ...rest } = item;
+            const overrides = Object.keys(rest).length > 0
+                ? cloneConfigValue(rest)
+                : undefined;
+            bindings.push({ ref, ...(overrides ? { overrides } : {}) });
+            return;
+        }
+        const raw = cloneConfigValue(item);
+        const implementation = asObject(raw.implementation);
+        const name = typeof raw.name === "string" && raw.name.trim().length > 0
+            ? raw.name.trim()
+            : typeof raw.id === "string" && raw.id.trim().length > 0
+                ? raw.id.trim()
+                : `tool-${index + 1}`;
+        const syntheticId = `${agentId}__${name}`;
+        const implementationPath = typeof implementation?.path === "string"
+            ? resolveModuleRelativePath(path.resolve(sourceDir, implementation.path), undefined)
+            : undefined;
+        const inferredType = typeof raw.type === "string"
+            ? raw.type
+            : raw.refs !== undefined || raw.bundle !== undefined
+                ? "bundle"
+                : raw.providerTool !== undefined || raw.provider !== undefined
+                    ? "provider"
+                    : raw.backend !== undefined || raw.operation !== undefined
+                        ? "backend"
+                        : raw.mcp !== undefined
+                            ? "mcp"
+                            : "function";
+        if (inferredType === "function" && !implementationPath) {
+            throw new Error(`Inline tool ${name} must define implementation.path`);
+        }
+        const workspaceObject = {
+            id: syntheticId,
+            kind: "tool",
+            sourcePath: implementationPath ?? sourcePath,
+            value: {
+                id: syntheticId,
+                ...raw,
+                ...(typeof implementation?.export === "string" && typeof raw.implementationName !== "string"
+                    ? { implementationName: implementation.export }
+                    : {}),
+            },
+        };
+        const parsedTool = parseToolObject(workspaceObject);
+        inlineTools.push(parsedTool);
+        bindings.push({ ref: `tool/${syntheticId}` });
+    });
+    return { bindings, inlineTools };
+}
 function readPathArray(items) {
     return toArray(items)
         .map((item) => typeof item === "string"
@@ -347,6 +431,7 @@ function readAgentConfig(item, options = {}) {
 export function parseAgentItem(item, sourcePath) {
     const moduleRoot = moduleRootForSourcePath(sourcePath, "agents");
     const subagentRefs = readExecutionValue(item, "subagents", readRefArray);
+    const { bindings: toolBindings, inlineTools } = readInlineToolObjects(readExecutionValue(item, "tools", toArray), sourcePath, String(item.id));
     const subagentPathRefs = readExecutionValue(item, "subagents", readPathArray).map((entry) => resolveModuleRelativePath(entry, moduleRoot));
     const executionMode = String(resolveExecutionBackend(item) ?? "deepagent");
     const runtime = readRuntimeConfig(item);
@@ -360,7 +445,9 @@ export function parseAgentItem(item, sourcePath) {
         description: String(item.description ?? ""),
         modelRef: readExecutionValue(item, "modelRef", readSingleRef) ?? "",
         runRoot: typeof runtime?.runRoot === "string" ? runtime.runRoot : undefined,
-        toolRefs: readExecutionValue(item, "tools", readRefArray),
+        toolRefs: toolBindings.map((binding) => binding.ref),
+        toolBindings,
+        inlineTools,
         mcpServers: readExecutionValue(item, "mcpServers", readObjectArray),
         skillPathRefs: readExecutionValue(item, "skills", readPathArray).map((entry) => resolveModuleRelativePath(entry, moduleRoot)),
         memorySources: readExecutionValue(item, "memory", readPathArray).map((entry) => resolveModuleRelativePath(entry, moduleRoot)),
@@ -409,9 +496,19 @@ function mergeValues(base, override) {
 }
 function mergeRawItemRecord(records, key, item, sourcePath) {
     const current = records.get(key);
+    const mergedItem = current ? mergeValues(current.item, item) : item;
+    const kind = typeof mergedItem.kind === "string" ? mergedItem.kind : undefined;
+    const type = typeof mergedItem.type === "string" ? mergedItem.type : undefined;
+    const resolvedSourcePath = current &&
+        kind === "tool" &&
+        type === "function" &&
+        isSupportedToolModulePath(current.sourcePath) &&
+        !isSupportedToolModulePath(sourcePath)
+        ? current.sourcePath
+        : sourcePath;
     const mergedRecord = {
-        item: current ? mergeValues(current.item, item) : item,
-        sourcePath,
+        item: mergedItem,
+        sourcePath: resolvedSourcePath,
     };
     records.set(key, mergedRecord);
     return mergedRecord;

package/dist/workspace/resource-compilers.js

@@ -248,7 +248,13 @@ export function parseToolObject(object) {
                 ...(mcpServerConfig && Object.keys(mcpServerConfig).length > 0 ? { mcpServer: mcpServerConfig } : {}),
             }
             : undefined),
+        subprocess: value.subprocess === true,
         inputSchemaRef: typeof asObject(value.inputSchema)?.ref === "string" ? String(asObject(value.inputSchema)?.ref) : undefined,
+        embeddingModelRef: typeof value.embeddingModelRef === "string"
+            ? value.embeddingModelRef
+            : typeof asObject(value.embeddingModel)?.ref === "string"
+                ? String(asObject(value.embeddingModel)?.ref)
+                : undefined,
         backendOperation: typeof backend?.operation === "string"
             ? backend.operation
             : typeof value.operation === "string"

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;
@@ -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.135",
   "description": "Workspace runtime for multi-agent applications",
   "type": "module",
   "packageManager": "npm@10.9.2",