@botbotgo/agent-harness 0.0.135 → 0.0.136

package/dist/workspace/object-loader.js

@@ -6,7 +6,6 @@ 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"];
@@ -94,19 +93,48 @@ function readRefArray(items) {
             : undefined)
         .filter((item) => Boolean(item));
 }
+function normalizeToolUsageOverrides(value) {
+    const record = asMutableObject(value);
+    if (!record) {
+        return undefined;
+    }
+    const directKeys = new Set(["config", "hitl", "retryable", "subprocess", "embeddingModelRef"]);
+    const directOverrides = {};
+    const configOverrides = {};
+    for (const [key, entry] of Object.entries(record)) {
+        if (directKeys.has(key)) {
+            directOverrides[key] = cloneConfigValue(entry);
+            continue;
+        }
+        configOverrides[key] = cloneConfigValue(entry);
+    }
+    return {
+        ...directOverrides,
+        ...(Object.keys(configOverrides).length > 0
+            ? {
+                config: {
+                    ...(asMutableObject(directOverrides.config) ?? {}),
+                    ...configOverrides,
+                },
+            }
+            : {}),
+    };
+}
 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") {
+        if (typeof item !== "object" || !item || Array.isArray(item)) {
             return undefined;
         }
-        const { ref, ...rest } = item;
-        const overrides = Object.keys(rest).length > 0
-            ? cloneConfigValue(rest)
-            : undefined;
+        const entries = Object.entries(item);
+        if (entries.length !== 1 || typeof entries[0]?.[0] !== "string") {
+            throw new Error("Agent tools entries must be either a tool name string or a single-key override object");
+        }
+        const [ref, rawOverride] = entries[0];
+        const overrides = normalizeToolUsageOverrides(rawOverride);
         return {
             ref,
             ...(overrides ? { overrides } : {}),
@@ -114,69 +142,6 @@ function readToolBindingArray(items) {
     })
         .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"
@@ -186,6 +151,11 @@ function readPathArray(items) {
             : undefined)
         .filter((item) => Boolean(item));
 }
