wolbarg 0.5.1 → 0.5.2

package/CHANGELOG.md

@@ -5,6 +5,31 @@ All notable changes to this project are documented here.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/).
 
+## [0.5.2] — 2026-07-19
+
+### Added
+
+- **`rememberFromMessages()` (experimental)** — conversation → memory bridge with `mode: "raw"` (default, no LLM) and optional `mode: "extract"` via configured `llm`
+- **Vercel AI SDK adapter example** — `examples/adapters/vercel-ai/` (now uses official `@wolbarg/vercel-ai` middleware)
+- **Companion package `@wolbarg/vercel-ai`** — Language Model Middleware (`wolbargMiddleware` + `wrapLanguageModel`) for automatic recall / remember (published separately under `packages/vercel-ai/`)
+
+### Compatibility
+
+- Additive only. Omit the new method and behavior matches **0.5.1**. Experimental API may change before 1.0 — pin versions if you depend on it.
+- Core `wolbarg` remains framework-agnostic; AI SDK types live only in `@wolbarg/vercel-ai`.
+- `@wolbarg/vercel-ai@1` requires **AI SDK v7+** (`ai@^7`). Upgrade from AI SDK v4 before adopting the middleware.
+
+## [0.5.1] — 2026-07-19
+
+
+### Fixed
+
+- **SQLite vec0 rowid binding on Linux** — bind `memory_rowid` as `BigInt` for `node:sqlite` + sqlite-vec so CI / Linux inserts and KNN search do not fail on integer PK binds
+
+### Compatibility
+
+- Drop-in patch for **0.5.0**. No API or schema changes.
+
 ## [0.5.0] — 2026-07-19
 
 ### Added
