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

package/dist/react/index.mjs

@@ -821,9 +821,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 } = await import("./transformers.node-BSHUG7OY.mjs");
+  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,
@@ -833,13 +856,12 @@ async function generateLocalChatCompletion(messages, options = {}) {
     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;
-  }
+  const { TextStreamer } = await import("./transformers.node-BSHUG7OY.mjs");
+  const chatPipeline = await getTextGenerationPipeline({
+    model,
+    device: "wasm",
+    dtype: "q4"
+  });
   class CallbackStreamer extends TextStreamer {
     constructor(tokenizer, cb) {
       super(tokenizer, {
@@ -866,6 +888,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 {
@@ -875,9 +1039,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] = useState(false);
+  const [isSelectingTool, setIsSelectingTool] = useState(false);
   const abortControllerRef = useRef(null);
   const stop = useCallback(() => {
     if (abortControllerRef.current) {
@@ -893,11 +1061,17 @@ function useChat(options) {
       }
     };
   }, []);
+  useEffect(() => {
+    if (tools && tools.length > 0) {
+      preloadToolSelectorModel({ model: toolSelectorModel });
+    }
+  }, [tools, toolSelectorModel]);
   const sendMessage = useCallback(
     async ({
       messages,
       model,
-      onData
+      onData,
+      runTools = true
     }) => {
       if (!messages?.length) {
         const errorMsg = "messages are required to call sendMessage.";
@@ -910,13 +1084,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,
@@ -935,7 +1180,7 @@ function useChat(options) {
                 index: 0,
                 message: {
                   role: "assistant",
-                  content: accumulatedContent
+                  content: [{ type: "text", text: accumulatedContent }]
                 },
                 finish_reason: "stop"
               }
@@ -951,30 +1196,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
             },
@@ -1033,7 +1294,7 @@ function useChat(options) {
                 index: 0,
                 message: {
                   role: "assistant",
-                  content: accumulatedContent
+                  content: [{ type: "text", text: accumulatedContent }]
                 },
                 finish_reason: finishReason
               }
@@ -1044,12 +1305,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);
@@ -1057,7 +1326,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;
@@ -1071,11 +1344,15 @@ function useChat(options) {
       onFinish,
       onError,
       chatProvider,
-      localModel
+      localModel,
+      tools,
+      toolSelectorModel,
+      onToolExecution
     ]
   );
   return {
     isLoading,
+    isSelectingTool,
     sendMessage,
     stop
   };
@@ -1638,9 +1915,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
           },
@@ -1661,7 +1941,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;
@@ -1997,12 +2283,15 @@ var extractConversationContext = (messages, maxMessages = 3) => {
   return userMessages.trim();
 };
 export {
+  DEFAULT_TOOL_SELECTOR_MODEL,
   createMemoryContextSystemMessage,
   decryptData,
   decryptDataBytes,
   encryptData,
+  executeTool,
   extractConversationContext,
   formatMemoriesForChat,
+  selectTool,
   useChat,
   useEncryption,
   useMemory,

package/dist/vercel/index.cjs

@@ -37,7 +37,7 @@ function mapMessagesToCompletionPayload(messages) {
     if (!content.length) return null;
     const llmMessage = {
       role: message.role,
-      content
+      content: [{ type: "text", text: content }]
     };
     return llmMessage;
   }).filter((m) => m !== null);

package/dist/vercel/index.d.mts

@@ -7,9 +7,33 @@ type LlmapiMessage = {
     /**
      * Content is the message content
      */
-    content?: string;
+    content?: Array<LlmapiMessageContentPart>;
     role?: LlmapiRole;
 };
+/**
+ * ImageURL is used when Type=image_url
+ */
+type LlmapiMessageContentImage = {
+    /**
+     * Detail is the OpenAI detail hint (auto|low|high)
+     */
+    detail?: string;
+    /**
+     * URL is the image URL or data URI
+     */
+    url?: string;
+};
+type LlmapiMessageContentPart = {
+    image_url?: LlmapiMessageContentImage;
+    /**
+     * Text holds the text content when Type=text
+     */
+    text?: string;
+    /**
+     * Type is the block type (`text` or `image_url`)
+     */
+    type?: string;
+};
 /**
  * Role is the message role (system, user, assistant)
  */

package/dist/vercel/index.d.ts

@@ -7,9 +7,33 @@ type LlmapiMessage = {
     /**
      * Content is the message content
      */
-    content?: string;
+    content?: Array<LlmapiMessageContentPart>;
     role?: LlmapiRole;
 };
+/**
+ * ImageURL is used when Type=image_url
+ */
+type LlmapiMessageContentImage = {
+    /**
+     * Detail is the OpenAI detail hint (auto|low|high)
+     */
+    detail?: string;
+    /**
+     * URL is the image URL or data URI
+     */
+    url?: string;
+};
+type LlmapiMessageContentPart = {
+    image_url?: LlmapiMessageContentImage;
+    /**
+     * Text holds the text content when Type=text
+     */
+    text?: string;
+    /**
+     * Type is the block type (`text` or `image_url`)
+     */
+    type?: string;
+};
 /**
  * Role is the message role (system, user, assistant)
  */

package/dist/vercel/index.mjs

@@ -9,7 +9,7 @@ function mapMessagesToCompletionPayload(messages) {
     if (!content.length) return null;
     const llmMessage = {
       role: message.role,
-      content
+      content: [{ type: "text", text: content }]
     };
     return llmMessage;
   }).filter((m) => m !== null);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reverbia/sdk",
-  "version": "1.0.0-next.20251202092727",
+  "version": "1.0.0-next.20251202130234",
   "description": "",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
@@ -57,7 +57,7 @@
   "homepage": "https://github.com/zeta-chain/ai-sdk#readme",
   "dependencies": {
     "@huggingface/transformers": "^3.8.0",
-    "@reverbia/portal": "1.0.0-next.20251126175613",
+    "@reverbia/portal": "1.0.0-next.20251201184846",
     "ai": "5.0.93"
   },
   "devDependencies": {