@botbotgo/agent-harness 0.0.100 → 0.0.102

package/dist/runtime/support/runtime-factories.js

@@ -1,8 +1,8 @@
 import path from "node:path";
 import { MemorySaver } from "@langchain/langgraph";
 import { SqliteSaver } from "@langchain/langgraph-checkpoint-sqlite";
-import { FileCheckpointSaver } from "../file-checkpoint-saver.js";
-import { ManagedSqliteSaver } from "../sqlite-maintained-checkpoint-saver.js";
+import { FileCheckpointSaver } from "../maintenance/file-checkpoint-saver.js";
+import { ManagedSqliteSaver } from "../maintenance/sqlite-maintained-checkpoint-saver.js";
 import { createInMemoryStore, FileBackedStore } from "../harness/system/store.js";
 export function createStoreForConfig(storeConfig, runRoot) {
     const kind = typeof storeConfig.kind === "string" ? storeConfig.kind : "FileStore";

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"
@@ -235,12 +134,29 @@ function readCapabilities(value) {
     };
     return Object.keys(capabilities).length > 0 ? capabilities : undefined;
 }
+const CONSUMED_AGENT_CONFIG_KEYS = [
+    "systemPrompt",
+    "checkpointer",
+    "interruptOn",
+    "stateSchema",
+    "responseFormat",
+    "contextSchema",
+    "includeAgentName",
+    "version",
+    "middleware",
+    "backend",
+    "store",
+    "runtimeMemory",
+    "taskDescription",
+    "generalPurposeAgent",
+    "filesystem",
+];
 function readExecutionConfig(value) {
     return asMutableObject(value);
 }
