@anuma/sdk 6.1.1 → 6.3.0

package/dist/react/index.mjs

@@ -68,6 +68,7 @@ import {
   encryptDataWithKey,
   encryptField,
   encryptJsonField,
+  encryptVaultMemoryContent,
   exportPublicKey,
   extractAssistantText,
   extractUserMessageFromMessages,
@@ -120,6 +121,7 @@ import {
   makeSyntheticStoredMessage,
   onClearAllEncryptionState,
   onKeyAvailable,
+  parseMedia,
   postApiV1CreditsPurchase,
   postApiV1PhoneCalls,
   postApiV1SubscriptionsCancel,
@@ -166,7 +168,7 @@ import {
   updateVaultMemoryOp,
   useEncryption,
   vaultMemoryToStored
-} from "./chunk-GIBV5GBW.mjs";
+} from "./chunk-TI3UVQPF.mjs";
 import {
   PiiRedactor,
   createStreamingDeAnonymizer,
@@ -5344,6 +5346,43 @@ async function cleanupConversationSummary(database, conversationId) {
   }
 }
 
+// src/lib/chat/toolResultMessage.ts
+var HEADER = "[Tool Execution Results]\n\n";
+var FOOTER = "\n\nBased on these results, continue with the task.";
+var ENTRY_SEPARATOR = "\n\n";
+var MAX_PERSISTED_TOOL_RESULT_CHARS = 1e5;
+function buildToolResultContent(results) {
+  const entries = results.map((r) => `Tool "${r.name}" returned: ${JSON.stringify(r.result)}`);
+  const framing = HEADER.length + FOOTER.length + ENTRY_SEPARATOR.length * Math.max(0, entries.length - 1);
+  const summary = capEntries(entries, MAX_PERSISTED_TOOL_RESULT_CHARS - framing).join(
+    ENTRY_SEPARATOR
+  );
+  return `${HEADER}${summary}${FOOTER}`;
+}
+function capEntries(entries, budget) {
+  const smallestFirst = entries.map((_, index) => index).sort((a, b) => entries[a].length - entries[b].length);
+  const capped = [...entries];
+  let remaining = budget;
+  let unassigned = entries.length;
+  for (const index of smallestFirst) {
+    capped[index] = truncateEntry(entries[index], Math.floor(remaining / unassigned));
+    remaining -= capped[index].length;
+    unassigned--;
+  }
+  return capped;
+}
+function truncateEntry(entry, allowance) {
+  if (entry.length <= allowance) return entry;
+  const keep = allowance - truncationMarker(entry.length).length;
+  if (keep <= 0) return entry.slice(0, Math.max(0, allowance));
+  return `${entry.slice(0, keep)}${truncationMarker(entry.length - keep)}`;
+}
+function truncationMarker(omitted) {
+  return `
+
+... (tool output truncated, ${omitted} characters omitted)`;
+}
+
 // src/lib/db/chat/lazyDecrypt.ts
 var LRU_CAPACITY = 256;
 var titleCache = /* @__PURE__ */ new Map();
@@ -5487,6 +5526,9 @@ __decorateClass([
 __decorateClass([
   json("tool_call_events", (raw) => raw)
 ], Message.prototype, "toolCallEvents", 2);
+__decorateClass([
+  text("origin")
+], Message.prototype, "origin", 2);
 var Conversation = class extends Model {
 };
 Conversation.table = "conversations";
@@ -6790,6 +6832,9 @@ __decorateClass([
 __decorateClass([
   field3("topics_updated_at")
 ], VaultMemory.prototype, "topicsUpdatedAt", 2);
+__decorateClass([
+  field3("media")
+], VaultMemory.prototype, "media", 2);
 __decorateClass([
   field3("topics_extracted_at")
 ], VaultMemory.prototype, "topicsExtractedAt", 2);
@@ -6837,6 +6882,133 @@ __decorateClass([
   field3("is_deleted")
 ], VaultMemory.prototype, "isDeleted", 2);
 
+// src/lib/memory/decay.ts
+var DAY_MS = 24 * 60 * 60 * 1e3;
+var SHORT_TTL_MS = 30 * DAY_MS;
+var MEDIUM_TTL_MS = 180 * DAY_MS;
+var SOURCE_PHOTO = "photo";
+var NEVER_TTL_MS = Number.POSITIVE_INFINITY;
+var HARD_DELETE_WINDOW_MS = 30 * DAY_MS;
+var PAST_EVENT_GRACE_MS = 7 * DAY_MS;
+var DEFAULT_DECAY_POLICY = {
+  ttlByType: {
+    identity: NEVER_TTL_MS,
+    preference: NEVER_TTL_MS,
+    relationship: NEVER_TTL_MS,
+    constraint: NEVER_TTL_MS,
+    plan: SHORT_TTL_MS,
+    ongoing_context: SHORT_TTL_MS,
+    other: MEDIUM_TTL_MS
+  },
+  fallbackTtlMs: MEDIUM_TTL_MS,
+  hardDeleteWindowMs: HARD_DELETE_WINDOW_MS,
+  pastEventGraceMs: PAST_EVENT_GRACE_MS
+};
+function resolvePolicy(policy) {
+  if (!policy) return DEFAULT_DECAY_POLICY;
+  return {
+    ttlByType: { ...DEFAULT_DECAY_POLICY.ttlByType, ...policy.ttlByType },
+    fallbackTtlMs: policy.fallbackTtlMs ?? DEFAULT_DECAY_POLICY.fallbackTtlMs,
+    hardDeleteWindowMs: policy.hardDeleteWindowMs ?? DEFAULT_DECAY_POLICY.hardDeleteWindowMs,
+    pastEventGraceMs: policy.pastEventGraceMs ?? DEFAULT_DECAY_POLICY.pastEventGraceMs
+  };
+}
+function ttlForType(factType, policy) {
+  const resolved = resolvePolicy(policy);
+  if (factType === null) return resolved.fallbackTtlMs;
+  return resolved.ttlByType[factType] ?? resolved.fallbackTtlMs;
+}
+function isTimeSensitiveType(factType) {
+  return factType === "plan" || factType === "ongoing_context";
+}
+function hasFiniteTimestamps(m, now) {
+  return Number.isFinite(now) && Number.isFinite(m.updatedAt) && (m.archivedAt === null || Number.isFinite(m.archivedAt));
+}
+function classifyDecay(m, now, policy) {
+  const resolved = resolvePolicy(policy);
+  if (!hasFiniteTimestamps(m, now)) {
+    getLogger().warn("[memory/decay] non-finite timestamp on a memory row; keeping it", {
+      now,
+      updatedAt: m.updatedAt,
+      archivedAt: m.archivedAt,
+      factType: m.factType
+    });
+    return "keep";
+  }
+  if (m.archivedAt !== null) {
+    return now - m.archivedAt > resolved.hardDeleteWindowMs ? "delete" : "keep";
+  }
+  if (m.source === "manual" || m.source === SOURCE_PHOTO) return "keep";
+  if (isTimeSensitiveType(m.factType) && m.eventTimeEnd !== null) {
+    if (m.eventTimeEnd < now - resolved.pastEventGraceMs) return "archive";
+    if (m.eventTimeEnd >= now) return "keep";
+  }
+  if (now - m.updatedAt > ttlForType(m.factType, resolved)) return "archive";
+  return "keep";
+}
+
+// src/lib/db/memoryVault/photoIngest.ts
+var PHOTO_MEMORY_ID_PREFIX = "photo:";
+async function ingestPublishedPhotoMemoriesOp(ctx, rows) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    if (typeof r.memoryId !== "string" || !r.memoryId.startsWith(PHOTO_MEMORY_ID_PREFIX)) continue;
+    if (!byId.has(r.memoryId)) byId.set(r.memoryId, r);
+  }
+  const photoRows = [...byId.values()];
+  if (photoRows.length === 0) return { inserted: 0, skipped: 0 };
+  const known = await ctx.vaultMemoryCollection.query().fetchIds().then((ids) => new Set(ids));
+  const candidates = photoRows.filter((r) => !known.has(r.memoryId));
+  if (candidates.length === 0) return { inserted: 0, skipped: photoRows.length };
+  const fresh = candidates;
+  const contents = await Promise.all(
+    fresh.map(async (r) => {
+      if (ctx.walletAddress && ctx.signMessage) {
+        return encryptVaultMemoryContent(
+          r.text,
+          ctx.walletAddress,
+          ctx.signMessage,
+          ctx.embeddedWalletSigner
+        );
+      }
+      return r.text;
+    })
+  );
+  const now = Date.now();
+  let inserted = 0;
+  await ctx.database.write(async () => {
+    const present = new Set(await ctx.vaultMemoryCollection.query().fetchIds());
+    const writable = fresh.map((row, i) => ({ row, content: contents[i] })).filter(({ row }) => !present.has(row.memoryId));
+    inserted = writable.length;
+    if (writable.length === 0) return;
+    const prepared = writable.map(
+      ({ row, content }) => ctx.vaultMemoryCollection.prepareCreate((record) => {
+        record._raw.id = row.memoryId;
+        record._setRaw("content", content);
+        record._setRaw("scope", "private");
+        record._setRaw("folder_id", null);
+        record._setRaw("user_id", ctx.userId ?? null);
+        record._setRaw("is_deleted", false);
+        record._setRaw("proof_count", 1);
+        record._setRaw("source", SOURCE_PHOTO);
+        record._setRaw(
+          "media",
+          row.media && row.media.length > 0 ? JSON.stringify(row.media) : null
+        );
+        record._setRaw("visibility", "public");
+        record._setRaw("published_at", now);
+        if (row.eventTime) {
+          record._setRaw("event_time_start", row.eventTime.start ?? null);
+          record._setRaw("event_time_end", row.eventTime.end ?? null);
+          record._setRaw("event_time_kind", row.eventTime.kind ?? null);
+        }
+      })
+    );
+    await ctx.database.batch(...prepared);
+  });
+  return { inserted, skipped: photoRows.length - inserted };
+}
+
 // src/lib/memory/autoExtract.ts
 import { Q as Q4 } from "@nozbe/watermelondb";
 
@@ -8253,70 +8425,6 @@ function createChunkVectorCache(maxSize = DEFAULT_CHUNK_CACHE_SIZE) {
   return new LRUCache(maxSize);
 }
 
-// src/lib/memory/decay.ts
-var DAY_MS = 24 * 60 * 60 * 1e3;
-var SHORT_TTL_MS = 30 * DAY_MS;
-var MEDIUM_TTL_MS = 180 * DAY_MS;
-var NEVER_TTL_MS = Number.POSITIVE_INFINITY;
-var HARD_DELETE_WINDOW_MS = 30 * DAY_MS;
-var PAST_EVENT_GRACE_MS = 7 * DAY_MS;
-var DEFAULT_DECAY_POLICY = {
-  ttlByType: {
-    identity: NEVER_TTL_MS,
-    preference: NEVER_TTL_MS,
-    relationship: NEVER_TTL_MS,
-    constraint: NEVER_TTL_MS,
-    plan: SHORT_TTL_MS,
-    ongoing_context: SHORT_TTL_MS,
-    other: MEDIUM_TTL_MS
-  },
-  fallbackTtlMs: MEDIUM_TTL_MS,
-  hardDeleteWindowMs: HARD_DELETE_WINDOW_MS,
-  pastEventGraceMs: PAST_EVENT_GRACE_MS
-};
-function resolvePolicy(policy) {
-  if (!policy) return DEFAULT_DECAY_POLICY;
-  return {
-    ttlByType: { ...DEFAULT_DECAY_POLICY.ttlByType, ...policy.ttlByType },
-    fallbackTtlMs: policy.fallbackTtlMs ?? DEFAULT_DECAY_POLICY.fallbackTtlMs,
-    hardDeleteWindowMs: policy.hardDeleteWindowMs ?? DEFAULT_DECAY_POLICY.hardDeleteWindowMs,
-    pastEventGraceMs: policy.pastEventGraceMs ?? DEFAULT_DECAY_POLICY.pastEventGraceMs
-  };
-}
-function ttlForType(factType, policy) {
-  const resolved = resolvePolicy(policy);
-  if (factType === null) return resolved.fallbackTtlMs;
-  return resolved.ttlByType[factType] ?? resolved.fallbackTtlMs;
-}
-function isTimeSensitiveType(factType) {
-  return factType === "plan" || factType === "ongoing_context";
-}
-function hasFiniteTimestamps(m, now) {
-  return Number.isFinite(now) && Number.isFinite(m.updatedAt) && (m.archivedAt === null || Number.isFinite(m.archivedAt));
-}
-function classifyDecay(m, now, policy) {
-  const resolved = resolvePolicy(policy);
-  if (!hasFiniteTimestamps(m, now)) {
-    getLogger().warn("[memory/decay] non-finite timestamp on a memory row; keeping it", {
-      now,
-      updatedAt: m.updatedAt,
-      archivedAt: m.archivedAt,
-      factType: m.factType
-    });
-    return "keep";
-  }
-  if (m.archivedAt !== null) {
-    return now - m.archivedAt > resolved.hardDeleteWindowMs ? "delete" : "keep";
-  }
-  if (m.source === "manual") return "keep";
-  if (isTimeSensitiveType(m.factType) && m.eventTimeEnd !== null) {
-    if (m.eventTimeEnd < now - resolved.pastEventGraceMs) return "archive";
-    if (m.eventTimeEnd >= now) return "keep";
-  }
-  if (now - m.updatedAt > ttlForType(m.factType, resolved)) return "archive";
-  return "keep";
-}
-
 // src/lib/memory/decayClassifier.ts
 var DEFAULT_MODEL2 = "inclusionai/ling-2.6-flash";
 var DEFAULT_ATTEMPTS2 = 2;
@@ -8414,7 +8522,7 @@ function toDecayInput(c) {
   };
 }
 function isBorderline(input) {
-  if (input.source === "manual") return false;
+  if (input.source === "manual" || input.source === SOURCE_PHOTO) return false;
   if (input.trustTier === "quarantined") return false;
   if (input.archivedAt !== null) return false;
   if (input.factType === null || input.factType === "other") return true;
@@ -13998,12 +14106,7 @@ function useChatStorage(options) {
       }
       const autoToolResults = result.autoExecutedToolResults;
       if (autoToolResults && autoToolResults.length > 0) {
-        const toolSummary = autoToolResults.map((r) => `Tool "${r.name}" returned: ${JSON.stringify(r.result)}`).join("\n\n");
-        const toolResultContent = `[Tool Execution Results]
-
-${toolSummary}
-
-Based on these results, continue with the task.`;
+        const toolResultContent = buildToolResultContent(autoToolResults);
         try {
           await writeOrQueue(
             "createMessage",
@@ -14012,21 +14115,24 @@ Based on these results, continue with the task.`;
               role: "user",
               content: toolResultContent,
               model: "",
-              parentMessageId: storedAssistantMessage.uniqueId
+              parentMessageId: storedAssistantMessage.uniqueId,
+              origin: "tool_result"
             },
             () => createMessageOp(storageCtx, {
               conversationId: convId,
               role: "user",
               content: toolResultContent,
               model: "",
-              parentMessageId: storedAssistantMessage.uniqueId
+              parentMessageId: storedAssistantMessage.uniqueId,
+              origin: "tool_result"
             }),
             () => makeSyntheticStoredMessage({
               conversationId: convId,
               role: "user",
               content: toolResultContent,
               model: "",
-              parentMessageId: storedAssistantMessage.uniqueId
+              parentMessageId: storedAssistantMessage.uniqueId,
+              origin: "tool_result"
             }),
             assistantMsgQueueId ? [assistantMsgQueueId] : []
           );
@@ -14339,7 +14445,7 @@ __decorateClass([
 ], VaultFolder.prototype, "context", 2);
 
 // src/lib/db/schema.ts
-var SDK_SCHEMA_VERSION = 43;
+var SDK_SCHEMA_VERSION = 45;
 var sdkSchema = appSchema2({
   version: SDK_SCHEMA_VERSION,
   tables: [
@@ -14377,8 +14483,10 @@ var sdkSchema = appSchema2({
         // Parent message for branching
         { name: "feedback", type: "string", isOptional: true },
         // 'like' | 'dislike' | null
-        { name: "tool_call_events", type: "string", isOptional: true }
+        { name: "tool_call_events", type: "string", isOptional: true },
         // JSON stringified LlmapiToolCallEvent[]
+        { name: "origin", type: "string", isOptional: true }
+        // MessageOrigin — provenance, NOT encrypted (see v44)
       ]
     }),
     tableSchema2({
@@ -14485,6 +14593,18 @@ var sdkSchema = appSchema2({
         // paths key on `updated_at` — so without this a topic-only change would
         // neither upload nor merge. Null = `topics` never written.
         { name: "topics_updated_at", type: "number", isOptional: true },
+        // The photo(s) a SERVER-EXTRACTED memory was read out of, as a JSON
+        // array of `{feed_item_id, object_key}` — exactly what
+        // GET /api/memories/published returns in `media[]`. Enough to render the
+        // source image without a second round-trip per memory.
+        //
+        // A JSON column rather than a join table: nothing on the client ever
+        // queries BY photo (the only direction is memory -> render its image),
+        // so a table would add a sync lane and a local-id space to serve a
+        // question nobody asks. `topics` and `source_chunk_ids` set the
+        // precedent for a list that is only ever read back whole. Null on
+        // anything not extracted from a photo.
+        { name: "media", type: "string", isOptional: true },
         // Unix ms of the last LLM topic-extraction pass over this memory's
         // content. Null = never extracted standalone (legacy rows with entity
         // links are grandfathered — see getMemoriesNeedingTopicExtractionOp).
@@ -15306,6 +15426,33 @@ var sdkMigrations = schemaMigrations2({
           "CREATE INDEX IF NOT EXISTS conversations_is_deleted_created_at ON conversations (is_deleted, created_at);"
         )
       ]
+    },
+    // v43 -> v44: Added origin column to history — the provenance tag the embedding
+    // sweep reads to skip never-rendered tool-result rows. No backfill: NULL means
+    // "legacy, provenance unknown" and keeps the pre-v44 behaviour of embedding the
+    // row, so the only rows that stop being embedded are ones a v44+ producer tagged.
+    {
+      toVersion: 44,
+      steps: [
+        addColumns2({
+          table: "history",
+          columns: [{ name: "origin", type: "string", isOptional: true }]
+        })
+      ]
+    },
+    // v44 -> v45: `media` on memory_vault — the photo(s) a server-extracted
+    // memory was read out of, as JSON `[{feed_item_id, object_key}]`, mirroring
+    // the `media[]` that GET /api/memories/published already returns. Existing
+    // rows keep NULL, which is the correct value for every memory that did not
+    // come from a photo (i.e. all of them until photo ingest runs).
+    {
+      toVersion: 45,
+      steps: [
+        addColumns2({
+          table: "memory_vault",
+          columns: [{ name: "media", type: "string", isOptional: true }]
+        })
+      ]
     }
   ]
 });
@@ -23435,7 +23582,7 @@ IMPORTANT: For write operations (POST, PUT, PATCH, DELETE), always confirm with
         }
         try {
           const data = JSON.parse(text12);
-          const json4 = JSON.stringify(data, null, 2);
+          const json4 = JSON.stringify(data);
           return truncate(json4, MAX_RESPONSE_SIZE);
         } catch {
           return truncate(text12, MAX_RESPONSE_SIZE);
@@ -25182,6 +25329,7 @@ export {
   hasICloudCredentials,
   hasKeyPair,
   hasNotionCredentials,
+  ingestPublishedPhotoMemoriesOp,
   injectionSignatureCatalog,
   insertAfterId,
   insertChild,
@@ -25208,6 +25356,7 @@ export {
   noopLogger,
   onKeyAvailable,
   parseJsx,
+  parseMedia,
   preEmbedVaultMemories,
   preprocessFiles,
   previewToolSelection,

package/dist/react/{recall-KOKU2PPN.mjs → recall-PCM7H5TA.mjs}

@@ -1,6 +1,6 @@
 import {
   recall
-} from "./chunk-GIBV5GBW.mjs";
+} from "./chunk-TI3UVQPF.mjs";
 import "./chunk-ILAWDQDE.mjs";
 import "./chunk-GYKJOWEO.mjs";
 export {

package/dist/server/{chunk-FYT5MBVO.mjs → chunk-S5WEN7TE.mjs}

@@ -15469,7 +15469,8 @@ function messageToStoredRaw(message, projection) {
     thinking: message.thinking,
     parentMessageId: message.parentMessageId,
     feedback: message.feedback || null,
-    toolCallEvents: parseJsonField(toolCallEventsRaw)
+    toolCallEvents: parseJsonField(toolCallEventsRaw),
+    origin: message.origin
   };
 }
 async function messageToStored(message, walletAddress, signMessage, embeddedWalletSigner, projection) {
@@ -15530,7 +15531,11 @@ function messageRawToStoredRaw(raw, projection) {
     thinking: raw.thinking,
     parentMessageId: raw.parent_message_id,
     feedback: raw.feedback || null,
-    toolCallEvents: parseJsonField(raw.tool_call_events)
+    toolCallEvents: parseJsonField(raw.tool_call_events),
+    // Load-bearing on this path specifically: getMessagesOp reads raws, and it is
+    // what the deferred embedding sweep iterates, so the provenance gate depends
+    // on `origin` surviving the raw mapper as well as the Model one.
+    origin: raw.origin
   };
 }
 async function messageRawToStored(raw, walletAddress, signMessage, embeddedWalletSigner, projection) {
@@ -15793,6 +15798,7 @@ function applyMessageFields(msg, encryptedOpts) {
     const tceValue = typeof encryptedOpts.toolCallEvents === "string" ? encryptedOpts.toolCallEvents : JSON.stringify(encryptedOpts.toolCallEvents);
     msg._setRaw("tool_call_events", tceValue);
   }
+  if (encryptedOpts.origin) msg._setRaw("origin", encryptedOpts.origin);
 }
 async function createMessageOp(ctx, opts) {
   if (opts.uniqueId) {
@@ -16211,7 +16217,8 @@ function makeSyntheticStoredMessage(opts) {
     thoughtProcess: opts.thoughtProcess,
     thinking: opts.thinking,
     parentMessageId: opts.parentMessageId,
-    toolCallEvents: opts.toolCallEvents
+    toolCallEvents: opts.toolCallEvents,
+    origin: opts.origin
   };
 }
 function makeSyntheticStoredConversation(opts, defaultTitle) {
@@ -16605,6 +16612,22 @@ async function decryptVaultMemoryFields(memory, address, signMessage, embeddedWa
   };
 }
 
+// src/lib/db/memoryVault/types.ts
+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";
@@ -16668,6 +16691,7 @@ function vaultMemoryToStoredRaw(memory) {
     sourceChunkIds,
     proofCount: memory.proofCount ?? null,
     source: memory.source ?? null,
+    media: parseMedia(memory.media),
     eventTimeStart: memory.eventTimeStart ?? null,
     eventTimeEnd: memory.eventTimeEnd ?? null,
     eventTimeKind: memory.eventTimeKind ?? null,
@@ -16950,6 +16974,7 @@ function vaultMemoryRawToStoredRaw(raw) {
     eventTimeKind: raw.event_time_kind ?? null,
     // SQLite stores booleans as 0/1, LokiJS as true/false — coerce both.
     topicsUserManaged: raw.topics_user_managed === true || raw.topics_user_managed === 1,
+    media: parseMedia(raw.media),
     topics: parseTopics(raw.topics),
     topicsUpdatedAt: raw.topics_updated_at ?? null,
     topicsExtractedAt: raw.topics_extracted_at ?? null,
@@ -18795,6 +18820,7 @@ async function generateEmbeddings(texts, options) {
 
 // src/lib/memoryEngine/embeddings.ts
 var DEFAULT_MIN_CONTENT_LENGTH = 10;
+var NON_EMBEDDABLE_ORIGIN = "tool_result";
 async function embedMessage(ctx, messageId, options) {
   const message = await getMessageOp(ctx, messageId);
   if (!message) {
@@ -18803,6 +18829,9 @@ async function embedMessage(ctx, messageId, options) {
   if (message.vector && message.vector.length > 0) {
     return message;
   }
+  if (message.origin === NON_EMBEDDABLE_ORIGIN) {
+    return message;
+  }
   const embedding = await generateEmbedding(message.content, options);
   const embeddingModel = options.model ?? DEFAULT_API_EMBEDDING_MODEL;
   return updateMessageEmbeddingOp(ctx, messageId, embedding, embeddingModel);
@@ -18824,6 +18853,9 @@ async function embedAllMessages(ctx, options, filter) {
       if (message.role === "system") {
         continue;
       }
+      if (message.origin === NON_EMBEDDABLE_ORIGIN) {
+        continue;
+      }
       const minLength = filter?.minContentLength ?? DEFAULT_MIN_CONTENT_LENGTH;
       if (message.content.length < minLength) {
         continue;
@@ -18849,6 +18881,9 @@ async function chunkAndEmbedMessage(ctx, messageId, options) {
   if (message.chunks && message.chunks.length > 0) {
     return message;
   }
+  if (message.origin === NON_EMBEDDABLE_ORIGIN) {
+    return message;
+  }
   const embeddingModel = options.model ?? DEFAULT_API_EMBEDDING_MODEL;
   if (!shouldChunkMessage(message.content, chunkSize)) {
     const embedding = await generateEmbedding(message.content, options);
@@ -18882,6 +18917,7 @@ async function chunkAndEmbedAllMessages(ctx, options, filter) {
       if (hasVector && !filter?.rechunkExisting && !isStale) continue;
       if (filter?.roles && !filter.roles.includes(message.role)) continue;
       if (message.role === "system") continue;
+      if (message.origin === NON_EMBEDDABLE_ORIGIN) continue;
       if (message.content.length < minLength) continue;
       if (shouldChunkMessage(message.content, chunkSize)) {
         longMessages.push({
@@ -20673,7 +20709,7 @@ function createMemoryVaultSearchTool(vaultCtx, embeddingOptions, cache, searchOp
             subQueries = decomp.subQueries;
           }
         }
-        const { recall: recall2 } = await import("./recall-P2HA3MUA.mjs");
+        const { recall: recall2 } = await import("./recall-BQSCJBGI.mjs");
         let recallDegraded = [];
         const result = await recall2(
           query,
@@ -21692,6 +21728,8 @@ export {
   ENTITY_KINDS,
   linkMemoryEntitiesOp,
   replaceMemoryEntitiesGuardedOp,
+  encryptVaultMemoryContent,
+  parseMedia,
   vaultMemoryToStored,
   createVaultMemoryOp,
   createSupersedingMemoryOp,