+function readStringArray(items) {
+    return toArray(items)
+        .filter((item) => typeof item === "string" && item.trim().length > 0)
+        .map((item) => item.trim());
+}
 function readSingleRef(value) {
     if (typeof value === "string" && value.trim()) {
         return value;
@@ -235,7 +205,16 @@ const CONSUMED_AGENT_CONFIG_KEYS = [
     "generalPurposeAgent",
     "filesystem",
 ];
-const RESERVED_EXECUTION_KEYS = [
+const NON_AGENT_CONFIG_ITEM_KEYS = [
+    "id",
+    "kind",
+    "description",
+    "capabilities",
+    "runtime",
+    "executionMode",
+    "sourcePath",
+];
+const RESERVED_AGENT_KEYS = [
     "backend",
     "modelRef",
     "tools",
@@ -245,7 +224,7 @@ const RESERVED_EXECUTION_KEYS = [
     "mcpServers",
     "config",
 ];
-const MIGRATED_EXECUTION_CONFIG_KEYS = [
+const MIGRATED_AGENT_CONFIG_KEYS = [
     "systemPrompt",
     "checkpointer",
     "interruptOn",
@@ -260,23 +239,19 @@ const MIGRATED_EXECUTION_CONFIG_KEYS = [
     "generalPurposeAgent",
     "filesystem",
 ];
-function readExecutionConfig(value) {
-    return asMutableObject(value);
-}
 function normalizeAgentItemForMerge(item) {
     const normalized = { ...item };
-    const execution = readExecutionConfig(normalized.execution);
-    if (!execution) {
-        return normalized;
+    if (normalized.execution !== undefined) {
+        throw new Error("Agent spec.execution is no longer supported; move backend, modelRef, tools, skills, memory, subagents, mcpServers, and config directly under spec");
     }
-    const config = asMutableObject(execution.config);
+    const config = asMutableObject(normalized.config);
     const runtime = readRuntimeConfig(normalized);
     if (config) {
-        for (const key of MIGRATED_EXECUTION_CONFIG_KEYS) {
-            if (!(key in config) || execution[key] !== undefined) {
+        for (const key of MIGRATED_AGENT_CONFIG_KEYS) {
+            if (!(key in config) || normalized[key] !== undefined) {
                 continue;
             }
-            execution[key] = cloneConfigValue(config[key]);
+            normalized[key] = cloneConfigValue(config[key]);
             delete config[key];
         }
         if (config.runtimeMemory !== undefined && runtime?.runtimeMemory === undefined) {
@@ -287,26 +262,24 @@ function normalizeAgentItemForMerge(item) {
         }
     }
     if (config && Object.keys(config).length > 0) {
-        execution.config = config;
+        normalized.config = config;
     }
     else {
-        delete execution.config;
+        delete normalized.config;
     }
-    normalized.execution = execution;
     return normalized;
 }
 function readExecutionAgentConfig(item) {
-    const execution = readExecutionConfig(item.execution) ?? {};
-    const config = asMutableObject(execution.config) ?? {};
-    const directExecutionConfig = Object.fromEntries(Object.entries(execution).filter(([key]) => !RESERVED_EXECUTION_KEYS.includes(key)));
+    const config = asMutableObject(item.config) ?? {};
+    const directExecutionConfig = Object.fromEntries(Object.entries(item).filter(([key]) => !RESERVED_AGENT_KEYS.includes(key) &&
+        !NON_AGENT_CONFIG_ITEM_KEYS.includes(key)));
     return {
         ...config,
         ...directExecutionConfig,
     };
 }
 function readExecutionValue(item, key, reader) {
-    const execution = readExecutionConfig(item.execution);
-    return reader(execution?.[key]);
+    return reader(item[key]);
 }
 function readRuntimeConfig(item) {
     return asMutableObject(item.runtime);
@@ -369,13 +342,22 @@ function readPassthroughConfig(item, consumedKeys) {
     return Object.keys(passthrough).length > 0 ? passthrough : undefined;
 }
 function resolveExecutionBackend(item, current) {
-    const execution = readExecutionConfig(item.execution) ?? readExecutionConfig(current?.execution);
-    if (typeof execution?.mode === "string" && execution.mode.trim().length > 0) {
-        throw new Error("Agent execution.mode is no longer supported; use execution.backend");
+    if (item.execution !== undefined || current?.execution !== undefined) {
+        throw new Error("Agent spec.execution is no longer supported; move backend, modelRef, tools, skills, memory, subagents, mcpServers, and config directly under spec");
     }
-    const backend = typeof execution?.backend === "string"
-        ? execution.backend.trim().toLowerCase()
-        : undefined;
+    const mode = typeof item.mode === "string"
+        ? item.mode
+        : typeof current?.mode === "string"
+            ? current.mode
+            : undefined;
+    if (typeof mode === "string" && mode.trim().length > 0) {
+        throw new Error("Agent mode is no longer supported; use backend");
+    }
+    const backend = typeof item.backend === "string"
+        ? item.backend.trim().toLowerCase()
+        : typeof current?.backend === "string"
+            ? current.backend.trim().toLowerCase()
+            : undefined;
     if (backend === "langchain-v1") {
         return "langchain-v1";
     }
@@ -383,7 +365,7 @@ function resolveExecutionBackend(item, current) {
         return "deepagent";
     }
     if (backend === "langgraph") {
-        throw new Error("Agent execution.backend=langgraph is no longer supported; use execution.backend=langchain-v1 or execution.backend=deepagent");
+        throw new Error("Agent backend=langgraph is no longer supported; use backend=langchain-v1 or backend=deepagent");
     }
     return undefined;
 }
@@ -429,32 +411,33 @@ function readAgentConfig(item, options = {}) {
     };
 }
 export function parseAgentItem(item, sourcePath) {
+    const normalizedItem = normalizeAgentItemForMerge(item);
     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);
+    const subagentRefs = readExecutionValue(normalizedItem, "subagents", readRefArray);
+    const toolBindings = readExecutionValue(normalizedItem, "tools", readToolBindingArray);
+    const subagentPathRefs = readExecutionValue(normalizedItem, "subagents", readPathArray).map((entry) => resolveModuleRelativePath(entry, moduleRoot));
+    const executionMode = String(resolveExecutionBackend(normalizedItem) ?? "deepagent");
+    const runtime = readRuntimeConfig(normalizedItem);
     return {
-        id: String(item.id),
+        id: String(normalizedItem.id),
         executionMode: executionMode,
-        runtimeMemory: readRuntimeMemoryConfig(item, runtime),
-        capabilities: readCapabilities(item.capabilities) ?? (executionMode === "deepagent"
+        runtimeMemory: readRuntimeMemoryConfig(normalizedItem, runtime),
+        capabilities: readCapabilities(normalizedItem.capabilities) ?? (executionMode === "deepagent"
             ? { delegation: true, memory: true }
             : { delegation: true, memory: true }),
-        description: String(item.description ?? ""),
-        modelRef: readExecutionValue(item, "modelRef", readSingleRef) ?? "",
+        description: String(normalizedItem.description ?? ""),
+        modelRef: readExecutionValue(normalizedItem, "modelRef", readSingleRef) ?? "",
         runRoot: typeof runtime?.runRoot === "string" ? runtime.runRoot : undefined,
         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)),
+        inlineTools: undefined,
+        mcpServers: readExecutionValue(normalizedItem, "mcpServers", readObjectArray),
+        skillPathRefs: readExecutionValue(normalizedItem, "skills", readStringArray),
+        memorySources: readExecutionValue(normalizedItem, "memory", readPathArray).map((entry) => resolveModuleRelativePath(entry, moduleRoot)),
         subagentRefs,
         subagentPathRefs,
-        langchainAgentConfig: normalizeModuleAgentConfig(readAgentConfig(item, { includeDelegationControls: true }), moduleRoot),
-        deepAgentConfig: normalizeModuleAgentConfig(readAgentConfig(item, {
+        langchainAgentConfig: normalizeModuleAgentConfig(readAgentConfig(normalizedItem, { includeDelegationControls: true }), moduleRoot),
+        deepAgentConfig: normalizeModuleAgentConfig(readAgentConfig(normalizedItem, {
             includeObjectBackend: true,
             includeDelegationControls: false,
         }), moduleRoot),
@@ -560,7 +543,7 @@ async function loadConventionalObjectsForRoot(root, mergedObjects) {
         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") {
+                if (!workspaceObject) {
                     continue;
                 }
                 mergeWorkspaceObjectRecord(mergedObjects, workspaceObject, item, sourcePath);
@@ -664,24 +647,39 @@ function isAgentKind(kind) {
     return kind === "agent";
 }
 async function readConfigAgentItems(configRoot) {
-    const records = await readYamlItems(configRoot, "agents", { recursive: true });
+    const records = await readYamlItems(configRoot, undefined, { recursive: true });
     return records.filter(({ item, sourcePath }) => {
         const kind = typeof item.kind === "string" ? item.kind : undefined;
         if (!isAgentKind(kind)) {
             return false;
         }
-        return sourcePath.includes(`${path.sep}agents${path.sep}`);
+        const relativePath = path.relative(configRoot, sourcePath);
+        if (!relativePath || relativePath.startsWith("..")) {
+            return false;
+        }
+        return !relativePath.includes(path.sep) || relativePath.startsWith(`agents${path.sep}`);
     });
 }
 export async function readToolModuleItems(root) {
     if (!(await fileExists(root))) {
         return [];
     }
-    const entries = await readdir(root, { withFileTypes: true });
-    const files = entries
-        .filter((entry) => entry.isFile() && isSupportedToolModulePath(entry.name))
-        .map((entry) => path.join(root, entry.name))
-        .sort();
+    const files = [];
+    const pending = [root];
+    while (pending.length > 0) {
+        const current = pending.shift();
+        const entries = await readdir(current, { withFileTypes: true });
+        for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+            const entryPath = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                pending.push(entryPath);
+                continue;
+            }
+            if (entry.isFile() && isSupportedToolModulePath(entry.name)) {
+                files.push(entryPath);
+            }
+        }
+    }
     const records = [];
     for (const filePath of files) {
         const sourceText = await readFile(filePath, "utf8");

package/dist/workspace/support/source-collectors.js

@@ -1,6 +1,6 @@
 import { isExternalSourceLocator } from "../../resource/sources.js";
 export function collectToolSourceRefs(tools, agents, options) {
-    const refs = new Set(options.resourceSources ?? []);
+    const refs = new Set(options.resources ?? []);
     for (const tool of tools.values()) {
         for (const ref of tool.bundleRefs) {
             if (isExternalSourceLocator(ref)) {

package/dist/workspace/support/workspace-ref-utils.d.ts

@@ -33,6 +33,7 @@ export type ResilienceConfig = {
 };
 export declare function getWorkspaceObject(refs: Map<string, WorkspaceObject | ParsedAgentObject>, ref: string | undefined): WorkspaceObject | undefined;
 export declare function getRuntimeDefaults(refs: Map<string, WorkspaceObject | ParsedAgentObject>): Record<string, unknown> | undefined;
+export declare function getRuntimeResources(refs: Map<string, WorkspaceObject | ParsedAgentObject>): string[];
 export declare function getRuntimeMemoryDefaults(refs: Map<string, WorkspaceObject | ParsedAgentObject>): Record<string, unknown> | undefined;
 export declare function getRecoveryConfig(refs: Map<string, WorkspaceObject | ParsedAgentObject>): RecoveryConfig;
 export declare function getConcurrencyConfig(refs: Map<string, WorkspaceObject | ParsedAgentObject>): ConcurrencyConfig;

package/dist/workspace/support/workspace-ref-utils.js

@@ -26,6 +26,15 @@ export function getRuntimeDefaults(refs) {
     }
     return runtimes[0].value;
 }
+export function getRuntimeResources(refs) {
+    const runtimeDefaults = getRuntimeDefaults(refs);
+    if (!Array.isArray(runtimeDefaults?.resources)) {
+        return [];
+    }
+    return runtimeDefaults.resources
+        .filter((value) => typeof value === "string" && value.trim().length > 0)
+        .map((value) => value.trim());
+}
 export function getRuntimeMemoryDefaults(refs) {
     const runtimeMemories = Array.from(refs.values()).filter((object) => !("executionMode" in object) && object.kind === "runtime-memory");
     if (runtimeMemories.length === 0) {

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

@@ -104,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);

package/package.json

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