@anuma/sdk 6.38.0 → 6.39.1

package/dist/server/index.cjs

@@ -20430,15 +20430,17 @@ Build ONLY when the user gives an explicit instruction to build, create, generat
 
 Once the user HAS given an explicit build instruction, you are in App Builder mode: you produce polished, production-quality React apps that feel designed \u2014 not generic.
 
-DESIGN: on the initial build, before writing code, briefly state (2-3 sentences) what you want this app to feel like \u2014 name the specific fonts, the palette in hex, and one signature detail. Be concrete: "Fraunces display + Inter body + JetBrains Mono metadata, terracotta #b75432 accent on bone #f3efe6, paper-grain texture via inline SVG noise" is the kind of specificity that anchors the build. Default to nothing: don't pick "safe modern productivity" unless the brief literally asks for utilitarian. On later turns, state a design brief only when the change is visual (a restyle, new theme, or new UI); for a logic, data, or behavior-only change, skip the brief and just make the change.
+DESIGN: on the initial build, before writing code, briefly state (2-3 sentences) what you want this app to feel like \u2014 name the specific fonts, the palette in hex, and one signature detail. Be concrete: "Fraunces display + Inter body + JetBrains Mono metadata, terracotta #b75432 accent on bone #f3efe6, paper-grain texture via inline SVG noise" is the kind of specificity that anchors the build. Default to nothing: don't pick "safe modern productivity" unless the brief literally asks for utilitarian. On later turns, state a design brief only when the change is visual (a restyle, new theme, or new UI); for a text, logic, data, or behavior-only change, skip the brief and just make the change.
+
+EDIT SCOPE: Change only the files and lines required by the current user request. A title rename is a text edit, not a design change. Preserve styles, dependencies, and unrelated logic on text edits. Design feedback does not authorize unrelated edits.
 
 WORKFLOW:
 1. NEVER output code as text or markdown. ALWAYS use tools.
 2. Initial build: state your design brief, then create_file with a "files" array writing ALL files in one call. The preview renders automatically.
 3. patch_file requires read_file for that path earlier in the conversation (or create_file in the same conversation, which counts). read_file output is numbered "42: <text>" \u2014 the prefix is display-only; never copy it into "find". Each "find" must match exactly one location \u2014 include 2-3 lines of surrounding context. Pass multiple patches per call to change distinct locations.
 4. Prefer patch_file for changes to existing files \u2014 surgical, reviewable, preserves surrounding code. Reserve create_file overwrites for substantial restructuring. Inserts: find the line before, replace with that line + the new line. Deletes: empty replace.
-5. After substantial changes, call critique_design first (taste, hierarchy, distinctiveness, weakest decision) and then audit_design (mechanical: tokens, focus states, aria-labels, alt, heading order). Patch what each surfaces. critique catches taste issues no checklist would; audit catches mechanics you'd miss. Run both; act on both.
-6. Before declaring done, call verify_app. The host's preview runtime reports whether your app actually mounted and surfaces any errors it captured \u2014 hallucinated imports, syntax the bundler rejected, undefined components, runtime crashes. If \`rendered\` is false or \`errors\` is non-empty, fix every error before the next message. If the response includes a \`note\` that verify_app isn't wired in this host, skip \u2014 audit + critique are your feedback in that case.
+5. On the initial build, when adding new UI, or after user-requested design changes, call critique_design first and then audit_design. Critique checks taste, hierarchy, and distinctiveness. Audit checks tokens, focus states, aria-labels, alt text, and heading order. Patch only issues within the current user request. For text, logic, or data edits, skip both design tools.
+6. Before declaring done, call verify_app. The host's preview runtime reports whether your app actually mounted and surfaces any errors it captured \u2014 hallucinated imports, syntax the bundler rejected, undefined components, runtime crashes. If \`rendered\` is false or \`errors\` is non-empty, fix every error before the next message. If the response includes a \`note\` that verify_app isn't wired in this host, skip runtime verification. An unavailable runtime verifier does not authorize design changes. Use audit_design and critique_design only for the initial build, adding new UI, or user-requested design changes.
 7. Keep responses to a sentence or two. Exception: when responding to critique_design, write a substantive paragraph per rubric question.
 
 STRUCTURE:
@@ -20584,12 +20586,13 @@ function isCacheExpired(cache, expirationMs = DEFAULT_CACHE_EXPIRATION_MS) {
   if (!cache) return true;
   return Date.now() - cache.timestamp > expirationMs;
 }
