@botbotgo/agent-harness 0.0.329 → 0.0.330

package/dist/package-version.d.ts

@@ -1,2 +1,2 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.328";
+export declare const AGENT_HARNESS_VERSION = "0.0.329";
 export declare const AGENT_HARNESS_RELEASE_DATE = "2026-04-23";

package/dist/package-version.js

@@ -1,2 +1,2 @@
-export const AGENT_HARNESS_VERSION = "0.0.328";
+export const AGENT_HARNESS_VERSION = "0.0.329";
 export const AGENT_HARNESS_RELEASE_DATE = "2026-04-23";

package/dist/runtime/adapter/model/model-providers.js

@@ -415,7 +415,7 @@ async function createNodeLlamaCppModel(model) {
         }));
     }
     catch (error) {
-        throw new Error(`Failed to initialize ${model.provider} model ${model.id}. Install node-llama-cpp in the application workspace and ensure the GGUF file exists at ${modelPath}.`, { cause: error });
+        throw new Error(`Failed to initialize ${model.provider} model ${model.id}. Install @langchain/community and node-llama-cpp in the application workspace and ensure the GGUF file exists at ${modelPath}.`, { cause: error });
     }
 }
 export async function createResolvedModel(model, modelResolver) {

package/dist/runtime/harness/system/mem0-ingestion-sync.d.ts

@@ -1,4 +1,3 @@
-import { type Memory as Mem0Memory, type Message as Mem0Message } from "mem0ai";
 import type { HarnessEvent, HarnessEventProjection } from "../../../contracts/types.js";
 import type { RuntimePersistence } from "../../../persistence/types.js";
 import { type StoreLike } from "./store.js";
@@ -17,6 +16,24 @@ export type ResolvedMem0Config = {
     writeOnApprovalResolution: boolean;
     writeOnRequestCompletion: boolean;
 };
+type Mem0Message = {
+    role: string;
+    content: string;
+};
+type Mem0Memory = {
+    id?: string;
+    memory?: string;
+    data?: {
+        memory?: string;
+    };
+    score?: number;
+    categories?: string[];
+    metadata?: Record<string, unknown>;
+    agent_id?: string;
+    request_id?: string;
+    created_at?: string | Date;
+    updated_at?: string | Date;
+};
 type Mem0ClientLike = {
     add(messages: Mem0Message[], options?: Record<string, unknown>): Promise<unknown>;
     search(query: string, options?: Record<string, unknown>): Promise<Mem0Memory[]>;

package/dist/runtime/harness/system/mem0-ingestion-sync.js

@@ -1,6 +1,5 @@
 import { createHash } from "node:crypto";
 import path from "node:path";
-import { MemoryClient } from "mem0ai";
 import { extractMessageText } from "../../../utils/message-content.js";
 import { FileBackedStore } from "./store.js";
 const MEM0_EVENT_TYPES = new Set([
@@ -79,27 +78,24 @@ async function createDefaultMem0Client(config) {
     if (!apiKey) {
         throw new Error(`runtimeMemory.mem0 is enabled but environment variable ${config.apiKeyEnv} is not set`);
     }
-    return new MemoryClient({
-        apiKey,
-        ...(config.host ? { host: config.host } : {}),
-        ...(config.organizationName ? { organizationName: config.organizationName } : {}),
-        ...(config.projectName ? { projectName: config.projectName } : {}),
-        ...(config.organizationId ? { organizationId: config.organizationId } : {}),
-        ...(config.projectId ? { projectId: config.projectId } : {}),
-    });
+    return createCloudMem0Client(config, apiKey);
 }
 function normalizeMem0Host(host) {
     return host.replace(/\/+$/, "");
 }
+function buildMem0Headers(apiKey) {
+    return {
+        "Content-Type": "application/json",
+        ...(apiKey ? { Authorization: `Token ${apiKey}` } : {}),
+    };
+}
 async function selfHostedMem0Request(config, pathname, options = {}) {
     if (!config.host) {
         throw new Error("Self-hosted mem0 client requires runtimeMemory.mem0.host.");
     }
     const response = await fetch(`${normalizeMem0Host(config.host)}${pathname}`, {
         method: options.method ?? "GET",
-        headers: {
-            "Content-Type": "application/json",
-        },
+        headers: buildMem0Headers(),
         ...(options.body ? { body: JSON.stringify(options.body) } : {}),
     });
     if (!response.ok) {
@@ -107,6 +103,54 @@ async function selfHostedMem0Request(config, pathname, options = {}) {
     }
     return response.json();
 }
+function applyMem0Scope(payload, config) {
+    const scoped = { ...payload };
+    if (config.organizationName && config.projectName) {
+        scoped.org_name = config.organizationName;
+        scoped.project_name = config.projectName;
+    }
+    if (config.organizationId && config.projectId) {
+        scoped.org_id = config.organizationId;
+        scoped.project_id = config.projectId;
+        delete scoped.org_name;
+        delete scoped.project_name;
+    }
+    return scoped;
+}
+async function cloudMem0Request(config, apiKey, pathname, options = {}) {
+    const host = normalizeMem0Host(config.host ?? "https://api.mem0.ai");
+    const response = await fetch(`${host}${pathname}`, {
+        method: options.method ?? "GET",
+        headers: buildMem0Headers(apiKey),
+        ...(options.body ? { body: JSON.stringify(applyMem0Scope(options.body, config)) } : {}),
+    });
+    if (!response.ok) {
+        throw new Error(`Mem0 request failed: ${response.status} ${response.statusText}`);
+    }
+    return response.json();
+}
+function createCloudMem0Client(config, apiKey) {
+    return {
+        async add(messages, options = {}) {
+            return cloudMem0Request(config, apiKey, "/v1/memories/", {
+                method: "POST",
+                body: {
+                    messages,
+                    ...options,
+                },
+            });
+        },
+        async search(query, options = {}) {
+            return cloudMem0Request(config, apiKey, "/v1/memories/search/", {
+                method: "POST",
+                body: {
+                    query,
+                    ...options,
+                },
+            });
+        },
+    };
+}
 function createSelfHostedMem0Client(config) {
     return {
         async add(messages, options = {}) {
@@ -275,7 +319,7 @@ export class Mem0SemanticRecall {
             const createdAt = toIsoString(record.created_at) ?? new Date(0).toISOString();
             const updatedAt = toIsoString(record.updated_at) ?? createdAt;
             return {
-                id: record.id,
+                id: typeof record.id === "string" && record.id.trim().length > 0 ? record.id : memory,
                 memory,
                 score: typeof record.score === "number" && Number.isFinite(record.score) ? record.score : 0,
                 categories: Array.isArray(record.categories)

package/dist/runtime/support/embedding-models.js

@@ -65,7 +65,7 @@ async function createNodeLlamaCppEmbeddings(embeddingModel) {
         });
     }
     catch (error) {
-        throw new Error(`Failed to initialize ${embeddingModel.provider} embedding model ${embeddingModel.id}. Install node-llama-cpp in the application workspace and ensure the GGUF file exists at ${modelPath}.`, { cause: error });
+        throw new Error(`Failed to initialize ${embeddingModel.provider} embedding model ${embeddingModel.id}. Install @langchain/community and node-llama-cpp in the application workspace and ensure the GGUF file exists at ${modelPath}.`, { cause: error });
     }
 }
 async function createLazyLlamaIndexEmbeddingModel(embeddingModel) {

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

@@ -1,8 +1,6 @@
 import path from "node:path";
 import { mkdir } from "node:fs/promises";
-import { Document } from "@langchain/core/documents";
 import { createClient } from "@libsql/client";
-import { LibSQLVectorStore } from "@langchain/community/vectorstores/libsql";
 import { QdrantClient } from "@qdrant/js-client-rest";
 import { compileVectorStore } from "../../workspace/resource-compilers.js";
 import { getRuntimeStorageRoots, resolveRefId } from "../../workspace/support/workspace-ref-utils.js";
@@ -52,6 +50,69 @@ async function ensureLibSqlSchema(db, table, column, dimensions) {
     ON ${safeTable}(libsql_vector_idx(${safeColumn}))
   `);
 }
+function serializeVector(vector) {
+    if (!vector.every((value) => typeof value === "number" && Number.isFinite(value))) {
+        throw new Error("Invalid vector: all elements must be finite numbers.");
+    }
+    return `[${vector.join(",")}]`;
+}
+async function addLibSqlDocuments(db, table, column, documents, vectors) {
+    const safeTable = assertIdentifier(table, "table name");
+    const safeColumn = assertIdentifier(column, "column name");
+    const statements = documents.map((document, index) => ({
+        sql: `INSERT INTO ${safeTable} (content, metadata, ${safeColumn}) VALUES (:content, :metadata, vector(:embedding)) RETURNING ${safeTable}.rowid AS id`,
+        args: {
+            content: document.pageContent,
+            metadata: JSON.stringify(document.metadata ?? {}),
+            embedding: serializeVector(vectors[index] ?? []),
+        },
+    }));
+    if (statements.length === 0) {
+        return [];
+    }
+    const results = await db.batch(statements);
+    return results.flatMap((result) => result.rows.map((row) => String(row.id)));
+}
+async function similaritySearchLibSql(db, table, column, queryVector, limit) {
+    const safeTable = assertIdentifier(table, "table name");
+    const safeColumn = assertIdentifier(column, "column name");
+    const safeIndex = assertIdentifier(`idx_${safeTable}_${safeColumn}`, "index name");
+    const rows = await db.execute({
+        sql: `SELECT ${safeTable}.rowid AS id, ${safeTable}.content, ${safeTable}.metadata, vector_distance_cos(${safeTable}.${safeColumn}, vector(:queryVector)) AS distance
+      FROM vector_top_k('${safeIndex}', vector(:queryVector), CAST(:limit AS INTEGER)) AS top_k
+      JOIN ${safeTable} ON top_k.rowid = ${safeTable}.rowid`,
+        args: {
+            queryVector: serializeVector(queryVector),
+            limit,
+        },
+    });
+    return rows.rows.map((row) => {
+        const parsedMetadata = typeof row.metadata === "string" ? JSON.parse(row.metadata) : {};
+        const metadata = typeof parsedMetadata === "object" && parsedMetadata && !Array.isArray(parsedMetadata)
+            ? parsedMetadata
+            : {};
+        return {
+            pageContent: typeof row.content === "string" ? row.content : "",
+            metadata,
+            score: typeof row.distance === "number" ? 1 - row.distance : undefined,
+        };
+    });
+}
+async function deleteLibSqlVectors(db, table, params) {
+    const safeTable = assertIdentifier(table, "table name");
+    if (params.deleteAll) {
+        await db.execute(`DELETE FROM ${safeTable}`);
+        return;
+    }
+    const ids = params.ids ?? [];
+    if (ids.length === 0) {
+        throw new Error('You must provide an "ids" parameter or a "deleteAll" parameter.');
+    }
+    await db.batch(ids.map((id) => ({
+        sql: `DELETE FROM ${safeTable} WHERE rowid = :id`,
+        args: { id },
+    })));
+}
 function createQdrantClientForStore(vectorStore) {
     return new QdrantClient({
         ...(vectorStore.url ? { url: vectorStore.url } : {}),
@@ -197,35 +258,17 @@ export async function resolveCompiledVectorStore(workspace, vectorStore, options
         embeddingModelRef: vectorStore.embeddingModelRef,
         addDocuments: async (documents) => {
             await ensureSchemaForTexts(documents.map((document) => document.pageContent));
-            const store = new LibSQLVectorStore(embeddings, {
-                db,
-                table,
-                column,
-            });
-            return store.addDocuments(documents.map((document) => new Document(document)));
+            const vectors = await embeddings.embedDocuments(documents.map((document) => document.pageContent));
+            return addLibSqlDocuments(db, table, column, documents, vectors);
         },
         similaritySearch: async (query, limit) => {
             await ensureSchemaForTexts([query]);
-            const store = new LibSQLVectorStore(embeddings, {
-                db,
-                table,
-                column,
-            });
-            const rows = (await store.similaritySearchWithScore(query, limit));
-            return rows.map(([document, score]) => ({
-                pageContent: document.pageContent,
-                metadata: document.metadata,
-                score: typeof score === "number" ? 1 - score : score,
-            }));
+            const queryVector = await embeddings.embedQuery(query);
+            return similaritySearchLibSql(db, table, column, queryVector, limit);
         },
         delete: async (params) => {
             await ensureSchemaForTexts(["seed"]);
-            const store = new LibSQLVectorStore(embeddings, {
-                db,
-                table,
-                column,
-            });
-            await store.delete(params);
+            await deleteLibSqlVectors(db, table, params);
         },
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.329",
+  "version": "0.0.330",
   "description": "Workspace runtime for multi-agent applications",
   "license": "MIT",
   "type": "module",
@@ -48,7 +48,6 @@
   },
   "dependencies": {
     "@langchain/anthropic": "^1.3.27",
-    "@langchain/community": "^1.1.27",
     "@langchain/core": "^1.1.41",
     "@langchain/google": "^0.1.10",
     "@langchain/langgraph": "^1.2.9",
@@ -61,7 +60,6 @@
     "deepagents": "^1.9.0",
     "langchain": "^1.3.4",
     "llamaindex": "^0.12.1",
-    "mem0ai": "^2.4.6",
     "mustache": "^4.2.0",
     "yaml": "^2.8.1",
     "zod": "^3.25.76"
@@ -89,6 +87,7 @@
     "release:publish": "npm publish --access public --registry https://registry.npmjs.org/"
   },
   "devDependencies": {
+    "@langchain/community": "^1.1.27",
     "@types/node": "^25.5.2",
     "typescript": "^6.0.2",
     "vite": "^7.3.2",