@anuma/sdk 3.11.1 → 3.11.3

package/dist/server/index.cjs

@@ -19399,6 +19399,17 @@ var init_mmr = __esm({
   }
 });
 
+// src/lib/memory/recallConstants.ts
+var RECALL_TOOL_NAME, RECALL_MAX_LIMIT, EMBEDDINGS_DEGRADED_EMPTY;
+var init_recallConstants = __esm({
+  "src/lib/memory/recallConstants.ts"() {
+    "use strict";
+    RECALL_TOOL_NAME = "recall_memory";
+    RECALL_MAX_LIMIT = 50;
+    EMBEDDINGS_DEGRADED_EMPTY = "Semantic memory search is temporarily unavailable, so only keyword matching ran and it found no matches. Do not conclude the user has no such memory \u2014 say the memory lookup was degraded, or retry with different keywords.";
+  }
+});
+
 // src/lib/memory/recency.ts
 function recencyMultiplier(updatedAt, opts = {}) {
   const noDate = opts.noDateMultiplier ?? DEFAULT_NO_DATE_MULTIPLIER;
@@ -20717,6 +20728,9 @@ async function recall(query, ctx, options = {}) {
   let vaultSize;
   let didRerank = false;
   let hadV2Head = false;
+  let embeddingsUnavailable = false;
+  let chunkEmbedFailed = false;
+  let factLaneRankedOnCosine = false;
   const emitDiagnostics = (candidateCount) => {
     const cb = options.onDiagnostics;
     if (!cb) return;
@@ -20725,6 +20739,7 @@ async function recall(query, ctx, options = {}) {
       degraded.push("rerank-unavailable");
     }
     if (flags.decompose && !decomposeAvailable) degraded.push("decompose-unavailable");
+    if (embeddingsUnavailable) degraded.push("embeddings-unavailable");
     const diagnostics = {
       usedBudget,
       reranked: didRerank,
@@ -20755,7 +20770,26 @@ async function recall(query, ctx, options = {}) {
   const graphRefiner = flags.traverse && options.graphRefine && options.decomposeOptions ? createLlmNeighborRefiner(options.decomposeOptions) : void 0;
   const prepStart = nowMs();
   const [queryEmbedding, entityRanking, temporalRanking] = await Promise.all([
-    needsChunkEmbedding ? generateEmbedding(query, ctx.embeddingOptions) : Promise.resolve(void 0),
+    // The chunk lane is cosine-only — `searchChunksOp` needs a real vector, and
+    // there is no lexical fallback for it — so an embeddings outage must SKIP the
+    // lane, not reject this shared Promise.all and take the primary fact lane
+    // (which BM25 can still serve) down with it. Mirrors safeLane's posture.
+    needsChunkEmbedding ? generateEmbedding(query, ctx.embeddingOptions).then((vec) => {
+      if (vec.length === 0) {
+        getLogger().warn(
+          "[memory/recall] chunk-lane query embedding came back empty; skipping the chunk lane"
+        );
+        chunkEmbedFailed = true;
+        return void 0;
+      }
+      return vec;
+    }).catch((err) => {
+      getLogger().warn(
+        `[memory/recall] chunk-lane query embedding failed; skipping the chunk lane: ${err instanceof Error ? err.message : String(err)}`
+      );
+      chunkEmbedFailed = true;
+      return void 0;
+    }) : Promise.resolve(void 0),
     // The graph + temporal lanes are AUXILIARY (RRF side-signals). A transient
     // WatermelonDB throw in either must NOT reject this Promise.all and take
     // PRIMARY cosine/BM25 recall down with it — degrade the failing lane to an
@@ -20780,7 +20814,9 @@ async function recall(query, ctx, options = {}) {
       results,
       vaultSize: size,
       reranked,
-      hadV2Head: v2Head
+      hadV2Head: v2Head,
+      embeddingsUnavailable: factEmbeddingsUnavailable,
+      rankedOnCosine: factRankedOnCosine
     } = await searchVaultMemoriesWithSize(
       query,
       ctx.vaultCtx,
@@ -20837,8 +20873,11 @@ async function recall(query, ctx, options = {}) {
     vaultSize = size;
     didRerank = reranked;
     hadV2Head = v2Head;
+    if (factEmbeddingsUnavailable) embeddingsUnavailable = true;
+    factLaneRankedOnCosine = factRankedOnCosine;
     factLaneMs = nowMs() - factStart;
   }
+  if (chunkEmbedFailed && !factLaneRankedOnCosine) embeddingsUnavailable = true;
   if (types.includes("chunk") && ctx.storageCtx && queryEmbedding) {
     const chunkStart = nowMs();
     const chunkMinScore = options.minScore ?? DEFAULT_CHUNK_MIN_SCORE;
@@ -21601,6 +21640,24 @@ async function eagerEmbedContent(content, embeddingOptions, cache, vaultCtx, mem
     );
   }
 }
+async function embedQueryOrDegrade(query, embeddingOptions, onDegraded) {
+  try {
+    const embedding = await generateEmbedding(query, embeddingOptions);
+    if (embedding.length === 0) {
+      getLogger().warn(
+        "memoryVault: query embedding came back empty \u2014 falling back to BM25-only ranking for this search"
+      );
+      onDegraded?.();
+    }
+    return embedding;
+  } catch (err) {
+    getLogger().warn(
+      "memoryVault: query embedding failed \u2014 falling back to BM25-only ranking for this search: " + (err instanceof Error ? err.message : String(err))
+    );
+    onDegraded?.();
+    return [];
+  }
+}
 function admitVaultProjections(queryEmbedding, vectored, k) {
   return vectored.map((it) => ({ it, score: cosineSimilarity(queryEmbedding, it.embedding) })).sort((a, b) => b.score - a.score || b.it.updatedAt.getTime() - a.it.updatedAt.getTime()).slice(0, k).map((s) => s.it.uniqueId);
 }
@@ -21612,23 +21669,36 @@ async function buildProjectedCorpus(query, vaultCtx, embeddingOptions, cache, qu
   const hydrateOpts = queryOpts.includeArchived ? { includeArchived: true } : void 0;
   const vaultSize = keys.length;
   if (keys.length === 0) {
-    return { memories: [], embeddedItems: [], queryEmbedding: [], vaultSize: 0 };
+    return {
+      memories: [],
+      embeddedItems: [],
+      queryEmbedding: [],
+      vaultSize: 0,
+      laneEmbedFailed: false
+    };
   }
-  const queryEmbedding = await generateEmbedding(query, embeddingOptions);
+  const queryEmbedding = await embedQueryOrDegrade(
+    query,
+    embeddingOptions,
+    opts.onEmbeddingDegraded
+  );
+  const embeddingsDegraded = queryEmbedding.length === 0;
   const currentModel = embeddingOptions.model ?? DEFAULT_API_EMBEDDING_MODEL;
   const vectored = [];
   const missIds = [];
   const noVectorIds = [];
   const keyById = new Map(keys.map((k2) => [k2.uniqueId, k2]));
-  for (const k2 of keys) {
-    const cached = cache.get(k2.uniqueId);
-    if (cached && cached.length === queryEmbedding.length) {
-      vectored.push({ uniqueId: k2.uniqueId, embedding: cached, updatedAt: k2.updatedAt });
-      continue;
+  if (!embeddingsDegraded) {
+    for (const k2 of keys) {
+      const cached = cache.get(k2.uniqueId);
+      if (cached && cached.length === queryEmbedding.length) {
+        vectored.push({ uniqueId: k2.uniqueId, embedding: cached, updatedAt: k2.updatedAt });
+        continue;
+      }
+      const modelCompatible = (k2.embeddingModel ?? currentModel) === currentModel;
+      if (modelCompatible) missIds.push(k2.uniqueId);
+      else noVectorIds.push(k2.uniqueId);
     }
-    const modelCompatible = (k2.embeddingModel ?? currentModel) === currentModel;
-    if (modelCompatible) missIds.push(k2.uniqueId);
-    else noVectorIds.push(k2.uniqueId);
   }
   if (missIds.length > 0) {
     const rows = await getVaultEmbeddingsByIdsOp(vaultCtx, missIds, hydrateOpts);
@@ -21649,6 +21719,7 @@ async function buildProjectedCorpus(query, vaultCtx, embeddingOptions, cache, qu
     }
     for (const id of missIds) if (!gotVector.has(id)) noVectorIds.push(id);
   }
+  let laneEmbedFailed = false;
   if (noVectorIds.length > 0) {
     const laneIds = noVectorIds.slice(0, opts.unembeddedCap);
     if (noVectorIds.length > laneIds.length) {
@@ -21660,26 +21731,44 @@ async function buildProjectedCorpus(query, vaultCtx, embeddingOptions, cache, qu
       (m) => !isEncrypted(m.content)
     );
     if (laneRows.length > 0) {
-      const laneVecs = await generateEmbeddings(
-        laneRows.map((m) => m.content),
-        embeddingOptions
-      );
-      laneRows.forEach((m, i) => {
-        const vec = Float32Array.from(laneVecs[i]);
-        cache.set(m.uniqueId, vec);
-        vectored.push({ uniqueId: m.uniqueId, embedding: vec, updatedAt: m.updatedAt });
-        updateVaultMemoryEmbeddingOp(
-          vaultCtx,
-          m.uniqueId,
-          JSON.stringify(laneVecs[i]),
-          currentModel
-        ).catch(() => {
+      let laneVecs;
+      try {
+        laneVecs = await generateEmbeddings(
+          laneRows.map((m) => m.content),
+          embeddingOptions
+        );
+      } catch (err) {
+        laneEmbedFailed = true;
+        getLogger().warn(
+          `memoryVault: un-embedded lane embedding failed for ${laneRows.length} rows \u2014 they rank on BM25 alone for this search: ` + (err instanceof Error ? err.message : String(err))
+        );
+      }
+      if (laneVecs) {
+        const vecs = laneVecs;
+        laneRows.forEach((m, i) => {
+          const vec = Float32Array.from(vecs[i]);
+          cache.set(m.uniqueId, vec);
+          vectored.push({ uniqueId: m.uniqueId, embedding: vec, updatedAt: m.updatedAt });
+          updateVaultMemoryEmbeddingOp(
+            vaultCtx,
+            m.uniqueId,
+            JSON.stringify(vecs[i]),
+            currentModel
+          ).catch(() => {
+          });
         });
-      });
+      }
     }
   }
   const k = Math.max(opts.limit * opts.admitFactor, opts.admitFloor);
   const admittedIds = admitVaultProjections(queryEmbedding, vectored, k);
+  if ((embeddingsDegraded || laneEmbedFailed) && admittedIds.length < k) {
+    const already = new Set(admittedIds);
+    for (const key of [...keys].sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime())) {
+      if (admittedIds.length >= k) break;
+      if (!already.has(key.uniqueId)) admittedIds.push(key.uniqueId);
+    }
+  }
   const admissionSet = new Set(admittedIds);
   if (opts.forceIncludeIds) {
     for (const id of opts.forceIncludeIds) {
@@ -21707,11 +21796,18 @@ async function buildProjectedCorpus(query, vaultCtx, embeddingOptions, cache, qu
     eventTimeKind: normalizeEventTimeKind(m.eventTimeKind),
     factType: m.factType
   }));
-  return { memories, embeddedItems, queryEmbedding, vaultSize };
+  return { memories, embeddedItems, queryEmbedding, vaultSize, laneEmbedFailed };
 }
 async function prepareVaultCandidates(query, vaultCtx, embeddingOptions, cache, searchOptions) {
   if (!query || typeof query !== "string") {
-    return { memories: [], embeddedItems: [], queryEmbedding: [], vaultSize: 0 };
+    return {
+      memories: [],
+      embeddedItems: [],
+      queryEmbedding: [],
+      vaultSize: 0,
+      embeddingsUnavailable: false,
+      embeddingFailure: false
+    };
   }
   const limit = searchOptions?.limit ?? 5;
   const scopes = searchOptions?.scopes;
@@ -21728,6 +21824,12 @@ async function prepareVaultCandidates(query, vaultCtx, embeddingOptions, cache,
   let embeddedItems;
   let queryEmbedding;
   let vaultSize;
+  let embeddingsUnavailable = false;
+  let embeddingFailure = false;
+  const onEmbeddingDegraded = () => {
+    embeddingsUnavailable = true;
+    embeddingFailure = true;
+  };
   if (searchOptions?.decryptLast) {
     const forceIncludeIds = [
       ...searchOptions.entityRanking ?? [],
@@ -21738,14 +21840,30 @@ async function prepareVaultCandidates(query, vaultCtx, embeddingOptions, cache,
       admitFactor: ADMIT_FACTOR,
       admitFloor: ADMIT_FLOOR,
       unembeddedCap: UNEMBEDDED_CAP,
-      ...forceIncludeIds.length > 0 && { forceIncludeIds }
+      ...forceIncludeIds.length > 0 && { forceIncludeIds },
+      onEmbeddingDegraded
     });
     if (corpus.vaultSize === 0) {
-      return { memories: [], embeddedItems: [], queryEmbedding: [], vaultSize: 0 };
+      return {
+        memories: [],
+        embeddedItems: [],
+        queryEmbedding: [],
+        vaultSize: 0,
+        embeddingsUnavailable: false,
+        embeddingFailure: false
+      };
     }
     ({ memories, embeddedItems, queryEmbedding, vaultSize } = corpus);
+    if (corpus.laneEmbedFailed) embeddingFailure = true;
     if (memories.length === 0) {
-      return { memories: [], embeddedItems: [], queryEmbedding: [], vaultSize };
+      return {
+        memories: [],
+        embeddedItems: [],
+        queryEmbedding: [],
+        vaultSize,
+        embeddingsUnavailable,
+        embeddingFailure
+      };
     }
   } else {
     const loaded = await getAllVaultMemoriesOp(
@@ -21760,14 +21878,21 @@ async function prepareVaultCandidates(query, vaultCtx, embeddingOptions, cache,
       );
     }
     if (memories.length === 0) {
-      return { memories: [], embeddedItems: [], queryEmbedding: [], vaultSize: loaded.length };
+      return {
+        memories: [],
+        embeddedItems: [],
+        queryEmbedding: [],
+        vaultSize: loaded.length,
+        embeddingsUnavailable: false,
+        embeddingFailure: false
+      };
     }
-    queryEmbedding = await generateEmbedding(query, embeddingOptions);
+    queryEmbedding = await embedQueryOrDegrade(query, embeddingOptions, onEmbeddingDegraded);
     const currentModel = embeddingOptions.model ?? DEFAULT_API_EMBEDDING_MODEL;
     const uncachedTexts = [];
     const uncachedIndices = [];
     let staleReembedCount = 0;
-    for (let i = 0; i < memories.length; i++) {
+    for (let i = 0; queryEmbedding.length > 0 && i < memories.length; i++) {
       const content = memories[i].content;
       const memoryId = memories[i].uniqueId;
       const cached = cache.get(memoryId);
@@ -21795,20 +21920,30 @@ async function prepareVaultCandidates(query, vaultCtx, embeddingOptions, cache,
       );
     }
     if (uncachedTexts.length > 0) {
-      const newEmbeddings = await generateEmbeddings(uncachedTexts, embeddingOptions);
-      for (let j = 0; j < uncachedTexts.length; j++) {
-        cache.set(memories[uncachedIndices[j]].uniqueId, Float32Array.from(newEmbeddings[j]));
-        updateVaultMemoryEmbeddingOp(
-          vaultCtx,
-          memories[uncachedIndices[j]].uniqueId,
-          JSON.stringify(newEmbeddings[j]),
-          currentModel
-        ).catch(
-          // Silently swallow – SDK must not use console.*; embedding will be retried on next search
-          () => {
-          }
+      let newEmbeddings;
+      try {
+        newEmbeddings = await generateEmbeddings(uncachedTexts, embeddingOptions);
+      } catch (err) {
+        embeddingFailure = true;
+        getLogger().warn(
+          `memoryVault: (re)embedding ${uncachedTexts.length} vault rows failed \u2014 they rank on BM25 alone for this search: ` + (err instanceof Error ? err.message : String(err))
         );
       }
+      if (newEmbeddings) {
+        for (let j = 0; j < uncachedTexts.length; j++) {
+          cache.set(memories[uncachedIndices[j]].uniqueId, Float32Array.from(newEmbeddings[j]));
+          updateVaultMemoryEmbeddingOp(
+            vaultCtx,
+            memories[uncachedIndices[j]].uniqueId,
+            JSON.stringify(newEmbeddings[j]),
+            currentModel
+          ).catch(
+            // Silently swallow – SDK must not use console.*; embedding will be retried on next search
+            () => {
+            }
+          );
+        }
+      }
     }
     embeddedItems = memories.map((m) => ({
       id: m.uniqueId,
@@ -21825,12 +21960,22 @@ async function prepareVaultCandidates(query, vaultCtx, embeddingOptions, cache,
       factType: m.factType
     }));
   }
-  return { memories, embeddedItems, queryEmbedding, vaultSize };
+  if (!embeddingsUnavailable && !embeddedItems.some((it) => it.embedding.length > 0)) {
+    embeddingsUnavailable = true;
+  }
+  return {
+    memories,
+    embeddedItems,
+    queryEmbedding,
+    vaultSize,
+    embeddingsUnavailable,
+    embeddingFailure
+  };
 }
 async function rankPreparedVaultCandidates(query, prepared, embeddingOptions, searchOptions) {
   const limit = searchOptions?.limit ?? 5;
   const minSimilarity = searchOptions?.minSimilarity ?? 0.1;
-  const { memories, embeddedItems, queryEmbedding, vaultSize } = prepared;
+  const { memories, embeddedItems, queryEmbedding, vaultSize, embeddingsUnavailable } = prepared;
   if (queryEmbedding.length > 0) {
     const mismatched = embeddedItems.filter(
       (it) => it.embedding.length > 0 && it.embedding.length !== queryEmbedding.length
@@ -21867,7 +22012,8 @@ async function rankPreparedVaultCandidates(query, prepared, embeddingOptions, se
       results: results2,
       vaultSize: out.vaultSize,
       reranked: out.reranked ?? false,
-      hadV2Head: out.hadV2Head ?? false
+      hadV2Head: out.hadV2Head ?? false,
+      embeddingsUnavailable
     };
   };
   const rerankStats = { applied: false };
@@ -21890,36 +22036,46 @@ async function rankPreparedVaultCandidates(query, prepared, embeddingOptions, se
     ...searchOptions?.rrfK !== void 0 && { rrfK: searchOptions.rrfK },
     ...searchOptions?.factTypeWeights && { factTypeWeights: searchOptions.factTypeWeights }
   };
-  if (useFusion && searchOptions?.decompose === "llm" && searchOptions.decomposeOptions) {
+  if (useFusion && !embeddingsUnavailable && searchOptions?.decompose === "llm" && searchOptions.decomposeOptions) {
     const decomp = await decomposeQuery(query, searchOptions.decomposeOptions);
     if (decomp.mode === "composite") {
-      const subEmbeddings = await generateEmbeddings(decomp.subQueries, embeddingOptions);
-      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
-      });
+      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 = [];
+      }
+      if (subEmbeddings.length > 0) {
+        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
+        });
+      }
     }
   }
   if (useFusion && searchOptions?.rerank) {
@@ -21970,7 +22126,14 @@ async function rankPreparedVaultCandidates(query, prepared, embeddingOptions, se
 }
 async function searchVaultMemoriesWithSize(query, vaultCtx, embeddingOptions, cache, searchOptions) {
   if (!query || typeof query !== "string") {
-    return { results: [], vaultSize: 0, reranked: false, hadV2Head: false };
+    return {
+      results: [],
+      vaultSize: 0,
+      reranked: false,
+      hadV2Head: false,
+      embeddingsUnavailable: false,
+      rankedOnCosine: false
+    };
   }
   const prepared = await prepareVaultCandidates(
     query,
@@ -21980,12 +22143,32 @@ async function searchVaultMemoriesWithSize(query, vaultCtx, embeddingOptions, ca
     searchOptions
   );
   if (prepared.vaultSize === 0) {
-    return { results: [], vaultSize: 0, reranked: false, hadV2Head: false };
+    return {
+      results: [],
+      vaultSize: 0,
+      reranked: false,
+      hadV2Head: false,
+      embeddingsUnavailable: prepared.embeddingsUnavailable,
+      rankedOnCosine: false
+    };
   }
   if (prepared.memories.length === 0) {
-    return { results: [], vaultSize: prepared.vaultSize, reranked: false, hadV2Head: false };
+    return {
+      results: [],
+      vaultSize: prepared.vaultSize,
+      reranked: false,
+      hadV2Head: false,
+      embeddingsUnavailable: prepared.embeddingsUnavailable,
+      rankedOnCosine: false
+    };
   }
-  return rankPreparedVaultCandidates(query, prepared, embeddingOptions, searchOptions);
+  const ranked = await rankPreparedVaultCandidates(
+    query,
+    prepared,
+    embeddingOptions,
+    searchOptions
+  );
+  return { ...ranked, rankedOnCosine: !ranked.embeddingsUnavailable };
 }
 async function searchVaultMemories(query, vaultCtx, embeddingOptions, cache, searchOptions) {
   const { results } = await searchVaultMemoriesWithSize(
@@ -22059,26 +22242,36 @@ function createMemoryVaultSearchTool(vaultCtx, embeddingOptions, cache, searchOp
         const budget = searchOptions?.decompose === "llm" && searchOptions.decomposeOptions ? "high" : searchOptions?.rerank ? "mid" : "low";
         const folderId = searchOptions?.folderId ?? argFolderId;
         if (searchOptions?.useFusion === false) {
-          const legacy = await searchVaultMemories(query, vaultCtx, embeddingOptions, cache, {
-            limit: requestLimit,
-            minSimilarity,
-            useFusion: false,
-            ...tuningForward,
-            ...folderId !== void 0 && { folderId },
-            ...searchOptions?.scopes && { scopes: searchOptions.scopes }
-          });
+          const { results: legacy, embeddingsUnavailable } = await searchVaultMemoriesWithSize(
+            query,
+            vaultCtx,
+            embeddingOptions,
+            cache,
+            {
+              limit: requestLimit,
+              minSimilarity,
+              useFusion: false,
+              ...tuningForward,
+              ...folderId !== void 0 && { folderId },
+              ...searchOptions?.scopes && { scopes: searchOptions.scopes }
+            }
+          );
           if (legacy.length === 0) {
-            return "No relevant memories found in the vault.";
+            return embeddingsUnavailable ? EMBEDDINGS_DEGRADED_EMPTY_NO_LEXICAL : "No relevant memories found in the vault.";
           }
           return formatVaultHits(
             legacy.map((r) => ({ id: r.uniqueId, content: r.content, score: r.similarity }))
           );
         }
         const { recall: recall2 } = await Promise.resolve().then(() => (init_recall(), recall_exports));
+        let recallDegraded = [];
         const result = await recall2(
           query,
           { vaultCtx, embeddingOptions, vaultCache: cache },
           {
+            onDiagnostics: (d) => {
+              recallDegraded = d.degraded;
+            },
             types: ["fact"],
             limit: requestLimit,
             minScore: minSimilarity,
@@ -22099,7 +22292,7 @@ function createMemoryVaultSearchTool(vaultCtx, embeddingOptions, cache, searchOp
           return "The memory vault is empty. No memories have been saved yet.";
         }
         if (result.memories.length === 0) {
-          return "No relevant memories found in the vault.";
+          return recallDegraded.includes("embeddings-unavailable") ? EMBEDDINGS_DEGRADED_EMPTY : "No relevant memories found in the vault.";
         }
         const formatted = formatVaultHits(
           result.memories.map((m) => ({
@@ -22118,7 +22311,7 @@ ${formatted}`;
     }
   };
 }
-var SUPERSESSION_SIMILARITY_THRESHOLD, SUPERSESSION_MIN_AGE_GAP_MS, SUPERSESSION_BOOST_FACTOR, SUPERSESSION_MAX_WINDOW;
+var SUPERSESSION_SIMILARITY_THRESHOLD, SUPERSESSION_MIN_AGE_GAP_MS, SUPERSESSION_BOOST_FACTOR, SUPERSESSION_MAX_WINDOW, EMBEDDINGS_DEGRADED_EMPTY_NO_LEXICAL;
 var init_searchTool = __esm({
   "src/lib/memoryVault/searchTool.ts"() {
     "use strict";
@@ -22126,6 +22319,7 @@ var init_searchTool = __esm({
     init_operations3();
     init_logger();
     init_mmr();
+    init_recallConstants();
     init_recency();
     init_reranker();
     init_rrf();
@@ -22139,6 +22333,7 @@ var init_searchTool = __esm({
     SUPERSESSION_MIN_AGE_GAP_MS = 30 * 24 * 60 * 60 * 1e3;
     SUPERSESSION_BOOST_FACTOR = 0.8;
     SUPERSESSION_MAX_WINDOW = 50;
+    EMBEDDINGS_DEGRADED_EMPTY_NO_LEXICAL = "Memory search is temporarily unavailable \u2014 the semantic lookup failed and this search mode has no keyword fallback, so no memory search ran at all. Do not conclude the user has no such memory; say the memory lookup was unavailable.";
   }
 });
 
@@ -27835,6 +28030,11 @@ async function retain(content, ctx, options = {}) {
         ...options.folderId !== void 0 && { folderId: options.folderId }
       }
     );
+    if (prepared.embeddingFailure || prepared.embeddingsUnavailable) {
+      throw new Error(
+        "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."
+      );
+    }
     if (options.consolidateOptions) {
       const outcome = await tryConsolidate(trimmed, ctx, options, prepared);
       if (outcome) {
@@ -29086,12 +29286,7 @@ init_recall();
 
 // src/lib/memory/recallTool.ts
 init_recall();
-
-// src/lib/memory/recallConstants.ts
-var RECALL_TOOL_NAME = "recall_memory";
-var RECALL_MAX_LIMIT = 50;
-
-// src/lib/memory/recallTool.ts
+init_recallConstants();
 var DEFAULT_LIMIT2 = 8;
 var DEFAULT_BUDGET2 = "low";
 function formatEventTime(start, end, kind) {
@@ -29241,7 +29436,11 @@ function createRecallTool(ctx, toolOptions, callbacks) {
       conversationMemories += effectiveLimit;
       let surfaced = 0;
       try {
+        let recallDegraded = [];
         const recallOpts = {
+          onDiagnostics: (d) => {
+            recallDegraded = d.degraded;
+          },
           types: defaultTypes,
           limit: effectiveLimit,
           budget: defaultBudget,
@@ -29273,6 +29472,9 @@ function createRecallTool(ctx, toolOptions, callbacks) {
           }
         }
         surfaced = result.memories.length;
+        if (result.memories.length === 0 && recallDegraded.includes("embeddings-unavailable")) {
+          return EMBEDDINGS_DEGRADED_EMPTY;
+        }
         const formatted = formatRecallResult(result.memories);
         return truncatedByBudget && surfaced > 0 ? `${formatted}
 
@@ -29453,6 +29655,7 @@ init_embeddings();
 init_vector();
 init_observationTrend();
 init_recall();
+init_recallConstants();
 var DEFAULT_SYNTHESIS_MODEL = "inclusionai/ling-2.6-flash";
 var DEFAULT_FACET_RECALL_LIMIT = 20;
 var DEFAULT_FACET_MAX_TOKENS = 512;
@@ -32749,6 +32952,9 @@ var CompletionsStrategy = class {
           }
         }
       }
+      if (choice.finish_reason) {
+        accumulator.finishReason = choice.finish_reason;
+      }
       if (choice.finish_reason === "tool_calls" || choice.finish_reason === "stop") {
         if (accumulator.toolCalls.size > 0) {
           accumulator.content = mergeXaiInlineParameterTags(
@@ -32831,7 +33037,9 @@ var CompletionsStrategy = class {
             content: finalContent,
             ...toolCalls && { tool_calls: toolCalls }
           },
-          finish_reason: toolCalls ? "tool_calls" : "stop"
+          // Prefer what the provider actually said; fall back to the derived
+          // value only when the stream carried no finish_reason at all.
+          finish_reason: accumulator.finishReason ?? (toolCalls ? "tool_calls" : "stop")
         }
       ],
       ...usage && { usage },
@@ -33502,7 +33710,7 @@ var ResponsesStrategy = class {
       }
       return result;
     }
-    if (typedChunk.type === "response.completed") {
+    if (typedChunk.type === "response.completed" || typedChunk.type === "response.incomplete") {
       if (typedChunk.response?.usage) {
         const u = typedChunk.response.usage;
         const promptTokens = u.input_tokens ?? u.prompt_tokens ?? 0;
@@ -33518,6 +33726,11 @@ var ResponsesStrategy = class {
           ...creditsExhausted !== void 0 && { credits_exhausted: creditsExhausted }
         };
       }
+      const resp = typedChunk.response;
+      const looksIncomplete = typedChunk.type === "response.incomplete" || resp?.status === "incomplete";
+      if (looksIncomplete && resp?.incomplete_details?.reason === "max_output_tokens") {
+        accumulator.finishReason = "length";
+      }
       if (typedChunk.response?.tools_checksum && !accumulator.toolsChecksum) {
         accumulator.toolsChecksum = typedChunk.response.tools_checksum;
       }
@@ -35054,7 +35267,17 @@ Executing tool: ${toolInfo}
       flushDeAnon();
       currentAccumulator.content += tip;
     }
+    const truncatedToNothing = (acc) => acc.finishReason === "length" && acc.toolCalls.size === 0 && acc.content.trim() === "";
+    const TRUNCATION_ERROR = "Model response was truncated at the output-token limit before it produced any usable content or tool call. Retry with a higher `maxOutputTokens`, or prompt for fewer/smaller tool calls per turn.";
     if (toolIteration > 0) {
+      if (truncatedToNothing(currentAccumulator)) {
+        await fireRunError({ error: TRUNCATION_ERROR, stage: "model" });
+        return {
+          data: buildResponseFinal(currentAccumulator),
+          error: TRUNCATION_ERROR,
+          toolsChecksum: currentAccumulator.toolsChecksum
+        };
+      }
       const finalResponse = buildResponseFinal(currentAccumulator);
       if (onFinish) onFinish(finalResponse);
       await fireRunEnd({
@@ -35068,6 +35291,14 @@ Executing tool: ${toolInfo}
         autoExecutedToolResults: accumulatedToolResults
       };
     }
+    if (truncatedToNothing(accumulator)) {
+      await fireRunError({ error: TRUNCATION_ERROR, stage: "model" });
+      return {
+        data: response,
+        error: TRUNCATION_ERROR,
+        toolsChecksum: accumulator.toolsChecksum
+      };
+    }
     if (onFinish) onFinish(response);
     await fireRunEnd({
       finalContent: finalContentText(accumulator),