@botbotgo/agent-harness 0.0.22 → 0.0.24

package/dist/workspace/tool-hydration.js

@@ -0,0 +1,158 @@
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { listRemoteMcpTools } from "../resource/resource-impl.js";
+import { ensureExternalResourceSource, isExternalSourceLocator } from "../resource/sources.js";
+import { listResourceTools, listResourceToolsForSource } from "../resource/resource.js";
+import { readToolModuleItems } from "./object-loader.js";
+import { parseMcpServerObject, parseToolObject } from "./resource-compilers.js";
+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 hydrateExternalToolSource(tools, source, workspaceRoot) {
+    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,
+        });
+    }
+}
+export async function hydrateResourceAndExternalTools(tools, toolSourceRefs, workspaceRoot) {
+    for (const source of toolSourceRefs) {
+        if (isExternalSourceLocator(source)) {
+            await hydrateExternalToolSource(tools, source, workspaceRoot);
+        }
+    }
+    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,
+        });
+    }
+}
+export 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);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.22",
+  "version": "0.0.24",
   "description": "Agent Harness framework package",
   "type": "module",
   "packageManager": "npm@10.9.2",

package/dist/config/model.yaml

@@ -1,44 +0,0 @@
-# agent-harness feature: schema version for this declarative config object.
-apiVersion: agent-harness/v1alpha1
-# agent-harness feature: object type for a named model preset.
-# Available options today: `Model`.
-# The harness resolves this object into LangChain model construction parameters.
-kind: Model
-metadata:
-  # agent-harness feature: stable model object id used by refs such as `model/default`.
-  name: default
-spec:
-  # ====================
-  # LangChain v1 Features
-  # ====================
-  # LangChain aligned feature: provider family or integration namespace.
-  # Common options in this harness today include:
-  # - `ollama`
-  # - `openai`
-  # - `openai-compatible`
-  # - `anthropic`
-  # - `google` / `google-genai` / `gemini`
-  # The runtime adapter uses this to select the concrete LangChain chat model implementation.
-  provider: ollama
-  # LangChain aligned feature: concrete model identifier passed to the selected provider integration.
-  # Example values depend on `provider`, such as `gpt-oss:latest` for `ollama`.
-  model: gpt-oss:latest
-  init:
-    # LangChain aligned feature: provider-specific initialization options.
-    # Available keys are provider-specific; common examples include `baseUrl`, `temperature`, and auth/client settings.
-    # `baseUrl` configures the Ollama-compatible endpoint used by the model client.
-    # For `openai-compatible`, `baseUrl` is normalized into the ChatOpenAI `configuration.baseURL` field.
-    baseUrl: https://ollama-rtx-4070.easynet.world/
-    # LangChain aligned feature: provider/model initialization option controlling sampling temperature.
-    temperature: 0.2
-  # ===================
-  # DeepAgents Features
-  # ===================
-  # DeepAgents uses the same model object shape indirectly through `createDeepAgent({ model })`.
-  # There is no separate DeepAgents-only field here; DeepAgent bindings consume the same compiled model.
-
-  # ======================
-  # agent-harness Features
-  # ======================
-  # This object is packaged and referenced through `modelRef` fields in harness config, but the actual
-  # model arguments above map directly onto the upstream LangChain model layer.