-function readExecutionAgentConfig(item) {
+function readExecutionValue(item, key, reader) {
     const execution = readExecutionConfig(item.execution);
-    return asMutableObject(execution?.config) ?? {};
+    return reader(execution?.[key]);
 }
 function readRuntimeConfig(item) {
     return asMutableObject(item.runtime);
@@ -323,21 +239,13 @@ function resolveExecutionBackend(item, current) {
     }
     return undefined;
 }
-function readExecutionSingleRef(item, key) {
-    const execution = readExecutionConfig(item.execution);
-    return readSingleRef(execution?.[key]);
-}
-function readExecutionRefArray(item, key) {
-    const execution = readExecutionConfig(item.execution);
-    return readRefArray(execution?.[key]);
-}
-function readExecutionPathArray(item, key) {
-    const execution = readExecutionConfig(item.execution);
-    return readPathArray(execution?.[key]);
-}
-function readExecutionObjectArray(item, key) {
-    const execution = readExecutionConfig(item.execution);
-    return readObjectArray(execution?.[key]);
+function readSharedAgentConfigFields(config) {
+    return {
+        ...(typeof config.store === "object" && config.store ? { store: config.store } : {}),
+        ...(typeof config.runtimeMemory === "object" && config.runtimeMemory ? { runtimeMemory: config.runtimeMemory } : {}),
+        ...(typeof config.taskDescription === "string" && config.taskDescription.trim() ? { taskDescription: config.taskDescription } : {}),
+        ...(typeof config.generalPurposeAgent === "boolean" ? { generalPurposeAgent: config.generalPurposeAgent } : {}),
+    };
 }
 function readSharedAgentConfig(config) {
     const middleware = readMiddlewareArray(config.middleware);
@@ -359,67 +267,20 @@ function readSharedAgentConfig(config) {
         ...(middleware ? { middleware } : {}),
     };
 }
-function readLangchainAgentConfig(item) {
-    const config = readExecutionAgentConfig(item);
-    const passthrough = readPassthroughConfig(config, [
-        "systemPrompt",
-        "checkpointer",
-        "interruptOn",
-        "stateSchema",
-        "responseFormat",
-        "contextSchema",
-        "includeAgentName",
-        "version",
-        "middleware",
-        "backend",
-        "store",
-        "runtimeMemory",
-        "taskDescription",
-        "generalPurposeAgent",
-        "filesystem",
-    ]);
+function readAgentConfig(item, options = {}) {
+    const config = readExecutionValue(item, "config", asMutableObject) ?? {};
+    const passthrough = readPassthroughConfig(config, [...CONSUMED_AGENT_CONFIG_KEYS]);
     return {
         ...readSharedAgentConfig(config),
-        ...(typeof config.store === "object" && config.store ? { store: config.store } : {}),
-        ...(typeof config.runtimeMemory === "object" && config.runtimeMemory ? { runtimeMemory: config.runtimeMemory } : {}),
-        ...(typeof config.taskDescription === "string" && config.taskDescription.trim() ? { taskDescription: config.taskDescription } : {}),
-        ...(typeof config.generalPurposeAgent === "boolean" ? { generalPurposeAgent: config.generalPurposeAgent } : {}),
-        ...(passthrough ? { passthrough } : {}),
-    };
-}
-function readDeepAgentConfig(item) {
-    const config = readExecutionAgentConfig(item);
-    const passthrough = readPassthroughConfig(config, [
-        "systemPrompt",
-        "checkpointer",
-        "interruptOn",
-        "stateSchema",
-        "responseFormat",
-        "contextSchema",
-        "includeAgentName",
-        "version",
-        "middleware",
-        "backend",
-        "store",
-        "runtimeMemory",
-        "taskDescription",
-        "generalPurposeAgent",
-        "filesystem",
-    ]);
-    return {
-        ...readSharedAgentConfig(config),
-        ...(typeof config.backend === "object" && config.backend ? { backend: config.backend } : {}),
-        ...(typeof config.store === "object" && config.store ? { store: config.store } : {}),
-        ...(typeof config.runtimeMemory === "object" && config.runtimeMemory ? { runtimeMemory: config.runtimeMemory } : {}),
-        ...(typeof config.taskDescription === "string" && config.taskDescription.trim() ? { taskDescription: config.taskDescription } : {}),
-        ...(typeof config.generalPurposeAgent === "boolean" ? { generalPurposeAgent: config.generalPurposeAgent } : {}),
+        ...readSharedAgentConfigFields(config),
+        ...(options.includeObjectBackend && typeof config.backend === "object" && config.backend ? { backend: config.backend } : {}),
         ...(passthrough ? { passthrough } : {}),
     };
 }
 export function parseAgentItem(item, sourcePath) {
     const moduleRoot = moduleRootForSourcePath(sourcePath, "agents");
-    const subagentRefs = readExecutionRefArray(item, "subagents");
-    const subagentPathRefs = readExecutionPathArray(item, "subagents").map((entry) => resolveModuleRelativePath(entry, moduleRoot));
+    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);
     return {
@@ -430,45 +291,19 @@ export function parseAgentItem(item, sourcePath) {
             ? { delegation: true, memory: true }
             : { delegation: true, memory: true }),
         description: String(item.description ?? ""),
-        modelRef: readExecutionSingleRef(item, "modelRef") ?? "",
+        modelRef: readExecutionValue(item, "modelRef", readSingleRef) ?? "",
         runRoot: typeof runtime?.runRoot === "string" ? runtime.runRoot : undefined,
-        toolRefs: readExecutionRefArray(item, "tools"),
-        mcpServers: readExecutionObjectArray(item, "mcpServers"),
-        skillPathRefs: readExecutionPathArray(item, "skills").map((entry) => resolveModuleRelativePath(entry, moduleRoot)),
-        memorySources: readExecutionPathArray(item, "memory").map((entry) => resolveModuleRelativePath(entry, moduleRoot)),
+        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)),
         subagentRefs,
         subagentPathRefs,
-        langchainAgentConfig: normalizeModuleAgentConfig(readLangchainAgentConfig(item), moduleRoot),
-        deepAgentConfig: normalizeModuleAgentConfig(readDeepAgentConfig(item), moduleRoot),
+        langchainAgentConfig: normalizeModuleAgentConfig(readAgentConfig(item), moduleRoot),
+        deepAgentConfig: normalizeModuleAgentConfig(readAgentConfig(item, { includeObjectBackend: true }), moduleRoot),
         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;
@@ -657,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.100",
+  "version": "0.0.102",
   "description": "Workspace runtime for multi-agent applications",
   "type": "module",
   "packageManager": "npm@10.9.2",

package/dist/runtime/checkpoint-maintenance.d.ts

@@ -1 +0,0 @@
-export * from "./maintenance/checkpoint-maintenance.js";

package/dist/runtime/checkpoint-maintenance.js

@@ -1 +0,0 @@
-export * from "./maintenance/checkpoint-maintenance.js";

package/dist/runtime/file-checkpoint-saver.d.ts

@@ -1 +0,0 @@
-export * from "./maintenance/file-checkpoint-saver.js";

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

@@ -1 +0,0 @@
-export * from "./maintenance/file-checkpoint-saver.js";

package/dist/runtime/sqlite-maintained-checkpoint-saver.d.ts

@@ -1 +0,0 @@
-export * from "./maintenance/sqlite-maintained-checkpoint-saver.js";

package/dist/runtime/sqlite-maintained-checkpoint-saver.js

@@ -1 +0,0 @@
-export * from "./maintenance/sqlite-maintained-checkpoint-saver.js";