-function buildCacheEntry(tools, checksum) {
+function buildCacheEntry(tools, checksum, etag) {
   return {
     tools,
     timestamp: Date.now(),
     version: CACHE_VERSION,
-    ...checksum && { checksum }
+    ...checksum && { checksum },
+    ...etag && { etag }
   };
 }
 function writeLocalStorageCache(entry) {
@@ -20624,19 +20627,36 @@ function shouldRefreshTools(responseChecksum, cache = localStorageToolsCache) {
   const cachedChecksum = getToolsChecksum(cache);
   return cachedChecksum instanceof Promise ? cachedChecksum.then(decide) : decide(cachedChecksum);
 }
-async function fetchServerToolsFromApi(baseUrl, token) {
-  const response = await fetch(`${baseUrl}/api/v1/tools`, {
+async function fetchServerToolsFromApi(baseUrl, authHeaders, etag) {
+  const request = (validator) => fetch(`${baseUrl}/api/v1/tools`, {
     method: "GET",
     headers: {
-      Authorization: `Bearer ${token}`,
-      "Content-Type": "application/json"
+      ...authHeaders,
+      "Content-Type": "application/json",
+      ...validator && { "If-None-Match": validator }
     }
   });
+  let response;
+  try {
+    response = await request(etag);
+  } catch (error) {
+    if (!etag || !(error instanceof TypeError)) throw error;
+    etag = void 0;
+    response = await request();
+  }
+  if (etag && response.status === 304) {
+    return { notModified: true };
+  }
   if (!response.ok) {
     throw new Error(`Failed to fetch server tools: ${response.status}`);
   }
   const data = await response.json();
-  return convertServerToolsResponse(data);
+  const responseEtag = response.headers?.get("ETag") ?? void 0;
+  return {
+    notModified: false,
+    ...convertServerToolsResponse(data),
+    ...responseEtag && { etag: responseEtag }
+  };
 }
 async function getServerTools(options) {
   const {
@@ -20668,34 +20688,30 @@ async function getServerTools(options) {
   try {
     const { BASE_URL: BASE_URL2 } = await Promise.resolve().then(() => (init_clientConfig(), clientConfig_exports));
     const effectiveBaseUrl = baseUrl ?? BASE_URL2;
+    const validator = cached && !forceRefresh ? cached.etag : void 0;
+    let authHeaders;
     if (apiKey) {
-      const response = await fetch(`${effectiveBaseUrl}/api/v1/tools`, {
-        method: "GET",
-        headers: {
-          "X-API-Key": apiKey,
-          "Content-Type": "application/json"
-        }
-      });
-      if (!response.ok) {
-        throw new Error(`Failed to fetch server tools: ${response.status}`);
+      authHeaders = { "X-API-Key": apiKey };
+    } else {
+      if (!getToken) {
+        getLogger().warn("[serverTools] No auth method available for fetching tools");
+        return cached?.tools ?? [];
       }
-      const data = await response.json();
-      const { tools: tools2, checksum: checksum2 } = convertServerToolsResponse(data);
-      await persistCache(buildCacheEntry(tools2, checksum2));
-      return tools2;
-    }
-    if (!getToken) {
-      getLogger().warn("[serverTools] No auth method available for fetching tools");
-      return cached?.tools ?? [];
+      const token = await getToken();
+      if (!token) {
+        getLogger().warn("[serverTools] No auth token available for fetching tools");
+        return cached?.tools ?? [];
+      }
+      authHeaders = { Authorization: `Bearer ${token}` };
     }
-    const token = await getToken();
-    if (!token) {
-      getLogger().warn("[serverTools] No auth token available for fetching tools");
-      return cached?.tools ?? [];
+    const result = await fetchServerToolsFromApi(effectiveBaseUrl, authHeaders, validator);
+    if (result.notModified) {
+      const confirmed = cached;
+      await persistCache({ ...confirmed, timestamp: Date.now() });
+      return confirmed.tools;
     }
-    const { tools, checksum } = await fetchServerToolsFromApi(effectiveBaseUrl, token);
-    await persistCache(buildCacheEntry(tools, checksum));
-    return tools;
+    await persistCache(buildCacheEntry(result.tools, result.checksum, result.etag));
+    return result.tools;
   } catch (error) {
     getLogger().error("[serverTools] Failed to fetch server tools:", error);
     if (cached?.tools) {
@@ -33957,7 +33973,6 @@ async function recall(query, ctx, options = {}) {
   }
   const needsChunkEmbedding = types.includes("chunk") && ctx.storageCtx;
   const wantsTemporal = types.includes("fact") && (ctx.factSource || ctx.vaultCtx);
-  const graphRefiner = flags.traverse && options.graphRefine && options.decomposeOptions ? createLlmNeighborRefiner(options.decomposeOptions) : void 0;
   const queryEmbedTotalTimeoutMs = options.queryEmbedTotalTimeoutMs ?? DEFAULT_QUERY_EMBED_TOTAL_TIMEOUT_MS;
   const prepStart = nowMs2();
   let sharedEmbedMs = 0;
@@ -33986,13 +34001,12 @@ async function recall(query, ctx, options = {}) {
     safeLane(
       "graph",
       () => graphLaneFailed = true,
-      () => ctx.factSource ? ctx.factSource.graphRanking(query, flags.traverse, options) : buildGraphLaneRanking(query, ctx, flags.traverse, {
-        ...options.maxHops !== void 0 && { maxHops: options.maxHops },
-        ...options.entityFanout !== void 0 && { entityFanout: options.entityFanout },
-        ...options.nodeBudget !== void 0 && { nodeBudget: options.nodeBudget },
-        ...options.rrfK !== void 0 && { rrfK: options.rrfK },
-        ...graphRefiner && { refineNeighbors: graphRefiner }
-      })
+      () => ctx.factSource ? ctx.factSource.graphRanking(query, flags.traverse, options) : buildGraphLaneRanking(
+        query,
+        ctx,
+        flags.traverse,
+        graphTraversalOptions(options, flags.traverse)
+      )
     ),
     wantsTemporal ? safeLane(
       "temporal",
@@ -34211,6 +34225,16 @@ function toFactMemory(r, now) {
     updatedAt: r.updatedAt ?? /* @__PURE__ */ new Date(0)
   };
 }
+function graphTraversalOptions(options, traverse) {
+  const refineNeighbors = traverse && options.graphRefine && options.decomposeOptions ? createLlmNeighborRefiner(options.decomposeOptions) : void 0;
+  return {
+    ...options.maxHops !== void 0 && { maxHops: options.maxHops },
+    ...options.entityFanout !== void 0 && { entityFanout: options.entityFanout },
+    ...options.nodeBudget !== void 0 && { nodeBudget: options.nodeBudget },
+    ...options.rrfK !== void 0 && { rrfK: options.rrfK },
+    ...refineNeighbors && { refineNeighbors }
+  };
+}
 async function buildGraphLaneRanking(query, ctx, traverse = false, traversalOptions = {}) {
   const entityCtx = ctx.entityCtx ?? ctx.vaultCtx?.entityCtx;
   if (!entityCtx) return [];
@@ -34376,24 +34400,33 @@ function isDumpQuery(query) {
   return false;
 }
 async function listRecentFacts(ctx, limit, toolOptions) {
+  const store = toolOptions?.memoryStore;
   const vaultCtx = ctx.vaultCtx;
-  if (!vaultCtx) return [];
-  const ordered = await getVaultRankingProjectionsOp(vaultCtx, {
+  if (!vaultCtx && !store) return [];
+  const read = (ids) => store ? store.list({ memoryIds: ids }) : getVaultMemoriesByIdsOp(vaultCtx, ids);
+  const filters = {
     ...toolOptions?.scopes && { scopes: toolOptions.scopes },
-    ...toolOptions?.memoryIds !== void 0 && { memoryIds: toolOptions.memoryIds },
+    ...toolOptions?.memoryIds !== void 0 && { memoryIds: toolOptions.memoryIds }
+  };
+  const project = (size) => store ? store.listProjections({ ...filters, limit: size }) : getVaultRankingProjectionsOp(vaultCtx, {
+    ...filters,
     ...toolOptions?.folderId !== void 0 && { folderId: toolOptions.folderId }
   });
   const readable = [];
-  for (let i = 0; i < ordered.length && readable.length < limit; i += limit) {
-    const batch = ordered.slice(i, i + limit).map((p) => p.uniqueId);
-    const byId = new Map(
-      (await getVaultMemoriesByIdsOp(vaultCtx, batch)).map((m) => [m.uniqueId, m])
-    );
-    for (const id of batch) {
-      const m = byId.get(id);
-      if (m && !isEncrypted(m.content)) readable.push(m);
-      if (readable.length >= limit) break;
+  let start = 0;
+  for (let size = limit; readable.length < limit; size *= 2) {
+    const ordered = await project(size);
+    for (let i = start; i < ordered.length && readable.length < limit; i += limit) {
+      const batch = ordered.slice(i, i + limit).map((p) => p.uniqueId);
+      const byId = new Map((await read(batch)).map((m) => [m.uniqueId, m]));
+      for (const id of batch) {
+        const m = byId.get(id);
+        if (m && !isEncrypted(m.content)) readable.push(m);
+        if (readable.length >= limit) break;
+      }
     }
+    if (!store || ordered.length < size) break;
+    start = ordered.length;
   }
   return readable.map((m) => ({
     id: m.uniqueId,
@@ -34410,6 +34443,8 @@ async function listRecentFacts(ctx, limit, toolOptions) {
   }));
 }
 function createRecallTool(ctx, toolOptions, callbacks) {
+  if (toolOptions?.memoryStore && toolOptions.folderId !== void 0)
+    throw new Error("Folders are not supported with a memoryStore");
   const defaultTypes = toolOptions?.types ?? ["fact", "chunk"];
   const defaultLimit = toolOptions?.limit ?? DEFAULT_LIMIT2;
   const defaultBudget = toolOptions?.budget ?? DEFAULT_BUDGET2;
@@ -34481,7 +34516,7 @@ function createRecallTool(ctx, toolOptions, callbacks) {
       let surfaced = 0;
       try {
         let recallDegraded = [];
-        const wantsRecent = args.sort === "recent" && defaultTypes.includes("fact") && ctx.vaultCtx !== void 0;
+        const wantsRecent = args.sort === "recent" && defaultTypes.includes("fact") && (ctx.vaultCtx !== void 0 || toolOptions?.memoryStore !== void 0);
         let result;
         if (wantsRecent) {
           result = { memories: await listRecentFacts(ctx, effectiveLimit, toolOptions) };
@@ -34991,6 +35026,7 @@ function createLocalMemoryStore(options) {
     });
   };
   return {
+    masksEmbeddingInput: options.embeddingOptions.maskInput !== void 0,
     list: (listOptions) => getAllVaultMemoriesOp(vaultCtx, listOptions),
     get: (id) => getVaultMemoryOp(vaultCtx, id),
     listArchived: async () => {
@@ -35072,6 +35108,22 @@ function createLocalMemoryStore(options) {
       { vaultCtx, embeddingOptions: options.embeddingOptions, vaultCache },
       retainOptions
     ),
+    factSource: {
+      search: (query, searchOptions) => searchVaultMemoriesWithSize(
+        query,
+        vaultCtx,
+        options.embeddingOptions,
+        vaultCache,
+        searchOptions
+      ),
+      graphRanking: (query, traverse, recallOptions) => buildGraphLaneRanking(
+        query,
+        { vaultCtx, entityCtx, embeddingOptions: options.embeddingOptions },
+        traverse,
+        graphTraversalOptions(recallOptions, traverse)
+      ),
+      temporalRanking: (query, now) => buildTemporalLaneRanking(query, vaultCtx, now)
+    },
     subscribe: (onChange, subscribeOptions) => {
       const afterFirst = () => {
         let first = true;
@@ -36767,19 +36819,20 @@ function createMemoryVaultSearchTool(vaultCtx, embeddingOptions, cache, searchOp
         const budget = wantsDecompose ? "high" : searchOptions?.rerank ? "mid" : "low";
         const folderId = searchOptions?.folderId ?? argFolderId;
         if (searchOptions?.useFusion === false) {
-          const { results: legacy, embeddingsUnavailable } = await searchVaultMemoriesWithSize(
+          const legacyOptions = {
+            limit: requestLimit,
+            minSimilarity,
+            useFusion: false,
+            ...tuningForward,
+            ...folderId !== void 0 && { folderId },
+            ...searchOptions?.scopes && { scopes: searchOptions.scopes }
+          };
+          const { results: legacy, embeddingsUnavailable } = "retain" in vaultCtx ? await vaultCtx.factSource.search(query, legacyOptions) : await searchVaultMemoriesWithSize(
             query,
             vaultCtx,
             embeddingOptions,
             cache,
-            {
-              limit: requestLimit,
-              minSimilarity,
-              useFusion: false,
-              ...tuningForward,
-              ...folderId !== void 0 && { folderId },
-              ...searchOptions?.scopes && { scopes: searchOptions.scopes }
-            }
+            legacyOptions
           );
           if (legacy.length === 0) {
             return embeddingsUnavailable ? EMBEDDINGS_DEGRADED_EMPTY_NO_LEXICAL : "No relevant memories found in the vault.";
@@ -36798,7 +36851,7 @@ function createMemoryVaultSearchTool(vaultCtx, embeddingOptions, cache, searchOp
         let recallDegraded = [];
         const result = await recall(
           query,
-          { vaultCtx, embeddingOptions, vaultCache: cache },
+          "retain" in vaultCtx ? { factSource: vaultCtx.factSource, embeddingOptions } : { vaultCtx, embeddingOptions, vaultCache: cache },
           {
             onDiagnostics: (d) => {
               recallDegraded = d.degraded;
@@ -36878,8 +36931,10 @@ function describeWriteOutcome(outcome) {
   }
 }
 function createMemoryVaultTool(vaultCtx, options, embeddingOptions, cache) {
+  const store = "retain" in vaultCtx ? vaultCtx : void 0;
+  const ctx = "retain" in vaultCtx ? void 0 : vaultCtx;
   const hasOnSave = !!options?.onSave;
-  const folderNames = options?.folderMap ? Array.from(options.folderMap.keys()) : [];
+  const folderNames = !store && options?.folderMap ? Array.from(options.folderMap.keys()) : [];
   return {
     type: "function",
     function: {
@@ -36924,7 +36979,7 @@ function createMemoryVaultTool(vaultCtx, options, embeddingOptions, cache) {
         let previousContent;
         const scope = options?.scope ?? "private";
         if (isUpdate) {
-          const existing = await getVaultMemoryOp(vaultCtx, id);
+          const existing = store ? await store.get(id) : await getVaultMemoryOp(ctx, id);
           if (!existing) {
             return `Error: Memory with ID "${id}" not found. Creating a new memory instead would require a separate call without an ID.`;
           }
@@ -36945,9 +37000,18 @@ function createMemoryVaultTool(vaultCtx, options, embeddingOptions, cache) {
             return isUpdate ? `Memory update was cancelled by the user. The memory "${id}" was not modified.` : "Memory save was cancelled by the user. No memory was created.";
           }
         }
-        if (isUpdate) {
+        if (isUpdate && store) {
+          const updated = await store.update(id, {
+            content,
+            ...factType !== void 0 && { factType }
+          });
+          if (!updated) {
+            return `Error: Failed to update memory "${id}".`;
+          }
+          return `Memory updated successfully (ID: ${updated.uniqueId}).`;
+        } else if (isUpdate) {
           const folderId = folderName ? options?.folderMap?.get(folderName) : void 0;
-          const updated = await updateVaultMemoryOp(vaultCtx, id, {
+          const updated = await updateVaultMemoryOp(ctx, id, {
             content,
             embedding: null,
             folderId,
@@ -36962,7 +37026,7 @@ function createMemoryVaultTool(vaultCtx, options, embeddingOptions, cache) {
               content,
               embeddingOptions,
               cache,
-              vaultCtx,
+              ctx,
               id,
               updated.updatedAt
             ).catch(() => {
@@ -36982,18 +37046,22 @@ function createMemoryVaultTool(vaultCtx, options, embeddingOptions, cache) {
             await notifyWritten(options, input, outcome);
             return describeWriteOutcome(outcome);
           }
-          const created = await createVaultMemoryOp(vaultCtx, {
+          const created = store ? await store.create({
+            content,
+            scope,
+            ...factType !== void 0 && { factType }
+          }) : await createVaultMemoryOp(ctx, {
             content,
             scope,
             folderId,
             ...factType !== void 0 && { factType }
           });
-          if (embeddingOptions && cache) {
+          if (ctx && embeddingOptions && cache) {
             eagerEmbedContent(
               content,
               embeddingOptions,
               cache,
-              vaultCtx,
+              ctx,
               created.uniqueId,
               created.updatedAt
             ).catch(() => {