@botbotgo/agent-harness 0.0.267 → 0.0.269

package/dist/workspace/object-loader.d.ts

@@ -1,4 +1,5 @@
 import type { ParsedAgentObject, WorkspaceLoadOptions, WorkspaceObject } from "../contracts/types.js";
+import type { ToolModuleDiscoveryScope } from "./support/workspace-ref-utils.js";
 export { normalizeYamlItem, readYamlItems } from "./yaml-object-reader.js";
 type RefMap = Map<string, WorkspaceObject | ParsedAgentObject>;
 export type WorkspaceObjects = {
@@ -7,7 +8,9 @@ export type WorkspaceObjects = {
 };
 export declare function conventionalPackageRoots(root: string, relativeDir: "tools" | "skills"): string[];
 export declare function parseAgentItem(item: Record<string, unknown>, sourcePath: string): ParsedAgentObject;
-export declare function readToolModuleItems(root: string): Promise<Array<{
+export declare function readToolModuleItems(root: string, options?: {
+    scope?: ToolModuleDiscoveryScope;
+}): Promise<Array<{
     item: Record<string, unknown>;
     sourcePath: string;
 }>>;

package/dist/workspace/object-loader.js

@@ -613,7 +613,14 @@ async function loadModuleAgentsForRoot(root, mergedAgents) {
         }
     }
 }
