@anuma/sdk 6.21.0 → 6.22.0

package/dist/{react/recall-7Q3V337H.mjs → expo/recall-CUTJWQDQ.mjs}

@@ -1,6 +1,6 @@
 import {
   recall
-} from "./chunk-JRVAUZHM.mjs";
+} from "./chunk-6BULYLRY.mjs";
 import "./chunk-WUG6GTHO.mjs";
 import "./chunk-GYKJOWEO.mjs";
 export {

package/dist/memory/context.cjs

@@ -0,0 +1,183 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/memory/context.ts
+var context_exports = {};
+__export(context_exports, {
+  assembleMemoryContext: () => assembleMemoryContext,
+  shouldRecallMemory: () => shouldRecallMemory
+});
+module.exports = __toCommonJS(context_exports);
+function shouldRecallMemory(query) {
+  const normalized = query.trim().toLowerCase().replace(/[.!?。！？¡¿]+$/u, "").replace(/^[¡¿]+/u, "");
+  return normalized.length > 0 && !/^(hi|hi there|hello|hey|yes|no|yep|nope|sure|k|ok|okay|thanks|thank you|thank you very much|thanks a lot|cool|great|got it|sounds good|hola|buenos días|buenas|sí|si|gracias|muchas gracias|vale|bonjour|salut|oui|non|merci|merci beaucoup|d'accord|hallo|guten tag|ja|nein|danke|danke schön|alles klar|olá|obrigado|obrigada|ciao|grazie|sì|你好|谢谢|好的|こんにちは|ありがとう|안녕하세요|감사합니다)$/u.test(
+    normalized
+  );
+}
+async function assembleMemoryContext(options) {
+  const { query, recall, loadFacts, loadSessionRefs } = options;
+  const memoryIds = options.memoryIds ?? options.recallOptions?.memoryIds;
+  const ranked = shouldRecallMemory(query);
+  const degraded = [];
+  const guard = async (lane, run, fallback) => {
+    try {
+      return await run();
+    } catch (error) {
+      degraded.push(lane);
+      try {
+        options.onDegraded?.(lane, error);
+      } catch {
+      }
+      return fallback;
+    }
+  };
+  const scoped = memoryIds !== void 0 || options.recallOptions?.scopes !== void 0 || options.recallOptions?.folderId !== void 0;
+  const allowed = memoryIds !== void 0 ? new Set(memoryIds) : void 0;
+  const filters = {
+    ...options.recallOptions?.scopes && { scopes: options.recallOptions.scopes },
+    ...options.recallOptions?.folderId !== void 0 && {
+      folderId: options.recallOptions.folderId
+    }
+  };
+  const active = (m) => !m.isDeleted && !m.archivedAt && !m.supersededBy && m.trustTier !== "quarantined" && (!allowed || allowed.has(m.uniqueId));
+  const asItem = (m, lane, score = 1) => ({
+    id: m.uniqueId,
+    content: m.content,
+    score,
+    lane,
+    sourceIds: m.sourceChunkIds ?? []
+  });
+  const empty = {
+    memories: [],
+    usedBudget: options.recallOptions?.budget ?? "low",
+    reranked: false,
+    candidateCount: 0
+  };
+  const [facts, episodes, profile, session] = await Promise.all([
+    ranked ? guard(
+      "fact",
+      () => recall(query, { ...options.recallOptions, types: ["fact"], limit: 20, memoryIds }),
+      empty
+    ) : empty,
+    ranked && !scoped && options.includeEpisodes !== false ? guard(
+      "episode",
+      () => recall(query, {
+        ...options.recallOptions,
+        types: ["chunk"],
+        limit: 4,
+        minScore: 0.5,
+        onDiagnostics: void 0
+      }),
+      empty
+    ) : empty,
+    loadFacts ? guard(
+      "profile",
+      async () => {
+        const stable = await loadFacts({
+          ...filters,
+          memoryIds,
+          factTypes: ["identity", "preference", "constraint", "relationship"],
+          limit: 8
+        });
+        const dynamic = await loadFacts({
+          ...filters,
+          memoryIds,
+          factTypes: ["ongoing_context", "plan"],
+          limit: 4
+        });
+        return [...stable, ...dynamic].filter(active).map((m) => asItem(m, "profile"));
+      },
+      []
+    ) : [],
+    loadFacts && loadSessionRefs ? guard(
+      "session",
+      async () => {
+        const refs = (await loadSessionRefs()).filter((r) => !allowed || allowed.has(r.memoryId)).sort((a, b) => b.score - a.score).slice(0, 10);
+        if (!refs.length) return [];
+        const rows = await loadFacts({ ...filters, memoryIds: refs.map((r) => r.memoryId) });
+        const byId = new Map(rows.filter(active).map((m) => [m.uniqueId, m]));
+        return refs.flatMap((ref) => {
+          const m = byId.get(ref.memoryId);
+          return m ? [asItem(m, "session", ref.score)] : [];
+        });
+      },
+      []
+    ) : []
+  ]);
+  const toItems = (result, lane) => result.memories.filter((m) => !allowed || allowed.has(m.id)).map((m) => ({
+    id: m.id,
+    content: m.content,
+    score: m.score,
+    lane,
+    ...lane === "fact" && { recalled: true },
+    sourceIds: m.sourceChunkIds ?? (m.messageId ? [m.messageId] : [])
+  }));
+  const recalledFacts = toItems(facts, "fact");
+  const recalledScores = /* @__PURE__ */ new Map();
+  const recalledContentScores = /* @__PURE__ */ new Map();
+  for (const item of recalledFacts) {
+    recalledScores.set(item.id, Math.max(recalledScores.get(item.id) ?? -Infinity, item.score));
+    const content = item.content.trim();
+    recalledContentScores.set(
+      content,
+      Math.max(recalledContentScores.get(content) ?? -Infinity, item.score)
+    );
+  }
+  const rankedProfile = profile.map((item) => {
+    const score = Math.max(
+      recalledScores.get(item.id) ?? -Infinity,
+      recalledContentScores.get(item.content.trim()) ?? -Infinity
+    );
+    return score === -Infinity ? item : { ...item, score, recalled: true };
+  });
+  const lanes = [
+    [rankedProfile, 2e3],
+    [recalledFacts, 6e3],
+    [toItems(episodes, "episode"), 3e3],
+    [session, 1e3]
+  ];
+  const items = [];
+  const seenIds = /* @__PURE__ */ new Set();
+  const seenContent = /* @__PURE__ */ new Set();
+  let remaining = Math.max(0, options.maxChars ?? 12e3);
+  let truncated = false;
+  for (const [candidates, laneBudget] of lanes) {
+    let laneRemaining = Math.min(laneBudget, remaining);
+    for (const item of candidates) {
+      const content = item.content?.trim();
+      const key = `${item.lane === "episode" ? "episode" : "fact"}:${item.id}`;
+      if (!content || seenIds.has(key) || seenContent.has(content)) continue;
+      if (content.length > laneRemaining) {
+        truncated = true;
+        continue;
+      }
+      items.push({ ...item, content });
+      seenIds.add(key);
+      seenContent.add(content);
+      remaining -= content.length;
+      laneRemaining -= content.length;
+    }
+  }
+  return { items, ranked, rankedCount: recalledFacts.length, degraded, truncated };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assembleMemoryContext,
+  shouldRecallMemory
+});