@botbotgo/agent-harness 0.0.134 → 0.0.136

package/dist/workspace/compile.js

@@ -1,11 +1,16 @@
+import path from "node:path";
+import { existsSync } from "node:fs";
+import { readdir } from "node:fs/promises";
 import { ensureResourceSources } from "../resource/resource.js";
-import { loadWorkspaceObjects } from "./object-loader.js";
+import { ensureExternalResourceSource, isExternalSourceLocator, resolveResourcePackageRoot } from "../resource/sources.js";
+import { loadWorkspaceObjects, readToolModuleItems, readYamlItems } from "./object-loader.js";
+import { validateSkillMetadata } from "../runtime/support/skill-metadata.js";
 import { parseEmbeddingModelObject, parseMcpServerObject, parseModelObject, parseToolObject, parseVectorStoreObject, validateEmbeddingModelObject, validateMcpServerObject, validateModelObject, validateToolObject, validateVectorStoreObject, } from "./resource-compilers.js";
 import { validateAgent, validateTopology } from "./validate.js";
 import { compileBinding } from "./agent-binding-compiler.js";
 import { discoverSubagents, ensureDiscoverySources } from "./support/discovery.js";
 import { collectAgentDiscoverySourceRefs, collectToolSourceRefs } from "./support/source-collectors.js";
