@reverbia/sdk 1.0.0-next.20251205183506 → 1.0.0-next.20251208094446

package/dist/expo/index.mjs

@@ -0,0 +1,236 @@
+// src/expo/useChat.ts
+import { useCallback, useEffect, useRef, useState } from "react";
+
+// src/clientConfig.ts
+var BASE_URL = "https://ai-portal-dev.zetachain.com";
+
+// src/expo/useChat.ts
+function useChat(options) {
+  const {
+    getToken,
+    baseUrl = BASE_URL,
+    onData: globalOnData,
+    onFinish,
+    onError
+  } = options || {};
+  const [isLoading, setIsLoading] = useState(false);
+  const abortControllerRef = useRef(null);
+  const stop = useCallback(() => {
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+      abortControllerRef.current = null;
+    }
+  }, []);
+  useEffect(() => {
+    return () => {
+      if (abortControllerRef.current) {
+        abortControllerRef.current.abort();
+        abortControllerRef.current = null;
+      }
+    };
+  }, []);
+  const sendMessage = useCallback(
+    async ({
+      messages,
+      model,
+      onData
+    }) => {
+      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 result = await new Promise((resolve) => {
+          const xhr = new XMLHttpRequest();
+          const url = `${baseUrl}/api/v1/chat/completions`;
+          let accumulatedContent = "";
+          let completionId = "";
+          let completionModel = "";
+          let accumulatedUsage = {};
+          let finishReason;
+          let lastProcessedIndex = 0;
+          let incompleteLineBuffer = "";
+          const abortHandler = () => {
+            xhr.abort();
+          };
+          abortController.signal.addEventListener("abort", abortHandler);
+          xhr.open("POST", url, true);
+          xhr.setRequestHeader("Content-Type", "application/json");
+          xhr.setRequestHeader("Authorization", `Bearer ${token}`);
+          xhr.setRequestHeader("Accept", "text/event-stream");
+          xhr.onprogress = () => {
+            const newData = xhr.responseText.substring(lastProcessedIndex);
+            lastProcessedIndex = xhr.responseText.length;
+            const dataToProcess = incompleteLineBuffer + newData;
+            incompleteLineBuffer = "";
+            const lines = dataToProcess.split("\n");
+            if (!newData.endsWith("\n") && lines.length > 0) {
+              incompleteLineBuffer = lines.pop() || "";
+            }
+            for (const line of lines) {
+              if (line.startsWith("data: ")) {
+                const data = line.substring(6).trim();
+                if (data === "[DONE]") continue;
+                try {
+                  const chunk = JSON.parse(data);
+                  if (chunk.id && !completionId) {
+                    completionId = chunk.id;
+                  }
+                  if (chunk.model && !completionModel) {
+                    completionModel = chunk.model;
+                  }
+                  if (chunk.usage) {
+                    accumulatedUsage = { ...accumulatedUsage, ...chunk.usage };
+                  }
+                  if (chunk.choices?.[0]) {
+                    const choice = chunk.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;
+                    }
+                  }
+                } catch {
+                }
+              }
+            }
+          };
+          xhr.onload = () => {
+            abortController.signal.removeEventListener("abort", abortHandler);
+            if (incompleteLineBuffer) {
+              const line = incompleteLineBuffer.trim();
+              if (line.startsWith("data: ")) {
+                const data = line.substring(6).trim();
+                if (data !== "[DONE]") {
+                  try {
+                    const chunk = JSON.parse(data);
+                    if (chunk.id && !completionId) {
+                      completionId = chunk.id;
+                    }
+                    if (chunk.model && !completionModel) {
+                      completionModel = chunk.model;
+                    }
+                    if (chunk.usage) {
+                      accumulatedUsage = {
+                        ...accumulatedUsage,
+                        ...chunk.usage
+                      };
+                    }
+                    if (chunk.choices?.[0]) {
+                      const choice = chunk.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;
+                      }
+                    }
+                  } catch {
+                  }
+                }
+              }
+              incompleteLineBuffer = "";
+            }
+            if (xhr.status >= 200 && xhr.status < 300) {
+              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
+              };
+              setIsLoading(false);
+              if (onFinish) onFinish(completion);
+              resolve({ data: completion, error: null });
+            } else {
+              const errorMsg = `Request failed with status ${xhr.status}`;
+              setIsLoading(false);
+              if (onError) onError(new Error(errorMsg));
+              resolve({ data: null, error: errorMsg });
+            }
+          };
+          xhr.onerror = () => {
+            abortController.signal.removeEventListener("abort", abortHandler);
+            const errorMsg = "Network error";
+            setIsLoading(false);
+            if (onError) onError(new Error(errorMsg));
+            resolve({ data: null, error: errorMsg });
+          };
+          xhr.onabort = () => {
+            abortController.signal.removeEventListener("abort", abortHandler);
+            setIsLoading(false);
+            resolve({ data: null, error: "Request aborted" });
+          };
+          xhr.send(
+            JSON.stringify({
+              messages,
+              model,
+              stream: true
+            })
+          );
+        });
+        return result;
+      } catch (err) {
+        const errorMsg = err instanceof Error ? err.message : "Failed to send message.";
+        const errorObj = err instanceof Error ? err : new Error(errorMsg);
+        setIsLoading(false);
+        if (onError) {
+          onError(errorObj);
+        }
+        return { data: null, error: errorMsg };
+      } finally {
+        if (abortControllerRef.current === abortController) {
+          abortControllerRef.current = null;
+        }
+      }
+    },
+    [getToken, baseUrl, globalOnData, onFinish, onError]
+  );
+  return {
+    isLoading,
+    sendMessage,
+    stop
+  };
+}
+export {
+  useChat
+};

