@anuma/sdk 3.0.0 → 3.1.0

package/dist/server/index.d.mts

@@ -2741,6 +2741,33 @@ interface CachedServerTools {
     /** Checksum from the server for cache invalidation */
     checksum?: string;
 }
+/**
+ * Pluggable persistence for the fetched server-tools list.
+ *
+ * The default backend ({@link localStorageToolsCache}) writes to browser
+ * `localStorage` and is a silent no-op where `localStorage` is undefined
+ * (Node, React Native). Pass a custom backend to `getServerTools` to cache
+ * somewhere that survives on those platforms — e.g. an AsyncStorage/MMKV
+ * adapter on RN, or an in-memory `Map` on a server. Methods may be sync or
+ * async; `getServerTools` awaits them either way.
+ *
+ * The stored payload carries a `version`; `getServerTools` discards any entry
+ * whose version does not match the current cache format, so a stale custom
+ * backend can never feed an incompatible shape back into selection.
+ */
+interface ToolsCacheBackend {
+    /** Return the cached payload, or null when absent/unreadable. */
+    get(): CachedServerTools | null | Promise<CachedServerTools | null>;
+    /** Persist the payload. Implementations should swallow write failures. */
+    set(value: CachedServerTools): void | Promise<void>;
+    /**
+     * Remove the cached payload. Optional — a read/write-only backend may omit it,
+     * in which case `clearServerToolsCache` (and the version-mismatch
+     * invalidation) is a no-op for that backend. The default
+     * {@link localStorageToolsCache} implements it.
+     */
+    clear?(): void | Promise<void>;
+}
 /**
  * Options for fetching server tools
  */
@@ -2755,6 +2782,12 @@ interface ServerToolsOptions {
     getToken?: () => Promise<string | null>;
     /** Direct API key for server-side usage (uses X-API-Key header) */
     apiKey?: string;
+    /**
+     * Where to read/write the cached tools list. Defaults to
+     * {@link localStorageToolsCache} (browser `localStorage`; no-op elsewhere).
+     * Provide a backend to enable caching on Node / React Native.
+     */
+    cache?: ToolsCacheBackend;
 }
 /** Default cache expiration: 1 day */
 declare const DEFAULT_CACHE_EXPIRATION_MS: number;