-import { getRoutingDefaultAgentId, getRoutingRules, resolveRefId, } from "./support/workspace-ref-utils.js";
+import { getRoutingDefaultAgentId, getRuntimeResources, getRoutingRules, resolveRefId, } from "./support/workspace-ref-utils.js";
 import { hydrateAgentMcpTools, hydrateResourceAndExternalTools } from "./tool-hydration.js";
 function collectParsedResources(refs) {
     const embeddings = new Map();
@@ -42,6 +47,17 @@ function validateWorkspaceResources(embeddings, mcpServers, models, vectorStores
     models.forEach((model) => validateModelObject(model, models));
     vectorStores.forEach((vectorStore) => validateVectorStoreObject(vectorStore));
     tools.forEach((tool) => validateToolObject(tool, tools));
+    tools.forEach((tool) => {
+        if (!tool.embeddingModelRef) {
+            return;
+        }
+        const embeddingModelId = tool.embeddingModelRef.startsWith("embedding-model/")
+            ? tool.embeddingModelRef.slice("embedding-model/".length)
+            : tool.embeddingModelRef;
+        if (!embeddings.has(embeddingModelId)) {
+            throw new Error(`Tool ${tool.id} references missing embedding model ${tool.embeddingModelRef}`);
+        }
+    });
     agents.forEach(validateAgent);
     validateTopology(agents);
     tools.forEach((tool) => {
@@ -82,6 +98,109 @@ function validateRoutingTargets(refs, agentsList) {
         }
     }
 }
+function resolveLocalResourceRoot(candidate, workspaceRoot) {
+    const resolved = path.resolve(workspaceRoot, candidate);
+    const resourceRoot = resolveResourcePackageRoot(resolved);
+    if (!resourceRoot) {
+        throw new Error(`Workspace resource ${candidate} is missing resources/package.json.`);
+    }
+    return resourceRoot;
+}
+async function resolveConfiguredResources(entries, workspaceRoot) {
+    const resolved = [];
+    for (const entry of entries) {
+        const key = entry.trim();
+        if (!key) {
+            continue;
+        }
+        const root = isExternalSourceLocator(key)
+            ? await ensureExternalResourceSource(key, workspaceRoot)
+            : resolveLocalResourceRoot(key, workspaceRoot);
+        resolved.push({ key, root });
+    }
+    return resolved;
+}
+async function registerAttachedResourceTools(tools, resourceRoot) {
+    const toolsRoot = path.join(resourceRoot, "tools");
+    for (const { item, sourcePath } of await readYamlItems(toolsRoot, undefined, { recursive: true })) {
+        const parsed = parseToolObject({
+            id: typeof item.id === "string" ? item.id : path.basename(sourcePath).replace(/\.(yaml|yml|json)$/i, ""),
+            kind: "tool",
+            sourcePath,
+            value: item,
+        });
+        tools.set(parsed.id, parsed);
+    }
+    for (const { item, sourcePath } of await readToolModuleItems(toolsRoot)) {
+        const parsed = parseToolObject({
+            id: String(item.id),
+            kind: "tool",
+            sourcePath,
+            value: item,
+        });
+        tools.set(parsed.id, parsed);
+    }
+}
+async function collectSkillRoots(root) {
+    try {
+        const entries = await readdir(root, { withFileTypes: true });
+        const skillDocument = entries.find((entry) => entry.isFile() && entry.name === "SKILL.md");
+        if (skillDocument) {
+            return [root];
+        }
+        const nested = await Promise.all(entries
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => collectSkillRoots(path.join(root, entry.name))));
+        return nested.flat();
+    }
+    catch {
+        return [];
+    }
+}
+async function registerWorkspaceSkillRegistry(skillCollectionRoots) {
+    const registry = new Map();
+    for (const skillsRoot of skillCollectionRoots) {
+        for (const skillRoot of await collectSkillRoots(skillsRoot)) {
+            const metadata = validateSkillMetadata(skillRoot);
+            const existing = registry.get(metadata.name);
+            if (existing && existing !== skillRoot) {
+                throw new Error(`Duplicate skill name ${metadata.name} found in ${existing} and ${skillRoot}`);
+            }
+            registry.set(metadata.name, skillRoot);
+        }
+    }
+    return registry;
+}
+function validateToolNameConflicts(tools) {
+    const seen = new Map();
+    for (const tool of tools.values()) {
+        const existing = seen.get(tool.name);
+        if (existing && existing !== tool.sourcePath) {
+            throw new Error(`Duplicate tool name ${tool.name} found in ${existing} and ${tool.sourcePath}`);
+        }
+        seen.set(tool.name, tool.sourcePath);
+    }
+}
+function resolveAgentSkillNames(agents, skillRegistry, skillCollectionRoots) {
+    for (const agent of agents) {
+        agent.skillPathRefs = agent.skillPathRefs.map((entry) => {
+            const registered = skillRegistry.get(entry);
+            if (registered) {
+                return registered;
+            }
+            if (path.isAbsolute(entry) || entry.includes("/") || entry.startsWith("builtin://")) {
+                return entry;
+            }
+            for (const skillsRoot of skillCollectionRoots) {
+                const candidate = path.join(skillsRoot, entry);
+                if (existsSync(path.join(candidate, "SKILL.md"))) {
+                    return candidate;
+                }
+            }
+            return entry;
+        });
+    }
+}
 export async function loadWorkspace(workspaceRoot, options = {}) {
     const loaded = await loadWorkspaceObjects(workspaceRoot, options);
     loaded.agents = await discoverSubagents(loaded.agents, workspaceRoot);
@@ -92,14 +211,39 @@ export async function loadWorkspace(workspaceRoot, options = {}) {
     }
     const { embeddings, mcpServers, models, vectorStores, tools } = collectParsedResources(loaded.refs);
     await hydrateAgentMcpTools(loaded.agents, mcpServers, tools);
-    const toolSourceRefs = collectToolSourceRefs(tools, loaded.agents, options);
-    await ensureResourceSources(toolSourceRefs, workspaceRoot);
-    await hydrateResourceAndExternalTools(tools, toolSourceRefs, workspaceRoot);
+    const configuredResources = Array.from(new Set([
+        ...getRuntimeResources(loaded.refs),
+        ...(options.resources ?? []),
+    ]));
+    const resolvedConfiguredResources = await resolveConfiguredResources(configuredResources, workspaceRoot);
+    for (const resource of resolvedConfiguredResources) {
+        await registerAttachedResourceTools(tools, resource.root);
+    }
+    const localResourceRoot = resolveResourcePackageRoot(workspaceRoot);
+    const skillCollectionRoots = [
+        path.join(workspaceRoot, "modules", "skills"),
+        ...(localResourceRoot ? [path.join(localResourceRoot, "skills")] : []),
+        ...resolvedConfiguredResources.map((resource) => path.join(resource.root, "skills")),
+    ];
+    const skillRegistry = await registerWorkspaceSkillRegistry(skillCollectionRoots);
+    resolveAgentSkillNames(loaded.agents, skillRegistry, skillCollectionRoots);
+    const collectedResources = collectToolSourceRefs(tools, loaded.agents, {
+        ...options,
+        resources: configuredResources,
+    });
+    const externalResources = collectedResources.filter((resource) => isExternalSourceLocator(resource));
+    await ensureResourceSources(externalResources, workspaceRoot);
+    await hydrateResourceAndExternalTools(tools, externalResources, workspaceRoot);
+    validateToolNameConflicts(tools);
+    const resources = Array.from(new Set([
+        ...(localResourceRoot ? [localResourceRoot] : []),
+        ...collectedResources,
+    ]));
     validateWorkspaceResources(embeddings, mcpServers, models, vectorStores, tools, loaded.agents);
     validateRoutingTargets(loaded.refs, loaded.agents);
     return {
         workspaceRoot,
-        resourceSources: [...toolSourceRefs],
+        resources,
         refs: loaded.refs,
         embeddings,
         mcpServers,

package/dist/workspace/object-loader.js

@@ -93,6 +93,55 @@ 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 || Array.isArray(item)) {
+            return 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 } : {}),
+        };
+    })
+        .filter((item) => Boolean(item));
+}
 function readPathArray(items) {
     return toArray(items)
         .map((item) => typeof item === "string"
@@ -102,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;
@@ -151,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",
@@ -161,7 +224,7 @@ const RESERVED_EXECUTION_KEYS = [
     "mcpServers",
     "config",
 ];
-const MIGRATED_EXECUTION_CONFIG_KEYS = [
+const MIGRATED_AGENT_CONFIG_KEYS = [
     "systemPrompt",
     "checkpointer",
     "interruptOn",
@@ -176,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) {
@@ -203,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);
@@ -285,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");
-    }
-    const backend = typeof execution?.backend === "string"
-        ? execution.backend.trim().toLowerCase()
-        : undefined;
+    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 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";
     }
@@ -299,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;
 }
@@ -345,29 +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 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: readExecutionValue(item, "tools", readRefArray),
-        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)),
+        toolRefs: toolBindings.map((binding) => binding.ref),
+        toolBindings,
+        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),
@@ -409,9 +479,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;
@@ -463,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);
@@ -567,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/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/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) {