@botbotgo/agent-harness 0.0.80 → 0.0.82

package/dist/workspace/object-loader.js

@@ -4,11 +4,29 @@ import { readdir, readFile } from "node:fs/promises";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { parseAllDocuments } from "yaml";
 import { resolveIsolatedResourceModulePath } from "../resource/isolation.js";
-import { resolveResourcePackageRoot } from "../resource/sources.js";
+import { isExternalSourceLocator, resolveResourcePackageRoot } from "../resource/sources.js";
 import { discoverToolModuleDefinitions, isSupportedToolModulePath } from "../tool-modules.js";
 import { fileExists, listFilesRecursive, readYamlOrJson } from "../utils/fs.js";
 const MODEL_FILENAMES = ["models.yaml", "models.yml"];
 const CONVENTIONAL_OBJECT_DIRECTORIES = ["tools"];
+const MODULE_AGENT_FILENAMES = ["agent.yaml", "agent.yml"];
+const MODULE_TOOL_FILENAMES = ["tool.yaml", "tool.yml"];
+const MODULE_TOOL_ENTRY_FILENAMES = ["index.mjs", "index.js", "index.cjs"];
+function moduleCollectionRoot(root, kind) {
+    return path.join(root, "modules", kind);
+}
+function isModuleDefinitionPath(sourcePath, kind) {
+    const normalized = sourcePath.split(path.sep).join("/");
+    const suffix = kind === "agents" ? "/agent.yaml" : "/tool.yaml";
+    const altSuffix = kind === "agents" ? "/agent.yml" : "/tool.yml";
+    return normalized.includes(`/modules/${kind}/`) && (normalized.endsWith(suffix) || normalized.endsWith(altSuffix));
+}
+function moduleRootForSourcePath(sourcePath, kind) {
+    if (!isModuleDefinitionPath(sourcePath, kind)) {
+        return undefined;
+    }
+    return path.dirname(sourcePath);
+}
 function conventionalConfigRoot(root) {
     if (path.basename(root) === "config" && existsSync(root) && statSync(root).isDirectory()) {
         return root;
@@ -236,6 +254,36 @@ function cloneConfigValue(value) {
     }
     return value;
 }
+function isModuleRelativePathCandidate(value) {
+    return !path.isAbsolute(value) && !isExternalSourceLocator(value) && !value.includes("://");
+}
+function resolveModuleRelativePath(value, moduleRoot) {
+    if (!moduleRoot || !isModuleRelativePathCandidate(value)) {
+        return value;
+    }
+    return path.resolve(moduleRoot, value);
+}
+function normalizeModulePromptConfig(value, moduleRoot) {
+    if (!moduleRoot || typeof value !== "object" || value === null || Array.isArray(value)) {
+        return value;
+    }
+    const typed = { ...value };
+    if (typeof typed.path === "string") {
+        typed.path = resolveModuleRelativePath(typed.path, moduleRoot);
+    }
+    return typed;
+}
+function normalizeModuleAgentConfig(config, moduleRoot) {
+    if (!moduleRoot) {
+        return config;
+    }
+    return {
+        ...config,
+        ...(config.systemPrompt !== undefined
+            ? { systemPrompt: normalizeModulePromptConfig(config.systemPrompt, moduleRoot) }
+            : {}),
+    };
+}
 function readPassthroughConfig(item, consumedKeys) {
     const passthrough = Object.fromEntries(Object.entries(item)
         .filter(([key]) => !consumedKeys.includes(key))
@@ -277,7 +325,10 @@ function readExecutionObjectArray(item, key) {
 function readSharedAgentConfig(config) {
     const middleware = readMiddlewareArray(config.middleware);
     return {
-        ...(typeof config.systemPrompt === "string" ? { systemPrompt: config.systemPrompt } : {}),
+        ...((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 }
             : {}),
@@ -349,8 +400,9 @@ function readDeepAgentConfig(item) {
     };
 }
 export function parseAgentItem(item, sourcePath) {
+    const moduleRoot = moduleRootForSourcePath(sourcePath, "agents");
     const subagentRefs = readExecutionRefArray(item, "subagents");
-    const subagentPathRefs = readExecutionPathArray(item, "subagents");
+    const subagentPathRefs = readExecutionPathArray(item, "subagents").map((entry) => resolveModuleRelativePath(entry, moduleRoot));
     const executionMode = String(resolveExecutionBackend(item) ?? "deepagent");
     const runtime = readRuntimeConfig(item);
     return {
@@ -364,12 +416,12 @@ export function parseAgentItem(item, sourcePath) {
         runRoot: typeof runtime?.runRoot === "string" ? runtime.runRoot : undefined,
         toolRefs: readExecutionRefArray(item, "tools"),
         mcpServers: readExecutionObjectArray(item, "mcpServers"),
-        skillPathRefs: readExecutionPathArray(item, "skills"),
-        memorySources: readExecutionPathArray(item, "memory"),
+        skillPathRefs: readExecutionPathArray(item, "skills").map((entry) => resolveModuleRelativePath(entry, moduleRoot)),
+        memorySources: readExecutionPathArray(item, "memory").map((entry) => resolveModuleRelativePath(entry, moduleRoot)),
         subagentRefs,
         subagentPathRefs,
-        langchainAgentConfig: readLangchainAgentConfig(item),
-        deepAgentConfig: readDeepAgentConfig(item),
+        langchainAgentConfig: normalizeModuleAgentConfig(readLangchainAgentConfig(item), moduleRoot),
+        deepAgentConfig: normalizeModuleAgentConfig(readDeepAgentConfig(item), moduleRoot),
         sourcePath,
     };
 }
@@ -465,6 +517,23 @@ async function loadConfigAgentsForRoot(configRoot, mergedAgents) {
         mergeAgentRecord(mergedAgents, item, sourcePath);
     }
 }
+async function loadModuleAgentsForRoot(root, mergedAgents) {
+    const modulesRoot = moduleCollectionRoot(root, "agents");
+    if (!(await fileExists(modulesRoot))) {
+        return;
+    }
+    const entries = await readdir(modulesRoot, { withFileTypes: true });
+    for (const entry of entries.filter((candidate) => candidate.isDirectory()).sort((left, right) => left.name.localeCompare(right.name))) {
+        const moduleRoot = path.join(modulesRoot, entry.name);
+        for (const { item, sourcePath } of await readNamedYamlItems(moduleRoot, [...MODULE_AGENT_FILENAMES])) {
+            const normalizedItem = typeof item.id === "string" && item.id.trim() ? item : { ...item, id: entry.name };
+            if (!isAgentKind(normalizedItem.kind)) {
+                continue;
+            }
+            mergeAgentRecord(mergedAgents, normalizedItem, sourcePath);
+        }
+    }
+}
 async function loadConventionalObjectsForRoot(root, mergedObjects) {
     for (const directory of CONVENTIONAL_OBJECT_DIRECTORIES) {
         for (const objectRoot of conventionalDirectoryRoots(root, directory)) {
@@ -485,6 +554,61 @@ async function loadConventionalObjectsForRoot(root, mergedObjects) {
         }
     }
 }
+async function readModuleToolItems(root) {
+    const modulesRoot = moduleCollectionRoot(root, "tools");
+    if (!(await fileExists(modulesRoot))) {
+        return [];
+    }
+    const entries = await readdir(modulesRoot, { withFileTypes: true });
+    const records = [];
+    for (const entry of entries.filter((candidate) => candidate.isDirectory()).sort((left, right) => left.name.localeCompare(right.name))) {
+        const moduleRoot = path.join(modulesRoot, entry.name);
+        for (const { item, sourcePath } of await readNamedYamlItems(moduleRoot, [...MODULE_TOOL_FILENAMES])) {
+            const normalizedItem = typeof item.id === "string" && item.id.trim() ? item : { ...item, id: entry.name };
+            const workspaceObject = parseWorkspaceObject(normalizedItem, sourcePath);
+            if (!workspaceObject || workspaceObject.kind !== "tool") {
+                continue;
+            }
+            const implementation = asObject(normalizedItem.implementation);
+            const explicitPath = typeof implementation?.path === "string" ? path.resolve(moduleRoot, implementation.path) : undefined;
+            const discoveredPath = explicitPath ??
+                MODULE_TOOL_ENTRY_FILENAMES.map((filename) => path.join(moduleRoot, filename)).find((candidate) => existsSync(candidate));
+            const inferredType = typeof normalizedItem.type === "string"
+                ? normalizedItem.type
+                : normalizedItem.refs !== undefined || normalizedItem.bundle !== undefined
+                    ? "bundle"
+                    : normalizedItem.providerTool !== undefined || normalizedItem.provider !== undefined
+                        ? "provider"
+                        : normalizedItem.backend !== undefined || normalizedItem.operation !== undefined
+                            ? "backend"
+                            : normalizedItem.mcp !== undefined
+                                ? "mcp"
+                                : "function";
+            if (inferredType === "function" && !discoveredPath) {
+                throw new Error(`Module tool ${workspaceObject.id} must define implementation.path or provide index.mjs|index.js|index.cjs`);
+            }
+            records.push({
+                item: {
+                    ...normalizedItem,
+                    ...(typeof implementation?.export === "string" && !normalizedItem.implementationName
+                        ? { implementationName: implementation.export }
+                        : {}),
+                },
+                sourcePath: discoveredPath ?? sourcePath,
+            });
+        }
+    }
+    return records;
+}
+async function loadModuleObjectsForRoot(root, mergedObjects) {
+    for (const { item, sourcePath } of await readModuleToolItems(root)) {
+        const workspaceObject = parseWorkspaceObject(item, sourcePath);
+        if (!workspaceObject) {
+            continue;
+        }
+        mergeWorkspaceObjectRecord(mergedObjects, workspaceObject, item, sourcePath);
+    }
+}
 async function loadConfigObjectsForRoot(root, configRoot, mergedObjects) {
     if (!conventionalConfigRoot(root)) {
         return;
@@ -645,8 +769,10 @@ export async function loadWorkspaceObjects(workspaceRoot, options = {}) {
         const configRoot = conventionalConfigRoot(root) ?? root;
         await loadNamedModelsForRoot(configRoot, mergedObjects);
         await loadConfigAgentsForRoot(configRoot, mergedAgents);
+        await loadModuleAgentsForRoot(root, mergedAgents);
         await loadConventionalObjectsForRoot(root, mergedObjects);
         await loadConfigObjectsForRoot(root, configRoot, mergedObjects);
+        await loadModuleObjectsForRoot(root, mergedObjects);
         await loadRootObjects(root, mergedObjects);
     }
     const agents = Array.from(mergedAgents.values()).map(({ item, sourcePath }) => parseAgentItem(item, sourcePath));

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

@@ -19,6 +19,9 @@ export type RecoveryConfig = {
 };
 export type ConcurrencyConfig = {
     maxConcurrentRuns: number;
+    leaseMs: number;
+    heartbeatIntervalMs: number;
+    heartbeatTimeoutMs: number;
 };
 export type ProviderRetryConfig = {
     maxAttempts: number;

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

@@ -1,3 +1,4 @@
+import { readFileSync } from "node:fs";
 import path from "node:path";
 function getRoutingObject(refs) {
     const runtimeDefaults = getRuntimeDefaults(refs);
@@ -63,7 +64,27 @@ export function getConcurrencyConfig(refs) {
         concurrency.maxConcurrentRuns > 0
         ? Math.floor(concurrency.maxConcurrentRuns)
         : 3;
-    return { maxConcurrentRuns };
+    const leaseMs = typeof concurrency.leaseMs === "number" &&
+        Number.isFinite(concurrency.leaseMs) &&
+        concurrency.leaseMs > 0
+        ? Math.floor(concurrency.leaseMs)
+        : 30_000;
+    const heartbeatIntervalMs = typeof concurrency.heartbeatIntervalMs === "number" &&
+        Number.isFinite(concurrency.heartbeatIntervalMs) &&
+        concurrency.heartbeatIntervalMs > 0
+        ? Math.floor(concurrency.heartbeatIntervalMs)
+        : 5_000;
+    const heartbeatTimeoutMs = typeof concurrency.heartbeatTimeoutMs === "number" &&
+        Number.isFinite(concurrency.heartbeatTimeoutMs) &&
+        concurrency.heartbeatTimeoutMs > 0
+        ? Math.floor(concurrency.heartbeatTimeoutMs)
+        : Math.max(leaseMs, heartbeatIntervalMs * 3);
+    return {
+        maxConcurrentRuns,
+        leaseMs,
+        heartbeatIntervalMs,
+        heartbeatTimeoutMs,
+    };
 }
 export function getResilienceConfig(refs) {
     const runtimeDefaults = getRuntimeDefaults(refs);
@@ -210,6 +231,14 @@ export function resolvePromptValue(promptConfig) {
     if (typeof promptConfig === "string" && promptConfig.trim()) {
         return promptConfig;
     }
+    if (typeof promptConfig === "object" && promptConfig !== null && !Array.isArray(promptConfig)) {
+        const promptPath = typeof promptConfig.path === "string"
+            ? promptConfig.path
+            : undefined;
+        if (promptPath?.trim()) {
+            return readFileSync(promptPath, "utf8");
+        }
+    }
     return undefined;
 }
 export function resolveRefId(ref) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.80",
+  "version": "0.0.82",
   "description": "Workspace runtime for multi-agent applications",
   "type": "module",
   "packageManager": "npm@10.9.2",
@@ -53,7 +53,7 @@
   "scripts": {
     "build": "rm -rf dist tsconfig.tsbuildinfo && tsc -p tsconfig.json && cp -R config dist/",
     "check": "tsc -p tsconfig.json --noEmit",
-    "test": "vitest run test/hello-file.test.ts test/public-api.test.ts test/runtime-health.test.ts test/memory-runtime.test.ts test/sqlite-persistence.test.ts test/runtime-record-maintenance.test.ts test/resource-optional-provider.test.ts test/resource-isolation.test.ts test/stock-research-app-load-harness.test.ts test/stock-research-app-run.test.ts test/stock-research-app-config.test.ts test/release-workflow.test.ts test/release-version.test.ts test/gitignore.test.ts test/package-lock.test.ts test/readme.test.ts test/product-boundary-docs.test.ts test/long-term-memory-docs.test.ts test/local-docs-persistence-inventory.test.ts test/docs-site.test.ts test/runtime-adapter-regressions.test.ts test/runtime-capabilities.test.ts test/runtime-recovery.test.ts test/tool-extension-gaps.test.ts test/checkpoint-maintenance.test.ts test/llamaindex-dependency-compat.test.ts test/skill-standard.test.ts test/routing-config.test.ts test/workspace-compat-regressions.test.ts test/upstream-compat-regressions.test.ts test/yaml-format.test.ts test/config-secrets.test.ts test/init-command.test.ts test/coding-agent-guide.test.ts",
+    "test": "vitest run test/hello-file.test.ts test/public-api.test.ts test/runtime-health.test.ts test/memory-runtime.test.ts test/sqlite-persistence.test.ts test/runtime-queue-lease.test.ts test/runtime-cancel.test.ts test/runtime-record-maintenance.test.ts test/resource-optional-provider.test.ts test/resource-isolation.test.ts test/stock-research-app-load-harness.test.ts test/stock-research-app-run.test.ts test/stock-research-app-config.test.ts test/release-workflow.test.ts test/release-version.test.ts test/gitignore.test.ts test/package-lock.test.ts test/readme.test.ts test/product-boundary-docs.test.ts test/long-term-memory-docs.test.ts test/local-docs-persistence-inventory.test.ts test/docs-site.test.ts test/runtime-adapter-regressions.test.ts test/runtime-capabilities.test.ts test/runtime-recovery.test.ts test/tool-extension-gaps.test.ts test/checkpoint-maintenance.test.ts test/llamaindex-dependency-compat.test.ts test/skill-standard.test.ts test/routing-config.test.ts test/workspace-compat-regressions.test.ts test/upstream-compat-regressions.test.ts test/yaml-format.test.ts test/config-secrets.test.ts test/init-command.test.ts test/coding-agent-guide.test.ts",
     "test:real-providers": "vitest run test/real-provider-harness.test.ts",
     "release:prepare": "npm version patch --no-git-tag-version && node ./scripts/sync-example-version.mjs",
     "release:pack": "npm pack --dry-run",