@pentatonic-ai/ai-agent-sdk 0.5.9 → 0.5.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pentatonic-ai/ai-agent-sdk",
-  "version": "0.5.9",
+  "version": "0.5.10",
   "description": "TES SDK — LLM observability and lifecycle tracking via Pentatonic Thing Event System. Track token usage, tool calls, and conversations. Manage things through event-sourced lifecycle stages with AI enrichment and vector search.",
   "type": "module",
   "main": "./dist/index.cjs",

package/packages/memory/src/__tests__/api-contract.test.js

@@ -709,6 +709,37 @@ describe("ingest dedup option", () => {
     expect(inserted[0].client_id).toBe("c");
   });
 
+  it("opts.dedupContent: matches against the raw form, stores the wrapped form", async () => {
+    const { db, inserted } = makeMockDb({
+      existing: [
+        // Row was stored on a previous run with a 10:00 timestamp prefix
+        {
+          id: "mem_legacy",
+          client_id: "c",
+          content: "[2026-04-26T10:00:00Z] Caroline went to a support group",
+        },
+      ],
+    });
+
+    const out = await ingest(
+      db,
+      mockAi,
+      mockLlm,
+      // The retry would store with a fresh timestamp — strict-equality
+      // would miss the dup. dedupContent makes us match on the raw form.
+      "[2026-04-26T10:00:01Z] Caroline went to a support group",
+      {
+        clientId: "c",
+        dedup: true,
+        dedupContent: "Caroline went to a support group",
+      }
+    );
+
+    expect(out.deduped).toBe(true);
+    expect(out.id).toBe("mem_legacy");
+    expect(inserted).toHaveLength(0);
+  });
+
   it("dedup check failure falls through to insert (best-effort semantics)", async () => {
     let dupCheckSql = null;
     const flakyDb = async (sql, params) => {

package/packages/memory/src/ingest.js

@@ -31,6 +31,12 @@ import { distill } from "./distill.js";
  *   `dedup:false` behaviour). The eventual structural fix is a
  *   `UNIQUE(client_id, content_hash)` constraint at the schema level;
  *   this option is the bridge.
+ * @param {string} [opts.dedupContent] - Optional: the string to dedup
+ *   against, when it differs from what gets stored. Use when callers
+ *   wrap the stored content in a non-stable prefix (timestamps, run
+ *   ids) — pass the raw form here so retries of the same logical event
+ *   match across runs whose prefixes differ by a few ms. Defaults to
+ *   `content`.
  * @returns {Promise<{id: string, content: string, layerId: string, deduped?: boolean}>}
  */
 export async function ingest(db, ai, llm, content, opts = {}) {
@@ -54,17 +60,21 @@ export async function ingest(db, ai, llm, content, opts = {}) {
 
   // Optional dedup: skip the insert (and all the embedding/HyDE/distill
   // work that would follow) if a row with byte-equal content already
-  // exists for this tenant. The OR-LIKE branch matches against the
-  // legacy `[<iso>] <content>` form so callers that wrote with a
+  // exists for this tenant. The dedup key is `opts.dedupContent` if
+  // provided (use for callers that wrap the stored form in a non-stable
+  // prefix like a timestamp), else `content`. The OR-LIKE branch matches
+  // against legacy `[<iso>] <content>` rows so callers that wrote with a
   // timestamp prefix dedup correctly until the legacy corpus ages out.
   if (opts.dedup) {
+    const dedupKey =
+      typeof opts.dedupContent === "string" ? opts.dedupContent : content;
     try {
       const dupCheck = await db(
         `SELECT id FROM memory_nodes
            WHERE client_id = $1
              AND (content = $2 OR content LIKE '%] ' || $2)
            LIMIT 1`,
-        [clientId, content]
+        [clientId, dedupKey]
       );
       if (dupCheck.rows?.length) {
         log(`dedup: matched existing memory ${dupCheck.rows[0].id}`);