@botbotgo/agent-harness 0.0.8 → 0.0.10

package/dist/{vendor → resource}/sources.js

@@ -14,6 +14,23 @@ function sourceCacheDir(locator) {
     const digest = createHash("sha256").update(locator).digest("hex").slice(0, 16);
     return path.join(cacheRoot(), digest);
 }
+export function resolveResourcePackageRoot(root) {
+    const candidates = path.basename(root) === "resources" ? [root] : [path.join(root, "resources")];
+    for (const candidate of candidates) {
+        if (!existsSync(candidate)) {
+            continue;
+        }
+        if (!statSync(candidate).isDirectory()) {
+            continue;
+        }
+        const packageJsonPath = path.join(candidate, "package.json");
+        if (!existsSync(packageJsonPath)) {
+            throw new Error(`Resource package ${candidate} is missing package.json.`);
+        }
+        return candidate;
+    }
+    return null;
+}
 export function isExternalSourceLocator(value) {
     return typeof value === "string" && /^(npm|tgz|file):/.test(value);
 }
@@ -91,6 +108,24 @@ export async function ensureExternalSource(locator, workspaceRoot) {
     sourceCache.set(cacheKey, basePath);
     return parsed.subpath ? path.join(basePath, parsed.subpath) : basePath;
 }
+export async function ensureExternalResourceSource(locator, workspaceRoot) {
+    const parsed = parseExternalSourceLocator(locator);
+    const baseLocator = `${parsed.kind}:${parsed.spec}`;
+    const packageRoot = await ensureExternalSource(baseLocator, workspaceRoot);
+    const resourcesRoot = path.join(packageRoot, "resources");
+    if (!existsSync(resourcesRoot) || !statSync(resourcesRoot).isDirectory()) {
+        throw new Error(`External source ${baseLocator} is missing resources/.`);
+    }
+    const resourcePackageJson = path.join(resourcesRoot, "package.json");
+    if (!existsSync(resourcePackageJson)) {
+        throw new Error(`External source ${baseLocator} is missing resources/package.json.`);
+    }
+    const resourcePackageRoot = resolveResourcePackageRoot(packageRoot);
+    if (!resourcePackageRoot) {
+        throw new Error(`External source ${baseLocator} is missing resources/package.json.`);
+    }
+    return parsed.subpath ? path.join(resourcePackageRoot, parsed.subpath) : resourcePackageRoot;
+}
 export async function ensureExternalSources(locators, workspaceRoot) {
     await Promise.all(Array.from(new Set(locators)).map((locator) => ensureExternalSource(locator, workspaceRoot)));
 }
@@ -110,6 +145,24 @@ export function resolveExternalSourcePath(locator, workspaceRoot) {
     }
     throw new Error(`External source ${locator} must be preloaded before synchronous resolution`);
 }
+export function resolveExternalResourcePath(locator, workspaceRoot) {
+    const parsed = parseExternalSourceLocator(locator);
+    const baseLocator = `${parsed.kind}:${parsed.spec}`;
+    const packageRoot = resolveExternalSourcePath(baseLocator, workspaceRoot);
+    const resourcesRoot = path.join(packageRoot, "resources");
+    if (!existsSync(resourcesRoot) || !statSync(resourcesRoot).isDirectory()) {
+        throw new Error(`External source ${baseLocator} is missing resources/.`);
+    }
+    const resourcePackageJson = path.join(resourcesRoot, "package.json");
+    if (!existsSync(resourcePackageJson)) {
+        throw new Error(`External source ${baseLocator} is missing resources/package.json.`);
+    }
+    const resourcePackageRoot = resolveResourcePackageRoot(packageRoot);
+    if (!resourcePackageRoot) {
+        throw new Error(`External source ${baseLocator} is missing resources/package.json.`);
+    }
+    return parsed.subpath ? path.join(resourcePackageRoot, parsed.subpath) : resourcePackageRoot;
+}
 export function isDirectoryPath(candidate) {
     return existsSync(candidate) && statSync(candidate).isDirectory();
 }

