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

package/dist/index.mjs

@@ -834,12 +834,32 @@ var postApiV1Embeddings = (options) => {
     }
   });
 };
+var postApiV1ImagesGenerations = (options) => {
+  return (options.client ?? client).post({
+    url: "/api/v1/images/generations",
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      ...options.headers
+    }
+  });
+};
 var getApiV1Models = (options) => {
   return (options?.client ?? client).get({
     url: "/api/v1/models",
     ...options
   });
 };
+var postApiV1Search = (options) => {
+  return (options.client ?? client).post({
+    url: "/api/v1/search",
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      ...options.headers
+    }
+  });
+};
 var getHealth = (options) => {
   return (options?.client ?? client).get({
     url: "/health",
@@ -850,5 +870,7 @@ export {
   getApiV1Models,
   getHealth,
   postApiV1ChatCompletions,
-  postApiV1Embeddings
+  postApiV1Embeddings,
+  postApiV1ImagesGenerations,
+  postApiV1Search
 };

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,
@@ -47503,9 +47506,32 @@ 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;
+// 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,
@@ -47515,13 +47541,12 @@ async function generateLocalChatCompletion(messages, options = {}) {
     onToken,
     signal
   } = options;
-  const { pipeline, TextStreamer } = await Promise.resolve().then(() => (init_transformers_node(), transformers_node_exports));
-  if (!chatPipeline || currentModel !== model) {
-    chatPipeline = await pipeline("text-generation", model, {
-      dtype: "fp16"
-    });
-    currentModel = model;
-  }
+  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, {
@@ -47548,6 +47573,148 @@ async function generateLocalChatCompletion(messages, options = {}) {
   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 {
@@ -47557,9 +47724,13 @@ function useChat(options) {
     onFinish,
     onError,
     chatProvider = "api",
-    localModel = DEFAULT_LOCAL_CHAT_MODEL
+    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) {
@@ -47575,11 +47746,17 @@ 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.";
@@ -47592,13 +47769,84 @@ function useChat(options) {
       const abortController = new AbortController();
       abortControllerRef.current = abortController;
       setIsLoading(true);
+      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);
+          const contentString = lastUserMessage.content?.map((part) => part.text || "").join("") || "";
+          try {
+            const selectionResult = await selectTool(contentString, 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: [
+                      {
+                        type: "text",
+                        text: `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: [
+                      {
+                        type: "text",
+                        text: `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];
+                }
+              }
+            }
+          } catch (err) {
+            console.warn("Tool selection error:", err);
+          } finally {
+            setIsSelectingTool(false);
+          }
+        }
+      }
       try {
         if (chatProvider === "local") {
           let accumulatedContent = "";
           const usedModel = localModel;
-          const formattedMessages = messages.map((m) => ({
+          const formattedMessages = messagesWithToolContext.map((m) => ({
             role: m.role || "user",
-            content: m.content || ""
+            content: m.content?.map((p) => p.text || "").join("") || ""
           }));
           await generateLocalChatCompletion(formattedMessages, {
             model: usedModel,
@@ -47617,7 +47865,7 @@ function useChat(options) {
                 index: 0,
                 message: {
                   role: "assistant",
-                  content: accumulatedContent
+                  content: [{ type: "text", text: accumulatedContent }]
                 },
                 finish_reason: "stop"
               }
@@ -47633,30 +47881,46 @@ function useChat(options) {
           if (onFinish) {
             onFinish(completion);
           }
-          return { data: completion, error: null };
+          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 };
+            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 };
+            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 };
+            return {
+              data: null,
+              error: errorMsg,
+              toolExecution: toolExecutionResult
+            };
           }
           const sseResult = await client.sse.post({
             baseUrl,
             url: "/api/v1/chat/completions",
             body: {
-              messages,
+              messages: messagesWithToolContext,
               model,
               stream: true
             },
@@ -47715,7 +47979,7 @@ function useChat(options) {
                 index: 0,
                 message: {
                   role: "assistant",
-                  content: accumulatedContent
+                  content: [{ type: "text", text: accumulatedContent }]
                 },
                 finish_reason: finishReason
               }
@@ -47726,12 +47990,20 @@ function useChat(options) {
           if (onFinish) {
             onFinish(completion);
           }
-          return { data: completion, error: null };
+          return {
+            data: completion,
+            error: null,
+            toolExecution: toolExecutionResult
+          };
         }
       } 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);
@@ -47739,7 +48011,11 @@ 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;
@@ -47753,11 +48029,15 @@ function useChat(options) {
       onFinish,
       onError,
       chatProvider,
-      localModel
+      localModel,
+      tools,
+      toolSelectorModel,
+      onToolExecution
     ]
   );
   return {
     isLoading,
+    isSelectingTool,
     sendMessage,
     stop
   };
@@ -48320,9 +48600,12 @@ function useMemory(options = {}) {
             messages: [
               {
                 role: "system",
-                content: FACT_EXTRACTION_PROMPT
+                content: [{ type: "text", text: FACT_EXTRACTION_PROMPT }]
               },
-              ...messages
+              ...messages.map((m) => ({
+                role: m.role,
+                content: [{ type: "text", text: m.content }]
+              }))
             ],
             model: model || completionsModel
           },
@@ -48343,7 +48626,13 @@ function useMemory(options = {}) {
           );
           return null;
         }
-        const content = completion.data.choices?.[0]?.message?.content?.trim() || "";
+        const messageContent = completion.data.choices?.[0]?.message?.content;
+        let content = "";
+        if (Array.isArray(messageContent)) {
+          content = messageContent.map((p) => p.text || "").join("").trim();
+        } else if (typeof messageContent === "string") {
+          content = messageContent.trim();
+        }
         if (!content) {
           console.error("No content in memory extraction response");
           return null;
@@ -48680,12 +48969,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,