@@ -166,6 +191,7 @@ const ctx = wolbarg({
 
 - Initial npm release path (pre–modular storage / ingest)
 
+[0.5.1]: https://github.com/wolbarg/wolbarg/releases/tag/v0.5.1
 [0.5.0]: https://github.com/wolbarg/wolbarg/releases/tag/v0.5.0
 [0.4.0]: https://github.com/wolbarg/wolbarg/releases/tag/v0.4.0
 [0.3.2]: https://github.com/wolbarg/wolbarg/releases/tag/v0.3.2

package/README.md

@@ -5,6 +5,7 @@
 **Modular, provider-agnostic semantic memory for AI agents.**
 
 [![npm version](https://img.shields.io/npm/v/wolbarg.svg)](https://www.npmjs.com/package/wolbarg)
+[![SDK CI](https://github.com/wolbarg/wolbarg/actions/workflows/sdk-ci.yml/badge.svg?branch=main)](https://github.com/wolbarg/wolbarg/actions/workflows/sdk-ci.yml)
 [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)
 [![Node.js](https://img.shields.io/badge/node-%3E%3D22.5-brightgreen.svg)](https://nodejs.org)
 [![Docs](https://img.shields.io/badge/docs-wolbarg.com-black)](https://wolbarg.com)
@@ -16,7 +17,7 @@ npm install wolbarg
 
 Wolbarg is **memory infrastructure**, not an agent framework. Agents call `remember()` / `recall()` (and optionally ingest, compress, subscribe, and link memories in a graph). You bring SQLite or PostgreSQL, any OpenAI-compatible embedding API, and optional peers for PDF/DOCX/OCR/Neo4j.
 
-**Current release: [v0.5.0](./CHANGELOG.md)** — optional graph memory (SQLite + Neo4j), `includeGraph` recall, cascade forget, graph-aware checkpoints, and [Wolbarg Studio](https://wolbarg.com/docs/observability) graph canvas.
+**Current release: [v0.5.2](./CHANGELOG.md)** — experimental `rememberFromMessages()` (chat → memory) and a [Vercel AI SDK adapter example](../examples/adapters/vercel-ai/). Still includes 0.5 graph memory (SQLite + Neo4j), `includeGraph` recall, and [Wolbarg Studio](https://wolbarg.com/docs/observability).
 
 ---
 
@@ -46,10 +47,12 @@ Wolbarg is **memory infrastructure**, not an agent framework. Agents call `remem
 - **Embedding cache** — `hash(content) + model`
 - **Dedupe / upsert** — opt-in exact / near / exact-or-near
 - **Graph memory (0.5)** — `sqliteGraph` / `neo4jGraph`, `linkMemories`, `getRelated`, `includeGraph`
+- **Conversation bridge (0.5.2, experimental)** — `rememberFromMessages()` raw or LLM extract
+- **Framework adapter** — official [`@wolbarg/vercel-ai`](../packages/vercel-ai/) middleware (`wrapLanguageModel`)
 - **Checkpoints / export** — file-backed SQLite snapshots (+ graph file when applicable)
 - **Telemetry** — independent event DB; Studio dashboard, Trace Explorer, graph canvas
 
-Docs: [Getting started](https://wolbarg.com/docs/getting-started) · [What's new in 0.5](https://wolbarg.com/docs/guides/whats-new) · [Graph memory](https://wolbarg.com/docs/graph-memory) · [Studio](https://wolbarg.com/docs/observability)
+Docs: [Getting started](https://wolbarg.com/docs/getting-started) · [Vercel AI](https://wolbarg.com/docs/integrations/vercel-ai) · [rememberFromMessages](https://wolbarg.com/docs/api/remember-from-messages) · [Graph memory](https://wolbarg.com/docs/graph-memory) · [Studio](https://wolbarg.com/docs/observability)
 
 ---
 

package/dist/index.cjs

@@ -3325,12 +3325,13 @@ var SqliteStorageProvider = class _SqliteStorageProvider {
   insertEmbedding(rowid, embedding) {
     const stmts = this.requireStatements();
     if (this.vectorBackend === "sqlite-vec") {
-      stmts.insertEmbedding.run(rowid, this.toVectorParam(embedding));
+      stmts.insertEmbedding.run(this.toVecRowid(rowid), this.toVectorParam(embedding));
       return;
     }
-    stmts.insertEmbeddingBlob.run(rowid, embeddingToBuffer(embedding));
+    const id = Number(rowid);
+    stmts.insertEmbeddingBlob.run(id, embeddingToBuffer(embedding));
     if (this.memoryIndex) {
-      this.memoryIndex.upsert(rowid, embedding);
+      this.memoryIndex.upsert(id, embedding);
       this.memoryIndexDirty = false;
     } else {
       this.memoryIndexDirty = true;
@@ -3340,10 +3341,11 @@ var SqliteStorageProvider = class _SqliteStorageProvider {
     const stmts = this.requireStatements();
     try {
       if (this.vectorBackend === "sqlite-vec" && stmts.deleteEmbedding) {
-        stmts.deleteEmbedding.run(rowid);
+        stmts.deleteEmbedding.run(this.toVecRowid(rowid));
       } else if (stmts.deleteEmbeddingBlob) {
-        stmts.deleteEmbeddingBlob.run(rowid);
-        this.memoryIndex?.remove(rowid);
+        const id = Number(rowid);
+        stmts.deleteEmbeddingBlob.run(id);
+        this.memoryIndex?.remove(id);
         this.memoryIndexDirty = true;
       }
     } catch {
@@ -3360,8 +3362,8 @@ var SqliteStorageProvider = class _SqliteStorageProvider {
       for (let i = 0; i < rows.length; i += 1) {
         const row = rows[i];
         hits[i] = {
-          memoryRowid: row.memory_rowid,
-          distance: row.distance
+          memoryRowid: Number(row.memory_rowid),
+          distance: Number(row.distance)
         };
       }
       return hits;
@@ -3437,6 +3439,10 @@ var SqliteStorageProvider = class _SqliteStorageProvider {
     const buffer = embeddingToBuffer(embedding);
     return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
   }
+  /** sqlite-vec vec0 PKs must be bound as BigInt under node:sqlite. */
+  toVecRowid(rowid) {
+    return typeof rowid === "bigint" ? rowid : BigInt(rowid);
+  }
   describe(error) {
     if (error instanceof Error) {
       return error.message;
@@ -5165,7 +5171,7 @@ function createDatabaseProvider(config) {
 }
 
 // src/version.ts
-var SDK_VERSION = "0.5.0";
+var SDK_VERSION = "0.5.2";
 
 // src/memory/transfer.ts
 var SqliteMemoryTransferProvider = class {
@@ -5291,6 +5297,96 @@ function resolvePath(p) {
   return path7__default.default.isAbsolute(p) ? p : path7__default.default.resolve(process.cwd(), p);
 }
 
+// src/memory/from-messages.ts
+var DEFAULT_RAW_STRATEGY = "last_user";
+function normalizeConversationMessages(messages) {
+  if (!Array.isArray(messages)) {
+    throw new ValidationError("messages must be an array");
+  }
+  if (messages.length === 0) {
+    throw new ValidationError("messages must be a non-empty array");
+  }
+  return messages.map((message, index) => {
+    if (!message || typeof message !== "object") {
+      throw new ValidationError(`messages[${index}] must be an object`);
+    }
+    if (typeof message.role !== "string" || message.role.trim().length === 0) {
+      throw new ValidationError(`messages[${index}].role must be a non-empty string`);
+    }
+    if (typeof message.content !== "string") {
+      throw new ValidationError(`messages[${index}].content must be a string`);
+    }
+    return {
+      role: message.role.trim(),
+      content: message.content.trim()
+    };
+  });
+}
+function resolveRememberFromMessagesOptions(options) {
+  if (!options || typeof options !== "object") {
+    throw new ValidationError("options is required");
+  }
+  if (typeof options.agent !== "string" || options.agent.trim().length === 0) {
+    throw new ValidationError("agent must be a non-empty string");
+  }
+  const mode = options.mode ?? "raw";
+  if (mode !== "raw" && mode !== "extract") {
+    throw new ValidationError('mode must be "raw" or "extract"');
+  }
+  const rawStrategy = options.rawStrategy ?? DEFAULT_RAW_STRATEGY;
+  if (rawStrategy !== "last_user" && rawStrategy !== "all_user") {
+    throw new ValidationError('rawStrategy must be "last_user" or "all_user"');
+  }
+  return {
+    agent: options.agent.trim(),
+    mode,
+    rawStrategy,
+    ...options.metadata !== void 0 ? { metadata: options.metadata } : {},
+    ...options.dedupe !== void 0 ? { dedupe: options.dedupe } : {}
+  };
+}
+function selectRawUserTexts(messages, strategy) {
+  const userTexts = messages.filter((m) => m.role === "user" && m.content.length > 0).map((m) => m.content);
+  if (userTexts.length === 0) {
+    throw new ValidationError(
+      'no user messages with non-empty content \u2014 nothing to remember in mode "raw"'
+    );
+  }
+  if (strategy === "last_user") {
+    return [userTexts[userTexts.length - 1]];
+  }
+  return userTexts;
+}
+function buildExtractMessages(messages) {
+  const transcript = messages.map((m) => `${m.role}: ${m.content}`).join("\n");
+  return [
+    {
+      role: "system",
+      content: "Extract durable factual memories from the conversation. Return only atomic facts, one per line. No numbering, bullets, or commentary. If there are no facts worth storing, reply with exactly NONE."
+    },
+    {
+      role: "user",
+      content: transcript
+    }
+  ];
+}
+function parseExtractedFacts(llmOutput) {
+  const trimmed = llmOutput.trim();
+  if (trimmed.length === 0 || /^none$/i.test(trimmed)) {
+    return [];
+  }
+  const facts = [];
+  for (const line of trimmed.split(/\r?\n/)) {
+    let fact = line.trim();
+    if (fact.length === 0) continue;
+    fact = fact.replace(/^[-*•]\s+/, "");
+    fact = fact.replace(/^\d+[.)]\s+/, "");
+    if (fact.length === 0 || /^none$/i.test(fact)) continue;
+    facts.push(fact);
+  }
+  return facts;
+}
+
 // src/memory/index.ts
 function toMemoryRecord(row) {
   return {
@@ -7739,6 +7835,81 @@ var Wolbarg = class {
       throw wrapOperationError("rememberBatch", error);
     }
   }
+  /**
+   * Store memories from a chat transcript.
+   *
+   * **Experimental** until 1.0 — API shape may change.
+   *
+   * - `mode: "raw"` (default) — remember user message text (no LLM).
+   * - `mode: "extract"` — require configured `llm`; extract atomic facts then remember each.
+   */
+  async rememberFromMessages(messages, options) {
+    const parent = this.telemetry.start("rememberFromMessages");
+    try {
+      const normalized = normalizeConversationMessages(messages);
+      const resolved = resolveRememberFromMessagesOptions(options);
+      let texts;
+      if (resolved.mode === "extract") {
+        if (!this.llm) {
+          throw new ProviderNotConfiguredError(
+            "llm",
+            "rememberFromMessages",
+            'pass llm: openaiLlm(...) in the constructor when mode is "extract"'
+          );
+        }
+        const llmOutput = await this.llm.complete(
+          buildExtractMessages(normalized)
+        );
+        texts = parseExtractedFacts(llmOutput);
+        if (texts.length === 0) {
+          parent.success({
+            returnedCount: 0,
+            agentId: resolved.agent,
+            extra: { mode: "extract", factCount: 0 }
+          });
+          return [];
+        }
+      } else {
+        texts = selectRawUserTexts(normalized, resolved.rawStrategy);
+      }
+      const out = [];
+      for (const text of texts) {
+        const child = parent.child("remember");
+        const result = await this.rememberOne(
+          {
+            agent: resolved.agent,
+            content: { text },
+            ...resolved.metadata !== void 0 ? { metadata: resolved.metadata } : {},
+            ...resolved.dedupe !== void 0 ? { dedupe: resolved.dedupe } : {}
+          },
+          child
+        );
+        child.success({
+          provider: this.storage?.name,
+          memoryIds: [result.id],
+          returnedCount: 1,
+          metadata: result.metadata,
+          agentId: result.agent,
+          tags: telemetryTags(result.metadata),
+          extra: { upsertAction: result.action, mode: resolved.mode }
+        });
+        out.push(result);
+      }
+      parent.success({
+        provider: this.storage?.name,
+        memoryIds: out.map((r) => r.id),
+        returnedCount: out.length,
+        embeddingProvider: this.embedding?.model,
+        model: this.embedding?.model,
+        agentId: resolved.agent,
+        extra: { mode: resolved.mode }
+      });
+      return out;
+    } catch (error) {
+      parent.failure(error, { agentId: options?.agent });
+      throw wrapOperationError("rememberFromMessages", error);
+    }
+  }
   /**
    * Update an existing memory by id (re-embeds when content changes).
    */