package/dist/runtime/agent-runtime-adapter.js

@@ -318,7 +318,7 @@ export class AgentRuntimeAdapter {
         if (!params) {
             throw new Error(`Agent ${binding.agent.id} has no runnable params`);
         }
-        return createDeepAgent({
+        const deepAgentConfig = {
             model: (await this.resolveModel(params.model)),
             tools: this.resolveTools(params.tools, binding),
             systemPrompt: params.systemPrompt,
@@ -331,7 +331,8 @@ export class AgentRuntimeAdapter {
             name: params.name,
             memory: params.memory,
             skills: params.skills,
-        });
+        };
+        return createDeepAgent(deepAgentConfig);
     }
     async route(input, primaryBinding, secondaryBinding, options = {}) {
         const routeModelConfig = primaryBinding.langchainAgentParams?.model ??

package/dist/runtime/file-checkpoint-saver.js

@@ -29,6 +29,21 @@ function decodeBinary(value) {
     }
     return value;
 }
+function pruneThreadEntries(record, threadId) {
+    for (const key of Object.keys(record)) {
+        if (key.includes(threadId)) {
+            delete record[key];
+            continue;
+        }
+        const value = record[key];
+        if (typeof value === "object" && value && !Array.isArray(value)) {
+            pruneThreadEntries(value, threadId);
+            if (Object.keys(value).length === 0) {
+                delete record[key];
+            }
+        }
+    }
+}
 export class FileCheckpointSaver extends MemorySaver {
     filePath;
     loaded = false;
@@ -83,9 +98,9 @@ export class FileCheckpointSaver extends MemorySaver {
     }
     async deleteThread(threadId) {
         await this.ensureLoaded();
-        const result = await super.deleteThread(threadId);
+        pruneThreadEntries(this.storage, threadId);
+        pruneThreadEntries(this.writes, threadId);
         await this.persist();
-        return result;
     }
 }
 export { FileCheckpointSaver as FileCheckpointer };

package/dist/runtime/harness.js

@@ -2,7 +2,7 @@ import { AUTO_AGENT_ID } from "../contracts/types.js";
 import { FilePersistence } from "../persistence/file-store.js";
 import { createPersistentId } from "../utils/id.js";
 import { AGENT_INTERRUPT_SENTINEL_PREFIX, AgentRuntimeAdapter } from "./agent-runtime-adapter.js";
-import { createBuiltinBackendResolver, createBuiltinToolResolver } from "../vendor/builtins.js";
+import { createResourceBackendResolver, createResourceToolResolver } from "../resource/resource.js";
 import { EventBus } from "./event-bus.js";
 import { PolicyEngine } from "./policy-engine.js";
 import { getRoutingSystemPrompt } from "../workspace/support/workspace-ref-utils.js";
@@ -115,7 +115,7 @@ export class AgentHarness {
         this.runtimeAdapter = new AgentRuntimeAdapter({
             ...runtimeAdapterOptions,
             toolResolver: runtimeAdapterOptions.toolResolver ??
-                createBuiltinToolResolver(workspace, {
+                createResourceToolResolver(workspace, {
                     getStore: (binding) => this.resolveStore(binding),
                     getEmbeddingModel: (embeddingModelRef) => this.resolveEmbeddingModel(embeddingModelRef),
                     getVectorStore: (vectorStoreRef) => this.resolveVectorStore(vectorStoreRef),
@@ -135,7 +135,7 @@ export class AgentHarness {
             storeResolver: runtimeAdapterOptions.storeResolver ??
                 ((binding) => this.resolveStore(binding)),
             backendResolver: runtimeAdapterOptions.backendResolver ??
-                ((binding) => createBuiltinBackendResolver(workspace)(binding)),
+                ((binding) => createResourceBackendResolver(workspace)(binding)),
         });
         this.routingSystemPrompt = getRoutingSystemPrompt(workspace.refs);
         this.threadMemorySync = new ThreadMemorySync(this.persistence, this.defaultStore);

package/dist/runtime/support/vector-stores.js

@@ -110,7 +110,7 @@ export async function resolveCompiledVectorStore(workspace, vectorStore, options
                 table,
                 column,
             });
-            const rows = await store.similaritySearchWithScore(query, limit);
+            const rows = (await store.similaritySearchWithScore(query, limit));
             return rows.map(([document, score]) => ({
                 pageContent: document.pageContent,
                 metadata: document.metadata,

package/dist/workspace/compile.js

@@ -1,6 +1,8 @@
-import { ensureBuiltinSources, listBuiltinTools, listBuiltinToolsForSource } from "../vendor/builtins.js";
-import { isExternalSourceLocator } from "../vendor/sources.js";
-import { loadWorkspaceObjects } from "./object-loader.js";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { ensureResourceSources, listResourceTools, listResourceToolsForSource } from "../resource/resource.js";
+import { ensureExternalResourceSource, isExternalSourceLocator } from "../resource/sources.js";
+import { loadWorkspaceObjects, readToolModuleItems } from "./object-loader.js";
 import { parseEmbeddingModelObject, parseModelObject, parseToolObject, parseVectorStoreObject, validateEmbeddingModelObject, validateModelObject, validateToolObject, validateVectorStoreObject, } from "./resource-compilers.js";
 import { validateAgent, validateTopology } from "./validate.js";
 import { compileBinding } from "./agent-binding-compiler.js";
@@ -32,34 +34,56 @@ function collectParsedResources(refs) {
     }
     return { embeddings, models, vectorStores, tools };
 }
-async function hydrateBuiltinAndExternalTools(tools, toolSourceRefs, workspaceRoot) {
+async function hydrateResourceAndExternalTools(tools, toolSourceRefs, workspaceRoot) {
     for (const source of toolSourceRefs) {
         if (isExternalSourceLocator(source)) {
-            const sourceTools = await listBuiltinToolsForSource(source, workspaceRoot);
-            if (sourceTools.length > 0) {
+            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"))) {
+                const toolId = typeof item.id === "string" ? item.id : undefined;
+                if (!toolId) {
+                    continue;
+                }
+                const namespacedId = `${sourcePrefix}.${toolId}`;
+                const parsed = parseToolObject({
+                    id: namespacedId,
+                    kind: "tool",
+                    sourcePath,
+                    value: {
+                        ...item,
+                        id: namespacedId,
+                    },
+                });
+                tools.set(parsed.id, parsed);
+                discoveredToolRefs.push(`tool/${parsed.id}`);
+            }
+            const sourceTools = await listResourceToolsForSource(source, workspaceRoot);
+            const bundleRefs = [...sourceTools.map((tool) => tool.toolPath), ...discoveredToolRefs];
+            if (bundleRefs.length > 0) {
                 tools.set(source, {
                     id: source,
                     type: "bundle",
                     name: source,
-                    description: `External builtin tool bundle loaded from ${source}`,
-                    bundleRefs: sourceTools.map((tool) => tool.builtinPath),
+                    description: `External tool resource loaded from ${source}`,
+                    bundleRefs,
                     sourcePath: source,
                 });
             }
         }
     }
-    for (const builtinTool of await listBuiltinTools(toolSourceRefs, workspaceRoot)) {
-        const existing = tools.get(builtinTool.builtinPath);
-        tools.set(builtinTool.builtinPath, {
-            id: builtinTool.builtinPath,
+    for (const resourceTool of await listResourceTools(toolSourceRefs, workspaceRoot)) {
+        const existing = tools.get(resourceTool.toolPath);
+        tools.set(resourceTool.toolPath, {
+            id: resourceTool.toolPath,
             type: existing?.type ?? "backend",
-            name: existing?.name || builtinTool.name,
-            description: existing?.description || builtinTool.description,
+            name: existing?.name || resourceTool.name,
+            description: existing?.description || resourceTool.description,
             config: existing?.config,
-            backendOperation: existing?.backendOperation ?? builtinTool.backendOperation,
+            backendOperation: existing?.backendOperation ?? resourceTool.backendOperation,
             bundleRefs: existing?.bundleRefs ?? [],
-            hitl: existing?.hitl ?? builtinTool.hitl,
-            sourcePath: existing?.sourcePath ?? builtinTool.builtinPath,
+            hitl: existing?.hitl ?? resourceTool.hitl,
+            sourcePath: existing?.sourcePath ?? resourceTool.toolPath,
         });
     }
 }
@@ -90,11 +114,12 @@ export async function loadWorkspace(workspaceRoot, options = {}) {
     }
     const { embeddings, models, vectorStores, tools } = collectParsedResources(loaded.refs);
     const toolSourceRefs = collectToolSourceRefs(tools, loaded.agents, options);
-    await ensureBuiltinSources(toolSourceRefs, workspaceRoot);
-    await hydrateBuiltinAndExternalTools(tools, toolSourceRefs, workspaceRoot);
+    await ensureResourceSources(toolSourceRefs, workspaceRoot);
+    await hydrateResourceAndExternalTools(tools, toolSourceRefs, workspaceRoot);
     validateWorkspaceResources(embeddings, models, vectorStores, tools, loaded.agents);
     return {
         workspaceRoot,
+        resourceSources: [...toolSourceRefs],
         builtinSources: [...toolSourceRefs],
         refs: loaded.refs,
         embeddings,

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

@@ -4,6 +4,7 @@ export type WorkspaceObjects = {
     refs: RefMap;
     agents: ParsedAgentObject[];
 };
+export declare function conventionalPackageRoots(root: string, relativeDir: "tools" | "skills"): string[];
 export declare function normalizeYamlItem(item: Record<string, unknown>): Record<string, unknown>;
 export declare function parseAgentItem(item: Record<string, unknown>, sourcePath: string): ParsedAgentObject;
 export declare function readYamlItems(root: string, relativeDir?: string, options?: {
@@ -12,5 +13,9 @@ export declare function readYamlItems(root: string, relativeDir?: string, option
     item: Record<string, unknown>;
     sourcePath: string;
 }>>;
+export declare function readToolModuleItems(root: string): Promise<Array<{
+    item: Record<string, unknown>;
+    sourcePath: string;
+}>>;
 export declare function loadWorkspaceObjects(workspaceRoot: string, options?: WorkspaceLoadOptions): Promise<WorkspaceObjects>;
 export {};

package/dist/workspace/object-loader.js

@@ -1,8 +1,9 @@
 import path from "node:path";
 import { existsSync, statSync } from "node:fs";
-import { readdir } from "node:fs/promises";
-import { fileURLToPath } from "node:url";
+import { readdir, readFile } from "node:fs/promises";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { parseAllDocuments } from "yaml";
+import { resolveResourcePackageRoot } from "../resource/sources.js";
 import { fileExists, listFilesRecursive, readYamlOrJson } from "../utils/fs.js";
 const ROOT_AGENT_FILENAMES = [
     "agent.yaml",
@@ -15,21 +16,51 @@ const ROOT_AGENT_FILENAMES = [
     "research.yml",
 ];
 const LEGACY_GLOBAL_AGENT_FILENAMES = ["agent.yaml", "agent.yml"];
-function frameworkConfigRoot() {
-    const resolved = fileURLToPath(new URL("../../config", import.meta.url));
-    const distSegment = `${path.sep}dist${path.sep}config`;
-    if (!resolved.includes(distSegment)) {
+const CONVENTIONAL_OBJECT_DIRECTORIES = ["tools"];
+function conventionalConfigRoot(root) {
+    if (path.basename(root) === "config" && existsSync(root) && statSync(root).isDirectory()) {
+        return root;
+    }
+    const candidate = path.join(root, "config");
+    if (existsSync(candidate) && statSync(candidate).isDirectory()) {
+        return candidate;
+    }
+    return null;
+}
+function conventionalDirectoryRoots(root, relativeDir) {
+    const resourceRoot = resolveResourcePackageRoot(root);
+    const configRoot = conventionalConfigRoot(root);
+    const candidates = relativeDir === "agents"
+        ? [
+            ...(configRoot ? [path.join(configRoot, "agents")] : []),
+            path.join(root, "agents"),
+        ]
+        : [
+            ...(resourceRoot ? [path.join(resourceRoot, relativeDir)] : []),
+            path.join(root, relativeDir),
+        ];
+    return Array.from(new Set(candidates));
+}
+export function conventionalPackageRoots(root, relativeDir) {
+    const resourceRoot = resolveResourcePackageRoot(root);
+    const candidates = resourceRoot ? [path.join(resourceRoot, relativeDir), resourceRoot] : [];
+    return Array.from(new Set(candidates));
+}
+function frameworkWorkspaceRoot() {
+    const resolved = fileURLToPath(new URL("../..", import.meta.url));
+    const distSegment = `${path.sep}dist`;
+    if (!resolved.endsWith(distSegment)) {
         return resolved;
     }
-    const sourceConfigRoot = resolved.replace(distSegment, `${path.sep}config`);
-    if (!existsSync(sourceConfigRoot)) {
+    const sourceRoot = resolved.slice(0, -distSegment.length);
+    if (!existsSync(sourceRoot)) {
         return resolved;
     }
     try {
-        return statSync(sourceConfigRoot).mtimeMs >= statSync(resolved).mtimeMs ? sourceConfigRoot : resolved;
+        return statSync(sourceRoot).mtimeMs >= statSync(resolved).mtimeMs ? sourceRoot : resolved;
     }
     catch {
-        return sourceConfigRoot;
+        return sourceRoot;
     }
 }
 function toArray(value) {
@@ -106,7 +137,7 @@ export function normalizeYamlItem(item) {
         ...(kind ? { kind } : {}),
     };
 }
-function normalizeCatalogItem(item) {
+function normalizeResourceItem(item) {
     if ("metadata" in item || "spec" in item || "path" in item || typeof item.name !== "string") {
         return item;
     }
@@ -215,7 +246,7 @@ async function objectItemsFromDocument(document, sourcePath) {
                 }
                 continue;
             }
-            records.push(normalizeCatalogItem(typedItem));
+            records.push(normalizeResourceItem(typedItem));
         }
         return records;
     }
@@ -292,6 +323,66 @@ async function readNamedYamlItems(root, filenames) {
     }
     return records;
 }
+function isAgentKind(kind) {
+    return kind === "deepagent" || kind === "langchain-agent";
+}
+async function readConfigAgentItems(configRoot) {
+    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;
+        }
+        const parentDir = path.dirname(sourcePath);
+        const filename = path.basename(sourcePath).toLowerCase();
+        return !(parentDir === configRoot && ROOT_AGENT_FILENAMES.includes(filename));
+    });
+}
+function discoverAnnotatedFunctionNames(sourceText) {
+    const matches = sourceText.matchAll(/@tool[\s\S]*?export\s+(?:async\s+)?function\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(/g);
+    return Array.from(matches, (match) => match[1]);
+}
+export async function readToolModuleItems(root) {
+    if (!(await fileExists(root))) {
+        return [];
+    }
+    const entries = await readdir(root, { withFileTypes: true });
+    const files = entries
+        .filter((entry) => entry.isFile() && entry.name.endsWith(".mjs"))
+        .map((entry) => path.join(root, entry.name))
+        .sort();
+    const records = [];
+    for (const filePath of files) {
+        const sourceText = await readFile(filePath, "utf8");
+        const functionNames = discoverAnnotatedFunctionNames(sourceText);
+        if (functionNames.length === 0) {
+            continue;
+        }
+        const imported = await import(pathToFileURL(filePath).href);
+        for (const functionName of functionNames) {
+            const invoke = imported[functionName];
+            const schema = imported[`${functionName}Schema`];
+            if (typeof invoke !== "function") {
+                throw new Error(`Tool module ${filePath} must export function ${functionName}.`);
+            }
+            if (!schema?.parse) {
+                throw new Error(`Tool module ${filePath} must export ${functionName}Schema as a Zod schema.`);
+            }
+            records.push({
+                item: {
+                    kind: "tool",
+                    id: functionName,
+                    type: "function",
+                    name: functionName,
+                    description: typeof schema.description === "string" ? schema.description : `Auto-discovered tool ${functionName}`,
+                    implementationName: functionName,
+                },
+                sourcePath: filePath,
+            });
+        }
+    }
+    return records;
+}
 function isPrimaryAgentFile(sourcePath) {
     const base = path.basename(sourcePath).toLowerCase();
     return ROOT_AGENT_FILENAMES.includes(base);
@@ -337,35 +428,39 @@ export async function loadWorkspaceObjects(workspaceRoot, options = {}) {
     const refs = new Map();
     const mergedAgents = new Map();
     const mergedObjects = new Map();
-    const roots = [frameworkConfigRoot(), ...(options.overlayRoots ?? []), workspaceRoot];
+    const roots = [frameworkWorkspaceRoot(), ...(options.overlayRoots ?? []), workspaceRoot];
     let sharedAgentDefaults = {};
     let sharedAgentDefaultsByMode = {};
     for (const root of roots) {
-        for (const { item, sourcePath } of await readNamedYamlItems(root, [...ROOT_AGENT_FILENAMES])) {
-            const id = typeof item.id === "string" ? item.id : undefined;
-            if (!id) {
-                continue;
-            }
-            const current = mergedAgents.get(id);
-            mergedAgents.set(id, {
-                item: current ? mergeValues(current.item, item) : item,
-                sourcePath,
-            });
-            const filename = path.basename(sourcePath).toLowerCase();
-            if (LEGACY_GLOBAL_AGENT_FILENAMES.includes(filename)) {
-                sharedAgentDefaults = mergeValues(sharedAgentDefaults, extractSharedAgentDefaults(item));
-            }
-            else {
-                const executionMode = inferExecutionMode(item, current?.item);
-                if (executionMode) {
-                    sharedAgentDefaultsByMode = {
-                        ...sharedAgentDefaultsByMode,
-                        [executionMode]: mergeValues(sharedAgentDefaultsByMode[executionMode] ?? {}, extractSharedAgentDefaults(item)),
-                    };
+        const configRoot = conventionalConfigRoot(root) ?? root;
+        const namedAgentRoots = Array.from(new Set([root, configRoot]));
+        for (const namedAgentRoot of namedAgentRoots) {
+            for (const { item, sourcePath } of await readNamedYamlItems(namedAgentRoot, [...ROOT_AGENT_FILENAMES])) {
+                const id = typeof item.id === "string" ? item.id : undefined;
+                if (!id) {
+                    continue;
+                }
+                const current = mergedAgents.get(id);
+                mergedAgents.set(id, {
+                    item: current ? mergeValues(current.item, item) : item,
+                    sourcePath,
+                });
+                const filename = path.basename(sourcePath).toLowerCase();
+                if (LEGACY_GLOBAL_AGENT_FILENAMES.includes(filename)) {
+                    sharedAgentDefaults = mergeValues(sharedAgentDefaults, extractSharedAgentDefaults(item));
+                }
+                else {
+                    const executionMode = inferExecutionMode(item, current?.item);
+                    if (executionMode) {
+                        sharedAgentDefaultsByMode = {
+                            ...sharedAgentDefaultsByMode,
+                            [executionMode]: mergeValues(sharedAgentDefaultsByMode[executionMode] ?? {}, extractSharedAgentDefaults(item)),
+                        };
+                    }
                 }
             }
         }
-        for (const { item, sourcePath } of await readYamlItems(root, "agents", { recursive: true })) {
+        for (const { item, sourcePath } of await readConfigAgentItems(configRoot)) {
             const id = typeof item.id === "string" ? item.id : undefined;
             if (!id) {
                 continue;
@@ -377,7 +472,56 @@ export async function loadWorkspaceObjects(workspaceRoot, options = {}) {
                 sourcePath,
             });
         }
-        for (const { item, sourcePath } of (await readYamlItems(root)).filter(({ sourcePath: fullPath }) => !fullPath.includes(`${path.sep}agents${path.sep}`) && !isPrimaryAgentFile(fullPath))) {
+        for (const directory of CONVENTIONAL_OBJECT_DIRECTORIES) {
+            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) {
+                        continue;
+                    }
+                    const ref = `${workspaceObject.kind}/${workspaceObject.id}`;
+                    const current = mergedObjects.get(ref);
+                    mergedObjects.set(ref, {
+                        item: current ? mergeValues(current.item, item) : item,
+                        sourcePath,
+                    });
+                }
+                for (const { item, sourcePath } of await readToolModuleItems(objectRoot)) {
+                    const workspaceObject = parseWorkspaceObject(item, sourcePath);
+                    if (!workspaceObject) {
+                        continue;
+                    }
+                    const ref = `${workspaceObject.kind}/${workspaceObject.id}`;
+                    const current = mergedObjects.get(ref);
+                    mergedObjects.set(ref, {
+                        item: current ? mergeValues(current.item, item) : item,
+                        sourcePath,
+                    });
+                }
+            }
+        }
+        if (conventionalConfigRoot(root)) {
+            for (const { item, sourcePath } of await readYamlItems(configRoot, undefined, { recursive: true })) {
+                const workspaceObject = parseWorkspaceObject(item, sourcePath);
+                if (!workspaceObject) {
+                    continue;
+                }
+                if (isAgentKind(workspaceObject.kind)) {
+                    continue;
+                }
+                const ref = `${workspaceObject.kind}/${workspaceObject.id}`;
+                const current = mergedObjects.get(ref);
+                mergedObjects.set(ref, {
+                    item: current ? mergeValues(current.item, item) : item,
+                    sourcePath,
+                });
+            }
+        }
+        for (const { item, sourcePath } of (await readYamlItems(root)).filter(({ sourcePath: fullPath }) => !fullPath.includes(`${path.sep}config${path.sep}`) &&
+            !fullPath.includes(`${path.sep}resources${path.sep}`) &&
+            !fullPath.includes(`${path.sep}agents${path.sep}`) &&
+            !CONVENTIONAL_OBJECT_DIRECTORIES.some((directory) => fullPath.includes(`${path.sep}${directory}${path.sep}`)) &&
+            !isPrimaryAgentFile(fullPath))) {
             const workspaceObject = parseWorkspaceObject(item, sourcePath);
             if (!workspaceObject) {
                 continue;

package/dist/workspace/resource-compilers.js

@@ -161,6 +161,7 @@ export function parseToolObject(object) {
         type: String(inferredType),
         name: String(value.name ?? "").trim(),
         description: String(value.description ?? "").trim(),
+        implementationName: typeof value.implementationName === "string" ? value.implementationName : undefined,
         config: asObject(value.config),
         inputSchemaRef: typeof asObject(value.inputSchema)?.ref === "string" ? String(asObject(value.inputSchema)?.ref) : undefined,
         backendOperation: typeof backend?.operation === "string"

package/dist/workspace/support/discovery.js

@@ -1,7 +1,7 @@
 import { existsSync, readdirSync, statSync } from "node:fs";
 import path from "node:path";
-import { builtinConfigRoot, builtinSkillsRoot } from "../../vendor/builtins.js";
-import { ensureExternalSource, isDirectoryPath, isExternalSourceLocator, resolveExternalSourcePath } from "../../vendor/sources.js";
+import { defaultResourceConfigRoot, defaultResourceSkillsRoot } from "../../resource/resource.js";
+import { ensureExternalResourceSource, isDirectoryPath, isExternalSourceLocator, resolveExternalResourcePath, resolveResourcePackageRoot, } from "../../resource/sources.js";
 import { parseAgentItem, readYamlItems } from "../object-loader.js";
 function resolveBuiltinPath(kind, ref) {
     const normalized = ref.replace(/^builtin:\/\//, "").replace(/^\/+/, "");
@@ -10,7 +10,7 @@ function resolveBuiltinPath(kind, ref) {
             throw new Error(`Unsupported builtin skill discovery path ${ref}`);
         }
         const suffix = normalized.replace(/^skills\/?/, "");
-        const root = builtinSkillsRoot();
+        const root = defaultResourceSkillsRoot();
         if (!suffix) {
             return root;
         }
@@ -18,8 +18,8 @@ function resolveBuiltinPath(kind, ref) {
         if (existsSync(candidate)) {
             return candidate;
         }
-        const sourceFallback = root.includes(`${path.sep}dist${path.sep}skills`)
-            ? path.join(path.resolve(root, "..", ".."), "skills", suffix)
+        const sourceFallback = root.includes(`${path.sep}dist${path.sep}resources${path.sep}skills`)
+            ? path.join(path.resolve(root, "..", "..", ".."), "resources", "skills", suffix)
             : null;
         if (sourceFallback && existsSync(sourceFallback)) {
             return sourceFallback;
@@ -30,7 +30,7 @@ function resolveBuiltinPath(kind, ref) {
         throw new Error(`Unsupported builtin subagent discovery path ${ref}`);
     }
     const suffix = normalized.replace(/^agents\/?/, "");
-    const root = path.join(builtinConfigRoot(), "agents");
+    const root = path.join(defaultResourceConfigRoot(), "agents");
     if (!suffix) {
         return root;
     }
@@ -47,9 +47,14 @@ function resolveBuiltinPath(kind, ref) {
     return candidate;
 }
 function preferPackageConvention(root, kind) {
-    const candidates = kind === "skills"
-        ? [path.join(root, "skills"), root]
-        : [path.join(root, "config", "agents"), path.join(root, "agents"), root];
+    const resourceRoot = resolveResourcePackageRoot(root);
+    const candidates = resourceRoot
+        ? kind === "skills"
+            ? [path.join(root, "config", "skills"), path.join(resourceRoot, "skills"), resourceRoot]
+            : [path.join(root, "config", "agents"), path.join(root, "agents"), path.join(resourceRoot, "agents"), resourceRoot]
+        : kind === "skills"
+            ? [path.join(root, "config", "skills"), path.join(root, "skills"), root]
+            : [path.join(root, "config", "agents"), path.join(root, "agents"), root];
     for (const candidate of candidates) {
         if (isDirectoryPath(candidate)) {
             return candidate;
@@ -60,25 +65,25 @@ function preferPackageConvention(root, kind) {
 export async function ensureDiscoverySources(locators, workspaceRoot) {
     await Promise.all(Array.from(new Set(locators))
         .filter((locator) => isExternalSourceLocator(locator))
-        .map((locator) => ensureExternalSource(locator, workspaceRoot)));
+        .map((locator) => ensureExternalResourceSource(locator, workspaceRoot)));
 }
 export function resolveDiscoveryRoot(ref, workspaceRoot, kind) {
     if (ref.startsWith("builtin://")) {
         return resolveBuiltinPath(kind, ref);
     }
     if (isExternalSourceLocator(ref)) {
-        return preferPackageConvention(resolveExternalSourcePath(ref, workspaceRoot), kind);
+        return preferPackageConvention(resolveExternalResourcePath(ref, workspaceRoot), kind);
     }
-    return path.resolve(workspaceRoot, ref);
+    return preferPackageConvention(path.resolve(workspaceRoot, ref), kind);
 }
 async function resolveDiscoveryRootAsync(ref, workspaceRoot, kind) {
     if (ref.startsWith("builtin://")) {
         return resolveBuiltinPath(kind, ref);
     }
     if (isExternalSourceLocator(ref)) {
-        return preferPackageConvention(await ensureExternalSource(ref, workspaceRoot), kind);
+        return preferPackageConvention(await ensureExternalResourceSource(ref, workspaceRoot), kind);
     }
-    return path.resolve(workspaceRoot, ref);
+    return preferPackageConvention(path.resolve(workspaceRoot, ref), kind);
 }
 export function discoverSkillPaths(rootRefs, workspaceRoot) {
     const discovered = new Map();