package/dist/polyfills/index.cjs

@@ -0,0 +1,61 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/polyfills/index.ts
+var index_exports = {};
+__export(index_exports, {
+  needsTextDecoderStreamPolyfill: () => needsPolyfill
+});
+module.exports = __toCommonJS(index_exports);
+
+// 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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  needsTextDecoderStreamPolyfill
+});

package/dist/polyfills/index.d.mts

@@ -0,0 +1,9 @@
+/**
+ * TextDecoderStream polyfill for React Native compatibility.
+ *
+ * React Native doesn't have TextDecoderStream, but it does have TextDecoder.
+ * This polyfill creates a TransformStream that uses TextDecoder internally.
+ */
+declare const needsPolyfill: boolean;
+
+export { needsPolyfill as needsTextDecoderStreamPolyfill };

package/dist/polyfills/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * TextDecoderStream polyfill for React Native compatibility.
+ *
+ * React Native doesn't have TextDecoderStream, but it does have TextDecoder.
+ * This polyfill creates a TransformStream that uses TextDecoder internally.
+ */
+declare const needsPolyfill: boolean;
+
+export { needsPolyfill as needsTextDecoderStreamPolyfill };

package/dist/polyfills/index.mjs

@@ -0,0 +1,34 @@
+// 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;
+}
+export {
+  needsPolyfill as needsTextDecoderStreamPolyfill
+};

package/dist/react/chunk-BG7SZT33.mjs

@@ -0,0 +1,182 @@
+import {
+  getTextGenerationPipeline
+} from "./chunk-Q6FVPTTV.mjs";
+
+// 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 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 };
+  }
+}
+
+export {
+  DEFAULT_TOOL_SELECTOR_MODEL,
+  selectTool,
+  preloadToolSelectorModel,
+  executeTool
+};

package/dist/react/chunk-LVWIZZZP.mjs

@@ -0,0 +1,6 @@
+// src/lib/chat/constants.ts
+var DEFAULT_LOCAL_CHAT_MODEL = "onnx-community/Qwen2.5-0.5B-Instruct";
+
+export {
+  DEFAULT_LOCAL_CHAT_MODEL
+};

package/dist/react/chunk-Q6FVPTTV.mjs

@@ -0,0 +1,28 @@
+// 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-LUTOZWVQ.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;
+}
+
+export {
+  getTextGenerationPipeline
+};

package/dist/react/constants-WUGUGYE3.mjs

@@ -0,0 +1,7 @@
+import {
+  DEFAULT_LOCAL_CHAT_MODEL
+} from "./chunk-LVWIZZZP.mjs";
+import "./chunk-FBCDBTKJ.mjs";
+export {
+  DEFAULT_LOCAL_CHAT_MODEL
+};

package/dist/react/generation-NG4QVPCR.mjs

@@ -0,0 +1,52 @@
+import {
+  DEFAULT_LOCAL_CHAT_MODEL
+} from "./chunk-LVWIZZZP.mjs";
+import {
+  getTextGenerationPipeline
+} from "./chunk-Q6FVPTTV.mjs";
+import "./chunk-FBCDBTKJ.mjs";
+
+// 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("./transformers.node-LUTOZWVQ.mjs");
+  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;
+}
+export {
+  generateLocalChatCompletion
+};