@@ -2770,14 +2803,21 @@ interface ParsedServerToolsResponse {
  */
 declare function getCachedServerTools(): CachedServerTools | null;
 /**
- * Clear the server tools cache
+ * Clear the cached server tools. Defaults to the browser-`localStorage` backend;
+ * pass the SAME {@link ToolsCacheBackend} you gave `getServerTools` to invalidate
+ * a custom backend (a no-op when that backend defines no `clear`). Returns the
+ * backend's clear result, which may be async.
  */
 declare function clearServerToolsCache(): void;
+declare function clearServerToolsCache(cache: ToolsCacheBackend): void | Promise<void>;
 /**
- * Get the checksum of currently cached tools.
- * Returns undefined if no cache or no checksum stored.
+ * Get the checksum of the currently cached tools, or undefined when there is no
+ * cache / no stored checksum. Defaults to the browser-`localStorage` backend;
+ * pass the SAME backend you gave `getServerTools` to read a custom backend's
+ * checksum (an async backend yields a promise).
  */
 declare function getToolsChecksum(): string | undefined;
+declare function getToolsChecksum(cache: ToolsCacheBackend): string | undefined | Promise<string | undefined>;
 /**
  * Check if tools should be refreshed based on checksum comparison.
  * Returns true if:
@@ -2789,11 +2829,12 @@ declare function getToolsChecksum(): string | undefined;
  * - Checksums match
  */
 declare function shouldRefreshTools(responseChecksum: string | undefined): boolean;
+declare function shouldRefreshTools(responseChecksum: string | undefined, cache: ToolsCacheBackend | undefined): boolean | Promise<boolean>;
 /**
  * Get server tools with caching support.
  *
  * Flow:
- * 1. Check localStorage cache
+ * 1. Check the cache backend (localStorage by default; override via `cache`)
  * 2. If cache valid and not force refresh, return cached tools
  * 3. Otherwise, fetch from API, cache, and return
  * 4. On fetch failure, return cached tools if available (stale-while-error)
@@ -3085,6 +3126,11 @@ interface SelectServerToolsForPromptOptions {
     embeddingModel?: string;
     /** Cache expiration in ms for the server-tools catalog fetch. */
     cacheExpirationMs?: number;
+    /**
+     * Where to read/write the cached catalog. Defaults to browser `localStorage`
+     * (a no-op on Node/RN); pass a backend to persist on those platforms.
+     */
+    cache?: ToolsCacheBackend;
     /**
      * Phase 3 defer-loading. When `enabled`, this helper returns the FULL catalog (skipping semantic/
      * static filtering) to mirror useChatStorage's responses send path, which swaps in the full catalog
@@ -5366,11 +5412,26 @@ interface EmbeddingOptions {
 }
 
 /**
- * Memory Retrieval Embeddings
+ * Embedding generation — dependency-free core.
+ *
+ * The raw "text → embedding" calls, split out of `embeddings.ts` so they can be
+ * imported by node/React-Native-safe modules (the server-tool + client-tool
+ * selection engine in `../tools`) WITHOUT pulling in the WatermelonDB-backed
+ * `db/chat/operations` that `embeddings.ts` needs for its message-persistence
+ * helpers (`embedMessage`, `embedAllMessages`, `chunkAndEmbed*`).
  *
- * Functions for generating and storing embeddings for conversation messages.
+ * Nothing here touches the database; the only I/O is the HTTP embeddings
+ * endpoint. `embeddings.ts` re-exports these so existing importers of
+ * `../memoryEngine/embeddings` (and the `../memoryEngine` barrel) keep working.
  */
 
+/**
+ * Generate an embedding for text using the API
+ *
+ * Supports two auth methods:
+ * - `apiKey`: Uses X-API-Key header (for server-side/CLI usage)
+ * - `getToken`: Uses Authorization: Bearer header (for Privy identity tokens)
+ */
 declare function generateEmbedding(text: string, options: EmbeddingOptions): Promise<number[]>;
 /**
  * Generate embeddings for multiple texts, automatically chunking large inputs.
@@ -5385,6 +5446,18 @@ declare function generateEmbedding(text: string, options: EmbeddingOptions): Pro
  * @returns Array of embeddings in the same order as input texts
  */
 declare function generateEmbeddings(texts: string[], options: EmbeddingOptions): Promise<number[][]>;
+
+/**
+ * Memory Retrieval Embeddings
+ *
+ * Message-level embedding + persistence helpers: find messages via the
+ * WatermelonDB-backed `db/chat/operations`, embed their content, and store the
+ * vectors/chunks back. The raw "text → embedding" calls live in `./generate`
+ * (dependency-free so the tool-selection engine can import them without the DB
+ * layer) and are re-exported here so existing importers of
+ * `../memoryEngine/embeddings` and the `../memoryEngine` barrel keep working.
+ */
+
 /**
  * Embed a single message and store the embedding in the database
  *
@@ -6583,14 +6656,14 @@ declare function createChunkVectorCache(maxSize?: number): ChunkVectorCache;
 declare function recall(query: string, ctx: RecallContext, options?: RecallOptions): Promise<RecallResult>;
 
 /**
- * Unified Recall Tool
+ * Recall tool constants — deliberately dependency-free.
  *
- * Single chat-completion tool that searches both vault facts and
- * conversation chunks via `recall()`. Replaces the legacy pair of
- * `memory_vault_search` (facts) + `search_memory` (chunks) — the LLM no
- * longer has to route between two tools.
+ * Split out of `recallTool.ts` so the tool NAME can be referenced from
+ * node/React-Native-safe modules (e.g. the client-tool selector in
+ * `../tools/clientToolSelection`) without dragging `recall()` and its
+ * WatermelonDB-backed operations into the module graph. `recallTool.ts`
+ * re-exports these to preserve their public identity.
  */
-
 /** Tool name surfaced to the LLM. Exported so bench harnesses and chat
  * clients reference the same string — drift between prod and bench would
  * mask tool-routing bugs in eval. */
@@ -6598,6 +6671,16 @@ declare const RECALL_TOOL_NAME = "recall_memory";
 /** Maximum results the executor will return to the LLM, regardless of
  * the LLM-supplied `limit`. */
 declare const RECALL_MAX_LIMIT = 50;
+
+/**
+ * Unified Recall Tool
+ *
+ * Single chat-completion tool that searches both vault facts and
+ * conversation chunks via `recall()`. Replaces the legacy pair of
+ * `memory_vault_search` (facts) + `search_memory` (chunks) — the LLM no
+ * longer has to route between two tools.
+ */
+
 interface RecallToolOptions {
     /** Lanes to search. Default: ["fact", "chunk"]. */
     types?: MemoryKind[];

package/dist/server/index.d.ts

@@ -2741,6 +2741,33 @@ interface CachedServerTools {
     /** Checksum from the server for cache invalidation */
     checksum?: string;
 }
+/**
+ * Pluggable persistence for the fetched server-tools list.
+ *
+ * The default backend ({@link localStorageToolsCache}) writes to browser
+ * `localStorage` and is a silent no-op where `localStorage` is undefined
+ * (Node, React Native). Pass a custom backend to `getServerTools` to cache
+ * somewhere that survives on those platforms — e.g. an AsyncStorage/MMKV
+ * adapter on RN, or an in-memory `Map` on a server. Methods may be sync or
+ * async; `getServerTools` awaits them either way.
+ *
+ * The stored payload carries a `version`; `getServerTools` discards any entry
+ * whose version does not match the current cache format, so a stale custom
+ * backend can never feed an incompatible shape back into selection.
+ */
+interface ToolsCacheBackend {
+    /** Return the cached payload, or null when absent/unreadable. */
+    get(): CachedServerTools | null | Promise<CachedServerTools | null>;
+    /** Persist the payload. Implementations should swallow write failures. */
+    set(value: CachedServerTools): void | Promise<void>;
+    /**
+     * Remove the cached payload. Optional — a read/write-only backend may omit it,
+     * in which case `clearServerToolsCache` (and the version-mismatch
+     * invalidation) is a no-op for that backend. The default
+     * {@link localStorageToolsCache} implements it.
+     */
+    clear?(): void | Promise<void>;
+}
 /**
  * Options for fetching server tools
  */
@@ -2755,6 +2782,12 @@ interface ServerToolsOptions {
     getToken?: () => Promise<string | null>;
     /** Direct API key for server-side usage (uses X-API-Key header) */
     apiKey?: string;
+    /**
+     * Where to read/write the cached tools list. Defaults to
+     * {@link localStorageToolsCache} (browser `localStorage`; no-op elsewhere).
+     * Provide a backend to enable caching on Node / React Native.
+     */
+    cache?: ToolsCacheBackend;
 }
 /** Default cache expiration: 1 day */
 declare const DEFAULT_CACHE_EXPIRATION_MS: number;
@@ -2770,14 +2803,21 @@ interface ParsedServerToolsResponse {
  */
 declare function getCachedServerTools(): CachedServerTools | null;
 /**
- * Clear the server tools cache
+ * Clear the cached server tools. Defaults to the browser-`localStorage` backend;
+ * pass the SAME {@link ToolsCacheBackend} you gave `getServerTools` to invalidate
+ * a custom backend (a no-op when that backend defines no `clear`). Returns the
+ * backend's clear result, which may be async.
  */
 declare function clearServerToolsCache(): void;
+declare function clearServerToolsCache(cache: ToolsCacheBackend): void | Promise<void>;
 /**
- * Get the checksum of currently cached tools.
- * Returns undefined if no cache or no checksum stored.
+ * Get the checksum of the currently cached tools, or undefined when there is no
+ * cache / no stored checksum. Defaults to the browser-`localStorage` backend;
+ * pass the SAME backend you gave `getServerTools` to read a custom backend's
+ * checksum (an async backend yields a promise).
  */
 declare function getToolsChecksum(): string | undefined;
+declare function getToolsChecksum(cache: ToolsCacheBackend): string | undefined | Promise<string | undefined>;
 /**
  * Check if tools should be refreshed based on checksum comparison.
  * Returns true if:
@@ -2789,11 +2829,12 @@ declare function getToolsChecksum(): string | undefined;
  * - Checksums match
  */
 declare function shouldRefreshTools(responseChecksum: string | undefined): boolean;
+declare function shouldRefreshTools(responseChecksum: string | undefined, cache: ToolsCacheBackend | undefined): boolean | Promise<boolean>;
 /**
  * Get server tools with caching support.
  *
  * Flow:
- * 1. Check localStorage cache
+ * 1. Check the cache backend (localStorage by default; override via `cache`)
  * 2. If cache valid and not force refresh, return cached tools
  * 3. Otherwise, fetch from API, cache, and return
  * 4. On fetch failure, return cached tools if available (stale-while-error)
@@ -3085,6 +3126,11 @@ interface SelectServerToolsForPromptOptions {
     embeddingModel?: string;
     /** Cache expiration in ms for the server-tools catalog fetch. */
     cacheExpirationMs?: number;
+    /**
+     * Where to read/write the cached catalog. Defaults to browser `localStorage`
+     * (a no-op on Node/RN); pass a backend to persist on those platforms.
+     */
+    cache?: ToolsCacheBackend;
     /**
      * Phase 3 defer-loading. When `enabled`, this helper returns the FULL catalog (skipping semantic/
      * static filtering) to mirror useChatStorage's responses send path, which swaps in the full catalog
@@ -5366,11 +5412,26 @@ interface EmbeddingOptions {
 }
 
 /**
- * Memory Retrieval Embeddings
+ * Embedding generation — dependency-free core.
+ *
+ * The raw "text → embedding" calls, split out of `embeddings.ts` so they can be
+ * imported by node/React-Native-safe modules (the server-tool + client-tool
+ * selection engine in `../tools`) WITHOUT pulling in the WatermelonDB-backed
+ * `db/chat/operations` that `embeddings.ts` needs for its message-persistence
+ * helpers (`embedMessage`, `embedAllMessages`, `chunkAndEmbed*`).
  *
- * Functions for generating and storing embeddings for conversation messages.
+ * Nothing here touches the database; the only I/O is the HTTP embeddings
+ * endpoint. `embeddings.ts` re-exports these so existing importers of
+ * `../memoryEngine/embeddings` (and the `../memoryEngine` barrel) keep working.
  */
 
+/**
+ * Generate an embedding for text using the API
+ *
+ * Supports two auth methods:
+ * - `apiKey`: Uses X-API-Key header (for server-side/CLI usage)
+ * - `getToken`: Uses Authorization: Bearer header (for Privy identity tokens)
+ */
 declare function generateEmbedding(text: string, options: EmbeddingOptions): Promise<number[]>;
 /**
  * Generate embeddings for multiple texts, automatically chunking large inputs.
@@ -5385,6 +5446,18 @@ declare function generateEmbedding(text: string, options: EmbeddingOptions): Pro
  * @returns Array of embeddings in the same order as input texts
  */
 declare function generateEmbeddings(texts: string[], options: EmbeddingOptions): Promise<number[][]>;
+
+/**
+ * Memory Retrieval Embeddings
+ *
+ * Message-level embedding + persistence helpers: find messages via the
+ * WatermelonDB-backed `db/chat/operations`, embed their content, and store the
+ * vectors/chunks back. The raw "text → embedding" calls live in `./generate`
+ * (dependency-free so the tool-selection engine can import them without the DB
+ * layer) and are re-exported here so existing importers of
+ * `../memoryEngine/embeddings` and the `../memoryEngine` barrel keep working.
+ */
+
 /**
  * Embed a single message and store the embedding in the database
  *
@@ -6583,14 +6656,14 @@ declare function createChunkVectorCache(maxSize?: number): ChunkVectorCache;
 declare function recall(query: string, ctx: RecallContext, options?: RecallOptions): Promise<RecallResult>;
 
 /**
- * Unified Recall Tool
+ * Recall tool constants — deliberately dependency-free.
  *
- * Single chat-completion tool that searches both vault facts and
- * conversation chunks via `recall()`. Replaces the legacy pair of
- * `memory_vault_search` (facts) + `search_memory` (chunks) — the LLM no
- * longer has to route between two tools.
+ * Split out of `recallTool.ts` so the tool NAME can be referenced from
+ * node/React-Native-safe modules (e.g. the client-tool selector in
+ * `../tools/clientToolSelection`) without dragging `recall()` and its
+ * WatermelonDB-backed operations into the module graph. `recallTool.ts`
+ * re-exports these to preserve their public identity.
  */
-
 /** Tool name surfaced to the LLM. Exported so bench harnesses and chat
  * clients reference the same string — drift between prod and bench would
  * mask tool-routing bugs in eval. */
@@ -6598,6 +6671,16 @@ declare const RECALL_TOOL_NAME = "recall_memory";
 /** Maximum results the executor will return to the LLM, regardless of
  * the LLM-supplied `limit`. */
 declare const RECALL_MAX_LIMIT = 50;
+
+/**
+ * Unified Recall Tool
+ *
+ * Single chat-completion tool that searches both vault facts and
+ * conversation chunks via `recall()`. Replaces the legacy pair of
+ * `memory_vault_search` (facts) + `search_memory` (chunks) — the LLM no
+ * longer has to route between two tools.
+ */
+
 interface RecallToolOptions {
     /** Lanes to search. Default: ["fact", "chunk"]. */
     types?: MemoryKind[];

package/dist/server/index.mjs

@@ -22,7 +22,6 @@ import {
   createConversationOp,
   createMemoryVaultSearchTool,
   createMessageOp,
-  createSseClient,
   createSupersedingMemoryOp,
   createVaultEmbeddingCache,
   createVaultMemoriesBatchOp,
@@ -108,7 +107,7 @@ import {
   updateVaultMemoryOp,
   upsertMessageOp,
   vaultMemoryToStored
-} from "./chunk-QQOIC37O.mjs";
+} from "./chunk-RKUNGNBF.mjs";
 import {
   createStreamingDeAnonymizer,
   resolvePiiRedactor
@@ -5501,9 +5500,11 @@ function createChunkVectorCache(maxSize = DEFAULT_CHUNK_CACHE_SIZE) {
   return new LRUCache(maxSize);
 }
 
-// src/lib/memory/recallTool.ts
+// src/lib/memory/recallConstants.ts
 var RECALL_TOOL_NAME = "recall_memory";
 var RECALL_MAX_LIMIT = 50;
+
+// src/lib/memory/recallTool.ts
 var DEFAULT_LIMIT = 8;
 var DEFAULT_BUDGET = "low";
 function formatEventTime(start, end, kind) {
@@ -6062,7 +6063,7 @@ function getCachedServerTools() {
     if (!cached) return null;
     const parsed = JSON.parse(cached);
     if (parsed.version !== CACHE_VERSION) {
-      clearServerToolsCache();
+      removeLocalStorageCache();
       return null;
     }
     return parsed;
@@ -6074,37 +6075,45 @@ function isCacheExpired(cache, expirationMs = DEFAULT_CACHE_EXPIRATION_MS) {
   if (!cache) return true;
   return Date.now() - cache.timestamp > expirationMs;
 }
-function cacheServerTools(tools, checksum) {
-  if (typeof localStorage === "undefined") return;
-  const cacheData = {
+function buildCacheEntry(tools, checksum) {
+  return {
     tools,
     timestamp: Date.now(),
     version: CACHE_VERSION,
     ...checksum && { checksum }
   };
+}
+function writeLocalStorageCache(entry) {
+  if (typeof localStorage === "undefined") return;
   try {
-    localStorage.setItem(SERVER_TOOLS_CACHE_KEY, JSON.stringify(cacheData));
+    localStorage.setItem(SERVER_TOOLS_CACHE_KEY, JSON.stringify(entry));
   } catch (error) {
     getLogger().warn("[serverTools] Failed to cache tools:", error);
   }
 }
-function clearServerToolsCache() {
+function removeLocalStorageCache() {
   if (typeof localStorage === "undefined") return;
   localStorage.removeItem(SERVER_TOOLS_CACHE_KEY);
 }
-function getToolsChecksum() {
-  const cached = getCachedServerTools();
-  return cached?.checksum;
+var localStorageToolsCache = {
+  get: getCachedServerTools,
+  set: writeLocalStorageCache,
+  clear: removeLocalStorageCache
+};
+function clearServerToolsCache(cache = localStorageToolsCache) {
+  return cache.clear?.();
+}
+function getToolsChecksum(cache = localStorageToolsCache) {
+  const cached = cache.get();
+  return cached instanceof Promise ? cached.then((c) => c?.checksum) : cached?.checksum;
 }
-function shouldRefreshTools(responseChecksum) {
+function shouldRefreshTools(responseChecksum, cache = localStorageToolsCache) {
   if (!responseChecksum) {
     return false;
   }
-  const cachedChecksum = getToolsChecksum();
-  if (!cachedChecksum) {
-    return true;
-  }
-  return cachedChecksum !== responseChecksum;
+  const decide = (cachedChecksum2) => !cachedChecksum2 || cachedChecksum2 !== responseChecksum;
+  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`, {
@@ -6126,9 +6135,23 @@ async function getServerTools(options) {
     cacheExpirationMs = DEFAULT_CACHE_EXPIRATION_MS,
     forceRefresh = false,
     getToken,
-    apiKey
+    apiKey,
+    cache = localStorageToolsCache
   } = options;
-  const cached = getCachedServerTools();
+  const persistCache = async (entry) => {
+    try {
+      await cache.set(entry);
+    } catch (error) {
+      getLogger().warn("[serverTools] Cache write failed (non-fatal):", error);
+    }
+  };
+  let rawCached = null;
+  try {
+    rawCached = await cache.get();
+  } catch (error) {
+    getLogger().warn("[serverTools] Cache read failed; falling through to server fetch:", error);
+  }
+  const cached = rawCached && rawCached.version === CACHE_VERSION ? rawCached : null;
   const cacheValid = !isCacheExpired(cached, cacheExpirationMs);
   if (cached && cacheValid && !forceRefresh) {
     return cached.tools;
@@ -6149,7 +6172,7 @@ async function getServerTools(options) {
       }
       const data = await response.json();
       const { tools: tools2, checksum: checksum2 } = convertServerToolsResponse(data);
-      cacheServerTools(tools2, checksum2);
+      await persistCache(buildCacheEntry(tools2, checksum2));
       return tools2;
     }
     if (!getToken) {
@@ -6162,7 +6185,7 @@ async function getServerTools(options) {
       return cached?.tools ?? [];
     }
     const { tools, checksum } = await fetchServerToolsFromApi(effectiveBaseUrl, token);
-    cacheServerTools(tools, checksum);
+    await persistCache(buildCacheEntry(tools, checksum));
     return tools;
   } catch (error) {
     getLogger().error("[serverTools] Failed to fetch server tools:", error);
@@ -6546,13 +6569,14 @@ async function selectServerToolsForPrompt(options) {
     baseUrl,
     embeddingModel,
     cacheExpirationMs,
+    cache,
     deferLoading
   } = options;
   if (serverToolsFilter === void 0) return [];
   if (Array.isArray(serverToolsFilter) && serverToolsFilter.length === 0) return [];
   let allServerTools;
   try {
-    allServerTools = await getServerTools({ baseUrl, cacheExpirationMs, getToken });
+    allServerTools = await getServerTools({ baseUrl, cacheExpirationMs, getToken, cache });
   } catch {
     return [];
   }
@@ -7887,6 +7911,141 @@ function createCryptoPricePreProcessor(options = {}) {
   };
 }
 
+// src/client/core/serverSentEvents.gen.ts
+var createSseClient = ({
+  onRequest,
+  onSseError,
+  onSseEvent,
+  responseTransformer,
+  responseValidator,
+  sseDefaultRetryDelay,
+  sseMaxRetryAttempts,
+  sseMaxRetryDelay,
+  sseSleepFn,
+  url,
+  ...options
+}) => {
+  let lastEventId;
+  const sleep3 = sseSleepFn ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const createStream = async function* () {
+    let retryDelay = sseDefaultRetryDelay ?? 3e3;
+    let attempt = 0;
+    const signal = options.signal ?? new AbortController().signal;
+    while (true) {
+      if (signal.aborted) break;
+      attempt++;
+      const headers = options.headers instanceof Headers ? options.headers : new Headers(options.headers);
+      if (lastEventId !== void 0) {
+        headers.set("Last-Event-ID", lastEventId);
+      }
+      try {
+        const requestInit = {
+          redirect: "follow",
+          ...options,
+          body: options.serializedBody,
+          headers,
+          signal
+        };
+        let request = new Request(url, requestInit);
+        if (onRequest) {
+          request = await onRequest(url, requestInit);
+        }
+        const _fetch = options.fetch ?? globalThis.fetch;
+        const response = await _fetch(request);
+        if (!response.ok)
+          throw new Error(
+            `SSE failed: ${response.status} ${response.statusText}`
+          );
+        if (!response.body) throw new Error("No body in SSE response");
+        const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
+        let buffer = "";
+        const abortHandler = () => {
+          try {
+            reader.cancel();
+          } catch {
+          }
+        };
+        signal.addEventListener("abort", abortHandler);
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            buffer += value;
+            const chunks = buffer.split("\n\n");
+            buffer = chunks.pop() ?? "";
+            for (const chunk of chunks) {
+              const lines = chunk.split("\n");
+              const dataLines = [];
+              let eventName;
+              for (const line of lines) {
+                if (line.startsWith("data:")) {
+                  dataLines.push(line.replace(/^data:\s*/, ""));
+                } else if (line.startsWith("event:")) {
+                  eventName = line.replace(/^event:\s*/, "");
+                } else if (line.startsWith("id:")) {
+                  lastEventId = line.replace(/^id:\s*/, "");
+                } else if (line.startsWith("retry:")) {
+                  const parsed = Number.parseInt(
+                    line.replace(/^retry:\s*/, ""),
+                    10
+                  );
+                  if (!Number.isNaN(parsed)) {
+                    retryDelay = parsed;
+                  }
+                }
+              }
+              let data;
+              let parsedJson = false;
+              if (dataLines.length) {
+                const rawData = dataLines.join("\n");
+                try {
+                  data = JSON.parse(rawData);
+                  parsedJson = true;
+                } catch {
+                  data = rawData;
+                }
+              }
+              if (parsedJson) {
+                if (responseValidator) {
+                  await responseValidator(data);
+                }
+                if (responseTransformer) {
+                  data = await responseTransformer(data);
+                }
+              }
+              onSseEvent?.({
+                data,
+                event: eventName,
+                id: lastEventId,
+                retry: retryDelay
+              });
+              if (dataLines.length) {
+                yield data;
+              }
+            }
+          }
+        } finally {
+          signal.removeEventListener("abort", abortHandler);
+          reader.releaseLock();
+        }
+        break;
+      } catch (error) {
+        onSseError?.(error);
+        if (sseMaxRetryAttempts !== void 0 && attempt >= sseMaxRetryAttempts) {
+          break;
+        }
+        const backoff = Math.min(
+          retryDelay * 2 ** (attempt - 1),
+          sseMaxRetryDelay ?? 3e4
+        );
+        await sleep3(backoff);
+      }
+    }
+  };
+  const stream = createStream();
+  return { stream };
+};
+
 // src/lib/chat/runHooks.ts
 function composeHooks(hooks) {
   const handlers = hooks.filter((h) => h !== void 0 && h !== null);

package/dist/server/{recall-6QLUEYB7.mjs → recall-WT5HY2IA.mjs}

@@ -1,6 +1,6 @@
 import {
   recall
-} from "./chunk-QQOIC37O.mjs";
+} from "./chunk-RKUNGNBF.mjs";
 import "./chunk-AHJT66EO.mjs";
 import "./chunk-3RPGXXPZ.mjs";
 export {