@botbotgo/agent-harness 0.0.154 → 0.0.156

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

@@ -1,6 +1,9 @@
 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";
+const NAMESPACE_SEPARATOR = "\u001f";
 function encodeValue(value) {
     if (value instanceof Date) {
         return {
@@ -50,6 +53,18 @@ function decodeValue(value) {
     }
     return value;
 }
+function serializeNamespace(namespace) {
+    return namespace.join(NAMESPACE_SEPARATOR);
+}
+function parseRow(row) {
+    return {
+        value: decodeValue(JSON.parse(row.value_json)),
+        key: row.key,
+        namespace: JSON.parse(row.namespace_json),
+        createdAt: new Date(row.created_at),
+        updatedAt: new Date(row.updated_at),
+    };
+}
 export class FileBackedStore {
     filePath;
     delegate = new InMemoryStore();
@@ -131,6 +146,87 @@ export class FileBackedStore {
         });
     }
 }
+export class SqliteBackedStore {
+    filePath;
+    db;
+    constructor(filePath) {
+        this.filePath = filePath;
+        mkdirSync(path.dirname(filePath), { recursive: true });
+        this.db = new Database(filePath);
+        this.db.pragma("journal_mode = WAL");
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS store_entries (
+        namespace TEXT NOT NULL,
+        namespace_json TEXT NOT NULL,
+        key TEXT NOT NULL,
+        value_json TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        PRIMARY KEY (namespace, key)
+      );
+      CREATE INDEX IF NOT EXISTS idx_store_entries_namespace ON store_entries(namespace);
+    `);
+    }
+    async batch(operations) {
+        const results = this.db.transaction((items) => items.map((operation) => {
+            const namespace = Array.isArray(operation.namespace) ? operation.namespace.filter((item) => typeof item === "string") : [];
+            const key = typeof operation.key === "string" ? operation.key : "";
+            if ("value" in operation) {
+                this.putSync(namespace, key, operation.value);
+                return undefined;
+            }
+            if (operation.delete === true) {
+                this.deleteSync(namespace, key);
+                return undefined;
+            }
+            return this.getSync(namespace, key);
+        }))(operations);
+        return results;
+    }
+    async get(namespace, key) {
+        return this.getSync(namespace, key);
+    }
+    getSync(namespace, key) {
+        const row = this.db.prepare(`SELECT namespace, namespace_json, key, value_json, created_at, updated_at
+       FROM store_entries
+       WHERE namespace = ? AND key = ?`).get(serializeNamespace(namespace), key);
+        return row ? parseRow(row) : null;
+    }
+    async search(namespacePrefix) {
+        const prefix = serializeNamespace(namespacePrefix);
+        const rows = this.db.prepare(`SELECT namespace, namespace_json, key, value_json, created_at, updated_at
+       FROM store_entries
+       WHERE namespace = ? OR namespace LIKE ?
+       ORDER BY namespace ASC, key ASC`).all(prefix, `${prefix}${NAMESPACE_SEPARATOR}%`);
+        return rows.map((row) => parseRow(row));
+    }
+    async put(namespace, key, value, _index) {
+        this.putSync(namespace, key, value);
+    }
+    putSync(namespace, key, value) {
+        const now = new Date().toISOString();
+        const serializedNamespace = serializeNamespace(namespace);
+        const encodedValue = JSON.stringify(encodeValue(value));
+        this.db.prepare(`INSERT INTO store_entries (namespace, namespace_json, key, value_json, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?)
+       ON CONFLICT(namespace, key) DO UPDATE SET
+         namespace_json = excluded.namespace_json,
+         value_json = excluded.value_json,
+         updated_at = excluded.updated_at`).run(serializedNamespace, JSON.stringify(namespace), key, encodedValue, now, now);
+    }
+    async delete(namespace, key) {
+        this.deleteSync(namespace, key);
+    }
+    deleteSync(namespace, key) {
+        this.db.prepare(`DELETE FROM store_entries WHERE namespace = ? AND key = ?`).run(serializeNamespace(namespace), key);
+    }
+    async listNamespaces() {
+        const rows = this.db.prepare(`SELECT DISTINCT namespace_json
+       FROM store_entries
+       ORDER BY namespace ASC`).all();
+        return rows.map((row) => JSON.parse(row.namespace_json));
+    }
+}
 export function createInMemoryStore() {
     return new InMemoryStore();
 }

package/dist/runtime/harness.d.ts

@@ -1,4 +1,4 @@
-import type { ApprovalRecord, CancelOptions, HarnessEvent, HarnessStreamItem, RuntimeHealthSnapshot, MessageContent, RunRecord, RunStartOptions, RestartConversationOptions, RuntimeAdapterOptions, ResumeOptions, RunOptions, RunResult, RunSummary, MemorizeInput, MemorizeResult, RecallInput, RecallResult, ThreadSummary, ThreadRecord, WorkspaceBundle } from "../contracts/types.js";
+import type { ApprovalRecord, CancelOptions, HarnessEvent, HarnessStreamItem, RuntimeHealthSnapshot, ListMemoriesInput, ListMemoriesResult, MessageContent, RemoveMemoryInput, RunRecord, RunStartOptions, RestartConversationOptions, RuntimeAdapterOptions, ResumeOptions, RunOptions, RunResult, RunSummary, MemoryRecord, MemorizeInput, MemorizeResult, RecallInput, RecallResult, UpdateMemoryInput, ThreadSummary, ThreadRecord, WorkspaceBundle } from "../contracts/types.js";
 import { type ToolMcpServerOptions } from "../mcp.js";
 import { type InventoryAgentRecord, type InventorySkillRecord } from "./harness/system/inventory.js";
 import type { RequirementAssessmentOptions } from "./harness/system/skill-requirements.js";
@@ -29,6 +29,11 @@ export declare class AgentHarnessRuntime {
     private readonly unregisterRuntimeMemorySync;
     private readonly mem0IngestionSync;
     private readonly unregisterMem0IngestionSync;
+    private readonly mem0SemanticRecall;
+    private readonly runtimeMemoryFormationConfig;
+    private readonly runtimeMemoryManager;
+    private readonly runtimeMemoryFormationSync;
+    private readonly unregisterRuntimeMemoryFormationSync;
     private readonly resolvedRuntimeAdapterOptions;
     private readonly healthMonitor;
     private readonly recoveryConfig;
@@ -43,6 +48,7 @@ export declare class AgentHarnessRuntime {
     private closed;
     private readonly backgroundEventRuntime;
     private readonly runtimeEventOperations;
+    private resolveRuntimeMemoryVectorStore;
     private defaultRunRoot;
     private getDefaultRuntimeEntryAgentId;
     private resolveSelectedAgentId;
@@ -64,6 +70,9 @@ export declare class AgentHarnessRuntime {
     }): Promise<RunSummary[]>;
     memorize(input: MemorizeInput): Promise<MemorizeResult>;
     recall(input: RecallInput): Promise<RecallResult>;
+    listMemories(input?: ListMemoriesInput): Promise<ListMemoriesResult>;
+    updateMemory(input: UpdateMemoryInput): Promise<MemoryRecord>;
+    removeMemory(input: RemoveMemoryInput): Promise<MemoryRecord>;
     getRun(runId: string): Promise<RunRecord | null>;
     private getSession;
     getThread(threadId: string): Promise<ThreadRecord | null>;
@@ -96,9 +105,20 @@ export declare class AgentHarnessRuntime {
     private invokeWithHistory;
     private resolveMemoryNamespace;
     private getWorkspaceId;
+    private summarizeMemoryContent;
+    private matchesMemoryFilters;
     private resolveRecallScopes;
     private matchesRecallScope;
     private getMemoryScopeBoost;
+    private memoryFreshnessBoost;
+    private scoreStructuredRecord;
+    private normalizeMemoryDedupKey;
+    private inferMem0MemoryKind;
+    private inferMem0MemoryScope;
+    private createMem0MemoryRecord;
+    private rankRecallCandidates;
+    private rebuildRuntimeMemoryVectorIndex;
+    private refreshStructuredMemoryScope;
     private buildRuntimeMemoryContext;
     private persistRuntimeMemoryCandidates;
     private persistStructuredMemoryCandidates;