@reverbia/sdk 1.0.0-next.20251202085711 → 1.0.0-next.20251202092727

package/dist/react/index.d.mts

@@ -177,7 +177,7 @@ type LlmapiRole = string;
 
 type SendMessageArgs = {
     messages: LlmapiMessage[];
-    model: string;
+    model?: string;
     /**
      * Per-request callback for data chunks. Called in addition to the global
      * `onData` callback if provided in `useChat` options.
@@ -215,6 +215,17 @@ type UseChatOptions = {
      * @param error - The error that occurred (never an AbortError)
      */
     onError?: (error: Error) => void;
+    /**
+     * The provider to use for chat completions (default: "api")
+     * "local": Uses a local HuggingFace model (in-browser)
+     * "api": Uses the backend API
+     */
+    chatProvider?: "api" | "local";
+    /**
+     * The model to use for local chat completions
+     * Default is "ibm-granite/Granite-4.0-Nano-WebGPU"
+     */
+    localModel?: string;
 };
 type UseChatResult = {
     isLoading: boolean;
@@ -244,6 +255,8 @@ type UseChatResult = {
  * @param options.onFinish - Callback function to be called when the chat completion finishes successfully.
  * @param options.onError - Callback function to be called when an unexpected error
  *   is encountered. Note: This is NOT called for aborted requests (see `stop()`).
+ * @param options.chatProvider - The provider to use for chat completions (default: "api").
+ * @param options.localModel - The model to use for local chat completions.
  *
  * @returns An object containing:
  *   - `isLoading`: A boolean indicating whether a request is currently in progress
@@ -339,12 +352,20 @@ type UseMemoryOptions = {
     /**
      * The model to use for fact extraction (default: "openai/gpt-4o")
      */
-    memoryModel?: string;
+    completionsModel?: string;
     /**
-     * The model to use for generating embeddings (default: "openai/text-embedding-3-small")
-     * Set to null/undefined to disable embedding generation
+     * The model to use for generating embeddings
+     * For local: default is "Snowflake/snowflake-arctic-embed-xs"
+     * For api: default is "openai/text-embedding-3-small"
+     * Set to null to disable embedding generation
      */
     embeddingModel?: string | null;
+    /**
+     * The provider to use for generating embeddings (default: "local")
+     * "local": Uses a local HuggingFace model (in-browser)
+     * "api": Uses the backend API
+     */
+    embeddingProvider?: "local" | "api";
     /**
      * Whether to automatically generate embeddings for extracted memories (default: true)
      */

package/dist/react/index.d.ts

@@ -177,7 +177,7 @@ type LlmapiRole = string;
 
 type SendMessageArgs = {
     messages: LlmapiMessage[];
-    model: string;
+    model?: string;
     /**
      * Per-request callback for data chunks. Called in addition to the global
      * `onData` callback if provided in `useChat` options.
@@ -215,6 +215,17 @@ type UseChatOptions = {
      * @param error - The error that occurred (never an AbortError)
      */
     onError?: (error: Error) => void;
+    /**
+     * The provider to use for chat completions (default: "api")
+     * "local": Uses a local HuggingFace model (in-browser)
+     * "api": Uses the backend API
+     */
+    chatProvider?: "api" | "local";
+    /**
+     * The model to use for local chat completions
+     * Default is "ibm-granite/Granite-4.0-Nano-WebGPU"
+     */
+    localModel?: string;
 };
 type UseChatResult = {
     isLoading: boolean;
@@ -244,6 +255,8 @@ type UseChatResult = {
  * @param options.onFinish - Callback function to be called when the chat completion finishes successfully.
  * @param options.onError - Callback function to be called when an unexpected error
  *   is encountered. Note: This is NOT called for aborted requests (see `stop()`).
+ * @param options.chatProvider - The provider to use for chat completions (default: "api").
+ * @param options.localModel - The model to use for local chat completions.
  *
  * @returns An object containing:
  *   - `isLoading`: A boolean indicating whether a request is currently in progress
@@ -339,12 +352,20 @@ type UseMemoryOptions = {
     /**
      * The model to use for fact extraction (default: "openai/gpt-4o")
      */
-    memoryModel?: string;
+    completionsModel?: string;
     /**
-     * The model to use for generating embeddings (default: "openai/text-embedding-3-small")
-     * Set to null/undefined to disable embedding generation
+     * The model to use for generating embeddings
+     * For local: default is "Snowflake/snowflake-arctic-embed-xs"
+     * For api: default is "openai/text-embedding-3-small"
+     * Set to null to disable embedding generation
      */
     embeddingModel?: string | null;
+    /**
+     * The provider to use for generating embeddings (default: "local")
+     * "local": Uses a local HuggingFace model (in-browser)
+     * "api": Uses the backend API
+     */
+    embeddingProvider?: "local" | "api";
     /**
      * Whether to automatically generate embeddings for extracted memories (default: true)
      */

package/dist/react/index.mjs

@@ -1,3 +1,5 @@
+import "./chunk-FBCDBTKJ.mjs";
+
 // src/react/useChat.ts
 import { useCallback, useEffect, useRef, useState } from "react";
 
@@ -816,6 +818,54 @@ var createClientConfig = (config) => ({
 // src/client/client.gen.ts
 var client = createClient(createClientConfig(createConfig()));
 
+// src/lib/chat/constants.ts
+var DEFAULT_LOCAL_CHAT_MODEL = "onnx-community/Qwen2.5-0.5B-Instruct";
+
+// src/lib/chat/generation.ts
+var chatPipeline = null;
+var currentModel = null;
+async function generateLocalChatCompletion(messages, options = {}) {
+  const {
+    model = DEFAULT_LOCAL_CHAT_MODEL,
+    temperature = 0.7,
+    max_tokens = 1024,
+    top_p = 0.9,
+    onToken,
+    signal
+  } = options;
+  const { pipeline, TextStreamer } = await import("./transformers.node-BSHUG7OY.mjs");
+  if (!chatPipeline || currentModel !== model) {
+    chatPipeline = await pipeline("text-generation", model, {
+      dtype: "fp16"
+    });
+    currentModel = model;
+  }
+  class CallbackStreamer extends TextStreamer {
+    constructor(tokenizer, cb) {
+      super(tokenizer, {
+        skip_prompt: true,
+        skip_special_tokens: true
+      });
+      this.cb = cb;
+    }
+    on_finalized_text(text) {
+      if (signal?.aborted) {
+        throw new Error("AbortError");
+      }
+      this.cb(text);
+    }
+  }
+  const streamer = onToken ? new CallbackStreamer(chatPipeline.tokenizer, onToken) : void 0;
+  const output = await chatPipeline(messages, {
+    max_new_tokens: max_tokens,
+    temperature,
+    top_p,
+    streamer,
+    return_full_text: false
+  });
+  return output;
+}
+
 // src/react/useChat.ts
 function useChat(options) {
   const {
@@ -823,7 +873,9 @@ function useChat(options) {
     baseUrl = BASE_URL,
     onData: globalOnData,
     onFinish,
-    onError
+    onError,
+    chatProvider = "api",
+    localModel = DEFAULT_LOCAL_CHAT_MODEL
   } = options || {};
   const [isLoading, setIsLoading] = useState(false);
   const abortControllerRef = useRef(null);
@@ -852,16 +904,6 @@ function useChat(options) {
         if (onError) onError(new Error(errorMsg));
         return { data: null, error: errorMsg };
       }
-      if (!model) {
-        const errorMsg = "model is required to call sendMessage.";
-        if (onError) onError(new Error(errorMsg));
-        return { data: null, error: errorMsg };
-      }
-      if (!getToken) {
-        const errorMsg = "Token getter function is required.";
-        if (onError) onError(new Error(errorMsg));
-        return { data: null, error: errorMsg };
-      }
       if (abortControllerRef.current) {
         abortControllerRef.current.abort();
       }
@@ -869,88 +911,141 @@ function useChat(options) {
       abortControllerRef.current = abortController;
       setIsLoading(true);
       try {
-        const token = await getToken();
-        if (!token) {
-          const errorMsg = "No access token available.";
-          setIsLoading(false);
-          if (onError) onError(new Error(errorMsg));
-          return { data: null, error: errorMsg };
-        }
-        const sseResult = await client.sse.post({
-          baseUrl,
-          url: "/api/v1/chat/completions",
-          body: {
-            messages,
-            model,
-            stream: true
-          },
-          headers: {
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${token}`
-          },
-          signal: abortController.signal
-        });
-        let accumulatedContent = "";
-        let completionId = "";
-        let completionModel = "";
-        let accumulatedUsage = {};
-        let finishReason;
-        for await (const chunk of sseResult.stream) {
-          if (typeof chunk === "string" && (chunk.trim() === "[DONE]" || chunk.includes("[DONE]"))) {
-            continue;
-          }
-          if (chunk && typeof chunk === "object") {
-            const chunkData = chunk;
-            if (chunkData.id && !completionId) {
-              completionId = chunkData.id;
+        if (chatProvider === "local") {
+          let accumulatedContent = "";
+          const usedModel = localModel;
+          const formattedMessages = messages.map((m) => ({
+            role: m.role || "user",
+            content: m.content || ""
+          }));
+          await generateLocalChatCompletion(formattedMessages, {
+            model: usedModel,
+            signal: abortController.signal,
+            onToken: (token) => {
+              accumulatedContent += token;
+              if (onData) onData(token);
+              if (globalOnData) globalOnData(token);
             }
-            if (chunkData.model && !completionModel) {
-              completionModel = chunkData.model;
+          });
+          const completion = {
+            id: `local-${Date.now()}`,
+            model: usedModel,
+            choices: [
+              {
+                index: 0,
+                message: {
+                  role: "assistant",
+                  content: accumulatedContent
+                },
+                finish_reason: "stop"
+              }
+            ],
+            usage: {
+              prompt_tokens: 0,
+              // Not easily available from simple pipeline usage
+              completion_tokens: 0,
+              total_tokens: 0
             }
-            if (chunkData.usage) {
-              accumulatedUsage = {
-                ...accumulatedUsage,
-                ...chunkData.usage
-              };
+          };
+          setIsLoading(false);
+          if (onFinish) {
+            onFinish(completion);
+          }
+          return { data: completion, error: null };
+        } else {
+          if (!model) {
+            const errorMsg = "model is required to call sendMessage.";
+            if (onError) onError(new Error(errorMsg));
+            return { data: null, error: errorMsg };
+          }
+          if (!getToken) {
+            const errorMsg = "Token getter function is required.";
+            if (onError) onError(new Error(errorMsg));
+            return { data: null, error: errorMsg };
+          }
+          const token = await getToken();
+          if (!token) {
+            const errorMsg = "No access token available.";
+            setIsLoading(false);
+            if (onError) onError(new Error(errorMsg));
+            return { data: null, error: errorMsg };
+          }
+          const sseResult = await client.sse.post({
+            baseUrl,
+            url: "/api/v1/chat/completions",
+            body: {
+              messages,
+              model,
+              stream: true
+            },
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `Bearer ${token}`
+            },
+            signal: abortController.signal
+          });
+          let accumulatedContent = "";
+          let completionId = "";
+          let completionModel = "";
+          let accumulatedUsage = {};
+          let finishReason;
+          for await (const chunk of sseResult.stream) {
+            if (typeof chunk === "string" && (chunk.trim() === "[DONE]" || chunk.includes("[DONE]"))) {
+              continue;
             }
-            if (chunkData.choices && Array.isArray(chunkData.choices) && chunkData.choices.length > 0) {
-              const choice = chunkData.choices[0];
-              if (choice.delta?.content) {
-                const content = choice.delta.content;
-                accumulatedContent += content;
-                if (onData) {
-                  onData(content);
+            if (chunk && typeof chunk === "object") {
+              const chunkData = chunk;
+              if (chunkData.id && !completionId) {
+                completionId = chunkData.id;
+              }
+              if (chunkData.model && !completionModel) {
+                completionModel = chunkData.model;
+              }
+              if (chunkData.usage) {
+                accumulatedUsage = {
+                  ...accumulatedUsage,
+                  ...chunkData.usage
+                };
+              }
+              if (chunkData.choices && Array.isArray(chunkData.choices) && chunkData.choices.length > 0) {
+                const choice = chunkData.choices[0];
+                if (choice.delta?.content) {
+                  const content = choice.delta.content;
+                  accumulatedContent += content;
+                  if (onData) {
+                    onData(content);
+                  }
+                  if (globalOnData) {
+                    globalOnData(content);
+                  }
                 }
-                if (globalOnData) {
-                  globalOnData(content);
+                if (choice.finish_reason) {
+                  finishReason = choice.finish_reason;
                 }
               }
-              if (choice.finish_reason) {
-                finishReason = choice.finish_reason;
-              }
             }
           }
+          const completion = {
+            id: completionId,
+            model: completionModel,
+            choices: [
+              {
+                index: 0,
+                message: {
+                  role: "assistant",
+                  content: accumulatedContent
+                },
+                finish_reason: finishReason
+              }
+            ],
+            usage: Object.keys(accumulatedUsage).length > 0 ? accumulatedUsage : void 0
+          };
+          setIsLoading(false);
+          if (onFinish) {
+            onFinish(completion);
+          }
+          return { data: completion, error: null };
         }
-        const completion = {
-          id: completionId,
-          model: completionModel,
-          choices: [
-            {
-              index: 0,
-              message: {
-                role: "assistant",
-                content: accumulatedContent
-              },
-              finish_reason: finishReason
-            }
-          ],
-          usage: Object.keys(accumulatedUsage).length > 0 ? accumulatedUsage : void 0
-        };
-        setIsLoading(false);
-        if (onFinish) {
-          onFinish(completion);
-        }
-        return { data: completion, error: null };
       } catch (err) {
         if (err instanceof Error && err.name === "AbortError") {
           setIsLoading(false);
@@ -969,7 +1064,15 @@ function useChat(options) {
         }
       }
     },
-    [getToken, baseUrl, globalOnData, onFinish, onError]
+    [
+      getToken,
+      baseUrl,
+      globalOnData,
+      onFinish,
+      onError,
+      chatProvider,
+      localModel
+    ]
   );
   return {
     isLoading,
@@ -1372,37 +1475,61 @@ var getApiV1Models = (options) => {
   });
 };
 
+// src/lib/memory/constants.ts
+var DEFAULT_LOCAL_EMBEDDING_MODEL = "Snowflake/snowflake-arctic-embed-xs";
+var DEFAULT_API_EMBEDDING_MODEL = "openai/text-embedding-3-small";
+var DEFAULT_COMPLETION_MODEL = "openai/gpt-4o";
+
 // src/lib/memory/embeddings.ts
+var embeddingPipeline = null;
 var generateEmbeddingForText = async (text, options = {}) => {
-  const {
-    model = "openai/text-embedding-3-small",
-    getToken,
-    baseUrl = BASE_URL
-  } = options;
-  try {
-    const token = getToken ? await getToken() : null;
-    const headers = {};
-    if (token) {
-      headers.Authorization = `Bearer ${token}`;
+  const { baseUrl = BASE_URL, provider = "local" } = options;
+  if (provider === "api") {
+    const { getToken, model: model2 } = options;
+    if (!getToken) {
+      throw new Error("getToken is required for API embeddings");
+    }
+    const token = await getToken();
+    if (!token) {
+      throw new Error("No access token available for API embeddings");
     }
     const response = await postApiV1Embeddings({
       baseUrl,
       body: {
         input: text,
-        model
+        model: model2
       },
-      headers
+      headers: {
+        Authorization: `Bearer ${token}`
+      }
     });
-    if (!response.data || !response.data.data || response.data.data.length === 0) {
+    if (response.error) {
       throw new Error(
-        `Failed to generate embedding: ${response.error?.error ?? "No data returned"}`
+        typeof response.error === "object" && response.error && "error" in response.error ? response.error.error : "API embedding failed"
       );
     }
-    const embedding = response.data.data[0]?.embedding;
-    if (!embedding || !Array.isArray(embedding)) {
-      throw new Error("Invalid embedding format returned from API");
+    if (!response.data?.data?.[0]?.embedding) {
+      throw new Error("No embedding returned from API");
+    }
+    return response.data.data[0].embedding;
+  }
+  let { model } = options;
+  if (!model || model === DEFAULT_API_EMBEDDING_MODEL) {
+    model = DEFAULT_LOCAL_EMBEDDING_MODEL;
+  }
+  try {
+    if (!embeddingPipeline) {
+      const { pipeline } = await import("./transformers.node-BSHUG7OY.mjs");
+      embeddingPipeline = await pipeline("feature-extraction", model);
+    }
+    const output = await embeddingPipeline(text, {
+      pooling: "cls",
+      normalize: true
+    });
+    if (output?.data) {
+      return Array.from(output.data);
     }
-    return embedding;
+    throw new Error("Invalid embedding output from transformers.js");
   } catch (error) {
     console.error("Failed to generate embedding:", error);
     throw error;
@@ -1419,20 +1546,11 @@ var generateEmbeddingForMemory = async (memory, options = {}) => {
   return generateEmbeddingForText(text, options);
 };
 var generateEmbeddingsForMemories = async (memories, options = {}) => {
-  const {
-    model = "openai/text-embedding-3-small",
-    getToken,
-    baseUrl = BASE_URL
-  } = options;
   const embeddings = /* @__PURE__ */ new Map();
   for (const memory of memories) {
     const uniqueKey = `${memory.namespace}:${memory.key}:${memory.value}`;
     try {
-      const embedding = await generateEmbeddingForMemory(memory, {
-        model,
-        getToken,
-        baseUrl
-      });
+      const embedding = await generateEmbeddingForMemory(memory, options);
       embeddings.set(uniqueKey, embedding);
     } catch (error) {
       console.error(
@@ -1464,29 +1582,42 @@ var updateMemoriesWithEmbeddings = async (embeddings, embeddingModel) => {
   await Promise.all(updates);
 };
 var generateAndStoreEmbeddings = async (memories, options = {}) => {
-  const { model = "openai/text-embedding-3-small" } = options;
+  let { model } = options;
+  const { provider = "local" } = options;
+  if (!model) {
+    if (provider === "local") {
+      model = DEFAULT_LOCAL_EMBEDDING_MODEL;
+    } else {
+      model = DEFAULT_API_EMBEDDING_MODEL;
+    }
+  }
+  if (provider === "local" && model === DEFAULT_API_EMBEDDING_MODEL) {
+    model = DEFAULT_LOCAL_EMBEDDING_MODEL;
+  }
   if (memories.length === 0) {
     return;
   }
   console.log(`Generating embeddings for ${memories.length} memories...`);
-  const embeddings = await generateEmbeddingsForMemories(memories, options);
+  const embeddings = await generateEmbeddingsForMemories(memories, {
+    ...options,
+    model
+  });
   await updateMemoriesWithEmbeddings(embeddings, model);
   console.log(`Generated and stored ${embeddings.size} embeddings`);
 };
-var generateQueryEmbedding = async (query, options = {}) => {
-  return generateEmbeddingForText(query, options);
-};
 
 // src/react/useMemory.ts
 function useMemory(options = {}) {
   const {
-    memoryModel = "openai/gpt-4o",
-    embeddingModel = "openai/text-embedding-3-small",
+    completionsModel = DEFAULT_COMPLETION_MODEL,
+    embeddingModel: userEmbeddingModel,
+    embeddingProvider = "local",
     generateEmbeddings = true,
     onFactsExtracted,
     getToken,
     baseUrl = BASE_URL
   } = options;
+  const embeddingModel = userEmbeddingModel === void 0 ? embeddingProvider === "local" ? DEFAULT_LOCAL_EMBEDDING_MODEL : DEFAULT_API_EMBEDDING_MODEL : userEmbeddingModel;
   const extractionInProgressRef = useRef3(false);
   const extractMemoriesFromMessage = useCallback2(
     async (options2) => {
@@ -1511,7 +1642,7 @@ function useMemory(options = {}) {
               },
               ...messages
             ],
-            model: model || memoryModel
+            model: model || completionsModel
           },
           headers: {
             Authorization: `Bearer ${token}`
@@ -1626,6 +1757,7 @@ function useMemory(options = {}) {
               try {
                 await generateAndStoreEmbeddings(result.items, {
                   model: embeddingModel,
+                  provider: embeddingProvider,
                   getToken: getToken || void 0,
                   baseUrl
                 });
@@ -1652,8 +1784,9 @@ function useMemory(options = {}) {
       }
     },
     [
-      memoryModel,
+      completionsModel,
       embeddingModel,
+      embeddingProvider,
       generateEmbeddings,
       getToken,
       onFactsExtracted,
@@ -1662,16 +1795,15 @@ function useMemory(options = {}) {
   );
   const searchMemories = useCallback2(
     async (query, limit = 10, minSimilarity = 0.6) => {
-      if (!getToken || !embeddingModel) {
-        console.warn(
-          "Cannot search memories: getToken or embeddingModel not provided"
-        );
+      if (!embeddingModel) {
+        console.warn("Cannot search memories: embeddingModel not provided");
         return [];
       }
       try {
         console.log(`[Memory Search] Searching for: "${query}"`);
-        const queryEmbedding = await generateQueryEmbedding(query, {
+        const queryEmbedding = await generateEmbeddingForText(query, {
           model: embeddingModel,
+          provider: embeddingProvider,
           getToken,
           baseUrl
         });
@@ -1698,7 +1830,7 @@ function useMemory(options = {}) {
         return [];
       }
     },
-    [embeddingModel, getToken, baseUrl]
+    [embeddingModel, embeddingProvider, getToken, baseUrl]
   );
   return {
     extractMemoriesFromMessage,