@kontextso/sdk-react-native 0.0.9 → 0.0.10-rc.1

package/dist/index.mjs

@@ -1,58 +1,128 @@
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-
 // src/formats/InlineAd.tsx
-import { useContext as useContext6, useEffect as useEffect7, useState as useState8 } from "react";
+import { useContext as useContext6, useEffect as useEffect8, useState as useState7 } from "react";
 import {
   Image,
   Linking as Linking3,
-  Platform as Platform2,
+  Platform,
   Text as Text3,
   TouchableOpacity as TouchableOpacity2,
   View as View3
 } from "react-native";
 
-// src/hooks/useAdViewed.tsx
-import { useEffect as useEffect4, useState as useState5 } from "react";
-
-// src/context/AdsProvider.tsx
-import React2, { useState as useState4 } from "react";
-
-// src/hooks/useInitializeAds.tsx
+// ../sdk-common/dist/index.mjs
+import { useContext } from "react";
+import React2, { useEffect as useEffect4, useState as useState4 } from "react";
 import { useEffect, useState } from "react";
-
-// src/utils.ts
-var UNRETRIABLE_ERRORS = [400, 403, 429];
-var fetchWithTimeout = async (input, init) => {
-  const { timeout = 16e3 } = init || {};
+import { useEffect as useEffect2, useState as useState2 } from "react";
+import { useEffect as useEffect3, useState as useState3 } from "react";
+import { jsx } from "react/jsx-runtime";
+import { useContext as useContext2, useEffect as useEffect5 } from "react";
+var version = "0.1.12";
+var Logger = class {
+  localLevel = "log";
+  remoteLevel = "error";
+  remoteConfig = null;
+  levels = {
+    debug: 0,
+    info: 1,
+    log: 2,
+    warn: 3,
+    error: 4,
+    silent: 5
+  };
+  setLocalLevel(level) {
+    this.localLevel = level;
+  }
+  setRemoteLevel(level) {
+    this.remoteLevel = level;
+  }
+  configureRemote(url, params) {
+    this.remoteConfig = { url, params };
+  }
+  shouldLog(level, targetLevel) {
+    if (targetLevel === "silent") {
+      return false;
+    }
+    return this.levels[level] >= this.levels[targetLevel];
+  }
+  logToConsole(level, ...args) {
+    if (this.shouldLog(level, this.localLevel)) {
+      if (level === "silent") {
+        return;
+      }
+      console[level](...args);
+    }
+  }
+  logToRemote(level, ...args) {
+    if (this.remoteConfig && this.shouldLog(level, this.remoteLevel)) {
+      fetch(
+        `${this.remoteConfig.url}/log`,
+        {
+          method: "POST",
+          body: JSON.stringify({
+            ...this.remoteConfig.params,
+            level,
+            message: args,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          })
+        }
+      ).catch((e) => {
+      });
+    }
+  }
+  debug(...args) {
+    this.logToConsole("debug", ...args);
+    this.logToRemote("debug", ...args);
+  }
+  info(...args) {
+    this.logToConsole("info", ...args);
+    this.logToRemote("info", ...args);
+  }
+  log(...args) {
+    this.logToConsole("log", ...args);
+    this.logToRemote("log", ...args);
+  }
+  warn(...args) {
+    this.logToConsole("warn", ...args);
+    this.logToRemote("warn", ...args);
+  }
+  error(...args) {
+    this.logToConsole("error", ...args);
+    this.logToRemote("error", ...args);
+  }
+};
+var log = new Logger();
+var log_default = log;
+var UNRETRIABLE_ERRORS = [403, 429, 404];
+var fetchWithTimeout = async (input, init, customFetch) => {
+  const { timeout = 16e3, ...rest } = init || {};
   const controller = new AbortController();
   const id = setTimeout(() => controller.abort(), timeout);
   try {
-    const response = await fetch(input, {
-      ...init,
+    const response = await (customFetch || fetch)(input, {
+      ...rest,
       signal: controller.signal
     });
-    clearTimeout(id);
     return response;
-  } catch (e) {
+  } catch (err) {
+    if (controller.signal.aborted) {
+      throw new Error(`Fetch aborted after ${timeout}ms`);
+    }
+    throw err;
+  } finally {
     clearTimeout(id);
-    throw e;
   }
 };
-var fetchRetry = async (input, init, maxRetries = 3, retryPeriod = 500) => {
+var fetchRetry = async (input, init, singleRequestTimeout, maxRetries, onRetry, customFetch) => {
   let retries = 0;
   let response;
-  let unretriableError;
+  let lastError = null;
   while (retries < maxRetries) {
     try {
-      response = await fetchWithTimeout(input, init);
+      const requestInit = { ...init, timeout: singleRequestTimeout };
+      response = await fetchWithTimeout(input, requestInit, customFetch);
       if (UNRETRIABLE_ERRORS.includes(response.status)) {
-        unretriableError = new Error(response.statusText);
-        break;
+        throw new Error(`Unretriable error: ${response.statusText}`);
       }
       if (response.ok) {
         return response;
@@ -60,18 +130,20 @@ var fetchRetry = async (input, init, maxRetries = 3, retryPeriod = 500) => {
         throw new Error(`Failed with status ${response.status}`);
       }
     } catch (error) {
+      log_default.debug(`Retrying ${input} ${retries} times, error: ${error}`);
       retries++;
-      await new Promise((resolve) => setTimeout(resolve, retryPeriod));
+      lastError = error;
+      onRetry?.(error, retries);
     }
   }
-  if (unretriableError) {
-    throw unretriableError;
-  }
-  throw new Error("Failed to fetch after multiple retries");
+  throw lastError || new Error("Failed to fetch after multiple retries");
 };
 var fixUrl = (adserverUrl, ad) => {
   if (ad.content) {
-    ad.content = ad.content.replace("/impression/", `${adserverUrl}/impression/`);
+    ad.content = ad.content.replace(
+      "/impression/",
+      `${adserverUrl}/impression/`
+    );
     ad.content = ad.content.replace("/ad/", `${adserverUrl}/impression/`);
   }
   return { ...ad, url: `${adserverUrl}${ad.url}` };
@@ -112,6 +184,16 @@ var mergeAds = ({
   }
   return ads;
 };
+var loadExternalCss = (serverUrl, publisherToken, visitorId) => {
+  const visitorIdSearchParam = visitorId ? `&visitorId=${visitorId}` : "";
+  const url = `${serverUrl}/sdk/styles?publisherToken=${publisherToken}&sdkVersion=${version}${visitorIdSearchParam}`;
+  const link = document.createElement("link");
+  link.rel = "stylesheet";
+  link.type = "text/css";
+  link.href = url;
+  document.head.appendChild(link);
+  return link;
+};
 function mergeStyles(propStyles, defaultStyles, overridingStyles) {
   function deepMerge(target, source) {
     if (typeof target !== "object" || typeof source !== "object") {
@@ -133,165 +215,36 @@ function mergeStyles(propStyles, defaultStyles, overridingStyles) {
   mergedStyles = deepMerge(mergedStyles, overridingStyles || {});
   return mergedStyles;
 }
-var parseMessageText = (text) => {
-  const parts = [];
-  let start = 0;
-  const regex = /(\*(.*?)\*)|\[([^\]]+)\]\(([^)]+)\)/g;
-  let match;
-  while ((match = regex.exec(text)) !== null) {
-    if (match.index > start) {
-      parts.push({ text: text.substring(start, match.index), textType: "normal" });
-    }
-    if (match[1]) {
-      const themedText = match[2];
-      const innerMatches = themedText.match(/\[([^\]]+)\]\(([^)]+)\)/g);
-      if (innerMatches) {
-        let innerStart = 0;
-        innerMatches.forEach((linkMatch) => {
-          const linkRegex = /\[([^\]]+)\]\(([^)]+)\)/;
-          const innerLink = linkMatch.match(linkRegex);
-          const linkIndex = themedText.indexOf(linkMatch, innerStart);
-          if (linkIndex > innerStart) {
-            parts.push({ text: themedText.substring(innerStart, linkIndex), textType: "themed" });
-          }
-          parts.push({ text: innerLink[1], textType: "link", url: innerLink[2] });
-          innerStart = linkIndex + linkMatch.length;
-        });
-        if (innerStart < themedText.length) {
-          parts.push({ text: themedText.substring(innerStart), textType: "themed" });
-        }
-      } else {
-        parts.push({ text: themedText, textType: "themed" });
-      }
-    } else if (match[3] && match[4]) {
-      parts.push({ text: match[3], textType: "link", url: match[4] });
-    }
-    start = match.index + match[0].length;
-  }
-  if (start < text.length) {
-    parts.push({ text: text.substring(start), textType: "normal" });
-  }
-  return parts;
-};
-
-// src/log.ts
-var Logger = class {
-  localLevel = "log";
-  remoteLevel = "error";
-  remoteConfig = null;
-  levels = {
-    debug: 0,
-    info: 1,
-    log: 2,
-    warn: 3,
-    error: 4,
-    silent: 5
-  };
-  setLocalLevel(level) {
-    this.localLevel = level;
-  }
-  setRemoteLevel(level) {
-    this.remoteLevel = level;
-  }
-  configureRemote(url, params) {
-    this.remoteConfig = { url, params };
-  }
-  shouldLog(level, targetLevel) {
-    if (targetLevel === "silent") {
-      return false;
-    }
-    return this.levels[level] >= this.levels[targetLevel];
-  }
-  logToConsole(level, ...args) {
-    if (this.shouldLog(level, this.localLevel)) {
-      if (level === "silent") {
-        return;
-      }
-      console[level](...args);
-    }
-  }
-  logToRemote(level, ...args) {
-    if (this.remoteConfig && this.shouldLog(level, this.remoteLevel)) {
-      fetch(
-        `${this.remoteConfig.url}/log`,
-        {
-          method: "POST",
-          body: JSON.stringify({
-            ...this.remoteConfig.params,
-            level,
-            message: args,
-            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-          })
-        }
-      ).catch((e) => {
-      });
-    }
-  }
-  debug(...args) {
-    this.logToConsole("debug", ...args);
-    this.logToRemote("debug", ...args);
-  }
-  info(...args) {
-    this.logToConsole("info", ...args);
-    this.logToRemote("info", ...args);
-  }
-  log(...args) {
-    this.logToConsole("log", ...args);
-    this.logToRemote("log", ...args);
-  }
-  warn(...args) {
-    this.logToConsole("warn", ...args);
-    this.logToRemote("warn", ...args);
-  }
-  error(...args) {
-    this.logToConsole("error", ...args);
-    this.logToRemote("error", ...args);
-  }
-};
-var log = new Logger();
-var log_default = log;
-
-// package.json
-var version = "0.0.9";
-
-// src/hooks/useInitializeAds.tsx
-var RETRY_PERIOD_MS = 500;
-var INIT_RETRIES = 3;
-async function initialize(adServerUrl, publisherToken, userId, conversationId, legacyVisitorId, character) {
-  log_default.log("[BRAIN] init ads started");
+var SINGLE_INIT_TIMEOUT_BUDGET_MS = 5e3;
+async function initialise(adServerUrl, publisherToken, visitorId, userId, conversationId, legacyVisitorId, character, customFetch) {
+  log_default.log("[Kontext] init ads started");
   const response = await fetchRetry(
     `${adServerUrl}/init`,
     {
-      timeout: 1e4,
       method: "POST",
       body: JSON.stringify({
         publisherToken,
         userId,
-        visitorId: userId,
+        visitorId,
         conversationId,
-        sdkVersion: `native-${version}`,
+        sdkVersion: version,
         legacyVisitorId,
         character
       })
     },
-    INIT_RETRIES,
-    RETRY_PERIOD_MS
+    SINGLE_INIT_TIMEOUT_BUDGET_MS,
+    3,
+    () => {
+      log_default.warn("[Kontext] Reinitialising ads");
+    },
+    customFetch
   );
-  const {
-    sessionId,
-    enabledPlacements,
-    ads,
-    sessionDisabled,
-    streamAdServer,
-    onlyStream,
-    defaultReactNativeStyles,
-    overridingReactNativeStyles,
-    remoteLogLevel
-  } = await response.json();
+  const { sessionId, enabledPlacements, ads, sessionDisabled, streamAdServer, onlyStream, remoteLogLevel, preloadTimeout, streamTimeout, defaultReactNativeStyles, overridingReactNativeStyles } = await response.json();
   const fixedAds = ads.map((ad) => {
-    return fixUrl(adServerUrl, ad);
+    const fixedAd = fixUrl(adServerUrl, ad);
+    return fixedAd;
   });
-  log_default.log("[BRAIN] init ads done");
+  log_default.log("[Kontext] init ads done");
   return {
     sessionDisabled,
     sessionId,
@@ -299,126 +252,127 @@ async function initialize(adServerUrl, publisherToken, userId, conversationId, l
     ads: fixedAds,
     streamAdServer,
     onlyStream,
-    defaultReactNativeStylesResponse: defaultReactNativeStyles,
-    overridingReactNativeStylesResponse: overridingReactNativeStyles,
-    remoteLogLevel
+    remoteLogLevel,
+    preloadTimeout,
+    streamTimeout,
+    defaultReactNativeStyles,
+    overridingReactNativeStyles
   };
 }
 function useInitializeAds({
   adServerUrl,
   publisherToken,
+  visitorId,
   userId,
   conversationId,
   isDisabled,
   character,
-  legacyVisitorId
+  legacyVisitorId,
+  captureError,
+  customFetch,
+  reactNativePropStyles
 }) {
   const [enabledPlacements, setEnabledPlacements] = useState([]);
   const [ads, setAds] = useState([]);
   const [error, setError] = useState();
   const [streamAdServerUrl, setStreamAdServerUrl] = useState();
   const [onlyStream, setOnlyStream] = useState(false);
+  const [preloadTimeout, setPreloadTimeout] = useState(8e3);
+  const [streamTimeout, setStreamTimeout] = useState(5e3);
+  const [reactNativeStyles, setReactNativeStyles] = useState(null);
   const [sessionId, setSessionId] = useState();
-  const [defaultReactNativeStyles, setDefaultReactNativeStyles] = useState();
-  const [overridingReactNativeStyles, setOverridingReactNativeStyles] = useState();
   useEffect(() => {
-    log_default.setRemoteLevel("debug");
+    setSessionId(void 0);
     log_default.configureRemote(adServerUrl, {
       publisherToken,
       userId,
-      visitorId: userId,
+      visitorId,
       conversationId,
       character
     });
-    setSessionId(void 0);
-    if (!isDisabled && userId) {
-      log_default.debug("[BRAIN] Initializing ads.");
-      initialize(
+    if (!isDisabled && visitorId && userId) {
+      log_default.debug("[Kontext] Initalising ads.");
+      log_default.setRemoteLevel("debug");
+      initialise(
         adServerUrl,
         publisherToken,
+        visitorId,
         userId,
         conversationId,
         legacyVisitorId,
-        character
-      ).then(
-        ({
-          sessionId: sessionId2,
-          enabledPlacements: enabledPlacements2,
-          ads: ads2,
-          sessionDisabled,
-          streamAdServer,
-          onlyStream: onlyStream2,
-          defaultReactNativeStylesResponse,
-          overridingReactNativeStylesResponse,
-          remoteLogLevel
-        }) => {
+        character,
+        customFetch
+      ).then(({ sessionId: sessionId2, enabledPlacements: enabledPlacements2, ads: ads2, sessionDisabled, streamAdServer, onlyStream: onlyStream2, remoteLogLevel, preloadTimeout: preloadTimeout2, streamTimeout: streamTimeout2, defaultReactNativeStyles, overridingReactNativeStyles }) => {
+        log_default.configureRemote(adServerUrl, {
+          publisherToken,
+          adServerUrl,
+          visitorId,
+          userId,
+          conversationId,
+          legacyVisitorId,
+          character,
+          sessionId: sessionId2
+        });
+        if (remoteLogLevel) {
           log_default.setRemoteLevel(remoteLogLevel || "silent");
-          log_default.configureRemote(adServerUrl, {
-            publisherToken,
-            adServerUrl,
-            userId,
-            conversationId,
-            legacyVisitorId,
-            character,
-            sessionId: sessionId2
-          });
-          if (!sessionDisabled) {
-            setSessionId(sessionId2);
-            setEnabledPlacements(enabledPlacements2);
-            setAds(ads2);
-            setStreamAdServerUrl(streamAdServer);
-            setOnlyStream(onlyStream2);
-            setDefaultReactNativeStyles(defaultReactNativeStylesResponse);
-            setOverridingReactNativeStyles(overridingReactNativeStylesResponse);
-          } else {
-            log_default.debug("[BRAIN] Session is disabled by server.");
+        }
+        const mergedStyles = mergeStyles(reactNativePropStyles, defaultReactNativeStyles, overridingReactNativeStyles);
+        setReactNativeStyles(mergedStyles);
+        if (!sessionDisabled) {
+          setSessionId(sessionId2);
+          setEnabledPlacements(enabledPlacements2);
+          setAds(ads2);
+          setStreamAdServerUrl(streamAdServer);
+          setOnlyStream(onlyStream2);
+          if (preloadTimeout2) {
+            setPreloadTimeout(preloadTimeout2);
           }
+          if (streamTimeout2) {
+            setStreamTimeout(streamTimeout2);
+          }
+        } else {
+          log_default.info(`[Kontext] Session is disabled. Reason: ${sessionId2}`);
+          setSessionId(null);
+        }
+      }).catch((e) => {
+        {
+          log_default.warn("[Kontext] Error initializing ads", e);
+          setError(e.toString());
+          captureError(e);
         }
-      ).catch((e) => {
-        log_default.warn("[BRAIN] Error initializing ads", e);
-        setError(e.message);
       });
     } else {
-      log_default.debug("[BRAIN] Ads are disabled.");
+      log_default.debug("[Kontext] Ads are disabled.");
+      setSessionId(null);
     }
-  }, [
-    adServerUrl,
-    publisherToken,
-    userId,
-    conversationId,
-    isDisabled
-  ]);
-  return {
-    ads,
-    sessionId,
-    enabledPlacements,
-    error,
-    streamAdServerUrl,
-    onlyStream,
-    defaultReactNativeStyles,
-    overridingReactNativeStyles
-  };
+  }, [adServerUrl, publisherToken, visitorId, userId, conversationId, isDisabled]);
+  return { ads, sessionId, enabledPlacements, error, streamAdServerUrl, onlyStream, preloadTimeout, streamTimeout, reactNativeStyles };
 }
-
-// src/hooks/usePreloadAds.tsx
-import { useEffect as useEffect2, useState as useState2 } from "react";
 function usePreloadAds({
-  userId,
   sessionId,
   conversationId,
   adserverUrl,
   messages,
   publisherToken,
   character,
-  onlyStream
+  onlyStream,
+  captureError,
+  preloadTimeout,
+  customFetch
 }) {
   const [preloadDone, setPreloadDone] = useState2(false);
   const [ads, setAds] = useState2([]);
-  const userMessagesContent = messages.filter((m) => m.role === "user").map((m) => m.content).join(" ");
+  const lastUserMessageContent = [...messages].reverse().find((m) => m.role === "user")?.content;
+  const userMessagesContent = messages.slice(-6).filter((m) => m.role === "user").map((m) => m.content).join(" ");
+  const numberOfAssistantMessagesAtTheEnd = messages.slice().reverse().filter((m) => m.role === "assistant" || m.role === "user").findIndex((m) => m.role === "user");
+  const numberOfAssistantFollowups = Math.max(
+    0,
+    numberOfAssistantMessagesAtTheEnd - 1
+  );
   useEffect2(() => {
     if (onlyStream) {
       setPreloadDone(true);
-      log_default.log("[BRAIN] skipping preload ads");
+      log_default.log("[Kontext] skipping preload ads");
       return;
     }
     async function preload() {
@@ -426,47 +380,57 @@ function usePreloadAds({
       if (!sessionId) {
         return;
       }
-      log_default.log("[BRAIN] preload ads started");
-      try {
-        const response = await fetchRetry(
-          `${adserverUrl}/preload`,
-          {
-            timeout: 1e4,
-            method: "POST",
-            body: JSON.stringify({
-              messages,
-              sessionId,
-              userId,
-              visitorId: userId,
-              publisherToken,
-              conversationId,
-              character,
-              sdkVersion: "native"
-            })
-          },
-          3,
-          1e3
-        );
-        const { ads: ads2 } = await response.json();
+      if (!lastUserMessageContent) {
+        return;
+      }
+      log_default.log("[Kontext] preload ads started");
+      const response = await fetchWithTimeout(
+        `${adserverUrl}/preload`,
+        {
+          method: "POST",
+          timeout: preloadTimeout,
+          body: JSON.stringify({
+            messages,
+            sessionId,
+            publisherToken,
+            conversationId,
+            character,
+            sdkVersion: version
+          })
+        },
+        customFetch
+      );
+      if (!response.ok) {
+        throw new Error("Error preloading ads. Status: " + response.status);
+      }
+      const { ads: ads2 } = await response.json();
+      ads2.forEach((ad) => {
         setAds((oldAds) => {
-          const newAds = ads2.map((ad) => fixUrl(adserverUrl, ad));
-          return [...oldAds, ...newAds];
+          const fixedAd = fixUrl(adserverUrl, ad);
+          let found = false;
+          let newAds = oldAds.map((a) => {
+            if (a.code === ad.code) {
+              found = true;
+              return fixedAd;
+            }
+            return a;
+          });
+          if (!found) {
+            newAds.push(fixedAd);
+          }
+          return newAds;
         });
-        setPreloadDone(true);
-        log_default.log("[BRAIN] preload ads finished");
-      } catch (e) {
-        log_default.warn("[BRAIN] Error preloading ads", e);
-      }
+      });
+      setPreloadDone(true);
+      log_default.log("[Kontext] preload ads finished");
     }
-    preload();
-  }, [sessionId, userMessagesContent, conversationId]);
+    preload().catch((e) => {
+      captureError(e);
+      log_default.error("[Kontext] Error preloading ads", e);
+    });
+  }, [sessionId, userMessagesContent, numberOfAssistantFollowups]);
   return { preloadDone, ads };
 }
-
-// src/hooks/useStreamAds.tsx
-import { useEffect as useEffect3, useState as useState3 } from "react";
-
-// src/hooks/data-stream.ts
 var textStreamPart = {
   code: "0",
   name: "text",
@@ -669,12 +633,7 @@ async function* readDataStream(reader, {
     const concatenatedChunks = concatChunks(chunks, totalLength);
     totalLength = 0;
     const streamParts2 = decoder.decode(concatenatedChunks, { stream: true }).split("\n").filter((line) => line !== "").map(parseStreamPart);
-    let i = 0;
     for (const streamPart of streamParts2) {
-      if (!(i % 5)) {
-        await new Promise((resolve) => setTimeout(resolve));
-      }
-      i++;
       yield streamPart;
     }
     if (isAborted?.()) {
@@ -683,25 +642,8 @@ async function* readDataStream(reader, {
     }
   }
 }
-
-// src/hooks/useStreamAds.tsx
-import { polyfill as polyfillEncoding } from "react-native-polyfill-globals/src/encoding";
-import { polyfill as polyfillReadableStream } from "react-native-polyfill-globals/src/readable-stream";
-import { Platform } from "react-native";
-var patchFetch = fetch;
-if (Platform.OS !== "web") {
-  polyfillEncoding();
-  polyfillReadableStream();
-  patchFetch = __require("react-native-fetch-api").fetch;
-}
-ErrorUtils.setGlobalHandler((error, isFatal) => {
-  if (!isFatal) {
-    log_default.warn(error);
-  } else {
-    log_default.error(error);
-  }
-});
 function useStreamAds({
+  visitorId,
   userId,
   sessionId,
   conversationId,
@@ -711,7 +653,10 @@ function useStreamAds({
   preloadDone,
   enabledPlacements,
   character,
-  publisherToken
+  publisherToken,
+  captureError,
+  streamTimeout,
+  customFetch
 }) {
   const [ads, setAds] = useState3([]);
   const fetchStream = async (messages2, code) => {
@@ -729,43 +674,77 @@ function useStreamAds({
       return newAds;
     });
     const body = JSON.stringify({
+      visitorId,
       userId,
-      visitorId: userId,
       sessionId,
       code,
       messages: messages2,
       publisherToken,
       character,
       conversationId,
-      sdkVersion: "native"
+      sdkVersion: version
     });
     try {
-      const response = await patchFetch(`${adserverUrl}/stream`, {
-        method: "POST",
-        body,
-        headers: {
-          "Content-Type": "application/json"
+      const response = await fetchWithTimeout(
+        `${adserverUrl}/stream`,
+        {
+          method: "POST",
+          body,
+          headers: {
+            "Content-Type": "application/json"
+          },
+          timeout: streamTimeout
         },
-        reactNative: { textStreaming: true }
-      });
+        customFetch
+      );
       if (!response.ok) {
-        throw new Error("Error streaming ad");
+        throw new Error("Error streaming ad. Status: " + response.status);
       }
       if (!response.body) {
-        throw new Error("Response body is not a readable stream");
+        throw new Error("Response body is not readable stream");
       }
-      setAds(
-        (oldAds) => oldAds.map((ad) => ad.messageId === lastAssistantMessage.id && ad.code === code ? { ...ad, isLoading: false, isStreaming: true } : ad)
-      );
+      if (response.status === 204) {
+        setAds((oldAds) => {
+          const newAds = oldAds.map((ad) => {
+            if (ad.messageId === lastAssistantMessage.id && ad.code === code) {
+              return {
+                ...ad,
+                isLoading: false,
+                isStreaming: false
+              };
+            }
+            return ad;
+          });
+          return newAds;
+        });
+        return;
+      }
+      setAds((oldAds) => {
+        const newAds = oldAds.map((ad) => {
+          if (ad.messageId === lastAssistantMessage.id && ad.code === code) {
+            return {
+              ...ad,
+              isLoading: false,
+              isStreaming: true
+            };
+          }
+          return ad;
+        });
+        return newAds;
+      });
       let data = "";
       let adData = {};
-      log_default.log(`[BRAIN] streaming ${code} ad started`);
+      log_default.log(`[Kontext] streaming ${code} ad started`);
+      if (!response.body) {
+        throw new Error("Response body is not readable stream");
+      }
       const reader = response.body.getReader();
       for await (const { type, value } of readDataStream(reader)) {
         switch (type) {
-          case "text":
+          case "text": {
             data += value;
             break;
+          }
           case "data": {
             let val = value;
             if (Array.isArray(val)) {
@@ -774,11 +753,12 @@ function useStreamAds({
             adData = { ...adData, ...val };
             break;
           }
-          case "error":
+          case "error": {
             throw new Error(`Error streaming ad ${value}`);
+          }
         }
-        setAds(
-          (oldAds) => oldAds.map((ad) => {
+        setAds((oldAds) => {
+          const newAds = oldAds.map((ad) => {
             if (ad.messageId === lastAssistantMessage.id && ad.code === code) {
               const content = adData.content ?? data;
               const newAd = fixUrl(adserverUrl, {
@@ -787,81 +767,86 @@ function useStreamAds({
                 isLoading: false,
                 isStreaming: true,
                 content: content.replace(
-                  new RegExp(`/impression/${adData.product.id}/redirect`, "g"),
+                  new RegExp(`/(ad|impression)/${adData.product.id}/redirect`, "g"),
                   `/impression/${adData.id}/redirect`
                 )
               });
               return newAd;
             }
             return ad;
-          })
-        );
+          });
+          return newAds;
+        });
       }
-      setAds(
-        (oldAds) => oldAds.map(
-          (ad) => ad.messageId === lastAssistantMessage.id && ad.code === code ? { ...ad, isStreaming: false } : ad
-        )
-      );
-      log_default.log(`[BRAIN] streaming ${code} ad done`);
+      setAds((oldAds) => {
+        const newAds = oldAds.map((ad) => {
+          if (ad.messageId === lastAssistantMessage.id && ad.code === code) {
+            return {
+              ...ad,
+              isStreaming: false
+            };
+          }
+          return ad;
+        });
+        return newAds;
+      });
+      log_default.log(`[Kontext] streaming ${code} ad done`);
     } catch (e) {
-      log_default.warn("[BRAIN] Error streaming ad", e);
-      setAds((oldAds) => [...oldAds, { isError: true, code }]);
+      captureError(e);
+      log_default.error("[Kontext] Error streaming ad", e);
+      setAds((oldAds) => {
+        let found = false;
+        const newAds = oldAds.map((ad) => {
+          if (ad.messageId === lastAssistantMessage.id && ad.code === code) {
+            found = true;
+            return {
+              ...ad,
+              isLoading: false,
+              isStreaming: false,
+              isError: true
+            };
+          }
+          return ad;
+        });
+        if (!found) {
+          newAds.push({
+            isLoading: false,
+            isStreaming: false,
+            isError: true,
+            code
+          });
+        }
+        return newAds;
+      });
     }
   };
   useEffect3(() => {
-    if (!isLoading && sessionId && messages.length > 2 && messages[messages.length - 1]?.role === "assistant" && preloadDone) {
-      enabledPlacements.forEach((placement) => {
-        if (["QUERY_STREAM", "INLINE_AD", "BOX_AD"].includes(placement.format)) {
+    if (!isLoading && sessionId && messages.length > 0 && messages[messages.length - 1]?.role === "assistant" && preloadDone) {
+      for (const placement of enabledPlacements) {
+        if (placement.format === "QUERY_STREAM" || placement.format === "INLINE_AD" || placement.format === "BOX_AD") {
           fetchStream(messages, String(placement.code));
         }
-      });
+      }
     }
-  }, [isLoading, preloadDone, sessionId, messages[messages.length - 1]?.role]);
+  }, [isLoading, preloadDone, sessionId]);
   return { ads };
 }
-
-// src/components/ErrorBoundary.tsx
-import React from "react";
-var captureErrorFn = (adServerUrl, error, componentStack, context) => {
-  fetch(`${adServerUrl}/error`, {
+var DEFAULT_AD_SERVER_URL = "https://server.megabrain.co";
+var captureErrorFn = (error, componentStack, additionalData) => {
+  const adserverUrl = additionalData?.adserverUrl || DEFAULT_AD_SERVER_URL;
+  fetch(`${adserverUrl}/error`, {
     method: "POST",
     body: JSON.stringify({
-      error: error?.message,
+      error: error.message,
       stack: componentStack,
-      context
+      additionalData
     })
   }).catch((e) => {
-    log_default.warn("Error reporting client error", e);
+    log_default.error(e);
+  }).finally(() => {
+    log_default.error(error, componentStack);
   });
 };
-var ErrorBoundary = class extends React.Component {
-  constructor(props) {
-    super(props);
-    this.state = {
-      hasError: false
-    };
-  }
-  static getDerivedStateFromError() {
-    return {
-      hasError: true
-    };
-  }
-  componentDidCatch(error, info) {
-    const adServerUrl = this.props.adserverUrl;
-    if (adServerUrl) {
-      captureErrorFn(adServerUrl, error, info?.componentStack, this.props.reqBodyParams);
-    }
-  }
-  render() {
-    if (this.state.hasError) {
-      return this.props.fallback || null;
-    }
-    return this.props.children;
-  }
-};
-
-// src/context/AdsProvider.tsx
-import { jsx } from "react/jsx-runtime";
 var AdsContext = React2.createContext(null);
 AdsContext.displayName = "AdsContext";
 var VISITOR_ID_KEY = "brain-visitor-id";
@@ -874,48 +859,89 @@ var AdsProviderWithoutBoundary = ({
   isDisabled,
   character,
   conversationId,
+  visitorId,
   userId,
   logLevel,
   onAdView,
   onAdClick,
-  ...props
+  customFetch,
+  reactNativePropStyles,
+  isReactNative
 }) => {
+  const adServerUrlOrDefault = adserverUrl || DEFAULT_AD_SERVER_URL;
+  log_default.setLocalLevel(logLevel || "silent");
+  visitorId = visitorId || userId;
   const [viewedAds, setViewedAds] = useState4([]);
   const [clickedAds, setClickedAds] = useState4([]);
-  const adServerUrlOrDefault = adserverUrl || "https://server.megabrain.co";
-  log_default.setLocalLevel(logLevel || "silent");
+  const captureError = (error) => {
+    captureErrorFn(error, error.stack, {
+      publisherToken,
+      adserverUrl,
+      conversationId,
+      character,
+      visitorId,
+      userId,
+      isLoading,
+      messages
+    });
+  };
+  const legacyVisitorId = typeof window !== "undefined" && typeof window.localStorage !== "undefined" && localStorage.getItem(VISITOR_ID_KEY) ? localStorage.getItem(VISITOR_ID_KEY) : void 0;
+  useEffect4(() => {
+    if (isReactNative) {
+      return;
+    }
+    const linkElement = loadExternalCss(adServerUrlOrDefault, publisherToken, visitorId);
+    return () => {
+      try {
+        document.head.removeChild(linkElement);
+      } catch (e) {
+      }
+    };
+  }, [adServerUrlOrDefault, publisherToken, visitorId, isReactNative]);
   const {
     ads: initAds,
     sessionId,
     enabledPlacements,
-    error,
+    error: initError,
     streamAdServerUrl,
     onlyStream,
-    defaultReactNativeStyles,
-    overridingReactNativeStyles
+    preloadTimeout,
+    streamTimeout,
+    reactNativeStyles
   } = useInitializeAds({
     adServerUrl: adServerUrlOrDefault,
     publisherToken,
     userId,
-    legacyVisitorId: void 0,
+    visitorId,
+    legacyVisitorId,
     conversationId,
     character,
-    isDisabled: !!isDisabled
+    isDisabled: !!isDisabled,
+    captureError,
+    customFetch,
+    reactNativePropStyles
   });
-  const styles = mergeStyles(props.styles, defaultReactNativeStyles, overridingReactNativeStyles);
-  const isInitialised = !!isDisabled || !!error || !!sessionId;
-  const { preloadDone, ads: preloadAds } = usePreloadAds({
+  const isInitialised = !!isDisabled || !!initError || !!sessionId || sessionId === null;
+  const {
+    preloadDone,
+    ads: preloadAds
+  } = usePreloadAds({
     sessionId,
     adserverUrl: adServerUrlOrDefault,
     messages,
     publisherToken,
     conversationId,
     userId,
+    visitorId,
     character,
-    onlyStream
+    onlyStream,
+    captureError,
+    preloadTimeout,
+    customFetch
   });
   const { ads: streamAds } = useStreamAds({
     userId,
+    visitorId,
     sessionId,
     adserverUrl: onlyStream && streamAdServerUrl ? streamAdServerUrl : adServerUrlOrDefault,
     conversationId,
@@ -924,23 +950,28 @@ var AdsProviderWithoutBoundary = ({
     character,
     preloadDone,
     enabledPlacements,
-    publisherToken
+    publisherToken,
+    captureError,
+    streamTimeout,
+    customFetch
   });
   const ads = mergeAds({ initAds, preloadAds, streamAds, viewedAds, clickedAds });
   const markAdAsViewed = (ad) => {
-    log_default.debug("[Brain] Calling onAdView");
     onAdView && onAdView({
       id: ad.id,
       code: ad.code,
       messageId: ad.messageId,
       content: ad.content
     });
-    if (!ad.id) return;
-    if (viewedAds.includes(ad.id)) return;
+    if (!ad.id) {
+      return;
+    }
+    if (viewedAds.includes(ad.id)) {
+      return;
+    }
     setViewedAds((old) => [...old, ad.id]);
   };
   const onAdClickInternal = (ad) => {
-    log_default.debug("[Brain] Calling onAdClick");
     onAdClick && onAdClick({
       id: ad.id,
       code: ad.code,
@@ -963,81 +994,73 @@ var AdsProviderWithoutBoundary = ({
         streamAdServerUrl,
         children,
         messages,
-        publisherToken,
-        isLoading,
-        ads,
-        sessionId,
-        isInitialised,
         conversationId,
-        isDisabled,
-        onAdClickInternal,
-        enabledPlacements,
-        userId,
-        markAdAsViewed,
-        onlyStream,
-        styles
-      },
-      children
-    }
-  );
-};
-var AdsProvider = ({
-  children,
-  messages,
-  publisherToken,
-  isLoading,
-  adserverUrl,
-  isDisabled,
-  character,
-  conversationId,
-  userId,
-  logLevel,
-  onAdView,
-  onAdClick,
-  ...props
-}) => {
-  const adServerUrlOrDefault = adserverUrl || "https://server.megabrain.co";
-  return /* @__PURE__ */ jsx(
-    ErrorBoundary,
-    {
-      fallback: children,
-      adserverUrl: adServerUrlOrDefault,
-      reqBodyParams: {
-        publisherToken,
-        adserverUrl,
-        conversationId,
-        character,
-        userId,
-        isLoading,
-        messages
-      },
-      children: /* @__PURE__ */ jsx(
-        AdsProviderWithoutBoundary,
-        {
-          children,
-          messages,
-          publisherToken,
-          isLoading,
-          adserverUrl,
-          isDisabled,
-          character,
-          conversationId,
-          userId,
-          logLevel,
-          onAdView,
-          onAdClick,
-          ...props
-        }
-      )
+        publisherToken,
+        isLoading,
+        ads,
+        sessionId,
+        isInitialised,
+        isDisabled,
+        onAdClickInternal,
+        enabledPlacements,
+        userId,
+        visitorId,
+        markAdAsViewed,
+        onlyStream,
+        preloadTimeout,
+        streamTimeout,
+        reactNativeStyles
+      },
+      children
     }
   );
 };
-
-// src/hooks/useAdViewed.tsx
-import { useContext } from "react";
-function useAdViewed(ad) {
+function useAd({ code, messageId }) {
   const context = useContext(AdsContext);
-  const [stillMounted, setStillMounted] = useState5(false);
+  if (!context) {
+    return null;
+  }
+  const ad = context.ads.find((ad2) => {
+    if (messageId) {
+      return ad2.code === code && ad2.messageId === messageId;
+    }
+    return ad2.code === code;
+  });
+  if (!ad) {
+    return null;
+  }
+  const placement = context.enabledPlacements.find((p) => p.code === code);
+  if (!placement) {
+    return null;
+  }
+  const dependencies = placement.config.dependencies?.split(",").map((d) => d.trim()).filter((d) => d);
+  if (!dependencies || dependencies.length === 0) {
+    return ad;
+  }
+  const dependencyAds = context.enabledPlacements.filter(
+    (p) => dependencies.includes(p.code)
+  );
+  if (!dependencyAds.length) {
+    return ad;
+  }
+  const allAdsLoadedAndNotStreaming = dependencyAds.every((p) => {
+    let a;
+    if (messageId) {
+      a = context.ads.find(
+        (ad2) => ad2.code === p.code && ad2.messageId === messageId
+      );
+    } else {
+      a = context.ads.find((ad2) => ad2.code === p.code);
+    }
+    return a && !a.isLoading && !a.isStreaming || a && a.isError;
+  });
+  if (!allAdsLoadedAndNotStreaming) {
+    return null;
+  }
+  return ad;
+}
+function useAdViewed(ad, ref) {
+  const context = useContext2(AdsContext);
   const sendRequest = async () => {
     if (!context?.adserverUrl || !ad?.id) {
       return;
@@ -1054,43 +1077,95 @@ function useAdViewed(ad) {
       if (!response.ok) {
         throw new Error("Error sending view request");
       }
-      log_default.log("[BRAIN] ad marked as viewed", ad.id, ad.code);
+      log_default.log("[Kontext] ad marked as viewed", ad.id, ad.code);
     } catch (e) {
-      log_default.warn("[BRAIN] Error sending view request", e);
+      log_default.error("[Kontext] Error sending view request", e);
     }
   };
-  useEffect4(() => {
-    if (!ad || ad.isError || ad.isLoading || ad.isStreaming || ad.viewed || stillMounted) {
+  useEffect5(() => {
+    if (!ref?.current || !ad || !context?.visitorId || !context?.userId || ad.isError || ad.isLoading || ad.isStreaming || ad.viewed) {
       return;
     }
-    log_default.log("[BRAIN] setting timeout", ad.id, ad.code);
-    setTimeout(() => {
-      log_default.log("[BRAIN] setting setStillMounted", ad.id, ad.code);
-      setStillMounted(true);
-    }, 1e3);
-  }, [ad]);
-  useEffect4(() => {
-    if (stillMounted) {
-      log_default.log("[BRAIN] sending request");
+    if (typeof window.IntersectionObserver === "undefined") {
       sendRequest();
+      return;
     }
-  }, [stillMounted]);
+    const observer = new window.IntersectionObserver((entries, observer2) => {
+      entries.forEach((entry) => {
+        if (entry.isIntersecting) {
+          sendRequest();
+          observer2.unobserve(entry.target);
+        }
+      });
+    });
+    observer.observe(ref?.current);
+    return () => {
+      observer.disconnect();
+    };
+  }, [ad]);
 }
 
 // src/components/MarkdownText.tsx
-import { useContext as useContext2 } from "react";
+import { useContext as useContext3 } from "react";
 import { Linking, Pressable, Text } from "react-native";
+
+// src/utils.ts
+var getStyles = (context) => {
+  return context.reactNativeStyles;
+};
+var parseMessageText = (text) => {
+  const parts = [];
+  let start = 0;
+  const regex = /(\*(.*?)\*)|\[([^\]]+)\]\(([^)]+)\)/g;
+  let match;
+  while ((match = regex.exec(text)) !== null) {
+    if (match.index > start) {
+      parts.push({ text: text.substring(start, match.index), textType: "normal" });
+    }
+    if (match[1]) {
+      const themedText = match[2];
+      const innerMatches = themedText.match(/\[([^\]]+)\]\(([^)]+)\)/g);
+      if (innerMatches) {
+        let innerStart = 0;
+        innerMatches.forEach((linkMatch) => {
+          const linkRegex = /\[([^\]]+)\]\(([^)]+)\)/;
+          const innerLink = linkMatch.match(linkRegex);
+          const linkIndex = themedText.indexOf(linkMatch, innerStart);
+          if (linkIndex > innerStart) {
+            parts.push({ text: themedText.substring(innerStart, linkIndex), textType: "themed" });
+          }
+          parts.push({ text: innerLink[1], textType: "link", url: innerLink[2] });
+          innerStart = linkIndex + linkMatch.length;
+        });
+        if (innerStart < themedText.length) {
+          parts.push({ text: themedText.substring(innerStart), textType: "themed" });
+        }
+      } else {
+        parts.push({ text: themedText, textType: "themed" });
+      }
+    } else if (match[3] && match[4]) {
+      parts.push({ text: match[3], textType: "link", url: match[4] });
+    }
+    start = match.index + match[0].length;
+  }
+  if (start < text.length) {
+    parts.push({ text: text.substring(start), textType: "normal" });
+  }
+  return parts;
+};
+
+// src/components/MarkdownText.tsx
 import { Fragment, jsx as jsx2 } from "react/jsx-runtime";
 function MarkdownText({
   content,
   onLinkClick
 }) {
-  const context = useContext2(AdsContext);
+  const context = useContext3(AdsContext);
   const textParts = parseMessageText(content);
-  const styles = context?.styles?.markdownText;
+  const styles = getStyles(context)?.markdownText;
   const linkClickHandler = (href) => {
     onLinkClick();
-    Linking.openURL(href).catch((err) => log_default.warn("Failed to open URL:", err));
+    Linking.openURL(href).catch((err) => log.warn("Failed to open URL:", err));
     return false;
   };
   return /* @__PURE__ */ jsx2(Fragment, { children: textParts.map((t, i) => {
@@ -1118,17 +1193,18 @@ function MarkdownText({
 
 // src/components/VideoPlayer.tsx
 import { ResizeMode, Video } from "expo-av";
-import { useContext as useContext4, useEffect as useEffect6, useRef, useState as useState7 } from "react";
+import { useContext as useContext5, useEffect as useEffect7, useRef, useState as useState6 } from "react";
 import { Linking as Linking2, Text as Text2, TouchableOpacity, View as View2 } from "react-native";
 
 // src/components/VideoProgressBar.tsx
-import { useState as useState6, useEffect as useEffect5, useContext as useContext3 } from "react";
+import { useState as useState5, useEffect as useEffect6, useContext as useContext4 } from "react";
 import { View } from "react-native";
 import { jsx as jsx3 } from "react/jsx-runtime";
 function VideoProgressBar({ videoRef }) {
-  const [progress, setProgress] = useState6(0);
-  const styles = useContext3(AdsContext)?.styles?.videoPlayer?.videoProgress;
-  useEffect5(() => {
+  const [progress, setProgress] = useState5(0);
+  const context = useContext4(AdsContext);
+  const styles = getStyles(context)?.videoPlayer?.videoProgress;
+  useEffect6(() => {
     const interval = setInterval(() => {
       if (!videoRef.current) {
         return;
@@ -1162,13 +1238,14 @@ var VideoPlayer = ({
   onLinkClick
 }) => {
   const videoRef = useRef(null);
-  const [isPlaying, setIsPlaying] = useState7(false);
-  const [isPaused, setIsPaused] = useState7(true);
-  const [isEnded, setIsEnded] = useState7(false);
-  const [showDownloadBadge, setShowDownloadBadge] = useState7(false);
+  const [isPlaying, setIsPlaying] = useState6(false);
+  const [isPaused, setIsPaused] = useState6(true);
+  const [isEnded, setIsEnded] = useState6(false);
+  const [showDownloadBadge, setShowDownloadBadge] = useState6(false);
   const lastCallbackTimeRef = useRef(0);
-  const styles = useContext4(AdsContext)?.styles?.videoPlayer;
-  useEffect6(() => {
+  const context = useContext5(AdsContext);
+  const styles = getStyles(context)?.videoPlayer;
+  useEffect7(() => {
     const interval = setInterval(() => {
       if (videoRef.current) {
         videoRef.current.getStatusAsync().then((status) => {
@@ -1212,7 +1289,7 @@ var VideoPlayer = ({
   };
   const handleLinkClick = (url) => {
     if (url) {
-      Linking2.openURL(url).catch((err) => log_default.warn("Failed to open URL:", err));
+      Linking2.openURL(url).catch((err) => log.warn("Failed to open URL:", err));
       onLinkClick();
     }
   };
@@ -1250,62 +1327,15 @@ var VideoPlayer = ({
   ] });
 };
 
-// src/hooks/useAd.tsx
-import { useContext as useContext5 } from "react";
-function useAd({ code, messageId }) {
-  const context = useContext5(AdsContext);
-  if (!context) {
-    return null;
-  }
-  const ad = context.ads.find((ad2) => {
-    if (messageId) {
-      return ad2.code === code && ad2.messageId === messageId;
-    }
-    return ad2.code === code;
-  });
-  if (!ad) {
-    return null;
-  }
-  const placement = context.enabledPlacements.find((p) => p.code === code);
-  if (!placement) {
-    return null;
-  }
-  const dependencies = placement.config.dependencies?.split(",").map((d) => d.trim()).filter((d) => d);
-  if (!dependencies || dependencies.length === 0) {
-    return ad;
-  }
-  const dependencyAds = context.enabledPlacements.filter(
-    (p) => dependencies.includes(p.code)
-  );
-  if (!dependencyAds.length) {
-    return ad;
-  }
-  const allAdsLoadedAndNotStreaming = dependencyAds.every((p) => {
-    let a;
-    if (messageId) {
-      a = context.ads.find(
-        (ad2) => ad2.code === p.code && ad2.messageId === messageId
-      );
-    } else {
-      a = context.ads.find((ad2) => ad2.code === p.code);
-    }
-    return a && !a.isLoading && !a.isStreaming || a && a.isError;
-  });
-  if (!allAdsLoadedAndNotStreaming) {
-    return null;
-  }
-  return ad;
-}
-
 // src/formats/InlineAd.tsx
 import { jsx as jsx5, jsxs as jsxs2 } from "react/jsx-runtime";
 var InlineAd = ({ code, messageId, wrapper }) => {
   const ad = useAd({ code, messageId });
-  const [linkIncluded, setLinkIncluded] = useState8(false);
+  const [linkIncluded, setLinkIncluded] = useState7(false);
   const context = useContext6(AdsContext);
-  const styles = context?.styles?.inlineAd;
+  const styles = getStyles(context)?.inlineAd;
   useAdViewed(ad);
-  useEffect7(() => {
+  useEffect8(() => {
     if (ad?.content && !ad.isStreaming && !ad.content.match(/\[.*?\]\(.*?\)/) && !linkIncluded) {
       setLinkIncluded(true);
     }
@@ -1314,16 +1344,16 @@ var InlineAd = ({ code, messageId, wrapper }) => {
   if (ad.isLoading || ad.content?.trim().toLowerCase().includes("none"))
     return null;
   const onProgress = (progress) => {
-    log_default.log(`Progress: ${progress}`);
+    log.log(`Progress: ${progress}`);
   };
   const handleImageClick = (url) => {
     if (url) {
       context?.onAdClickInternal(ad);
-      if (Platform2.OS === "web") {
+      if (Platform.OS === "web") {
         window.open(url, "_blank");
       } else {
         Linking3.openURL(url).catch(
-          (err) => log_default.warn("Failed to open URL:", err)
+          (err) => log.warn("Failed to open URL:", err)
         );
       }
     }
@@ -1391,10 +1421,114 @@ var InlineAd = ({ code, messageId, wrapper }) => {
   return wrapper ? wrapper(content) : content;
 };
 var InlineAd_default = InlineAd;
+
+// src/components/ErrorBoundary.tsx
+import React5 from "react";
+var captureErrorFn2 = (adServerUrl, error, componentStack, context) => {
+  fetch(`${adServerUrl}/error`, {
+    method: "POST",
+    body: JSON.stringify({
+      error: error?.message,
+      stack: componentStack,
+      context
+    })
+  }).catch((e) => {
+    log.warn("Error reporting client error", e);
+  });
+};
+var ErrorBoundary = class extends React5.Component {
+  constructor(props) {
+    super(props);
+    this.state = {
+      hasError: false
+    };
+  }
+  static getDerivedStateFromError() {
+    return {
+      hasError: true
+    };
+  }
+  componentDidCatch(error, info) {
+    const adServerUrl = this.props.adserverUrl;
+    if (adServerUrl) {
+      captureErrorFn2(adServerUrl, error, info?.componentStack, this.props.reqBodyParams);
+    }
+  }
+  render() {
+    if (this.state.hasError) {
+      return this.props.fallback || null;
+    }
+    return this.props.children;
+  }
+};
+
+// src/context/AdsProvider.tsx
+import { fetch as fetch2 } from "expo/fetch";
+import { jsx as jsx6 } from "react/jsx-runtime";
+var VISITOR_ID_KEY2 = "brain-visitor-id";
+ErrorUtils.setGlobalHandler((error, isFatal) => {
+  if (!isFatal) {
+    log.warn(error);
+  } else {
+    log.error(error);
+  }
+});
+var AdsProvider = ({
+  children,
+  messages,
+  publisherToken,
+  isLoading,
+  adserverUrl,
+  isDisabled,
+  character,
+  conversationId,
+  userId,
+  logLevel,
+  onAdView,
+  onAdClick,
+  styles
+}) => {
+  const adServerUrlOrDefault = adserverUrl || "https://server.megabrain.co";
+  return /* @__PURE__ */ jsx6(
+    ErrorBoundary,
+    {
+      fallback: children,
+      adserverUrl: adServerUrlOrDefault,
+      reqBodyParams: {
+        publisherToken,
+        adserverUrl,
+        conversationId,
+        character,
+        userId,
+        isLoading,
+        messages
+      },
+      children: /* @__PURE__ */ jsx6(
+        AdsProviderWithoutBoundary,
+        {
+          children,
+          messages,
+          publisherToken,
+          isLoading,
+          adserverUrl,
+          isDisabled,
+          character,
+          conversationId,
+          userId,
+          logLevel,
+          onAdView,
+          onAdClick,
+          reactNativePropStyles: styles,
+          customFetch: fetch2,
+          isReactNative: true
+        }
+      )
+    }
+  );
+};
 export {
-  AdsContext,
   AdsProvider,
   InlineAd_default as InlineAd,
-  VISITOR_ID_KEY,
+  VISITOR_ID_KEY2 as VISITOR_ID_KEY,
   useAd
 };