@reverbia/sdk 1.0.0-next.20251202090922 → 1.0.0-next.20251202095402

package/dist/react/index.cjs

@@ -46669,12 +46669,15 @@ ${fake_token_around_image}${global_img_token}` + image_token.repeat(image_seq_le
 // src/react/index.ts
 var index_exports = {};
 __export(index_exports, {
+  DEFAULT_TOOL_SELECTOR_MODEL: () => DEFAULT_TOOL_SELECTOR_MODEL,
   createMemoryContextSystemMessage: () => createMemoryContextSystemMessage,
   decryptData: () => decryptData,
   decryptDataBytes: () => decryptDataBytes,
   encryptData: () => encryptData,
+  executeTool: () => executeTool,
   extractConversationContext: () => extractConversationContext,
   formatMemoriesForChat: () => formatMemoriesForChat,
+  selectTool: () => selectTool,
   useChat: () => useChat,
   useEncryption: () => useEncryption,
   useMemory: () => useMemory,
@@ -47500,6 +47503,218 @@ 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/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: env3 } = await Promise.resolve().then(() => (init_transformers_node(), transformers_node_exports));
+  env3.allowLocalModels = false;
+  if (env3.backends?.onnx) {
+    env3.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 Promise.resolve().then(() => (init_transformers_node(), transformers_node_exports));
+  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 extractParams(userMessage, tool) {
+  const params = {};
+  if (!tool.parameters) return params;
+  for (const param of tool.parameters) {
+    if (param.name === "expression" || param.name === "query") {
+      params[param.name] = userMessage;
+    } else if (param.name === "location" || param.name === "city") {
+      const words = userMessage.split(/\s+/);
+      const capitalizedWords = words.filter(
+        (w) => w.length > 1 && w[0] === w[0].toUpperCase()
+      );
+      params[param.name] = capitalizedWords.length > 0 ? capitalizedWords.join(" ") : userMessage;
+    } else if (param.name === "text" || param.name === "input") {
+      params[param.name] = userMessage;
+    } else {
+      params[param.name] = userMessage;
+    }
+  }
+  return params;
+}
+function parseToolSelectionResponse(response, tools, userMessage) {
+  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 = extractParams(userMessage, fuzzyTool);
+      return {
+        toolSelected: true,
+        toolName: fuzzyTool.name,
+        parameters: params2,
+        confidence: 0.6
+      };
+    }
+    console.warn(`[Tool Selector] Unknown tool: ${cleaned}`);
+    return { toolSelected: false };
+  }
+  const params = extractParams(userMessage, selectedTool);
+  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 parseToolSelectionResponse(generatedText, tools, userMessage);
+  } catch (error) {
+    console.error("[Tool Selector] Error:", error);
+    return { toolSelected: false };
+  }
+}
+var preloadPromise = null;
+async function preloadToolSelectorModel(options = {}) {
+  if (preloadPromise) {
+    return preloadPromise;
+  }
+  const { model = DEFAULT_TOOL_SELECTOR_MODEL, device = "wasm" } = options;
+  console.log(`[Tool Selector] Preloading model: ${model}`);
+  preloadPromise = getTextGenerationPipeline({
+    model,
+    device,
+    dtype: "q4"
+  }).then(() => {
+    console.log(`[Tool Selector] Model preloaded: ${model}`);
+  }).catch((error) => {
+    console.warn("[Tool Selector] Failed to preload model:", error);
+    preloadPromise = null;
+  });
+  return preloadPromise;
+}
+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 {
@@ -47507,9 +47722,15 @@ function useChat(options) {
     baseUrl = BASE_URL,
     onData: globalOnData,
     onFinish,
-    onError
+    onError,
+    chatProvider = "api",
+    localModel = DEFAULT_LOCAL_CHAT_MODEL,
+    tools,
+    toolSelectorModel = DEFAULT_TOOL_SELECTOR_MODEL,
+    onToolExecution
   } = options || {};
   const [isLoading, setIsLoading] = (0, import_react.useState)(false);
+  const [isSelectingTool, setIsSelectingTool] = (0, import_react.useState)(false);
   const abortControllerRef = (0, import_react.useRef)(null);
   const stop = (0, import_react.useCallback)(() => {
     if (abortControllerRef.current) {
@@ -47525,120 +47746,257 @@ function useChat(options) {
       }
     };
   }, []);
+  (0, import_react.useEffect)(() => {
+    if (tools && tools.length > 0) {
+      preloadToolSelectorModel({ model: toolSelectorModel });
+    }
+  }, [tools, toolSelectorModel]);
   const sendMessage = (0, import_react.useCallback)(
     async ({
       messages,
       model,
-      onData
+      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 };
       }
-      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();
       }
       const abortController = new AbortController();
       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;
+      let toolExecutionResult;
+      let messagesWithToolContext = messages;
+      if (runTools && tools && tools.length > 0) {
+        const lastUserMessage = [...messages].reverse().find((m) => m.role === "user");
+        if (lastUserMessage?.content) {
+          setIsSelectingTool(true);
+          try {
+            const selectionResult = await selectTool(
+              lastUserMessage.content,
+              tools,
+              {
+                model: toolSelectorModel,
+                signal: abortController.signal
+              }
+            );
+            if (selectionResult.toolSelected && selectionResult.toolName) {
+              const selectedTool = tools.find(
+                (t) => t.name === selectionResult.toolName
+              );
+              if (selectedTool) {
+                const execResult = await executeTool(
+                  selectedTool,
+                  selectionResult.parameters || {}
+                );
+                toolExecutionResult = {
+                  toolName: selectionResult.toolName,
+                  success: execResult.success,
+                  result: execResult.result,
+                  error: execResult.error
+                };
+                if (onToolExecution) {
+                  onToolExecution(toolExecutionResult);
+                }
+                if (toolExecutionResult.success && toolExecutionResult.result !== void 0) {
+                  const toolResultContext = {
+                    role: "system",
+                    content: `Tool "${toolExecutionResult.toolName}" was executed with the following result:
+${JSON.stringify(
+                      toolExecutionResult.result,
+                      null,
+                      2
+                    )}
+
+Use this information to respond to the user's request.`
+                  };
+                  messagesWithToolContext = [...messages, toolResultContext];
+                } else if (toolExecutionResult.error) {
+                  const toolErrorContext = {
+                    role: "system",
+                    content: `Tool "${toolExecutionResult.toolName}" was executed but encountered an error: ${toolExecutionResult.error}
+
+Please inform the user about this issue and try to help them alternatively.`
+                  };
+                  messagesWithToolContext = [...messages, toolErrorContext];
+                }
+              }
             }
