@botbotgo/agent-harness 0.0.135 → 0.0.137

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,66 @@ function readRefArray(items) {
             : undefined)
         .filter((item) => Boolean(item));
 }
+function readPrefixedRefArray(items, prefix) {
+    return toArray(items)
+        .map((item) => {
+        if (typeof item === "string") {
+            const value = item.trim();
+            if (!value) {
+                return undefined;
+            }
+            return value.startsWith(`${prefix}/`) ? value : `${prefix}/${value}`;
+        }
+        if (typeof item === "object" && item && "ref" in item && typeof item.ref === "string") {
+            const value = String(item.ref).trim();
+            return value || undefined;
+        }
+        return undefined;
+    })
+        .filter((item) => Boolean(item));
+}
+function normalizeToolUsageOverrides(value) {
+    const record = asMutableObject(value);
+    if (!record) {
+        return undefined;
+    }
+    const directKeys = new Set(["config", "hitl", "retryable", "subprocess", "embeddingModel", "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 +160,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 +169,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;
@@ -207,6 +195,20 @@ function readObjectArray(items) {
         .map((item) => ({ ...item }));
     return records.length > 0 ? records : undefined;
 }
+function readMcpServerArray(items) {
+    const records = toArray(items)
+        .map((item) => {
+        if (typeof item === "string" && item.trim()) {
+            return { ref: item.startsWith("mcp/") ? item : `mcp/${item.trim()}` };
+        }
+        if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+            return { ...item };
+        }
+        return undefined;
+    })
+        .filter((item) => Boolean(item));
+    return records.length > 0 ? records : undefined;
+}
 function readCapabilities(value) {
     if (typeof value !== "object" || value === null || Array.isArray(value)) {
         return undefined;
@@ -235,7 +237,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 +256,7 @@ const RESERVED_EXECUTION_KEYS = [
     "mcpServers",
     "config",
 ];
-const MIGRATED_EXECUTION_CONFIG_KEYS = [
+const MIGRATED_AGENT_CONFIG_KEYS = [
     "systemPrompt",
     "checkpointer",
     "interruptOn",
@@ -260,23 +271,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,35 +294,47 @@ 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);
 }
 function readRuntimeMemoryConfig(item, runtime) {
+    if (typeof runtime?.runtimeMemory === "string" && runtime.runtimeMemory.trim()) {
+        return {
+            ref: runtime.runtimeMemory.startsWith("runtime-memory/")
+                ? runtime.runtimeMemory
+                : `runtime-memory/${runtime.runtimeMemory.trim()}`,
+        };
+    }
     if (typeof runtime?.runtimeMemory === "object" && runtime.runtimeMemory && !Array.isArray(runtime.runtimeMemory)) {
         return cloneConfigValue(runtime.runtimeMemory);
     }
     const legacyExecutionConfig = readExecutionAgentConfig(item);
+    if (typeof legacyExecutionConfig.runtimeMemory === "string" && legacyExecutionConfig.runtimeMemory.trim()) {
+        return {
+            ref: legacyExecutionConfig.runtimeMemory.startsWith("runtime-memory/")
+                ? legacyExecutionConfig.runtimeMemory
+                : `runtime-memory/${legacyExecutionConfig.runtimeMemory.trim()}`,
+        };
+    }
     if (typeof legacyExecutionConfig.runtimeMemory === "object" &&
         legacyExecutionConfig.runtimeMemory &&
         !Array.isArray(legacyExecutionConfig.runtimeMemory)) {
@@ -369,13 +388,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 +411,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;
 }
@@ -400,14 +428,27 @@ function readSharedAgentConfigFields(config, options = {}) {
 }
 function readSharedAgentConfig(config) {
     const middleware = readMiddlewareArray(config.middleware);
+    const backend = typeof config.backend === "string" && config.backend.trim()
+        ? { ref: config.backend.startsWith("backend/") ? config.backend : `backend/${config.backend.trim()}` }
+        : typeof config.backend === "object" && config.backend
+            ? config.backend
+            : undefined;
+    const checkpointer = typeof config.checkpointer === "string" && config.checkpointer.trim()
+        ? { ref: config.checkpointer.startsWith("checkpointer/") ? config.checkpointer : `checkpointer/${config.checkpointer.trim()}` }
+        : (typeof config.checkpointer === "object" && config.checkpointer) || typeof config.checkpointer === "boolean"
+            ? config.checkpointer
+            : undefined;
+    const store = typeof config.store === "string" && config.store.trim()
+        ? { ref: config.store.startsWith("store/") ? config.store : `store/${config.store.trim()}` }
+        : typeof config.store === "object" && config.store
+            ? config.store
+            : undefined;
     return {
         ...((typeof config.systemPrompt === "string" && config.systemPrompt)
             || (typeof config.systemPrompt === "object" && config.systemPrompt && !Array.isArray(config.systemPrompt))
             ? { systemPrompt: cloneConfigValue(config.systemPrompt) }
             : {}),
-        ...((typeof config.checkpointer === "object" && config.checkpointer) || typeof config.checkpointer === "boolean"
-            ? { checkpointer: config.checkpointer }
-            : {}),
+        ...(checkpointer !== undefined ? { checkpointer } : {}),
         ...(typeof config.interruptOn === "object" && config.interruptOn ? { interruptOn: config.interruptOn } : {}),
         ...(config.stateSchema !== undefined ? { stateSchema: config.stateSchema } : {}),
         ...(config.responseFormat !== undefined ? { responseFormat: config.responseFormat } : {}),
@@ -415,6 +456,8 @@ function readSharedAgentConfig(config) {
         ...(config.includeAgentName === "inline" ? { includeAgentName: "inline" } : {}),
         ...(config.version === "v1" || config.version === "v2" ? { version: config.version } : {}),
         ...(typeof config.filesystem === "object" && config.filesystem ? { filesystem: config.filesystem } : {}),
+        ...(backend ? { backend } : {}),
+        ...(store ? { store } : {}),
         ...(middleware ? { middleware } : {}),
     };
 }
@@ -424,37 +467,39 @@ function readAgentConfig(item, options = {}) {
     return {
         ...readSharedAgentConfig(config),
         ...readSharedAgentConfigFields(config, { includeDelegationControls: options.includeDelegationControls }),
-        ...(options.includeObjectBackend && typeof config.backend === "object" && config.backend ? { backend: config.backend } : {}),
         ...(passthrough ? { passthrough } : {}),
     };
 }
 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)
+        .filter((entry) => path.isAbsolute(entry) || entry.startsWith("./") || entry.startsWith("../"))
+        .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", readMcpServerArray),
+        skillPathRefs: readExecutionValue(normalizedItem, "skills", (value) => readPrefixedRefArray(value, "skill")),
+        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 +605,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 +709,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/resource-compilers.js

@@ -220,7 +220,7 @@ export function parseToolObject(object) {
     const mcpServerConfig = mcp
         ? Object.fromEntries(Object.entries(mcp).filter(([key]) => key !== "ref" && key !== "serverRef" && key !== "tool"))
         : undefined;
-    const bundleRefs = asRefArray(value.refs ?? value.bundle);
+    const bundleRefs = asRefArray(value.tools ?? value.refs ?? value.bundle);
     const inferredType = typeof value.type === "string"
         ? value.type
         : bundleRefs.length > 0
@@ -252,9 +252,11 @@ export function parseToolObject(object) {
         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,
+            : typeof value.embeddingModel === "string"
+                ? `embedding-model/${String(value.embeddingModel).trim()}`
+                : 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/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);
@@ -144,7 +144,7 @@ async function objectItemsFromDocument(document, sourcePath) {
                 ? normalizeCatalogSpec(document)
                 : catalogKind === "Backends"
                     ? normalizeCatalogSpec(document, { defaultKind: "Backend" })
-                    : catalogKind === "Tools"
+                    : catalogKind === "Tools" || catalogKind === "ToolSets"
                         ? normalizeCatalogSpec(document, { defaultKind: "Tool" })
                         : catalogKind === "McpServers"
                             ? normalizeCatalogSpec(document, { defaultKind: "McpServer" })

package/package.json

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