@anuma/sdk 7.3.0 → 7.3.1

package/dist/react/index.mjs

@@ -10438,6 +10438,67 @@ __decorateClass([
 // src/lib/db/entities/operations.ts
 import { Q as Q5 } from "@nozbe/watermelondb";
 
+// src/lib/db/memoryVault/types.ts
+var MEMORY_KINDS = [
+  "display_name",
+  "birth_date",
+  "bio",
+  "occupation",
+  "interest",
+  "gender",
+  "height_cm",
+  "looking_for",
+  "politics",
+  "religion",
+  "ethnicity",
+  "smoking",
+  "drinking",
+  "exercise",
+  "sexuality",
+  "prompt"
+];
+var MEMORY_LEVELS = ["private", "matching", "profile"];
+var MemoryLevelError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MemoryLevelError";
+  }
+};
+var MemorySourceIneligibleError = class extends Error {
+  constructor() {
+    super("Memory source is no longer eligible");
+    this.name = "MemorySourceIneligibleError";
+  }
+};
+var PUBLISHED_SCOPES = /* @__PURE__ */ new Set(["shared", "public"]);
+function levelFromScope(scope) {
+  return typeof scope === "string" && PUBLISHED_SCOPES.has(scope) ? "matching" : "private";
+}
+function scopeForLevel(level) {
+  return level === "private" ? "private" : "shared";
+}
+function resolveMemoryLevel(level, scope) {
+  return typeof level === "string" && MEMORY_LEVELS.includes(level) ? level : levelFromScope(scope);
+}
+function levelForScopeChange(current, nextScope) {
+  const implied = levelFromScope(nextScope);
+  return implied === "matching" && resolveMemoryLevel(current.level, current.scope) === "profile" ? "profile" : implied;
+}
+function parseMedia(value) {
+  if (typeof value !== "string" || value === "") return null;
+  try {
+    const parsed = JSON.parse(value);
+    if (!Array.isArray(parsed)) return null;
+    const refs = parsed.filter((r) => typeof r === "object" && r !== null).map((r) => ({
+      feedItemId: Number(r.feedItemId ?? r.feed_item_id),
+      objectKey: r.objectKey ?? r.object_key ?? null
+    })).filter((r) => Number.isFinite(r.feedItemId));
+    return refs.length > 0 ? refs : null;
+  } catch {
+    return null;
+  }
+}
+
 // src/lib/db/entities/types.ts
 var ENTITY_KINDS = [
   "person",
@@ -10497,7 +10558,7 @@ function parseTopics(value) {
 // src/lib/db/entities/operations.ts
 async function assertCanWrite(ctx) {
   if (ctx.canWrite && !await ctx.canWrite()) {
-    throw new Error("Memory source is no longer eligible");
+    throw new MemorySourceIneligibleError();
   }
 }
 function entityToStored(e) {
@@ -13139,61 +13200,6 @@ function serializeSourceChunkIds(ids) {
   return JSON.stringify(ids.slice(start));
 }
 
-// src/lib/db/memoryVault/types.ts
-var MEMORY_KINDS = [
-  "display_name",
-  "birth_date",
-  "bio",
-  "occupation",
-  "interest",
-  "gender",
-  "height_cm",
-  "looking_for",
-  "politics",
-  "religion",
-  "ethnicity",
-  "smoking",
-  "drinking",
-  "exercise",
-  "sexuality",
-  "prompt"
-];
-var MEMORY_LEVELS = ["private", "matching", "profile"];
-var MemoryLevelError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "MemoryLevelError";
-  }
-};
-var PUBLISHED_SCOPES = /* @__PURE__ */ new Set(["shared", "public"]);
-function levelFromScope(scope) {
-  return typeof scope === "string" && PUBLISHED_SCOPES.has(scope) ? "matching" : "private";
-}
-function scopeForLevel(level) {
-  return level === "private" ? "private" : "shared";
-}
-function resolveMemoryLevel(level, scope) {
-  return typeof level === "string" && MEMORY_LEVELS.includes(level) ? level : levelFromScope(scope);
-}
-function levelForScopeChange(current, nextScope) {
-  const implied = levelFromScope(nextScope);
-  return implied === "matching" && resolveMemoryLevel(current.level, current.scope) === "profile" ? "profile" : implied;
-}
-function parseMedia(value) {
-  if (typeof value !== "string" || value === "") return null;
-  try {
-    const parsed = JSON.parse(value);
-    if (!Array.isArray(parsed)) return null;
-    const refs = parsed.filter((r) => typeof r === "object" && r !== null).map((r) => ({
-      feedItemId: Number(r.feedItemId ?? r.feed_item_id),
-      objectKey: r.objectKey ?? r.object_key ?? null
-    })).filter((r) => Number.isFinite(r.feedItemId));
-    return refs.length > 0 ? refs : null;
-  } catch {
-    return null;
-  }
-}
-
 // src/lib/db/memoryVault/operations.ts
 function visibilityOrPrivate(value) {
   return value === "public" ? value : "private";
@@ -13213,7 +13219,7 @@ function isKinded(record2) {
 }
 async function assertCanWrite2(ctx) {
   if (ctx.canWrite && !await ctx.canWrite()) {
-    throw new Error("Memory source is no longer eligible");
+    throw new MemorySourceIneligibleError();
   }
 }
 function assertValidKindLevel(kind, level) {
@@ -13904,7 +13910,7 @@ async function updateVaultMemoryOp(ctx, id, opts) {
       ctx.embeddedWalletSigner
     );
   } catch (err) {
-    if (err instanceof MemoryLevelError) throw err;
+    if (err instanceof MemoryLevelError || err instanceof MemorySourceIneligibleError) throw err;
     return null;
   }
 }
@@ -17878,6 +17884,13 @@ var DEFAULT_AUTO_MERGE_THRESHOLD = 0.8;
 var DEFAULT_SCOPE = "private";
 var DEFAULT_CONSOLIDATE_THRESHOLD = 0.55;
 var DEFAULT_CONSOLIDATE_TOP_K = 20;
+var RetainError = class extends Error {
+  constructor(reason, message) {
+    super(message);
+    this.reason = reason;
+    this.name = "RetainError";
+  }
+};
 async function retain(content, ctx, options = {}) {
   const embeddingOptions = {
     ...ctx.embeddingOptions,
@@ -17933,7 +17946,8 @@ async function retainWithPersistence(content, ctx, options = {}) {
     });
     prepared = withoutKindedRows(prepared);
     if (prepared.embeddingFailure || prepared.embeddingsUnavailable) {
-      throw new Error(
+      throw new RetainError(
+        "embeddings-unavailable",
         "retain: embeddings unavailable \u2014 refusing to auto-merge against an inert cosine lane, which would create a duplicate instead of merging into the existing memory. Retry when embeddings recover, or pass enableAutoMerge: false to force a create."
       );
     }
@@ -18303,7 +18317,10 @@ async function tryConsolidate(trimmed, ctx, options, prepared) {
 async function assertMergeTargetGoneOrThrow(ctx, targetId) {
   const stillExists = await (ctx.persistence.getFresh ? ctx.persistence.getFresh(targetId) : ctx.persistence.get(targetId));
   if (stillExists && (stillExists.kind === null || stillExists.kind === void 0)) {
-    throw new Error(`retain: merge into memory ${targetId} failed to persist`);
+    throw new RetainError(
+      "merge-not-persisted",
+      `retain: merge into memory ${targetId} failed to persist`
+    );
   }
 }
 
@@ -18461,6 +18478,12 @@ function restoreCandidates(candidates, redactor, ownNames) {
     (c) => c.candidate.content.length <= MAX_CONTENT_LENGTH && !c.unresolved && !isLowSignalContent(c.candidate.content, ownNames)
   ).map((c) => c.candidate);
 }
+function writeFailureReasonOf(err) {
+  if (err instanceof MemorySourceIneligibleError) return "source-ineligible";
+  if (err instanceof RetainError) return err.reason;
+  if (err?.name === "AbortError") return "aborted";
+  return "unknown";
+}
 async function extractAndRetain(messages, retainCtx, options) {
   const { memoryStore, signal } = options;
   if (memoryStore === null) throw new Error("Memory store is not ready");
@@ -18550,6 +18573,7 @@ async function extractAndRetain(messages, retainCtx, options) {
   const results = [];
   const quarantinedInfo = [];
   let failedWrites = 0;
+  let writeFailureReason;
   let auditRows;
   const tRetain = Date.now();
   for (const { candidate, isQuarantined, reason, signature } of toRetain) {
@@ -18645,6 +18669,7 @@ async function extractAndRetain(messages, retainCtx, options) {
       }
     } catch (err) {
       failedWrites++;
+      writeFailureReason ?? (writeFailureReason = writeFailureReasonOf(err));
       log.warn("[memory/extract] retain failed for one candidate", err);
       options.onCandidateFailed?.(candidate, err);
     }
@@ -18657,6 +18682,7 @@ async function extractAndRetain(messages, retainCtx, options) {
     candidates: succeededCandidates,
     results,
     failedCount: failedWrites,
+    ...writeFailureReason !== void 0 && { writeFailureReason },
     outcome: outcome2,
     quarantined: quarantinedInfo,
     funnel: {
@@ -18925,7 +18951,17 @@ function createAutoExtractor(options) {
     const t0 = Date.now();
     void (async () => {
       try {
-        const { candidates, results, failedCount, outcome: outcome2, failure, funnel, timings, model } = await extractAndRetain(window2, retainCtx, {
+        const {
+          candidates,
+          results,
+          failedCount,
+          writeFailureReason,
+          outcome: outcome2,
+          failure,
+          funnel,
+          timings,
+          model
+        } = await extractAndRetain(window2, retainCtx, {
           extract,
           memoryStore: options.memoryStore,
           signal: options.signal,
@@ -18961,6 +18997,7 @@ function createAutoExtractor(options) {
           candidates,
           results,
           failedCount,
+          ...writeFailureReason !== void 0 && { writeFailureReason },
           durationMs: Date.now() - t0,
           conversationId,
           outcome: outcome2,
@@ -21073,10 +21110,10 @@ function createLocalMemoryStore(options) {
   const assertWrite = async (writeOptions) => {
     writeOptions?.signal?.throwIfAborted();
     if (writeOptions?.canWrite && !await writeOptions.canWrite()) {
-      throw new Error("Memory source is no longer eligible");
+      throw new MemorySourceIneligibleError();
     }
     if (options.canWrite && !await options.canWrite()) {
-      throw new Error("Memory source is no longer eligible");
+      throw new MemorySourceIneligibleError();
     }
     writeOptions?.signal?.throwIfAborted();
   };
@@ -21885,7 +21922,7 @@ function createRemoteMemoryPipeline(options) {
     const assertWrite = async () => {
       signal?.throwIfAborted();
       if (writeOptions?.canWrite && !await writeOptions.canWrite())
-        throw new Error("Memory source is no longer eligible");
+        throw new MemorySourceIneligibleError();
       signal?.throwIfAborted();
     };
     const rejectUndecryptable = (failed) => {
@@ -22891,7 +22928,7 @@ function createRemoteMemoryStore(options) {
     if (!record2) return null;
     if (record2.memory.is_deleted) return null;
     if (writeOptions?.canWrite && !await writeOptions.canWrite())
-      throw new Error("Memory source is no longer eligible");
+      throw new MemorySourceIneligibleError();
     writeOptions?.signal?.throwIfAborted();
     const next = edit(structuredClone(record2.memory));
     if (!next) return null;
@@ -24519,6 +24556,26 @@ function createDurableAutoExtractor(options) {
             );
             continue;
           }
+          const foreign = new Set(
+            ids.filter((_id, index) => loaded[index]?.conversationId !== conversationId)
+          );
+          if (foreign.size) {
+            await database.write(
+              () => job.update(
+                (r) => r._setRaw(
+                  "message_ids",
+                  JSON.stringify(idsOf(job).filter((id) => !foreign.has(id)))
+                )
+              )
+            );
+            attempts.delete(job.id);
+            scheduleAfterSuccess = true;
+            reportError(
+              new Error(`Dropped ${foreign.size} source id(s) from another conversation`),
+              conversationId
+            );
+            continue;
+          }
           const locked = loaded.filter((message) => message && isEncrypted(message.content));
           if (locked.length) {
             throw new LockedSourcesError(
@@ -24528,7 +24585,7 @@ function createDurableAutoExtractor(options) {
             );
           }
           const messages = loaded.flatMap(
-            (m) => m && m.conversationId === conversationId && (m.role === "user" || m.role === "assistant") ? [{ id: m.uniqueId, role: m.role, content: m.content }] : []
+            (m) => m && (m.role === "user" || m.role === "assistant") ? [{ id: m.uniqueId, role: m.role, content: m.content }] : []
           );
           const jobScope = currentScope() === "private" ? "private" : String(job._getRaw("scope"));
           const jobFolderId = job._getRaw("folder_id") ?? null;
@@ -24621,9 +24678,31 @@ function createDurableAutoExtractor(options) {
             (candidate) => candidate._getRaw("scope") === scope && (candidate._getRaw("folder_id") ?? null) === folderId
           );
           const positions = new Map(ids.map((id, index) => [id, index]));
+          const watermarks = existing.flatMap((prior) => {
+            const watermark = prior._getRaw("watermark");
+            return typeof watermark === "string" && watermark ? [watermark] : [];
+          });
+          if (watermarks.length) {
+            const misplaced = new Set(
+              await storage.messagesCollection.query(
+                Q16.where("id", Q16.oneOf(watermarks)),
+                Q16.where("conversation_id", Q16.notEq(conversationId))
+              ).fetchIds()
+            );
+            for (const prior of existing)
+              if (misplaced.has(String(prior._getRaw("watermark"))))
+                await prior.update((r) => {
+                  r._setRaw("watermark", null);
+                  r._setRaw("watermark_seq", null);
+                });
+          }
           const rows = await storage.messagesCollection.query(Q16.where("id", Q16.oneOf(ids))).fetch();
+          const foreignRows = new Set(
+            rows.filter((row) => row._getRaw("conversation_id") !== conversationId).map((row) => row.id)
+          );
           const sequences = /* @__PURE__ */ new Map();
           for (const row of rows) {
+            if (foreignRows.has(row.id)) continue;
             const sequence = Number(row._getRaw("message_id"));
             if (Number.isFinite(sequence) && sequence > 0) sequences.set(row.id, sequence);
           }
@@ -24666,7 +24745,7 @@ function createDurableAutoExtractor(options) {
           const ownWatermark = job?._getRaw("watermark");
           const atOwnWatermark = !!job && boundary >= 0 && failedSessionsOf(job, String(ownWatermark)) < MAX_FAILED_SESSIONS && (ids[boundary] === ownWatermark || sequences.get(ids[boundary]) !== void 0 && sequences.get(ids[boundary]) === seqOf(job));
           const overlapStart = atOwnWatermark ? Math.max(0, boundary - 1) : start;
-          const fresh = ids.slice(overlapStart).filter((id) => !foreignSources.has(id));
+          const fresh = ids.slice(overlapStart).filter((id) => !foreignSources.has(id) && !foreignRows.has(id));
           if (!fresh.length) return;
           if (job) {
             await job.update(