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

package/dist/react/index.cjs

@@ -40,6 +40,19 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
+// src/lib/chat/constants.ts
+var constants_exports = {};
+__export(constants_exports, {
+  DEFAULT_LOCAL_CHAT_MODEL: () => DEFAULT_LOCAL_CHAT_MODEL
+});
+var DEFAULT_LOCAL_CHAT_MODEL;
+var init_constants = __esm({
+  "src/lib/chat/constants.ts"() {
+    "use strict";
+    DEFAULT_LOCAL_CHAT_MODEL = "onnx-community/Qwen2.5-0.5B-Instruct";
+  }
+});
+
 // node_modules/.pnpm/onnxruntime-common@1.21.0/node_modules/onnxruntime-common/dist/esm/backend-impl.js
 var backends, backendsSortedByPriority, registerBackend, tryResolveAndInitializeBackend, resolveBackendAndExecutionProviders;
 var init_backend_impl = __esm({
@@ -47098,6 +47111,276 @@ ${fake_token_around_image}${global_img_token}` + image_token.repeat(image_seq_le
   }
 });
 
+// src/lib/chat/pipeline.ts
+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;
+}
+var sharedPipeline, currentModel, currentDevice;
+var init_pipeline = __esm({
+  "src/lib/chat/pipeline.ts"() {
+    "use strict";
+    sharedPipeline = null;
+    currentModel = null;
+    currentDevice = null;
+  }
+});
+
+// src/lib/chat/generation.ts
+var generation_exports = {};
+__export(generation_exports, {
+  generateLocalChatCompletion: () => generateLocalChatCompletion
+});
+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;
+}
+var init_generation = __esm({
+  "src/lib/chat/generation.ts"() {
+    "use strict";
+    init_constants();
+    init_pipeline();
+  }
+});
+
+// src/lib/tools/selector.ts
+var selector_exports = {};
+__export(selector_exports, {
+  DEFAULT_TOOL_SELECTOR_MODEL: () => DEFAULT_TOOL_SELECTOR_MODEL,
+  executeTool: () => executeTool,
+  preloadToolSelectorModel: () => preloadToolSelectorModel,
+  selectTool: () => selectTool
+});
+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 };
+  }
+}
+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 };
+  }
+}
+var DEFAULT_TOOL_SELECTOR_MODEL, preloadPromise;
+var init_selector = __esm({
+  "src/lib/tools/selector.ts"() {
+    "use strict";
+    init_pipeline();
+    DEFAULT_TOOL_SELECTOR_MODEL = "Xenova/LaMini-GPT-124M";
+    preloadPromise = null;
+  }
+});
+
 // src/react/index.ts
 var index_exports = {};
 __export(index_exports, {
@@ -47125,6 +47408,38 @@ module.exports = __toCommonJS(index_exports);
 // src/react/useChat.ts
 var import_react = require("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(
@@ -47940,219 +48255,24 @@ 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
+var isReactNative = typeof navigator !== "undefined" && navigator.product === "ReactNative";
+var webFeatures = null;
+var webFeaturesPromise = isReactNative ? Promise.resolve(null) : Promise.all([
+  Promise.resolve().then(() => (init_generation(), generation_exports)),
+  Promise.resolve().then(() => (init_constants(), constants_exports)),
+  Promise.resolve().then(() => (init_selector(), selector_exports))
+]).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
+  };
+  return webFeatures;
+});
 function useChat(options) {
   const {
     getToken,
@@ -48161,13 +48281,14 @@ function useChat(options) {
     onFinish,
     onError,
     chatProvider = "api",
-    localModel = DEFAULT_LOCAL_CHAT_MODEL,
+    localModel,
     tools,
-    toolSelectorModel = DEFAULT_TOOL_SELECTOR_MODEL,
+    toolSelectorModel,
     onToolExecution
   } = options || {};
   const [isLoading, setIsLoading] = (0, import_react.useState)(false);
   const [isSelectingTool, setIsSelectingTool] = (0, import_react.useState)(false);
+  const [webFeaturesLoaded, setWebFeaturesLoaded] = (0, import_react.useState)(false);
   const abortControllerRef = (0, import_react.useRef)(null);
   const stop = (0, import_react.useCallback)(() => {
     if (abortControllerRef.current) {
@@ -48184,10 +48305,17 @@ function useChat(options) {
     };
   }, []);
   (0, import_react.useEffect)(() => {
-    if (tools && tools.length > 0) {
-      preloadToolSelectorModel({ model: toolSelectorModel });
+    webFeaturesPromise?.then((loaded) => {
+      if (loaded) setWebFeaturesLoaded(true);
+    });
+  }, []);
+  (0, import_react.useEffect)(() => {
+    if (!isReactNative && webFeaturesLoaded && webFeatures && tools && tools.length > 0) {
+      webFeatures.preloadToolSelectorModel({
+        model: toolSelectorModel || webFeatures.DEFAULT_TOOL_SELECTOR_MODEL
+      });
     }
-  }, [tools, toolSelectorModel]);
+  }, [tools, toolSelectorModel, webFeaturesLoaded]);
   const sendMessage = (0, import_react.useCallback)(
     async ({
       messages,
@@ -48208,22 +48336,27 @@ function useChat(options) {
       setIsLoading(true);
       let toolExecutionResult;
       let messagesWithToolContext = messages;
-      if (runTools && tools && tools.length > 0) {
+      const canRunTools = !isReactNative && webFeaturesLoaded && webFeatures !== null && runTools && tools && tools.length > 0;
+      if (canRunTools && webFeatures) {
         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
-            });
+            const selectionResult = await webFeatures.selectTool(
+              contentString,
+              tools,
+              {
+                model: toolSelectorModel || webFeatures.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 executeTool(
+                const execResult = await webFeatures.executeTool(
                   selectedTool,
                   selectionResult.parameters || {}
                 );
@@ -48279,13 +48412,23 @@ Please inform the user about this issue and try to help them alternatively.`
       }
       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;
+          const usedModel = localModel || webFeatures.DEFAULT_LOCAL_CHAT_MODEL;
           const formattedMessages = messagesWithToolContext.map((m) => ({
             role: m.role || "user",
             content: m.content?.map((p) => p.text || "").join("") || ""
           }));
-          await generateLocalChatCompletion(formattedMessages, {
+          await webFeatures.generateLocalChatCompletion(formattedMessages, {
             model: usedModel,
             signal: abortController.signal,
             onToken: (token) => {
@@ -48469,7 +48612,8 @@ Please inform the user about this issue and try to help them alternatively.`
       localModel,
       tools,
       toolSelectorModel,
-      onToolExecution
+      onToolExecution,
+      webFeaturesLoaded
     ]
   );
   return {
@@ -49671,6 +49815,9 @@ var extractConversationContext = (messages, maxMessages = 3) => {
   const userMessages = messages.filter((msg) => msg.role === "user").slice(-maxMessages).map((msg) => msg.content).join(" ");
   return userMessages.trim();
 };
+
+// src/react/index.ts
+init_selector();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DEFAULT_TOOL_SELECTOR_MODEL,