@botbotgo/agent-harness 0.0.243 → 0.0.245

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.242";
+export declare const AGENT_HARNESS_VERSION = "0.0.244";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.242";
+export const AGENT_HARNESS_VERSION = "0.0.244";

package/dist/runtime/harness/system/store.js

@@ -2,7 +2,7 @@ import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { mkdirSync } from "node:fs";
 import path from "node:path";
 import { InMemoryStore } from "@langchain/langgraph";
-import Database from "better-sqlite3";
+import { loadBetterSqlite3 } from "../../support/sqlite-drivers.js";
 const NAMESPACE_SEPARATOR = "\u001f";
 function encodeValue(value) {
     if (value instanceof Date) {
@@ -152,7 +152,8 @@ export class SqliteBackedStore {
     constructor(filePath) {
         this.filePath = filePath;
         mkdirSync(path.dirname(filePath), { recursive: true });
-        this.db = new Database(filePath);
+        const SqliteDatabase = loadBetterSqlite3();
+        this.db = new SqliteDatabase(filePath);
         this.db.pragma("journal_mode = WAL");
         this.db.exec(`
       CREATE TABLE IF NOT EXISTS store_entries (

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

@@ -1,9 +1,43 @@
 import path from "node:path";
 import { MemorySaver } from "@langchain/langgraph";
-import { SqliteSaver } from "@langchain/langgraph-checkpoint-sqlite";
 import { FileCheckpointSaver } from "../maintenance/file-checkpoint-saver.js";
-import { ManagedSqliteSaver } from "../maintenance/sqlite-maintained-checkpoint-saver.js";
 import { createInMemoryStore, FileBackedStore, SqliteBackedStore } from "../harness/system/store.js";
+import { loadLanggraphSqliteCheckpointModule } from "./sqlite-drivers.js";
+function createManagedSqliteSaver(SqliteSaver, db) {
+    class RuntimeManagedSqliteSaver extends SqliteSaver {
+        setup() {
+            super.setup();
+            this.db.exec(`
+CREATE TABLE IF NOT EXISTS checkpoint_maintenance_meta (
+  thread_id TEXT NOT NULL,
+  checkpoint_ns TEXT NOT NULL DEFAULT '',
+  checkpoint_id TEXT NOT NULL,
+  created_at_ms INTEGER NOT NULL,
+  PRIMARY KEY (thread_id, checkpoint_ns, checkpoint_id)
+);`);
+        }
+        async put(config, checkpoint, metadata) {
+            const result = await super.put(config, checkpoint, metadata);
+            const threadId = result.configurable?.thread_id;
+            const checkpointNs = result.configurable?.checkpoint_ns ?? "";
+            const checkpointId = result.configurable?.checkpoint_id;
+            if (!threadId || !checkpointId) {
+                throw new Error("Missing checkpoint identity after SqliteSaver.put");
+            }
+            this.db
+                .prepare(`INSERT OR IGNORE INTO checkpoint_maintenance_meta
+           (thread_id, checkpoint_ns, checkpoint_id, created_at_ms)
+           VALUES (?, ?, ?, ?)`)
+                .run(threadId, checkpointNs, checkpointId, Date.now());
+            return result;
+        }
+        async deleteThread(threadId) {
+            await super.deleteThread(threadId);
+            this.db.prepare(`DELETE FROM checkpoint_maintenance_meta WHERE thread_id = ?`).run(threadId);
+        }
+    }
+    return new RuntimeManagedSqliteSaver(db);
+}
 export function createStoreForConfig(storeConfig, runRoot) {
     const kind = typeof storeConfig.kind === "string" ? storeConfig.kind : "FileStore";
     switch (kind) {
@@ -36,7 +70,8 @@ export function createCheckpointerForConfig(checkpointerConfig, runRoot) {
         case "SqliteSaver": {
             const configuredPath = typeof checkpointerConfig.path === "string" ? String(checkpointerConfig.path) : "checkpoints.sqlite";
             const resolvedPath = path.isAbsolute(configuredPath) ? configuredPath : path.join(runRoot, configuredPath);
-            return new ManagedSqliteSaver(SqliteSaver.fromConnString(resolvedPath).db);
+            const { SqliteSaver } = loadLanggraphSqliteCheckpointModule();
+            return createManagedSqliteSaver(SqliteSaver, SqliteSaver.fromConnString(resolvedPath).db);
         }
         case "FileCheckpointer": {
             const configuredPath = typeof checkpointerConfig.path === "string" ? String(checkpointerConfig.path) : "checkpoints.json";

package/dist/runtime/support/sqlite-drivers.d.ts

@@ -0,0 +1,12 @@
+type BetterSqlite3Constructor = typeof import("better-sqlite3");
+type SqliteCheckpointModule = typeof import("@langchain/langgraph-checkpoint-sqlite");
+declare const defaultBetterSqlite3Loader: () => BetterSqlite3Constructor;
+declare const defaultLanggraphSqliteCheckpointLoader: () => SqliteCheckpointModule;
+export declare function loadBetterSqlite3(): BetterSqlite3Constructor;
+export declare function loadLanggraphSqliteCheckpointModule(): SqliteCheckpointModule;
+export declare function setSqliteModuleLoadersForTest(loaders: {
+    betterSqlite3?: typeof defaultBetterSqlite3Loader;
+    langgraphCheckpointSqlite?: typeof defaultLanggraphSqliteCheckpointLoader;
+}): void;
+export declare function resetSqliteModuleLoadersForTest(): void;
+export {};

package/dist/runtime/support/sqlite-drivers.js

@@ -0,0 +1,24 @@
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+const defaultBetterSqlite3Loader = () => require("better-sqlite3");
+const defaultLanggraphSqliteCheckpointLoader = () => require("@langchain/langgraph-checkpoint-sqlite");
+let betterSqlite3Loader = defaultBetterSqlite3Loader;
+let langgraphSqliteCheckpointLoader = defaultLanggraphSqliteCheckpointLoader;
+export function loadBetterSqlite3() {
+    return betterSqlite3Loader();
+}
+export function loadLanggraphSqliteCheckpointModule() {
+    return langgraphSqliteCheckpointLoader();
+}
+export function setSqliteModuleLoadersForTest(loaders) {
+    if (loaders.betterSqlite3) {
+        betterSqlite3Loader = loaders.betterSqlite3;
+    }
+    if (loaders.langgraphCheckpointSqlite) {
+        langgraphSqliteCheckpointLoader = loaders.langgraphCheckpointSqlite;
+    }
+}
+export function resetSqliteModuleLoadersForTest() {
+    betterSqlite3Loader = defaultBetterSqlite3Loader;
+    langgraphSqliteCheckpointLoader = defaultLanggraphSqliteCheckpointLoader;
+}

package/dist/workspace/object-loader.js

@@ -616,7 +616,7 @@ async function loadModuleAgentsForRoot(root, mergedAgents) {
 async function loadConventionalObjectsForRoot(root, mergedObjects) {
     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 })) {
+            for (const { item, sourcePath } of await readYamlItemsIgnoringNodeModules(objectRoot)) {
                 const workspaceObject = parseWorkspaceObject(item, sourcePath);
                 if (!workspaceObject) {
                     continue;
@@ -633,6 +633,32 @@ async function loadConventionalObjectsForRoot(root, mergedObjects) {
         }
     }
 }
+async function readYamlItemsIgnoringNodeModules(root) {
+    if (!(await fileExists(root))) {
+        return [];
+    }
+    const records = [];
+    const pending = [root];
+    while (pending.length > 0) {
+        const current = pending.shift();
+        const entries = await readdir(current, { withFileTypes: true });
+        for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+            const entryPath = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                if (entry.name === "node_modules") {
+                    continue;
+                }
+                pending.push(entryPath);
+                continue;
+            }
+            if (!entry.isFile() || (!entry.name.endsWith(".yaml") && !entry.name.endsWith(".yml"))) {
+                continue;
+            }
+            records.push(...(await readNamedYamlItems(current, [entry.name])));
+        }
+    }
+    return records;
+}
 async function readModuleToolItems(root) {
     const modulesRoot = moduleCollectionRoot(root, "tools");
     if (!(await fileExists(modulesRoot))) {

package/package.json

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