@reverbia/sdk 1.0.0-next.20251208112742 → 1.0.0-next.20251209090511

package/dist/react/index.mjs

@@ -1,46 +1,6 @@
-import {
-  DEFAULT_TOOL_SELECTOR_MODEL,
-  executeTool,
-  selectTool
-} from "./chunk-BG7SZT33.mjs";
-import "./chunk-Q6FVPTTV.mjs";
-import "./chunk-FBCDBTKJ.mjs";
-
 // src/react/useChat.ts
 import { useCallback, useEffect, useRef, useState } from "react";
 
-// src/lib/polyfills/textDecoderStream.ts
-var needsPolyfill = typeof globalThis.TextDecoderStream === "undefined";
-if (needsPolyfill && typeof globalThis.TransformStream !== "undefined") {
-  class TextDecoderStreamPolyfill {
-    constructor(label = "utf-8", options) {
-      this.decoder = new TextDecoder(label, options);
-      const decoder = this.decoder;
-      this.transform = new TransformStream({
-        transform(chunk, controller) {
-          const text = decoder.decode(chunk, { stream: true });
-          if (text) {
-            controller.enqueue(text);
-          }
-        },
-        flush(controller) {
-          const text = decoder.decode();
-          if (text) {
-            controller.enqueue(text);
-          }
-        }
-      });
-    }
-    get readable() {
-      return this.transform.readable;
-    }
-    get writable() {
-      return this.transform.writable;
-    }
-  }
-  globalThis.TextDecoderStream = TextDecoderStreamPolyfill;
-}
-
 // src/client/core/bodySerializer.gen.ts
 var jsonBodySerializer = {
   bodySerializer: (body) => JSON.stringify(
@@ -856,24 +816,373 @@ var createClientConfig = (config) => ({
 // src/client/client.gen.ts
 var client = createClient(createClientConfig(createConfig()));
 
-// src/react/useChat.ts
-var isReactNative = typeof navigator !== "undefined" && navigator.product === "ReactNative";
-var webFeatures = null;
-var webFeaturesPromise = isReactNative ? Promise.resolve(null) : Promise.all([
-  import("./generation-NG4QVPCR.mjs"),
-  import("./constants-WUGUGYE3.mjs"),
-  import("./selector-XMR5KL3E.mjs")
-]).then(([generation, constants, selector]) => {
-  webFeatures = {
-    generateLocalChatCompletion: generation.generateLocalChatCompletion,
-    DEFAULT_LOCAL_CHAT_MODEL: constants.DEFAULT_LOCAL_CHAT_MODEL,
-    selectTool: selector.selectTool,
-    executeTool: selector.executeTool,
-    preloadToolSelectorModel: selector.preloadToolSelectorModel,
-    DEFAULT_TOOL_SELECTOR_MODEL: selector.DEFAULT_TOOL_SELECTOR_MODEL
+// src/lib/chat/useChat/utils.ts
+var VALIDATION_ERROR_MESSAGES = {
+  messages_required: "messages are required to call sendMessage.",
+  model_required: "model is required to call sendMessage.",
+  token_getter_required: "Token getter function is required.",
+  token_unavailable: "No access token available."
+};
+function validateMessages(messages) {
+  if (!messages?.length) {
+    return {
+      valid: false,
+      error: "messages_required",
+      message: VALIDATION_ERROR_MESSAGES.messages_required
+    };
+  }
+  return { valid: true };
+}
+function validateModel(model) {
+  if (!model) {
+    return {
+      valid: false,
+      error: "model_required",
+      message: VALIDATION_ERROR_MESSAGES.model_required
+    };
+  }
+  return { valid: true };
+}
+function validateTokenGetter(getToken) {
+  if (!getToken) {
+    return {
+      valid: false,
+      error: "token_getter_required",
+      message: VALIDATION_ERROR_MESSAGES.token_getter_required
+    };
+  }
+  return { valid: true };
+}
+function validateToken(token) {
+  if (!token) {
+    return {
+      valid: false,
+      error: "token_unavailable",
+      message: VALIDATION_ERROR_MESSAGES.token_unavailable
+    };
+  }
+  return { valid: true };
+}
+function createStreamAccumulator() {
+  return {
+    content: "",
+    completionId: "",
+    completionModel: "",
+    usage: {},
+    finishReason: void 0
   };
-  return webFeatures;
-});
+}
+function processStreamingChunk(chunk, accumulator) {
+  if (chunk.id && !accumulator.completionId) {
+    accumulator.completionId = chunk.id;
+  }
+  if (chunk.model && !accumulator.completionModel) {
+    accumulator.completionModel = chunk.model;
+  }
+  if (chunk.usage) {
+    accumulator.usage = {
+      ...accumulator.usage,
+      ...chunk.usage
+    };
+  }
+  if (chunk.choices?.[0]) {
+    const choice = chunk.choices[0];
+    if (choice.delta?.content) {
+      accumulator.content += choice.delta.content;
+      return choice.delta.content;
+    }
+    if (choice.finish_reason) {
+      accumulator.finishReason = choice.finish_reason;
+    }
+  }
+  return null;
+}
+function buildCompletionResponse(accumulator) {
+  return {
+    id: accumulator.completionId,
+    model: accumulator.completionModel,
+    choices: [
+      {
+        index: 0,
+        message: {
+          role: "assistant",
+          content: [{ type: "text", text: accumulator.content }]
+        },
+        finish_reason: accumulator.finishReason
+      }
+    ],
+    usage: Object.keys(accumulator.usage).length > 0 ? accumulator.usage : void 0
+  };
+}
+function createErrorResult(message, onError) {
+  if (onError) {
+    onError(new Error(message));
+  }
+  return { data: null, error: message };
+}
+function handleError(err, onError) {
+  const errorMsg = err instanceof Error ? err.message : "Failed to send message.";
+  const errorObj = err instanceof Error ? err : new Error(errorMsg);
+  if (onError) {
+    onError(errorObj);
+  }
+  return { data: null, error: errorMsg };
+}
+function isAbortError(err) {
+  return err instanceof Error && err.name === "AbortError";
+}
+function isDoneMarker(chunk) {
+  if (typeof chunk === "string") {
+    const trimmed = chunk.trim();
+    return trimmed === "[DONE]" || trimmed.includes("[DONE]");
+  }
+  return false;
+}
+
+// src/lib/chat/constants.ts
+var DEFAULT_LOCAL_CHAT_MODEL = "onnx-community/Qwen2.5-0.5B-Instruct";
+
+// src/lib/chat/pipeline.ts
+var sharedPipeline = null;
+var currentModel = null;
+var currentDevice = null;
+async function getTextGenerationPipeline(options) {
+  const { model, device = "wasm", dtype = "q4" } = options;
+  if (sharedPipeline && currentModel === model && currentDevice === device) {
+    return sharedPipeline;
+  }
+  const { pipeline, env } = await import("@huggingface/transformers");
+  env.allowLocalModels = false;
+  if (env.backends?.onnx) {
+    env.backends.onnx.logLevel = "fatal";
+  }
+  console.log(`[Pipeline] Loading model: ${model} on ${device}...`);
+  sharedPipeline = await pipeline("text-generation", model, {
+    dtype,
+    device
+  });
+  currentModel = model;
+  currentDevice = device;
+  console.log(`[Pipeline] Model loaded: ${model}`);
+  return sharedPipeline;
+}
+
+// src/lib/chat/generation.ts
+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 { TextStreamer } = await import("@huggingface/transformers");
+  const chatPipeline = await getTextGenerationPipeline({
+    model,
+    device: "wasm",
+    dtype: "q4"
+  });
+  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/lib/tools/selector.ts
+var DEFAULT_TOOL_SELECTOR_MODEL = "Xenova/LaMini-GPT-124M";
+function buildToolSelectionPrompt(userMessage, tools) {
+  const toolList = tools.map((t) => `${t.name} (${t.description})`).join("\n");
+  return `Pick the best tool for the task. Reply with ONLY the tool name.
+
+Available tools:
+${toolList}
+none (no tool needed)
+
+Task: "${userMessage}"
+
+Best tool:`;
+}
+function buildParamExtractionPrompt(userMessage, paramName, paramDescription) {
+  const desc = paramDescription ? ` (${paramDescription})` : "";
+  return `Extract the value for "${paramName}"${desc} from the user message. Reply with ONLY the extracted value, nothing else.
+
+User message: "${userMessage}"
+
+Value for ${paramName}:`;
+}
+async function extractParams(userMessage, tool, options) {
+  const params = {};
+  if (!tool.parameters || tool.parameters.length === 0) return params;
+  const { model, device } = options;
+  try {
+    const pipeline = await getTextGenerationPipeline({
+      model,
+      device,
+      dtype: "q4"
+    });
+    for (const param of tool.parameters) {
+      const prompt = buildParamExtractionPrompt(
+        userMessage,
+        param.name,
+        param.description
+      );
+      const output = await pipeline(prompt, {
+        max_new_tokens: 32,
+        // Allow reasonable length for parameter values
+        temperature: 0,
+        do_sample: false,
+        return_full_text: false
+      });
+      const generatedText = output?.[0]?.generated_text || output?.generated_text || "";
+      const extractedValue = generatedText.trim().split("\n")[0].trim();
+      console.log(
+        `[Tool Selector] Extracted param "${param.name}":`,
+        extractedValue
+      );
+      params[param.name] = extractedValue || userMessage;
+    }
+  } catch (error) {
+    console.error("[Tool Selector] Error extracting params:", error);
+    for (const param of tool.parameters) {
+      params[param.name] = userMessage;
+    }
+  }
+  return params;
+}
+async function parseToolSelectionResponse(response, tools, userMessage, options) {
+  console.log("[Tool Selector] Raw response:", response);
+  const cleaned = response.toLowerCase().trim().split(/[\s\n,.]+/)[0].replace(/[^a-z0-9_-]/g, "");
+  console.log("[Tool Selector] Parsed tool name:", cleaned);
+  if (cleaned === "none" || cleaned === "null" || cleaned === "") {
+    console.log("[Tool Selector] No tool selected");
+    return { toolSelected: false };
+  }
+  const selectedTool = tools.find((t) => t.name.toLowerCase() === cleaned);
+  if (!selectedTool) {
+    const fuzzyTool = tools.find(
+      (t) => t.name.toLowerCase().includes(cleaned) || cleaned.includes(t.name.toLowerCase())
+    );
+    if (fuzzyTool) {
+      console.log(`[Tool Selector] Fuzzy matched tool: ${fuzzyTool.name}`);
+      const params2 = await extractParams(userMessage, fuzzyTool, options);
+      return {
+        toolSelected: true,
+        toolName: fuzzyTool.name,
+        parameters: params2,
+        confidence: 0.6
+      };
+    }
+    console.warn(`[Tool Selector] Unknown tool: ${cleaned}`);
+    return { toolSelected: false };
+  }
+  const params = await extractParams(userMessage, selectedTool, options);
+  console.log(`[Tool Selector] Selected tool: ${selectedTool.name}`, params);
+  return {
+    toolSelected: true,
+    toolName: selectedTool.name,
+    parameters: params,
+    confidence: 0.9
+  };
+}
+async function selectTool(userMessage, tools, options = {}) {
+  const {
+    model = DEFAULT_TOOL_SELECTOR_MODEL,
+    signal,
+    device = "wasm"
+  } = options;
+  if (!tools.length) {
+    return { toolSelected: false };
+  }
+  console.log(
+    `[Tool Selector] analyzing message: "${userMessage}" with model ${model}`
+  );
+  try {
+    const selectorPipeline = await getTextGenerationPipeline({
+      model,
+      device,
+      dtype: "q4"
+      // Aggressive quantization for speed
+    });
+    const prompt = buildToolSelectionPrompt(userMessage, tools);
+    const output = await selectorPipeline(prompt, {
+      max_new_tokens: 4,
+      // Just need the tool name
+      temperature: 0,
+      // Deterministic
+      do_sample: false,
+      return_full_text: false
+    });
+    if (signal?.aborted) {
+      return { toolSelected: false };
+    }
+    const generatedText = output?.[0]?.generated_text || output?.generated_text || "";
+    return await parseToolSelectionResponse(generatedText, tools, userMessage, {
+      model,
+      device
+    });
+  } catch (error) {
+    console.error("[Tool Selector] Error:", error);
+    return { toolSelected: false };
+  }
+}
+var preloadState = /* @__PURE__ */ new Map();
+async function preloadToolSelectorModel(options = {}) {
+  const { model = DEFAULT_TOOL_SELECTOR_MODEL, device = "wasm" } = options;
+  const existing = preloadState.get(model);
+  if (existing) {
+    return existing.promise;
+  }
+  console.log(`[Tool Selector] Preloading model: ${model}`);
+  const promise = getTextGenerationPipeline({
+    model,
+    device,
+    dtype: "q4"
+  }).then(() => {
+    console.log(`[Tool Selector] Model preloaded: ${model}`);
+  }).catch((error) => {
+    console.warn("[Tool Selector] Failed to preload model:", error);
+  });
+  preloadState.set(model, { promise, attempted: true });
+  return promise;
+}
+async function executeTool(tool, params) {
+  try {
+    console.log(
+      `[Tool Selector] Executing tool ${tool.name} with params:`,
+      params
+    );
+    const result = await tool.execute(params);
+    console.log(`[Tool Selector] Tool ${tool.name} execution result:`, result);
+    return { success: true, result };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Tool execution failed";
+    console.error(`[Tool Selector] Tool ${tool.name} failed:`, errorMessage);
+    return { success: false, error: errorMessage };
+  }
+}
+
+// src/react/useChat.ts
 function useChat(options) {
   const {
     getToken,
@@ -889,7 +1198,6 @@ function useChat(options) {
   } = options || {};
   const [isLoading, setIsLoading] = useState(false);
   const [isSelectingTool, setIsSelectingTool] = useState(false);
-  const [webFeaturesLoaded, setWebFeaturesLoaded] = useState(false);
   const abortControllerRef = useRef(null);
   const stop = useCallback(() => {
     if (abortControllerRef.current) {
@@ -906,17 +1214,12 @@ function useChat(options) {
     };
   }, []);
   useEffect(() => {
-    webFeaturesPromise?.then((loaded) => {
-      if (loaded) setWebFeaturesLoaded(true);
-    });
-  }, []);
-  useEffect(() => {
-    if (!isReactNative && webFeaturesLoaded && webFeatures && tools && tools.length > 0) {
-      webFeatures.preloadToolSelectorModel({
-        model: toolSelectorModel || webFeatures.DEFAULT_TOOL_SELECTOR_MODEL
+    if (tools && tools.length > 0) {
+      preloadToolSelectorModel({
+        model: toolSelectorModel || DEFAULT_TOOL_SELECTOR_MODEL
       });
     }
-  }, [tools, toolSelectorModel, webFeaturesLoaded]);
+  }, [tools, toolSelectorModel]);
   const sendMessage = useCallback(
     async ({
       messages,
@@ -924,10 +1227,9 @@ function useChat(options) {
       onData,
       runTools = true
     }) => {
-      if (!messages?.length) {
-        const errorMsg = "messages are required to call sendMessage.";
-        if (onError) onError(new Error(errorMsg));
-        return { data: null, error: errorMsg };
+      const messagesValidation = validateMessages(messages);
+      if (!messagesValidation.valid) {
+        return createErrorResult(messagesValidation.message, onError);
       }
       if (abortControllerRef.current) {
         abortControllerRef.current.abort();
@@ -937,27 +1239,23 @@ function useChat(options) {
       setIsLoading(true);
       let toolExecutionResult;
       let messagesWithToolContext = messages;
-      const canRunTools = !isReactNative && webFeaturesLoaded && webFeatures !== null && runTools && tools && tools.length > 0;
-      if (canRunTools && webFeatures) {
+      const shouldRunTools = runTools && tools && tools.length > 0;
+      if (shouldRunTools) {
         const lastUserMessage = [...messages].reverse().find((m) => m.role === "user");
         if (lastUserMessage?.content) {
           setIsSelectingTool(true);
           const contentString = lastUserMessage.content?.map((part) => part.text || "").join("") || "";
           try {
-            const selectionResult = await webFeatures.selectTool(
-              contentString,
-              tools,
-              {
-                model: toolSelectorModel || webFeatures.DEFAULT_TOOL_SELECTOR_MODEL,
-                signal: abortController.signal
-              }
-            );
+            const selectionResult = await selectTool(contentString, tools, {
+              model: toolSelectorModel || DEFAULT_TOOL_SELECTOR_MODEL,
+              signal: abortController.signal
+            });
             if (selectionResult.toolSelected && selectionResult.toolName) {
               const selectedTool = tools.find(
                 (t) => t.name === selectionResult.toolName
               );
               if (selectedTool) {
-                const execResult = await webFeatures.executeTool(
+                const execResult = await executeTool(
                   selectedTool,
                   selectionResult.parameters || {}
                 );
@@ -1005,31 +1303,38 @@ Please inform the user about this issue and try to help them alternatively.`
               }
             }
           } catch (err) {
+            if (isAbortError(err)) {
+              setIsLoading(false);
+              setIsSelectingTool(false);
+              return {
+                data: null,
+                error: "Request aborted",
+                toolExecution: toolExecutionResult
+              };
+            }
             console.warn("Tool selection error:", err);
           } finally {
             setIsSelectingTool(false);
           }
         }
       }
+      if (abortController.signal.aborted) {
+        setIsLoading(false);
+        return {
+          data: null,
+          error: "Request aborted",
+          toolExecution: toolExecutionResult
+        };
+      }
       try {
         if (chatProvider === "local") {
-          if (isReactNative || !webFeaturesLoaded || !webFeatures) {
-            const errorMsg = 'Local chat provider is not available in React Native. Use chatProvider: "api" instead.';
-            setIsLoading(false);
-            if (onError) onError(new Error(errorMsg));
-            return {
-              data: null,
-              error: errorMsg,
-              toolExecution: toolExecutionResult
-            };
-          }
           let accumulatedContent = "";
-          const usedModel = localModel || webFeatures.DEFAULT_LOCAL_CHAT_MODEL;
+          const usedModel = localModel || DEFAULT_LOCAL_CHAT_MODEL;
           const formattedMessages = messagesWithToolContext.map((m) => ({
             role: m.role || "user",
             content: m.content?.map((p) => p.text || "").join("") || ""
           }));
-          await webFeatures.generateLocalChatCompletion(formattedMessages, {
+          await generateLocalChatCompletion(formattedMessages, {
             model: usedModel,
             signal: abortController.signal,
             onToken: (token) => {
@@ -1068,32 +1373,34 @@ Please inform the user about this issue and try to help them alternatively.`
             toolExecution: toolExecutionResult
           };
         } else {
-          if (!model) {
-            const errorMsg = "model is required to call sendMessage.";
-            if (onError) onError(new Error(errorMsg));
+          const modelValidation = validateModel(model);
+          if (!modelValidation.valid) {
+            setIsLoading(false);
+            if (onError) onError(new Error(modelValidation.message));
             return {
               data: null,
-              error: errorMsg,
+              error: modelValidation.message,
               toolExecution: toolExecutionResult
             };
           }
-          if (!getToken) {
-            const errorMsg = "Token getter function is required.";
-            if (onError) onError(new Error(errorMsg));
+          const tokenGetterValidation = validateTokenGetter(getToken);
+          if (!tokenGetterValidation.valid) {
+            setIsLoading(false);
+            if (onError) onError(new Error(tokenGetterValidation.message));
             return {
               data: null,
-              error: errorMsg,
+              error: tokenGetterValidation.message,
               toolExecution: toolExecutionResult
             };
           }
           const token = await getToken();
-          if (!token) {
-            const errorMsg = "No access token available.";
+          const tokenValidation = validateToken(token);
+          if (!tokenValidation.valid) {
             setIsLoading(false);
-            if (onError) onError(new Error(errorMsg));
+            if (onError) onError(new Error(tokenValidation.message));
             return {
               data: null,
-              error: errorMsg,
+              error: tokenValidation.message,
               toolExecution: toolExecutionResult
             };
           }
@@ -1111,62 +1418,23 @@ Please inform the user about this issue and try to help them alternatively.`
             },
             signal: abortController.signal
           });
-          let accumulatedContent = "";
-          let completionId = "";
-          let completionModel = "";
-          let accumulatedUsage = {};
-          let finishReason;
+          const accumulator = createStreamAccumulator();
           for await (const chunk of sseResult.stream) {
-            if (typeof chunk === "string" && (chunk.trim() === "[DONE]" || chunk.includes("[DONE]"))) {
+            if (isDoneMarker(chunk)) {
               continue;
             }
             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 (choice.finish_reason) {
-                  finishReason = choice.finish_reason;
-                }
+              const contentDelta = processStreamingChunk(
+                chunk,
+                accumulator
+              );
+              if (contentDelta) {
+                if (onData) onData(contentDelta);
+                if (globalOnData) globalOnData(contentDelta);
               }
             }
           }
-          const completion = {
-            id: completionId,
-            model: completionModel,
-            choices: [
-              {
-                index: 0,
-                message: {
-                  role: "assistant",
-                  content: [{ type: "text", text: accumulatedContent }]
-                },
-                finish_reason: finishReason
-              }
-            ],
-            usage: Object.keys(accumulatedUsage).length > 0 ? accumulatedUsage : void 0
-          };
+          const completion = buildCompletionResponse(accumulator);
           setIsLoading(false);
           if (onFinish) {
             onFinish(completion);
@@ -1178,7 +1446,7 @@ Please inform the user about this issue and try to help them alternatively.`
           };
         }
       } catch (err) {
-        if (err instanceof Error && err.name === "AbortError") {
+        if (isAbortError(err)) {
           setIsLoading(false);
           return {
             data: null,
@@ -1186,15 +1454,10 @@ Please inform the user about this issue and try to help them alternatively.`
             toolExecution: toolExecutionResult
           };
         }
-        const errorMsg = err instanceof Error ? err.message : "Failed to send message.";
-        const errorObj = err instanceof Error ? err : new Error(errorMsg);
+        const errorResult = handleError(err, onError);
         setIsLoading(false);
-        if (onError) {
-          onError(errorObj);
-        }
         return {
-          data: null,
-          error: errorMsg,
+          ...errorResult,
           toolExecution: toolExecutionResult
         };
       } finally {
@@ -1213,8 +1476,7 @@ Please inform the user about this issue and try to help them alternatively.`
       localModel,
       tools,
       toolSelectorModel,
-      onToolExecution,
-      webFeaturesLoaded
+      onToolExecution
     ]
   );
   return {
@@ -1687,7 +1949,7 @@ var generateEmbeddingForText = async (text, options = {}) => {
   }
   try {
     if (!embeddingPipeline) {
-      const { pipeline } = await import("./transformers.node-LUTOZWVQ.mjs");
+      const { pipeline } = await import("@huggingface/transformers");
       embeddingPipeline = await pipeline("feature-extraction", model);
     }
     const output = await embeddingPipeline(text, {