-            if (chunkData.model && !completionModel) {
-              completionModel = chunkData.model;
+          } catch (err) {
+            console.warn("Tool selection error:", err);
+          } finally {
+            setIsSelectingTool(false);
+          }
+        }
+      }
+      try {
+        if (chatProvider === "local") {
+          let accumulatedContent = "";
+          const usedModel = localModel;
+          const formattedMessages = messagesWithToolContext.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.usage) {
-              accumulatedUsage = {
-                ...accumulatedUsage,
-                ...chunkData.usage
-              };
+          });
+          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.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);
+          };
+          setIsLoading(false);
+          if (onFinish) {
+            onFinish(completion);
+          }
+          return {
+            data: completion,
+            error: null,
+            toolExecution: toolExecutionResult
+          };
+        } else {
+          if (!model) {
+            const errorMsg = "model is required to call sendMessage.";
+            if (onError) onError(new Error(errorMsg));
+            return {
+              data: null,
+              error: errorMsg,
+              toolExecution: toolExecutionResult
+            };
+          }
+          if (!getToken) {
+            const errorMsg = "Token getter function is required.";
+            if (onError) onError(new Error(errorMsg));
+            return {
+              data: null,
+              error: errorMsg,
+              toolExecution: toolExecutionResult
+            };
+          }
+          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,
+              toolExecution: toolExecutionResult
+            };
+          }
+          const sseResult = await client.sse.post({
+            baseUrl,
+            url: "/api/v1/chat/completions",
+            body: {
+              messages: messagesWithToolContext,
+              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 (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,
+            toolExecution: toolExecutionResult
+          };
         }
-        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);
-          return { data: null, error: "Request aborted" };
+          return {
+            data: null,
+            error: "Request aborted",
+            toolExecution: toolExecutionResult
+          };
         }
         const errorMsg = err instanceof Error ? err.message : "Failed to send message.";
         const errorObj = err instanceof Error ? err : new Error(errorMsg);
@@ -47646,17 +48004,33 @@ function useChat(options) {
         if (onError) {
           onError(errorObj);
         }
-        return { data: null, error: errorMsg };
+        return {
+          data: null,
+          error: errorMsg,
+          toolExecution: toolExecutionResult
+        };
       } finally {
         if (abortControllerRef.current === abortController) {
           abortControllerRef.current = null;
         }
       }
     },
-    [getToken, baseUrl, globalOnData, onFinish, onError]
+    [
+      getToken,
+      baseUrl,
+      globalOnData,
+      onFinish,
+      onError,
+      chatProvider,
+      localModel,
+      tools,
+      toolSelectorModel,
+      onToolExecution
+    ]
   );
   return {
     isLoading,
+    isSelectingTool,
     sendMessage,
     stop
   };
@@ -48579,12 +48953,15 @@ var extractConversationContext = (messages, maxMessages = 3) => {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  DEFAULT_TOOL_SELECTOR_MODEL,
   createMemoryContextSystemMessage,
   decryptData,
   decryptDataBytes,
   encryptData,
+  executeTool,
   extractConversationContext,
   formatMemoriesForChat,
+  selectTool,
   useChat,
   useEncryption,
   useMemory,