-async function loadConventionalObjectsForRoot(root, mergedObjects) {
+function getMergedToolModuleDiscoveryScope(mergedObjects) {
+    const runtimeDefaults = mergedObjects.get("runtime/default")?.item;
+    const toolModuleDiscovery = typeof runtimeDefaults?.toolModuleDiscovery === "object" && runtimeDefaults.toolModuleDiscovery
+        ? runtimeDefaults.toolModuleDiscovery
+        : {};
+    return toolModuleDiscovery.scope === "top-level" ? "top-level" : "recursive";
+}
+async function loadConventionalObjectsForRoot(root, mergedObjects, toolModuleDiscoveryScope) {
     for (const directory of CONVENTIONAL_OBJECT_DIRECTORIES) {
         for (const objectRoot of conventionalDirectoryRoots(root, directory)) {
             for (const { item, sourcePath } of await readYamlItemsIgnoringNodeModules(objectRoot)) {
@@ -623,7 +630,7 @@ async function loadConventionalObjectsForRoot(root, mergedObjects) {
                 }
                 mergeWorkspaceObjectRecord(mergedObjects, workspaceObject, item, sourcePath);
             }
-            for (const { item, sourcePath } of await readToolModuleItems(objectRoot)) {
+            for (const { item, sourcePath } of await readToolModuleItems(objectRoot, { scope: toolModuleDiscoveryScope })) {
                 const workspaceObject = parseWorkspaceObject(item, sourcePath);
                 if (!workspaceObject) {
                     continue;
@@ -785,10 +792,11 @@ async function loadRootObjects(root, mergedObjects) {
 function isAgentKind(kind) {
     return kind === "agent";
 }
-export async function readToolModuleItems(root) {
+export async function readToolModuleItems(root, options = {}) {
     if (!(await fileExists(root))) {
         return [];
     }
+    const scope = options.scope === "top-level" ? "top-level" : "recursive";
     const files = [];
     const pending = [root];
     while (pending.length > 0) {
@@ -798,7 +806,7 @@ export async function readToolModuleItems(root) {
             const entryPath = path.join(current, entry.name);
             const entryType = await resolveScanEntryType(entryPath, entry);
             if (entryType === "directory") {
-                if (shouldSkipScanDirectory(entry.name)) {
+                if (shouldSkipScanDirectory(entry.name) || scope === "top-level") {
                     continue;
                 }
                 pending.push(entryPath);
@@ -886,7 +894,7 @@ export async function loadWorkspaceObjects(workspaceRoot, options = {}) {
         const configRoot = conventionalConfigRoot(root) ?? root;
         await loadConfigYamlForRoot(root, configRoot, mergedAgents, mergedObjects);
         await loadModuleAgentsForRoot(root, mergedAgents);
-        await loadConventionalObjectsForRoot(root, mergedObjects);
+        await loadConventionalObjectsForRoot(root, mergedObjects, getMergedToolModuleDiscoveryScope(mergedObjects));
         await loadModuleObjectsForRoot(root, mergedObjects);
         await loadRootObjects(root, mergedObjects);
     }

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

@@ -31,9 +31,14 @@ export type ProviderRetryConfig = {
 export type ResilienceConfig = {
     providerRetries: ProviderRetryConfig;
 };
+export type ToolModuleDiscoveryScope = "recursive" | "top-level";
+export type ToolModuleDiscoveryConfig = {
+    scope: ToolModuleDiscoveryScope;
+};
 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 getToolModuleDiscoveryConfig(refs: Map<string, WorkspaceObject | ParsedAgentObject>): ToolModuleDiscoveryConfig;
 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

@@ -35,6 +35,15 @@ export function getRuntimeResources(refs) {
         .filter((value) => typeof value === "string" && value.trim().length > 0)
         .map((value) => value.trim());
 }
+export function getToolModuleDiscoveryConfig(refs) {
+    const runtimeDefaults = getRuntimeDefaults(refs);
+    const toolModuleDiscovery = typeof runtimeDefaults?.toolModuleDiscovery === "object" && runtimeDefaults.toolModuleDiscovery
+        ? runtimeDefaults.toolModuleDiscovery
+        : {};
+    return {
+        scope: toolModuleDiscovery.scope === "top-level" ? "top-level" : "recursive",
+    };
+}
 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/tool-hydration.d.ts

@@ -1,3 +1,4 @@
 import type { ParsedAgentObject, ParsedMcpServerObject, ParsedToolObject } from "../contracts/types.js";
-export declare function hydrateResourceAndExternalTools(tools: Map<string, ParsedToolObject>, toolSourceRefs: string[], workspaceRoot: string): Promise<void>;
+import type { ToolModuleDiscoveryScope } from "./support/workspace-ref-utils.js";
+export declare function hydrateResourceAndExternalTools(tools: Map<string, ParsedToolObject>, toolSourceRefs: string[], workspaceRoot: string, toolModuleDiscoveryScope?: ToolModuleDiscoveryScope): Promise<void>;
 export declare function hydrateAgentMcpTools(agents: ParsedAgentObject[], mcpServers: Map<string, ParsedMcpServerObject>, tools: Map<string, ParsedToolObject>): Promise<void>;

package/dist/workspace/tool-hydration.js

@@ -144,11 +144,11 @@ function mergeReferencedMcpServer(referencedServer, item, agentId, name, sourceP
         sourcePath,
     };
 }
-async function hydrateExternalToolSource(tools, source, workspaceRoot) {
+async function hydrateExternalToolSource(tools, source, workspaceRoot, toolModuleDiscoveryScope) {
     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"))) {
+    for (const { item, sourcePath } of await readToolModuleItems(path.join(externalRoot, "tools"), { scope: toolModuleDiscoveryScope })) {
         const toolId = typeof item.id === "string" ? item.id : undefined;
         if (!toolId) {
             continue;
@@ -179,10 +179,10 @@ async function hydrateExternalToolSource(tools, source, workspaceRoot) {
         });
     }
 }
-export async function hydrateResourceAndExternalTools(tools, toolSourceRefs, workspaceRoot) {
+export async function hydrateResourceAndExternalTools(tools, toolSourceRefs, workspaceRoot, toolModuleDiscoveryScope = "recursive") {
     for (const source of toolSourceRefs) {
         if (isExternalSourceLocator(source)) {
-            await hydrateExternalToolSource(tools, source, workspaceRoot);
+            await hydrateExternalToolSource(tools, source, workspaceRoot, toolModuleDiscoveryScope);
         }
     }
     for (const resourceTool of await listResourceTools(toolSourceRefs, workspaceRoot)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.267",
+  "version": "0.0.269",
   "description": "Workspace runtime for multi-agent applications",
   "license": "MIT",
   "type": "module",