@anuma/sdk 6.1.1 → 6.3.0

package/dist/react/index.cjs

@@ -1609,7 +1609,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) {
@@ -1670,7 +1671,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) {
@@ -2016,6 +2021,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) {
@@ -2411,7 +2417,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) {
@@ -3626,6 +3633,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);
@@ -3647,6 +3657,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;
@@ -3672,6 +3685,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);
@@ -3705,6 +3721,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({
@@ -3761,7 +3778,7 @@ async function chunkAndEmbedAllMessages(ctx, options, filter) {
   }
   return embeddedCount;
 }
-var DEFAULT_MIN_CONTENT_LENGTH;
+var DEFAULT_MIN_CONTENT_LENGTH, NON_EMBEDDABLE_ORIGIN;
 var init_embeddings = __esm({
   "src/lib/memoryEngine/embeddings.ts"() {
     "use strict";
@@ -3772,6 +3789,7 @@ var init_embeddings = __esm({
     init_generate();
     init_generate();
     DEFAULT_MIN_CONTENT_LENGTH = 10;
+    NON_EMBEDDABLE_ORIGIN = "tool_result";
   }
 });
 
@@ -4866,6 +4884,27 @@ var init_encryption2 = __esm({
   }
 });
 
+// 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;
+  }
+}
+var init_types4 = __esm({
+  "src/lib/db/memoryVault/types.ts"() {
+    "use strict";
+  }
+});
+
 // src/lib/db/memoryVault/operations.ts
 function visibilityOrPrivate(value) {
   return value === "public" ? value : "private";
@@ -4927,6 +4966,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,
@@ -5209,6 +5249,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,
@@ -5995,6 +6036,7 @@ var init_operations3 = __esm({
     init_operations2();
     init_types3();
     init_encryption2();
+    init_types4();
     NON_PRIVATE_VISIBILITIES = ["public"];
     KNOWN_TRUST_TIERS = /* @__PURE__ */ new Set(["quarantined", "trusted"]);
     TOPICS_EXTRACTION_VERSION = 3;
@@ -6322,17 +6364,17 @@ function recencyMultiplier(updatedAt, opts = {}) {
   const now = opts.now ?? /* @__PURE__ */ new Date();
   const nowMs2 = now.getTime();
   if (!Number.isFinite(nowMs2)) return noDate;
-  const ageDays2 = Math.max(0, (nowMs2 - updatedMs) / DAY_MS);
+  const ageDays2 = Math.max(0, (nowMs2 - updatedMs) / DAY_MS2);
   const perYearDecay = opts.perYearDecay ?? DEFAULT_PER_YEAR_DECAY;
   const floor = opts.floor ?? DEFAULT_FLOOR;
   const decay = perYearDecay * (ageDays2 / 365);
   return Math.max(floor, 1 - decay);
 }
-var DAY_MS, DEFAULT_PER_YEAR_DECAY, DEFAULT_FLOOR, DEFAULT_NO_DATE_MULTIPLIER;
+var DAY_MS2, DEFAULT_PER_YEAR_DECAY, DEFAULT_FLOOR, DEFAULT_NO_DATE_MULTIPLIER;
 var init_recency = __esm({
   "src/lib/memory/recency.ts"() {
     "use strict";
-    DAY_MS = 1e3 * 60 * 60 * 24;
+    DAY_MS2 = 1e3 * 60 * 60 * 24;
     DEFAULT_PER_YEAR_DECAY = 0.2;
     DEFAULT_FLOOR = 0.1;
     DEFAULT_NO_DATE_MULTIPLIER = 0.5;
@@ -7089,8 +7131,8 @@ function classifyObservationTrend(input, now = Date.now()) {
   const lastMsRaw = input.lastObservedAt;
   const lastMs = lastMsRaw !== null && lastMsRaw !== void 0 && Number.isFinite(lastMsRaw) ? Math.max(createdMs, lastMsRaw) : createdMs;
   const proofs = Math.max(1, input.proofCount ?? 1);
-  const ageDays2 = Math.max(0, (now - createdMs) / DAY_MS2);
-  const daysSinceLast = Math.max(0, (now - lastMs) / DAY_MS2);
+  const ageDays2 = Math.max(0, (now - createdMs) / DAY_MS3);
+  const daysSinceLast = Math.max(0, (now - lastMs) / DAY_MS3);
   if (daysSinceLast >= TREND_STALE_WINDOW_DAYS) return "stale";
   if (daysSinceLast >= TREND_RECENT_WINDOW_DAYS) return "weakening";
   if (ageDays2 <= TREND_RECENT_WINDOW_DAYS && proofs <= 2) return "new";
@@ -7111,11 +7153,11 @@ function summarizeObservationTrends(inputs, now = Date.now()) {
   }
   return counts;
 }
-var DAY_MS2, TREND_RECENT_WINDOW_DAYS, TREND_STALE_WINDOW_DAYS;
+var DAY_MS3, TREND_RECENT_WINDOW_DAYS, TREND_STALE_WINDOW_DAYS;
 var init_observationTrend = __esm({
   "src/lib/memory/observationTrend.ts"() {
     "use strict";
-    DAY_MS2 = 1e3 * 60 * 60 * 24;
+    DAY_MS3 = 1e3 * 60 * 60 * 24;
     TREND_RECENT_WINDOW_DAYS = 30;
     TREND_STALE_WINDOW_DAYS = 90;
   }
@@ -9563,6 +9605,7 @@ __export(index_exports, {
   hasICloudCredentials: () => hasICloudCredentials,
   hasKeyPair: () => hasKeyPair,
   hasNotionCredentials: () => hasNotionCredentials,
+  ingestPublishedPhotoMemoriesOp: () => ingestPublishedPhotoMemoriesOp,
   injectionSignatureCatalog: () => injectionSignatureCatalog,
   insertAfterId: () => insertAfterId,
   insertChild: () => insertChild,
@@ -9589,6 +9632,7 @@ __export(index_exports, {
   noopLogger: () => noopLogger,
   onKeyAvailable: () => onKeyAvailable,
   parseJsx: () => parseJsx,
+  parseMedia: () => parseMedia,
   preEmbedVaultMemories: () => preEmbedVaultMemories,
   preprocessFiles: () => preprocessFiles,
   previewToolSelection: () => previewToolSelection,
@@ -14888,6 +14932,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
 init_useEncryption();
 init_encryption_utils();
@@ -15033,6 +15114,9 @@ __decorateClass([
 __decorateClass([
   (0, import_decorators.json)("tool_call_events", (raw) => raw)
 ], Message.prototype, "toolCallEvents", 2);
+__decorateClass([
+  (0, import_decorators.text)("origin")
+], Message.prototype, "origin", 2);
 var Conversation = class extends import_watermelondb3.Model {
 };
 Conversation.table = "conversations";
@@ -16348,6 +16432,9 @@ __decorateClass([
 __decorateClass([
   (0, import_decorators3.field)("topics_updated_at")
 ], VaultMemory.prototype, "topicsUpdatedAt", 2);
+__decorateClass([
+  (0, import_decorators3.field)("media")
+], VaultMemory.prototype, "media", 2);
 __decorateClass([
   (0, import_decorators3.field)("topics_extracted_at")
 ], VaultMemory.prototype, "topicsExtractedAt", 2);
@@ -16398,6 +16485,138 @@ __decorateClass([
 // src/lib/db/memoryVault/index.ts
 init_operations3();
 
+// src/lib/memory/decay.ts
+init_logger();
+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
+init_encryption2();
+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/db/memoryVault/index.ts
+init_types4();
+
 // src/react/useChatStorage.ts
 init_logger();
 
@@ -17837,71 +18056,6 @@ function createChunkVectorCache(maxSize = DEFAULT_CHUNK_CACHE_SIZE) {
   return new LRUCache(maxSize);
 }
 
-// src/lib/memory/decay.ts
-init_logger();
-var DAY_MS3 = 24 * 60 * 60 * 1e3;
-var SHORT_TTL_MS = 30 * DAY_MS3;
-var MEDIUM_TTL_MS = 180 * DAY_MS3;
-var NEVER_TTL_MS = Number.POSITIVE_INFINITY;
-var HARD_DELETE_WINDOW_MS = 30 * DAY_MS3;
-var PAST_EVENT_GRACE_MS = 7 * DAY_MS3;
-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
 init_logger();
 init_redactor();
@@ -18004,7 +18158,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;
@@ -23664,12 +23818,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",
@@ -23678,21 +23827,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] : []
           );
@@ -24000,7 +24152,7 @@ __decorateClass([
 ], VaultFolder.prototype, "context", 2);
 
 // src/lib/db/schema.ts
-var SDK_SCHEMA_VERSION = 43;
+var SDK_SCHEMA_VERSION = 45;
 var sdkSchema = (0, import_watermelondb20.appSchema)({
   version: SDK_SCHEMA_VERSION,
   tables: [
@@ -24038,8 +24190,10 @@ var sdkSchema = (0, import_watermelondb20.appSchema)({
         // 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)
       ]
     }),
     (0, import_watermelondb20.tableSchema)({
@@ -24146,6 +24300,18 @@ var sdkSchema = (0, import_watermelondb20.appSchema)({
         // 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).
@@ -24967,6 +25133,33 @@ var sdkMigrations = (0, import_migrations2.schemaMigrations)({
           "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: [
+        (0, import_migrations2.addColumns)({
+          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: [
+        (0, import_migrations2.addColumns)({
+          table: "memory_vault",
+          columns: [{ name: "media", type: "string", isOptional: true }]
+        })
+      ]
     }
   ]
 });
@@ -33120,7 +33313,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);
@@ -34868,6 +35061,7 @@ function renderAnumaJsx(jsx3) {
   hasICloudCredentials,
   hasKeyPair,
   hasNotionCredentials,
+  ingestPublishedPhotoMemoriesOp,
   injectionSignatureCatalog,
   insertAfterId,
   insertChild,
@@ -34894,6 +35088,7 @@ function renderAnumaJsx(jsx3) {
   noopLogger,
   onKeyAvailable,
   parseJsx,
+  parseMedia,
   preEmbedVaultMemories,
   preprocessFiles,
   previewToolSelection,