@anuma/sdk 4.2.1 → 5.0.1

package/dist/server/{chunk-UQDYBQVF.mjs → chunk-FKVYUOSD.mjs}

@@ -18939,6 +18939,107 @@ async function chunkAndEmbedAllMessages(ctx, options, filter) {
   return embeddedCount;
 }
 
+// src/lib/memoryVault/decomposeQuery.ts
+var DEFAULT_MODEL = "inclusionai/ling-2.6-flash";
+var MAX_SUB_QUERIES = 5;
+var SYSTEM_PROMPT = `You classify a memory query and, if needed, decompose it into concrete sub-queries.
+
+CLASSIFICATION RULES \u2014 be strict:
+- "specific": asks for one fact OR a list of items in ONE category (one dimension).
+  Examples: a name, a date, a preference, a location, an ID, a value, "what hobbies",
+  "which conferences", "what open source projects", "what does X do for exercise".
+  Even when the answer is a list, if all items belong to one dimension, it is specific.
+- "composite": asks about a person, system, or setup MULTI-DIMENSIONALLY \u2014 a summary,
+  an overview, a profile, "tell me about X", "what is my X setup", "describe the team's
+  X". The answer must span multiple distinct fact dimensions (e.g. for a "tech stack":
+  language + database + framework + tools \u2014 four different dimensions).
+
+When in doubt, prefer "specific". Mis-classifying a single-dimension list as composite
+hurts retrieval more than the reverse.
+
+SUB-QUERY RULES (composite only, 3\u20135 questions):
+- Each sub-query targets a DIFFERENT fact dimension.
+- Use SHORT parenthetical examples \u2014 2\u20134 concrete options that anchor the
+  embedding to likely memory content. Examples must be terms a user would
+  actually have in their notes (e.g., "Postgres" not "PostgreSQL 15.2 with
+  read replicas"). No verbose qualifiers like "and versions" or "and any
+  relevant configuration details".
+- 8\u201314 words including the parenthetical. Like a human asking a follow-up.
+
+Examples:
+  "What is my dog's name?" \u2192 {"mode":"specific","subQueries":["What is my dog's name?"]}
+  "What does the user do for exercise?" \u2192 {"mode":"specific","subQueries":["What does the user do for exercise?"]}
+  "What conferences has the user attended?" \u2192 {"mode":"specific","subQueries":["What conferences has the user attended?"]}
+  "What did I do last Tuesday?" \u2192 {"mode":"specific","subQueries":["What did I do last Tuesday?"]}
+  "Tell me about the user as a person" \u2192 {"mode":"composite","subQueries":["What is the user's name?","Where does the user live?","What does the user do for work?","Any health conditions or allergies?","What are the user's hobbies (sports, music, games)?"]}
+  "What is the user's tech stack?" \u2192 {"mode":"composite","subQueries":["What programming languages does the user use (Python, Go, TypeScript)?","What database does the user use (Postgres, MySQL, Mongo)?","What framework or ORM (React, Django, Prisma)?","What infrastructure (AWS, Docker, K8s)?","What testing tools (Jest, pytest, Cypress)?"]}
+  "Describe the user's development environment" \u2192 {"mode":"composite","subQueries":["What operating system does the user use (macOS, Linux, Windows)?","What editor or IDE (VS Code, Vim, IntelliJ)?","What shell or terminal setup (zsh, bash, tmux)?","What keyboard or display setup (mechanical, vertical monitor)?","Any UI preferences (dark mode, font, vim keybindings)?"]}
+
+Output strict JSON. No prose.`;
+async function decomposeQuery(query, options) {
+  const fallback = { mode: "specific", subQueries: [query] };
+  const trimmed = query.trim();
+  if (trimmed.length === 0) return fallback;
+  let parsed;
+  try {
+    parsed = await callPortalJsonCompletion({
+      ...options.apiKey !== void 0 && { apiKey: options.apiKey },
+      ...options.getToken !== void 0 && { getToken: options.getToken },
+      ...options.baseUrl !== void 0 && { baseUrl: options.baseUrl },
+      model: options.model ?? DEFAULT_MODEL,
+      systemPrompt: SYSTEM_PROMPT,
+      // Wrap the bare query in a task framing so the model treats it as
+      // input to classify, not as a question to answer conversationally.
+      // Bare-query inputs caused Anthropic models to respond with prose
+      // like "Do you mean...?" before this wrap.
+      userMessage: `Classify the following memory query and decompose if composite. Respond with JSON only \u2014 do not answer the question, do not ask for clarification.
+
+Query: ${trimmed}`,
+      // Decompose runs ahead of recall in the tool layer — tighter than the
+      // portalLlm default (consolidate/extract can wait longer).
+      timeoutMs: 2e4,
+      // No internal retry: a failure degrades to the safe `{specific,[query]}`
+      // fallback below. The agent/tool loop is the retry surface (719/B4).
+      maxAttempts: 1,
+      tag: "memory/decompose",
+      ...options.fetchFn && { fetchFn: options.fetchFn }
+    });
+  } catch (err) {
+    getLogger().warn("memoryVault/decompose: portal call failed, falling back to specific", err);
+    return fallback;
+  }
+  if (parsed === null) return fallback;
+  return validate(parsed, trimmed) ?? fallback;
+}
+function normalizeSubQueries(raw) {
+  if (!raw || raw.length === 0) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const s of raw) {
+    if (typeof s !== "string") continue;
+    const t = s.trim();
+    if (t.length === 0) continue;
+    const key = t.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(t);
+    if (out.length >= MAX_SUB_QUERIES) break;
+  }
+  return out;
+}
+function validate(parsed, originalQuery) {
+  if (typeof parsed !== "object" || parsed === null) return null;
+  const obj = parsed;
+  const mode = obj.mode === "composite" ? "composite" : "specific";
+  if (!Array.isArray(obj.subQueries)) return null;
+  const subQueries = normalizeSubQueries(obj.subQueries);
+  if (subQueries.length === 0) return null;
+  if (mode === "specific") {
+    return { mode: "specific", subQueries: [originalQuery] };
+  }
+  return { mode, subQueries };
+}
+
 // src/lib/memory/mmr.ts
 function applyMMR(candidates, k, lambda = 0.5) {
   if (candidates.length === 0 || k <= 0) return [];
@@ -19316,91 +19417,6 @@ function scoreBM25(query, items) {
   return scoreBM25Prepared(query, prepareBM25Corpus(items));
 }
 
-// src/lib/memoryVault/decomposeQuery.ts
-var DEFAULT_MODEL = "inclusionai/ling-2.6-flash";
-var MAX_SUB_QUERIES = 5;
-var SYSTEM_PROMPT = `You classify a memory query and, if needed, decompose it into concrete sub-queries.
-
-CLASSIFICATION RULES \u2014 be strict:
-- "specific": asks for one fact OR a list of items in ONE category (one dimension).
-  Examples: a name, a date, a preference, a location, an ID, a value, "what hobbies",
-  "which conferences", "what open source projects", "what does X do for exercise".
-  Even when the answer is a list, if all items belong to one dimension, it is specific.
-- "composite": asks about a person, system, or setup MULTI-DIMENSIONALLY \u2014 a summary,
-  an overview, a profile, "tell me about X", "what is my X setup", "describe the team's
-  X". The answer must span multiple distinct fact dimensions (e.g. for a "tech stack":
-  language + database + framework + tools \u2014 four different dimensions).
-
-When in doubt, prefer "specific". Mis-classifying a single-dimension list as composite
-hurts retrieval more than the reverse.
-
-SUB-QUERY RULES (composite only, 3\u20135 questions):
-- Each sub-query targets a DIFFERENT fact dimension.
-- Use SHORT parenthetical examples \u2014 2\u20134 concrete options that anchor the
-  embedding to likely memory content. Examples must be terms a user would
-  actually have in their notes (e.g., "Postgres" not "PostgreSQL 15.2 with
-  read replicas"). No verbose qualifiers like "and versions" or "and any
-  relevant configuration details".
-- 8\u201314 words including the parenthetical. Like a human asking a follow-up.
-
-Examples:
-  "What is my dog's name?" \u2192 {"mode":"specific","subQueries":["What is my dog's name?"]}
-  "What does the user do for exercise?" \u2192 {"mode":"specific","subQueries":["What does the user do for exercise?"]}
-  "What conferences has the user attended?" \u2192 {"mode":"specific","subQueries":["What conferences has the user attended?"]}
-  "What did I do last Tuesday?" \u2192 {"mode":"specific","subQueries":["What did I do last Tuesday?"]}
-  "Tell me about the user as a person" \u2192 {"mode":"composite","subQueries":["What is the user's name?","Where does the user live?","What does the user do for work?","Any health conditions or allergies?","What are the user's hobbies (sports, music, games)?"]}
-  "What is the user's tech stack?" \u2192 {"mode":"composite","subQueries":["What programming languages does the user use (Python, Go, TypeScript)?","What database does the user use (Postgres, MySQL, Mongo)?","What framework or ORM (React, Django, Prisma)?","What infrastructure (AWS, Docker, K8s)?","What testing tools (Jest, pytest, Cypress)?"]}
-  "Describe the user's development environment" \u2192 {"mode":"composite","subQueries":["What operating system does the user use (macOS, Linux, Windows)?","What editor or IDE (VS Code, Vim, IntelliJ)?","What shell or terminal setup (zsh, bash, tmux)?","What keyboard or display setup (mechanical, vertical monitor)?","Any UI preferences (dark mode, font, vim keybindings)?"]}
-
-Output strict JSON. No prose.`;
-async function decomposeQuery(query, options) {
-  const fallback = { mode: "specific", subQueries: [query] };
-  const trimmed = query.trim();
-  if (trimmed.length === 0) return fallback;
-  let parsed;
-  try {
-    parsed = await callPortalJsonCompletion({
-      ...options.apiKey !== void 0 && { apiKey: options.apiKey },
-      ...options.getToken !== void 0 && { getToken: options.getToken },
-      ...options.baseUrl !== void 0 && { baseUrl: options.baseUrl },
-      model: options.model ?? DEFAULT_MODEL,
-      systemPrompt: SYSTEM_PROMPT,
-      // Wrap the bare query in a task framing so the model treats it as
-      // input to classify, not as a question to answer conversationally.
-      // Bare-query inputs caused Anthropic models to respond with prose
-      // like "Do you mean...?" before this wrap.
-      userMessage: `Classify the following memory query and decompose if composite. Respond with JSON only \u2014 do not answer the question, do not ask for clarification.
-
-Query: ${trimmed}`,
-      // Decompose runs on the recall hot path — tighter than the
-      // portalLlm default (consolidate/extract can wait longer).
-      timeoutMs: 2e4,
-      // No internal retry: a failure degrades to the safe `{specific,[query]}`
-      // fallback below, so retrying would only add latency on the hot path.
-      maxAttempts: 1,
-      tag: "memory/decompose",
-      ...options.fetchFn && { fetchFn: options.fetchFn }
-    });
-  } catch (err) {
-    getLogger().warn("memoryVault/decompose: portal call failed, falling back to specific", err);
-    return fallback;
-  }
-  if (parsed === null) return fallback;
-  return validate(parsed, trimmed) ?? fallback;
-}
-function validate(parsed, originalQuery) {
-  if (typeof parsed !== "object" || parsed === null) return null;
-  const obj = parsed;
-  const mode = obj.mode === "composite" ? "composite" : "specific";
-  if (!Array.isArray(obj.subQueries)) return null;
-  const subQueries = obj.subQueries.filter((s) => typeof s === "string").map((s) => s.trim()).filter((s) => s.length > 0).slice(0, MAX_SUB_QUERIES);
-  if (subQueries.length === 0) return null;
-  if (mode === "specific") {
-    return { mode: "specific", subQueries: [originalQuery] };
-  }
-  return { mode, subQueries };
-}
-
 // src/lib/memoryVault/lruCache.ts
 var DEFAULT_VAULT_CACHE_SIZE = 5e3;
 var LRUCache = class extends Map {
@@ -19434,6 +19450,7 @@ function createVaultEmbeddingCache(maxSize = DEFAULT_VAULT_CACHE_SIZE) {
 }
 
 // src/lib/memoryVault/searchTool.ts
+var warnedProgrammaticDecomposeIgnored = false;
 function normalizeEventTimeKind(kind) {
   return kind === "point" || kind === "range" || kind === "ongoing" ? kind : null;
 }
@@ -20368,52 +20385,51 @@ async function rankPreparedVaultCandidates(query, prepared, embeddingOptions, se
     ...searchOptions?.rrfK !== void 0 && { rrfK: searchOptions.rrfK },
     ...searchOptions?.factTypeWeights && { factTypeWeights: searchOptions.factTypeWeights }
   };
-  if (useFusion && !embeddingsUnavailable && searchOptions?.decompose === "llm" && searchOptions.decomposeOptions) {
-    const decomp = await decomposeQuery(query, searchOptions.decomposeOptions);
-    if (decomp.mode === "composite") {
-      let subEmbeddings;
-      try {
-        subEmbeddings = await generateEmbeddings(decomp.subQueries, embeddingOptions);
-      } catch (err) {
-        getLogger().warn(
-          "memoryVault: sub-query embedding failed \u2014 falling back to single-query ranking: " + (err instanceof Error ? err.message : String(err))
-        );
-        subEmbeddings = [];
-      }
-      const subEmbeddingsUsable = decomp.subQueries.length > 0 && subEmbeddings.length === decomp.subQueries.length && subEmbeddings.every((v) => v.length > 0 && v.length === queryEmbedding.length);
-      if (subEmbeddings.length > 0 && !subEmbeddingsUsable) {
-        getLogger().warn(
-          `memoryVault: sub-query embedding returned ${subEmbeddings.length} vectors (dims ${subEmbeddings.map((v) => v.length).join(",")}) for ${decomp.subQueries.length} sub-queries against a ${queryEmbedding.length}-dim query \u2014 falling back to single-query ranking`
-        );
-      }
-      if (subEmbeddingsUsable) {
-        const subQueries = decomp.subQueries.map((sq, i) => ({
-          query: sq,
-          embedding: subEmbeddings[i]
-        }));
-        const v2HeadStats = { hadResults: false };
-        const composite = await rankComposite(query, queryEmbedding, subQueries, embeddedItems, {
-          limit,
-          minSimilarity,
-          rerank: !!searchOptions.rerank,
-          ...searchOptions.rerankTopN !== void 0 && {
-            rerankTopN: searchOptions.rerankTopN
-          },
-          ...searchOptions.ceWeight !== void 0 && { ceWeight: searchOptions.ceWeight },
-          ...searchOptions.mmr !== void 0 && { mmr: searchOptions.mmr },
-          ...tuning,
-          ...searchOptions.entityRanking && { entityRanking: searchOptions.entityRanking },
-          ...searchOptions.temporalRanking && { temporalRanking: searchOptions.temporalRanking },
-          rerankStats,
-          v2HeadStats
-        });
-        return stampTimestamps({
-          results: composite,
-          vaultSize,
-          reranked: rerankStats.applied,
-          hadV2Head: v2HeadStats.hadResults
-        });
-      }
+  const normalizedFacets = normalizeSubQueries(searchOptions?.subQueries);
+  const facetQueries = normalizedFacets.length >= 2 ? normalizedFacets : void 0;
+  if (useFusion && !embeddingsUnavailable && facetQueries) {
+    let subEmbeddings;
+    try {
+      subEmbeddings = await generateEmbeddings(facetQueries, embeddingOptions);
+    } catch (err) {
+      getLogger().warn(
+        "memoryVault: sub-query embedding failed \u2014 falling back to single-query ranking: " + (err instanceof Error ? err.message : String(err))
+      );
+      subEmbeddings = [];
+    }
+    const subEmbeddingsUsable = facetQueries.length > 0 && subEmbeddings.length === facetQueries.length && subEmbeddings.every((v) => v.length > 0 && v.length === queryEmbedding.length);
+    if (subEmbeddings.length > 0 && !subEmbeddingsUsable) {
+      getLogger().warn(
+        `memoryVault: sub-query embedding returned ${subEmbeddings.length} vectors (dims ${subEmbeddings.map((v) => v.length).join(",")}) for ${facetQueries.length} sub-queries against a ${queryEmbedding.length}-dim query \u2014 falling back to single-query ranking`
+      );
+    }
+    if (subEmbeddingsUsable) {
+      const subQueries = facetQueries.map((sq, i) => ({
+        query: sq,
+        embedding: subEmbeddings[i]
+      }));
+      const v2HeadStats = { hadResults: false };
+      const composite = await rankComposite(query, queryEmbedding, subQueries, embeddedItems, {
+        limit,
+        minSimilarity,
+        rerank: !!searchOptions?.rerank,
+        ...searchOptions?.rerankTopN !== void 0 && {
+          rerankTopN: searchOptions.rerankTopN
+        },
+        ...searchOptions?.ceWeight !== void 0 && { ceWeight: searchOptions.ceWeight },
+        ...searchOptions?.mmr !== void 0 && { mmr: searchOptions.mmr },
+        ...tuning,
+        ...searchOptions?.entityRanking && { entityRanking: searchOptions.entityRanking },
+        ...searchOptions?.temporalRanking && { temporalRanking: searchOptions.temporalRanking },
+        rerankStats,
+        v2HeadStats
+      });
+      return stampTimestamps({
+        results: composite,
+        vaultSize,
+        reranked: rerankStats.applied,
+        hadV2Head: v2HeadStats.hadResults
+      });
     }
   }
   if (useFusion && searchOptions?.rerank) {
@@ -20473,6 +20489,12 @@ async function searchVaultMemoriesWithSize(query, vaultCtx, embeddingOptions, ca
       rankedOnCosine: false
     };
   }
+  if (searchOptions?.decompose === "llm" && normalizeSubQueries(searchOptions.subQueries).length < 2 && !warnedProgrammaticDecomposeIgnored) {
+    warnedProgrammaticDecomposeIgnored = true;
+    getLogger().warn(
+      'memoryVault: decompose:"llm" is ignored by searchVaultMemories \u2014 pass subQueries or use createMemoryVaultSearchTool / createRecallTool (719/B4)'
+    );
+  }
   const prepared = await prepareVaultCandidates(
     query,
     vaultCtx,
@@ -20578,7 +20600,8 @@ function createMemoryVaultSearchTool(vaultCtx, embeddingOptions, cache, searchOp
         return "Error: A search query is required.";
       }
       try {
-        const budget = searchOptions?.decompose === "llm" && searchOptions.decomposeOptions ? "high" : searchOptions?.rerank ? "mid" : "low";
+        const wantsDecompose = searchOptions?.decompose === "llm" && !!searchOptions.decomposeOptions;
+        const budget = wantsDecompose ? "high" : searchOptions?.rerank ? "mid" : "low";
         const folderId = searchOptions?.folderId ?? argFolderId;
         if (searchOptions?.useFusion === false) {
           const { results: legacy, embeddingsUnavailable } = await searchVaultMemoriesWithSize(
@@ -20602,7 +20625,14 @@ function createMemoryVaultSearchTool(vaultCtx, embeddingOptions, cache, searchOp
             legacy.map((r) => ({ id: r.uniqueId, content: r.content, score: r.similarity }))
           );
         }
-        const { recall: recall2 } = await import("./recall-ZHEPQNEU.mjs");
+        let subQueries;
+        if (wantsDecompose && searchOptions?.decomposeOptions) {
+          const decomp = await decomposeQuery(query, searchOptions.decomposeOptions);
+          if (decomp.mode === "composite" && decomp.subQueries.length >= 2) {
+            subQueries = decomp.subQueries;
+          }
+        }
+        const { recall: recall2 } = await import("./recall-74L75BJ3.mjs");
         let recallDegraded = [];
         const result = await recall2(
           query,
@@ -20618,9 +20648,7 @@ function createMemoryVaultSearchTool(vaultCtx, embeddingOptions, cache, searchOp
             ...tuningForward,
             ...folderId !== void 0 && { folderId },
             ...searchOptions?.scopes && { scopes: searchOptions.scopes },
-            ...searchOptions?.decompose === "llm" && searchOptions.decomposeOptions && {
-              decomposeOptions: searchOptions.decomposeOptions
-            }
+            ...subQueries && { subQueries }
           }
         );
         if (result.vaultSize === 0) {
@@ -21148,12 +21176,12 @@ var DEFAULT_CHUNK_MIN_SCORE = 0.5;
 function flagsForBudget(budget) {
   switch (budget) {
     case "high":
-      return { rerank: true, decompose: true, traverse: true };
+      return { rerank: true, traverse: true };
     case "mid":
-      return { rerank: true, decompose: false, traverse: false };
+      return { rerank: true, traverse: false };
     case "low":
     default:
-      return { rerank: false, decompose: false, traverse: false };
+      return { rerank: false, traverse: false };
   }
 }
 function dedupeBy(items, ...keys) {
@@ -21172,10 +21200,10 @@ function dedupeBy(items, ...keys) {
 async function recall(query, ctx, options = {}) {
   const types = options.types ?? ["fact"];
   const limit = options.limit ?? DEFAULT_LIMIT;
-  const requestedBudget = options.budget ?? DEFAULT_BUDGET;
-  const flags = flagsForBudget(requestedBudget);
-  const decomposeAvailable = flags.decompose && !!options.decomposeOptions;
-  const usedBudget = requestedBudget === "high" && !decomposeAvailable ? "mid" : requestedBudget;
+  const usedBudget = options.budget ?? DEFAULT_BUDGET;
+  const flags = flagsForBudget(usedBudget);
+  const normalizedFacets = normalizeSubQueries(options.subQueries);
+  const subQueries = normalizedFacets.length >= 2 ? normalizedFacets : void 0;
   const t0 = nowMs();
   let prepMs = 0;
   let factLaneMs = 0;
@@ -21196,7 +21224,9 @@ async function recall(query, ctx, options = {}) {
     if (flags.rerank && factResults.length > 0 && hadV2Head && !didRerank) {
       degraded.push("rerank-unavailable");
     }
-    if (flags.decompose && !decomposeAvailable) degraded.push("decompose-unavailable");
+    if (usedBudget === "high" && options.decomposeOptions && !subQueries && !options.graphRefine) {
+      degraded.push("decompose-moved");
+    }
     if (embeddingsUnavailable) degraded.push("embeddings-unavailable");
     const diagnostics = {
       usedBudget,
@@ -21309,10 +21339,8 @@ async function recall(query, ctx, options = {}) {
         },
         ...options.rrfK !== void 0 && { rrfK: options.rrfK },
         ...options.decryptLast !== void 0 && { decryptLast: options.decryptLast },
-        ...decomposeAvailable && {
-          decompose: "llm",
-          decomposeOptions: options.decomposeOptions
-        },
+        // 719/B4 — composite facets arrive pre-built; no LLM call here.
+        ...subQueries && { subQueries },
         ...options.scopes && { scopes: options.scopes },
         ...options.folderId !== void 0 && { folderId: options.folderId },
         ...options.factTypes?.length && { factTypes: options.factTypes },
@@ -21660,6 +21688,7 @@ export {
   EMBEDDINGS_DEGRADED_EMPTY,
   RerankerUnavailableError,
   isRerankerAvailable,
+  decomposeQuery,
   MAX_HOPS,
   ENTITY_FANOUT,
   NODE_BUDGET,