@botbotgo/agent-harness 0.0.101 → 0.0.102

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

@@ -1,18 +1,12 @@
 import type { ParsedAgentObject, WorkspaceLoadOptions, WorkspaceObject } from "../contracts/types.js";
+export { normalizeYamlItem, readYamlItems } from "./yaml-object-reader.js";
 type RefMap = Map<string, WorkspaceObject | ParsedAgentObject>;
 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?: {
-    recursive?: boolean;
-}): Promise<Array<{
-    item: Record<string, unknown>;
-    sourcePath: string;
-}>>;
 export declare function readToolModuleItems(root: string): Promise<Array<{
     item: Record<string, unknown>;
     sourcePath: string;
@@ -30,4 +24,3 @@ export declare function readToolModuleItems(root: string): Promise<Array<{
  * - scalars and non-plain objects are replaced
  */
 export declare function loadWorkspaceObjects(workspaceRoot: string, options?: WorkspaceLoadOptions): Promise<WorkspaceObjects>;
-export {};

package/dist/workspace/object-loader.js

@@ -2,12 +2,12 @@ import path from "node:path";
 import { existsSync, statSync } from "node:fs";
 import { readdir, readFile } from "node:fs/promises";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { parseAllDocuments } from "yaml";
 import { resolveIsolatedResourceModulePath } from "../resource/isolation.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"];
+import { fileExists } from "../utils/fs.js";
+import { readNamedModelItems, readNamedYamlItems, readYamlItems, } from "./yaml-object-reader.js";
+export { normalizeYamlItem, readYamlItems } from "./yaml-object-reader.js";
 const CONVENTIONAL_OBJECT_DIRECTORIES = ["tools"];
 const MODULE_AGENT_FILENAMES = ["agent.yaml", "agent.yml"];
 const MODULE_TOOL_FILENAMES = ["tool.yaml", "tool.yml"];
@@ -84,107 +84,6 @@ function asMutableObject(value) {
         ? { ...value }
         : undefined;
 }
-function normalizeCatalogSpec(document, options = {}) {
-    const typed = asObject(document);
-    const spec = typed?.spec;
-    if (!Array.isArray(spec)) {
-        return [];
-    }
-    const normalized = spec
-        .filter((item) => typeof item === "object" && item !== null && !Array.isArray(item))
-        .map((item) => {
-        const id = typeof item.id === "string" && item.id.trim()
-            ? item.id
-            : typeof item.name === "string" && item.name.trim()
-                ? item.name
-                : undefined;
-        const itemKind = typeof item.kind === "string" && item.kind.trim()
-            ? item.kind
-            : options.defaultKind;
-        if (!id || !itemKind) {
-            return null;
-        }
-        return {
-            ...item,
-            kind: itemKind,
-            id,
-        };
-    });
-    return normalized.filter((item) => item !== null);
-}
-function normalizeKind(kind) {
-    switch (kind) {
-        case "Agent":
-            return "agent";
-        case "FileStore":
-            return "file-store";
-        case "InMemoryStore":
-            return "in-memory-store";
-        case "RedisStore":
-            return "redis-store";
-        case "PostgresStore":
-            return "postgres-store";
-        case "SqliteSaver":
-            return "sqlite-saver";
-        case "FileCheckpointer":
-            return "file-checkpointer";
-        case "Checkpointer":
-            return "checkpointer";
-        case "Model":
-            return "model";
-        case "EmbeddingModel":
-            return "embedding-model";
-        case "VectorStore":
-            return "vector-store";
-        case "Backend":
-            return "backend";
-        case "Store":
-            return "store";
-        case "Memory":
-            return "memory";
-        case "Tool":
-            return "tool";
-        case "Skill":
-            return "skill";
-        case "Runtime":
-            return "runtime";
-        case "RuntimeMemory":
-            return "runtime-memory";
-        case "Prompt":
-            return "prompt";
-        case "McpServer":
-            return "mcp";
-        default:
-            return 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`);
-    }
-    const metadata = asObject(item.metadata);
-    const spec = asObject(item.spec);
-    const kind = typeof item.kind === "string" ? normalizeKind(item.kind) : undefined;
-    const name = typeof metadata?.name === "string" ? metadata.name : undefined;
-    const description = typeof metadata?.description === "string" ? metadata.description : undefined;
-    if (!spec && !metadata) {
-        return kind ? { ...item, kind } : item;
-    }
-    if (!spec && metadata) {
-        return {
-            ...item,
-            ...(description ? { description } : {}),
-            ...(name ? { id: name } : {}),
-            ...(kind ? { kind } : {}),
-        };
-    }
-    return {
-        ...(spec ?? {}),
-        ...(description ? { description } : {}),
-        ...(name ? { id: name } : {}),
-        ...(kind ? { kind } : {}),
-    };
-}
 function readRefArray(items) {
     return toArray(items)
         .map((item) => typeof item === "string"
@@ -405,32 +304,6 @@ export function parseAgentItem(item, sourcePath) {
         sourcePath,
     };
 }
-async function objectItemsFromDocument(document, sourcePath) {
-    if (typeof document !== "object" || !document) {
-        return [];
-    }
-    const catalogKind = typeof document.kind === "string"
-        ? String(document.kind)
-        : undefined;
-    const catalogItems = catalogKind === "Models"
-        ? normalizeCatalogSpec(document, { defaultKind: "Model" })
-        : catalogKind === "Stores"
-            ? normalizeCatalogSpec(document)
-            : catalogKind === "Backends"
-                ? normalizeCatalogSpec(document, { defaultKind: "Backend" })
-                : catalogKind === "Tools"
-                    ? normalizeCatalogSpec(document, { defaultKind: "Tool" })
-                    : catalogKind === "McpServers"
-                        ? normalizeCatalogSpec(document, { defaultKind: "McpServer" })
-                        : [];
-    if (catalogItems.length > 0) {
-        return catalogItems;
-    }
-    if ("items" in document) {
-        throw new Error(`YAML document ${sourcePath} uses unsupported legacy items wrapper; use kind/spec catalog documents or metadata/spec objects instead`);
-    }
-    return [document];
-}
 function parseWorkspaceObject(item, sourcePath) {
     if (typeof item.id !== "string") {
         return null;
@@ -619,73 +492,6 @@ async function loadRootObjects(root, mergedObjects) {
         mergeWorkspaceObjectRecord(mergedObjects, workspaceObject, item, sourcePath);
     }
 }
-export async function readYamlItems(root, relativeDir, options = {}) {
-    const targetRoot = relativeDir ? path.join(root, relativeDir) : root;
-    if (!(await fileExists(targetRoot))) {
-        return [];
-    }
-    const files = options.recursive
-        ? await listFilesRecursive(targetRoot, ".yaml")
-        : (await readdir(targetRoot, { withFileTypes: true }))
-            .filter((entry) => entry.isFile() && /\.ya?ml$/i.test(entry.name))
-            .map((entry) => path.join(targetRoot, entry.name))
-            .sort();
-    const records = [];
-    for (const filePath of files) {
-        const parsedDocuments = parseAllDocuments(await readYamlOrJson(filePath));
-        for (const parsedDocument of parsedDocuments) {
-            for (const item of await objectItemsFromDocument(parsedDocument.toJSON(), filePath)) {
-                records.push({ item: normalizeYamlItem(item), sourcePath: filePath });
-            }
-        }
-    }
-    return records;
-}
-async function readNamedYamlItems(root, filenames) {
-    const records = [];
-    for (const filename of filenames) {
-        const filePath = path.join(root, filename);
-        if (!(await fileExists(filePath))) {
-            continue;
-        }
-        const parsedDocuments = parseAllDocuments(await readYamlOrJson(filePath));
-        for (const parsedDocument of parsedDocuments) {
-            for (const item of await objectItemsFromDocument(parsedDocument.toJSON(), filePath)) {
-                records.push({ item: normalizeYamlItem(item), sourcePath: filePath });
-            }
-        }
-    }
-    return records;
-}
-async function readNamedModelItems(root) {
-    const filePaths = new Set();
-    for (const filename of MODEL_FILENAMES) {
-        const directPath = path.join(root, filename);
-        if (await fileExists(directPath)) {
-            filePaths.add(directPath);
-        }
-    }
-    for (const extension of [".yaml", ".yml"]) {
-        for (const filePath of await listFilesRecursive(root, extension)) {
-            if (MODEL_FILENAMES.includes(path.basename(filePath))) {
-                filePaths.add(filePath);
-            }
-        }
-    }
-    const records = [];
-    for (const filePath of [...filePaths].sort()) {
-        const parsedDocuments = parseAllDocuments(await readYamlOrJson(filePath));
-        for (const parsedDocument of parsedDocuments) {
-            for (const item of await objectItemsFromDocument(parsedDocument.toJSON(), filePath)) {
-                const normalized = normalizeYamlItem(item);
-                if (normalized.kind === "model" && typeof normalized.id === "string" && normalized.id.trim()) {
-                    records.push({ item: normalized, sourcePath: filePath });
-                }
-            }
-        }
-    }
-    return records;
-}
 function isAgentKind(kind) {
     return kind === "agent";
 }

package/dist/workspace/yaml-object-reader.d.ts

@@ -0,0 +1,15 @@
+export declare function normalizeYamlItem(item: Record<string, unknown>): Record<string, unknown>;
+export declare function readYamlItems(root: string, relativeDir?: string, options?: {
+    recursive?: boolean;
+}): Promise<Array<{
+    item: Record<string, unknown>;
+    sourcePath: string;
+}>>;
+export declare function readNamedYamlItems(root: string, filenames: string[]): Promise<Array<{
+    item: Record<string, unknown>;
+    sourcePath: string;
+}>>;
+export declare function readNamedModelItems(root: string): Promise<Array<{
+    item: Record<string, unknown>;
+    sourcePath: string;
+}>>;

package/dist/workspace/yaml-object-reader.js

@@ -0,0 +1,202 @@
+import path from "node:path";
+import { readdir } from "node:fs/promises";
+import { parseAllDocuments } from "yaml";
+import { fileExists, listFilesRecursive, readYamlOrJson } from "../utils/fs.js";
+const MODEL_FILENAMES = ["models.yaml", "models.yml"];
+function asObject(value) {
+    return typeof value === "object" && value ? value : undefined;
+}
+function normalizeCatalogSpec(document, options = {}) {
+    const typed = asObject(document);
+    const spec = typed?.spec;
+    if (!Array.isArray(spec)) {
+        return [];
+    }
+    const normalized = spec
+        .filter((item) => typeof item === "object" && item !== null && !Array.isArray(item))
+        .map((item) => {
+        const id = typeof item.id === "string" && item.id.trim()
+            ? item.id
+            : typeof item.name === "string" && item.name.trim()
+                ? item.name
+                : undefined;
+        const itemKind = typeof item.kind === "string" && item.kind.trim()
+            ? item.kind
+            : options.defaultKind;
+        if (!id || !itemKind) {
+            return null;
+        }
+        return {
+            ...item,
+            kind: itemKind,
+            id,
+        };
+    });
+    return normalized.filter((item) => item !== null);
+}
+function normalizeKind(kind) {
+    switch (kind) {
+        case "Agent":
+            return "agent";
+        case "FileStore":
+            return "file-store";
+        case "InMemoryStore":
+            return "in-memory-store";
+        case "RedisStore":
+            return "redis-store";
+        case "PostgresStore":
+            return "postgres-store";
+        case "SqliteSaver":
+            return "sqlite-saver";
+        case "FileCheckpointer":
+            return "file-checkpointer";
+        case "Checkpointer":
+            return "checkpointer";
+        case "Model":
+            return "model";
+        case "EmbeddingModel":
+            return "embedding-model";
+        case "VectorStore":
+            return "vector-store";
+        case "Backend":
+            return "backend";
+        case "Store":
+            return "store";
+        case "Memory":
+            return "memory";
+        case "Tool":
+            return "tool";
+        case "Skill":
+            return "skill";
+        case "Runtime":
+            return "runtime";
+        case "RuntimeMemory":
+            return "runtime-memory";
+        case "Prompt":
+            return "prompt";
+        case "McpServer":
+            return "mcp";
+        default:
+            return 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`);
+    }
+    const metadata = asObject(item.metadata);
+    const spec = asObject(item.spec);
+    const kind = typeof item.kind === "string" ? normalizeKind(item.kind) : undefined;
+    const name = typeof metadata?.name === "string" ? metadata.name : undefined;
+    const description = typeof metadata?.description === "string" ? metadata.description : undefined;
+    if (!spec && !metadata) {
+        return kind ? { ...item, kind } : item;
+    }
+    if (!spec && metadata) {
+        return {
+            ...item,
+            ...(description ? { description } : {}),
+            ...(name ? { id: name } : {}),
+            ...(kind ? { kind } : {}),
+        };
+    }
+    return {
+        ...(spec ?? {}),
+        ...(description ? { description } : {}),
+        ...(name ? { id: name } : {}),
+        ...(kind ? { kind } : {}),
+    };
+}
+async function objectItemsFromDocument(document, sourcePath) {
+    if (typeof document !== "object" || !document) {
+        return [];
+    }
+    const catalogKind = typeof document.kind === "string"
+        ? String(document.kind)
+        : undefined;
+    const catalogItems = catalogKind === "Models"
+        ? normalizeCatalogSpec(document, { defaultKind: "Model" })
+        : catalogKind === "Stores"
+            ? normalizeCatalogSpec(document)
+            : catalogKind === "Backends"
+                ? normalizeCatalogSpec(document, { defaultKind: "Backend" })
+                : catalogKind === "Tools"
+                    ? normalizeCatalogSpec(document, { defaultKind: "Tool" })
+                    : catalogKind === "McpServers"
+                        ? normalizeCatalogSpec(document, { defaultKind: "McpServer" })
+                        : [];
+    if (catalogItems.length > 0) {
+        return catalogItems;
+    }
+    if ("items" in document) {
+        throw new Error(`YAML document ${sourcePath} uses unsupported legacy items wrapper; use kind/spec catalog documents or metadata/spec objects instead`);
+    }
+    return [document];
+}
+export async function readYamlItems(root, relativeDir, options = {}) {
+    const targetRoot = relativeDir ? path.join(root, relativeDir) : root;
+    if (!(await fileExists(targetRoot))) {
+        return [];
+    }
+    const files = options.recursive
+        ? await listFilesRecursive(targetRoot, ".yaml")
+        : (await readdir(targetRoot, { withFileTypes: true }))
+            .filter((entry) => entry.isFile() && /\.ya?ml$/i.test(entry.name))
+            .map((entry) => path.join(targetRoot, entry.name))
+            .sort();
+    const records = [];
+    for (const filePath of files) {
+        const parsedDocuments = parseAllDocuments(await readYamlOrJson(filePath));
+        for (const parsedDocument of parsedDocuments) {
+            for (const item of await objectItemsFromDocument(parsedDocument.toJSON(), filePath)) {
+                records.push({ item: normalizeYamlItem(item), sourcePath: filePath });
+            }
+        }
+    }
+    return records;
+}
+export async function readNamedYamlItems(root, filenames) {
+    const records = [];
+    for (const filename of filenames) {
+        const filePath = path.join(root, filename);
+        if (!(await fileExists(filePath))) {
+            continue;
+        }
+        const parsedDocuments = parseAllDocuments(await readYamlOrJson(filePath));
+        for (const parsedDocument of parsedDocuments) {
+            for (const item of await objectItemsFromDocument(parsedDocument.toJSON(), filePath)) {
+                records.push({ item: normalizeYamlItem(item), sourcePath: filePath });
+            }
+        }
+    }
+    return records;
+}
+export async function readNamedModelItems(root) {
+    const filePaths = new Set();
+    for (const filename of MODEL_FILENAMES) {
+        const directPath = path.join(root, filename);
+        if (await fileExists(directPath)) {
+            filePaths.add(directPath);
+        }
+    }
+    for (const extension of [".yaml", ".yml"]) {
+        for (const filePath of await listFilesRecursive(root, extension)) {
+            if (MODEL_FILENAMES.includes(path.basename(filePath))) {
+                filePaths.add(filePath);
+            }
+        }
+    }
+    const records = [];
+    for (const filePath of [...filePaths].sort()) {
+        const parsedDocuments = parseAllDocuments(await readYamlOrJson(filePath));
+        for (const parsedDocument of parsedDocuments) {
+            for (const item of await objectItemsFromDocument(parsedDocument.toJSON(), filePath)) {
+                const normalized = normalizeYamlItem(item);
+                if (normalized.kind === "model" && typeof normalized.id === "string" && normalized.id.trim()) {
+                    records.push({ item: normalized, sourcePath: filePath });
+                }
+            }
+        }
+    }
+    return records;
+}

package/package.json

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