@kontextso/sdk-react-native 0.0.4

package/dist/index.mjs

@@ -0,0 +1,1205 @@
+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 useEffect8, useState as useState8 } from "react";
+import {
+  Image,
+  Linking as Linking3,
+  Platform as Platform2,
+  Text as Text3,
+  TouchableOpacity as TouchableOpacity2,
+  View as View3
+} from "react-native";
+
+// src/hooks/useAdViewed.tsx
+import { useEffect as useEffect5, useState as useState5 } from "react";
+
+// src/context/AdsProvider.tsx
+import React, { useState as useState4 } from "react";
+
+// src/hooks/useInitializeAds.tsx
+import { useEffect, useState } from "react";
+
+// src/utils.ts
+var UNRETRIABLE_ERRORS = [403, 429];
+var fetchWithTimeout = async (input, init) => {
+  const { timeout = 16e3 } = init || {};
+  const controller = new AbortController();
+  const id = setTimeout(() => controller.abort(), timeout);
+  try {
+    const response = await fetch(input, {
+      ...init,
+      signal: controller.signal
+    });
+    clearTimeout(id);
+    return response;
+  } catch (e) {
+    clearTimeout(id);
+    throw e;
+  }
+};
+var fetchRetry = async (input, init, maxRetries = 3, retryPeriod = 500) => {
+  let retries = 0;
+  let response;
+  let unretriableError;
+  while (retries < maxRetries) {
+    try {
+      response = await fetchWithTimeout(input, init);
+      if (UNRETRIABLE_ERRORS.includes(response.status)) {
+        unretriableError = new Error(response.statusText);
+        break;
+      }
+      if (response.ok) {
+        return response;
+      } else {
+        throw new Error(`Failed with status ${response.status}`);
+      }
+    } catch (error) {
+      retries++;
+      await new Promise((resolve) => setTimeout(resolve, retryPeriod));
+    }
+  }
+  if (unretriableError) {
+    throw unretriableError;
+  }
+  throw new Error("Failed to fetch after multiple retries");
+};
+var fixUrl = (adserverUrl, ad) => {
+  if (ad.content) {
+    ad.content = ad.content.replace("/ad/", `${adserverUrl}/ad/`);
+  }
+  return { ...ad, url: `${adserverUrl}${ad.url}` };
+};
+var mergeAds = ({
+  initAds,
+  preloadAds,
+  streamAds,
+  viewedAds
+}) => {
+  const ads = [...initAds];
+  if (Array.isArray(preloadAds)) {
+    for (const ad of preloadAds) {
+      const index = ads.findIndex((a) => a.code === ad.code);
+      if (index !== -1) {
+        ads[index] = ad;
+      } else {
+        ads.push(ad);
+      }
+    }
+  }
+  if (Array.isArray(streamAds)) {
+    for (const ad of streamAds) {
+      const index = ads.findIndex(
+        (a) => a.code === ad.code && a.messageId === ad.messageId
+      );
+      if (index !== -1) {
+        ads[index] = ad;
+      } else {
+        ads.push(ad);
+      }
+    }
+  }
+  for (const ad of ads) {
+    ad.viewed = viewedAds.includes(ad?.id || "placeholder");
+  }
+  return ads;
+};
+function mergeStyles(propStyles, defaultStyles, overridingStyles) {
+  function deepMerge(target, source) {
+    if (typeof target !== "object" || typeof source !== "object") {
+      return source;
+    }
+    const result = { ...target };
+    for (const key in source) {
+      if (source.hasOwnProperty(key)) {
+        if (typeof source[key] === "object" && !Array.isArray(source[key])) {
+          result[key] = deepMerge(target[key], source[key]);
+        } else {
+          result[key] = source[key];
+        }
+      }
+    }
+    return result;
+  }
+  let mergedStyles = deepMerge({ ...defaultStyles }, propStyles || {});
+  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/hooks/useInitializeAds.tsx
+import log from "loglevel";
+
+// package.json
+var version = "0.0.4";
+
+// src/hooks/useInitializeAds.tsx
+async function initialize(adServerUrl, publisherToken, userId, conversationId, legacyVisitorId, character) {
+  log.log("[BRAIN] init ads started");
+  const response = await fetchRetry(
+    `${adServerUrl}/init`,
+    {
+      timeout: 1e4,
+      method: "POST",
+      body: JSON.stringify({
+        publisherToken,
+        userId,
+        visitorId: userId,
+        conversationId,
+        sdkVersion: `native-${version}`,
+        legacyVisitorId,
+        character
+      })
+    },
+    3,
+    1e3
+  );
+  const {
+    sessionId,
+    enabledPlacements,
+    ads,
+    sessionDisabled,
+    streamAdServer,
+    onlyStream,
+    defaultReactNativeStyles,
+    overridingReactNativeStyles
+  } = await response.json();
+  const fixedAds = ads.map((ad) => {
+    return fixUrl(adServerUrl, ad);
+  });
+  log.log("[BRAIN] init ads done");
+  return {
+    sessionDisabled,
+    sessionId,
+    enabledPlacements,
+    ads: fixedAds,
+    streamAdServer,
+    onlyStream,
+    defaultReactNativeStylesResponse: defaultReactNativeStyles,
+    overridingReactNativeStylesResponse: overridingReactNativeStyles
+  };
+}
+function useInitializeAds({
+  adServerUrl,
+  publisherToken,
+  userId,
+  conversationId,
+  isDisabled,
+  character,
+  legacyVisitorId
+}) {
+  const [enabledPlacements, setEnabledPlacements] = useState([]);
+  const [ads, setAds] = useState([]);
+  const [error, setError] = useState();
+  const [streamAdServerUrl, setStreamAdServerUrl] = useState();
+  const [onlyStream, setOnlyStream] = useState(false);
+  const [sessionId, setSessionId] = useState();
+  const [defaultReactNativeStyles, setDefaultReactNativeStyles] = useState();
+  const [overridingReactNativeStyles, setOverridingReactNativeStyles] = useState();
+  useEffect(() => {
+    setSessionId(void 0);
+    if (!isDisabled && userId) {
+      log.debug("[BRAIN] Initializing ads.");
+      initialize(
+        adServerUrl,
+        publisherToken,
+        userId,
+        conversationId,
+        legacyVisitorId,
+        character
+      ).then(
+        ({
+          sessionId: sessionId2,
+          enabledPlacements: enabledPlacements2,
+          ads: ads2,
+          sessionDisabled,
+          streamAdServer,
+          onlyStream: onlyStream2,
+          defaultReactNativeStylesResponse,
+          overridingReactNativeStylesResponse
+        }) => {
+          if (!sessionDisabled) {
+            setSessionId(sessionId2);
+            setEnabledPlacements(enabledPlacements2);
+            setAds(ads2);
+            setStreamAdServerUrl(streamAdServer);
+            setOnlyStream(onlyStream2);
+            setDefaultReactNativeStyles(defaultReactNativeStylesResponse);
+            setOverridingReactNativeStyles(overridingReactNativeStylesResponse);
+          } else {
+            log.debug("[BRAIN] Session is disabled by server.");
+          }
+        }
+      ).catch((e) => {
+        log.error("[BRAIN] Error initializing ads", e);
+        setError(e.message);
+      });
+    } else {
+      log.debug("[BRAIN] Ads are disabled.");
+    }
+  }, [
+    adServerUrl,
+    publisherToken,
+    userId,
+    conversationId,
+    isDisabled
+  ]);
+  return {
+    ads,
+    sessionId,
+    enabledPlacements,
+    error,
+    streamAdServerUrl,
+    onlyStream,
+    defaultReactNativeStyles,
+    overridingReactNativeStyles
+  };
+}
+
+// src/hooks/usePreloadAds.tsx
+import { useEffect as useEffect2, useState as useState2 } from "react";
+import log2 from "loglevel";
+function usePreloadAds({
+  userId,
+  sessionId,
+  conversationId,
+  adserverUrl,
+  messages,
+  publisherToken,
+  character,
+  onlyStream
+}) {
+  const [preloadDone, setPreloadDone] = useState2(false);
+  const [ads, setAds] = useState2([]);
+  const userMessagesContent = messages.filter((m) => m.role === "user").map((m) => m.content).join(" ");
+  useEffect2(() => {
+    if (onlyStream) {
+      setPreloadDone(true);
+      log2.log("[BRAIN] skipping preload ads");
+      return;
+    }
+    async function preload() {
+      setPreloadDone(false);
+      if (!sessionId) {
+        return;
+      }
+      log2.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();
+        setAds((oldAds) => {
+          const newAds = ads2.map((ad) => fixUrl(adserverUrl, ad));
+          return [...oldAds, ...newAds];
+        });
+        setPreloadDone(true);
+        log2.log("[BRAIN] preload ads finished");
+      } catch (e) {
+        log2.error("[BRAIN] Error preloading ads", e);
+        setPreloadDone(true);
+      }
+    }
+    preload();
+  }, [sessionId, userMessagesContent, conversationId]);
+  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",
+  parse: (value) => {
+    if (typeof value !== "string") {
+      throw new Error('"text" parts expect a string value.');
+    }
+    return { type: "text", value };
+  }
+};
+var functionCallStreamPart = {
+  code: "1",
+  name: "function_call",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("function_call" in value) || typeof value.function_call !== "object" || value.function_call == null || !("name" in value.function_call) || !("arguments" in value.function_call) || typeof value.function_call.name !== "string" || typeof value.function_call.arguments !== "string") {
+      throw new Error(
+        '"function_call" parts expect an object with a "function_call" property.'
+      );
+    }
+    return {
+      type: "function_call",
+      value
+    };
+  }
+};
+var dataStreamPart = {
+  code: "2",
+  name: "data",
+  parse: (value) => {
+    if (!Array.isArray(value)) {
+      throw new Error('"data" parts expect an array value.');
+    }
+    return { type: "data", value };
+  }
+};
+var errorStreamPart = {
+  code: "3",
+  name: "error",
+  parse: (value) => {
+    if (typeof value !== "string") {
+      throw new Error('"error" parts expect a string value.');
+    }
+    return { type: "error", value };
+  }
+};
+var assistantMessageStreamPart = {
+  code: "4",
+  name: "assistant_message",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("id" in value) || !("role" in value) || !("content" in value) || typeof value.id !== "string" || typeof value.role !== "string" || value.role !== "assistant" || !Array.isArray(value.content) || !value.content.every(
+      (item) => item != null && typeof item === "object" && "type" in item && item.type === "text" && "text" in item && item.text != null && typeof item.text === "object" && "value" in item.text && typeof item.text.value === "string"
+    )) {
+      throw new Error(
+        '"assistant_message" parts expect an object with an "id", "role", and "content" property.'
+      );
+    }
+    return {
+      type: "assistant_message",
+      value
+    };
+  }
+};
+var assistantControlDataStreamPart = {
+  code: "5",
+  name: "assistant_control_data",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("threadId" in value) || !("messageId" in value) || typeof value.threadId !== "string" || typeof value.messageId !== "string") {
+      throw new Error(
+        '"assistant_control_data" parts expect an object with a "threadId" and "messageId" property.'
+      );
+    }
+    return {
+      type: "assistant_control_data",
+      value: {
+        threadId: value.threadId,
+        messageId: value.messageId
+      }
+    };
+  }
+};
+var dataMessageStreamPart = {
+  code: "6",
+  name: "data_message",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("role" in value) || !("data" in value) || typeof value.role !== "string" || value.role !== "data") {
+      throw new Error(
+        '"data_message" parts expect an object with a "role" and "data" property.'
+      );
+    }
+    return {
+      type: "data_message",
+      value
+    };
+  }
+};
+var toolCallStreamPart = {
+  code: "7",
+  name: "tool_calls",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("tool_calls" in value) || typeof value.tool_calls !== "object" || value.tool_calls == null || !Array.isArray(value.tool_calls) || value.tool_calls.some((tc) => {
+      tc == null || typeof tc !== "object" || !("id" in tc) || typeof tc.id !== "string" || !("type" in tc) || typeof tc.type !== "string" || !("function" in tc) || tc.function == null || typeof tc.function !== "object" || !("arguments" in tc.function) || typeof tc.function.name !== "string" || typeof tc.function.arguments !== "string";
+    })) {
+      throw new Error(
+        '"tool_calls" parts expect an object with a ToolCallPayload.'
+      );
+    }
+    return {
+      type: "tool_calls",
+      value
+    };
+  }
+};
+var messageAnnotationsStreamPart = {
+  code: "8",
+  name: "message_annotations",
+  parse: (value) => {
+    if (!Array.isArray(value)) {
+      throw new Error('"message_annotations" parts expect an array value.');
+    }
+    return { type: "message_annotations", value };
+  }
+};
+var streamParts = [
+  textStreamPart,
+  functionCallStreamPart,
+  dataStreamPart,
+  errorStreamPart,
+  assistantMessageStreamPart,
+  assistantControlDataStreamPart,
+  dataMessageStreamPart,
+  toolCallStreamPart,
+  messageAnnotationsStreamPart
+];
+var streamPartsByCode = {
+  [textStreamPart.code]: textStreamPart,
+  [functionCallStreamPart.code]: functionCallStreamPart,
+  [dataStreamPart.code]: dataStreamPart,
+  [errorStreamPart.code]: errorStreamPart,
+  [assistantMessageStreamPart.code]: assistantMessageStreamPart,
+  [assistantControlDataStreamPart.code]: assistantControlDataStreamPart,
+  [dataMessageStreamPart.code]: dataMessageStreamPart,
+  [toolCallStreamPart.code]: toolCallStreamPart,
+  [messageAnnotationsStreamPart.code]: messageAnnotationsStreamPart
+};
+var StreamStringPrefixes = {
+  [textStreamPart.name]: textStreamPart.code,
+  [functionCallStreamPart.name]: functionCallStreamPart.code,
+  [dataStreamPart.name]: dataStreamPart.code,
+  [errorStreamPart.name]: errorStreamPart.code,
+  [assistantMessageStreamPart.name]: assistantMessageStreamPart.code,
+  [assistantControlDataStreamPart.name]: assistantControlDataStreamPart.code,
+  [dataMessageStreamPart.name]: dataMessageStreamPart.code,
+  [toolCallStreamPart.name]: toolCallStreamPart.code,
+  [messageAnnotationsStreamPart.name]: messageAnnotationsStreamPart.code
+};
+var validCodes = streamParts.map((part) => part.code);
+var parseStreamPart = (line) => {
+  const firstSeparatorIndex = line.indexOf(":");
+  if (firstSeparatorIndex === -1) {
+    throw new Error("Failed to parse stream string. No separator found.");
+  }
+  const prefix = line.slice(0, firstSeparatorIndex);
+  if (!validCodes.includes(prefix)) {
+    throw new Error(`Failed to parse stream string. Invalid code ${prefix}.`);
+  }
+  const code = prefix;
+  const textValue = line.slice(firstSeparatorIndex + 1);
+  const any = JSON.parse(textValue);
+  return streamPartsByCode[code].parse(any);
+};
+var NEWLINE = "\n".charCodeAt(0);
+function concatChunks(chunks, totalLength) {
+  const concatenatedChunks = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    concatenatedChunks.set(chunk, offset);
+    offset += chunk.length;
+  }
+  chunks.length = 0;
+  return concatenatedChunks;
+}
+async function* readDataStream(reader, {
+  isAborted
+} = {}) {
+  const decoder = new TextDecoder();
+  const chunks = [];
+  let totalLength = 0;
+  while (true) {
+    const { value } = await reader.read();
+    if (value) {
+      chunks.push(value);
+      totalLength += value.length;
+      if (value[value.length - 1] !== NEWLINE) {
+        continue;
+      }
+    }
+    if (chunks.length === 0) {
+      break;
+    }
+    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?.()) {
+      reader.cancel();
+      break;
+    }
+  }
+}
+
+// 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";
+import log3 from "loglevel";
+var patchFetch = fetch;
+if (Platform.OS !== "web") {
+  polyfillEncoding();
+  polyfillReadableStream();
+  patchFetch = __require("react-native-fetch-api").fetch;
+}
+ErrorUtils.setGlobalHandler((error, isFatal) => {
+  log3.error(error);
+});
+function useStreamAds({
+  userId,
+  sessionId,
+  conversationId,
+  adserverUrl,
+  messages,
+  isLoading,
+  preloadDone,
+  enabledPlacements,
+  character,
+  publisherToken
+}) {
+  const [ads, setAds] = useState3([]);
+  const fetchStream = async (messages2, code) => {
+    const lastAssistantMessage = [...messages2].reverse().find((m) => m.role === "assistant");
+    if (!lastAssistantMessage) {
+      return;
+    }
+    setAds((oldAds) => {
+      const newAds = [...oldAds];
+      newAds.push({
+        isLoading: true,
+        code,
+        messageId: lastAssistantMessage.id
+      });
+      return newAds;
+    });
+    const body = JSON.stringify({
+      userId,
+      visitorId: userId,
+      sessionId,
+      code,
+      messages: messages2,
+      publisherToken,
+      character,
+      conversationId,
+      sdkVersion: "native"
+    });
+    try {
+      const response = await patchFetch(`${adserverUrl}/stream`, {
+        method: "POST",
+        body,
+        headers: {
+          "Content-Type": "application/json"
+        },
+        reactNative: { textStreaming: true }
+      });
+      if (!response.ok) {
+        throw new Error("Error streaming ad");
+      }
+      if (!response.body) {
+        throw new Error("Response body is not a readable stream");
+      }
+      setAds(
+        (oldAds) => oldAds.map((ad) => ad.messageId === lastAssistantMessage.id && ad.code === code ? { ...ad, isLoading: false, isStreaming: true } : ad)
+      );
+      let data = "";
+      let adData = {};
+      log3.log(`[BRAIN] streaming ${code} ad started`);
+      const reader = response.body.getReader();
+      for await (const { type, value } of readDataStream(reader)) {
+        switch (type) {
+          case "text":
+            data += value;
+            break;
+          case "data": {
+            let val = value;
+            if (Array.isArray(val)) {
+              val = val[0];
+            }
+            adData = { ...adData, ...val };
+            break;
+          }
+          case "error":
+            throw new Error(`Error streaming ad ${value}`);
+        }
+        setAds(
+          (oldAds) => oldAds.map((ad) => {
+            if (ad.messageId === lastAssistantMessage.id && ad.code === code) {
+              const content = adData.content ?? data;
+              const newAd = fixUrl(adserverUrl, {
+                ...ad,
+                ...adData,
+                isLoading: false,
+                isStreaming: true,
+                content: content.replace(
+                  new RegExp(`/ad/${adData.product.id}/redirect`, "g"),
+                  `/ad/${adData.id}/redirect`
+                )
+              });
+              return newAd;
+            }
+            return ad;
+          })
+        );
+      }
+      setAds(
+        (oldAds) => oldAds.map(
+          (ad) => ad.messageId === lastAssistantMessage.id && ad.code === code ? { ...ad, isStreaming: false } : ad
+        )
+      );
+      log3.log(`[BRAIN] streaming ${code} ad done`);
+    } catch (e) {
+      log3.error("[BRAIN] Error streaming ad", e);
+      setAds((oldAds) => [...oldAds, { isError: true, code }]);
+    }
+  };
+  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)) {
+          fetchStream(messages, String(placement.code));
+        }
+      });
+    }
+  }, [isLoading, preloadDone, sessionId, messages[messages.length - 1]?.role]);
+  return { ads };
+}
+
+// src/context/AdsProvider.tsx
+import log4 from "loglevel";
+import { jsx } from "react/jsx-runtime";
+var AdsContext = React.createContext(null);
+AdsContext.displayName = "AdsContext";
+var VISITOR_ID_KEY = "brain-visitor-id";
+var AdsProvider = ({
+  children,
+  messages,
+  publisherToken,
+  isLoading,
+  adserverUrl,
+  isDisabled,
+  character,
+  conversationId,
+  userId,
+  logLevel,
+  onAdView,
+  onAdClick,
+  ...props
+}) => {
+  const [viewedAds, setViewedAds] = useState4([]);
+  const adServerUrlOrDefault = adserverUrl || "https://server.megabrain.co";
+  log4.setLevel(logLevel || "ERROR");
+  const {
+    ads: initAds,
+    sessionId,
+    enabledPlacements,
+    error,
+    streamAdServerUrl,
+    onlyStream,
+    defaultReactNativeStyles,
+    overridingReactNativeStyles
+  } = useInitializeAds({
+    adServerUrl: adServerUrlOrDefault,
+    publisherToken,
+    userId,
+    legacyVisitorId: void 0,
+    conversationId,
+    character,
+    isDisabled: !!isDisabled
+  });
+  const styles = mergeStyles(props.styles, defaultReactNativeStyles, overridingReactNativeStyles);
+  const isInitialised = !!isDisabled || !!error || !!sessionId;
+  const { preloadDone, ads: preloadAds } = usePreloadAds({
+    sessionId,
+    adserverUrl: adServerUrlOrDefault,
+    messages,
+    publisherToken,
+    conversationId,
+    userId,
+    character,
+    onlyStream
+  });
+  const { ads: streamAds } = useStreamAds({
+    userId,
+    sessionId,
+    adserverUrl: onlyStream && streamAdServerUrl ? streamAdServerUrl : adServerUrlOrDefault,
+    conversationId,
+    messages,
+    isLoading,
+    character,
+    preloadDone,
+    enabledPlacements,
+    publisherToken
+  });
+  const ads = mergeAds({ initAds, preloadAds, streamAds, viewedAds });
+  const markAdAsViewed = (ad) => {
+    log4.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;
+    setViewedAds((old) => [...old, ad.id]);
+  };
+  const onAdClickInternal = (ad) => {
+    log4.debug("[Brain] Calling onAdClick");
+    onAdClick && onAdClick({
+      id: ad.id,
+      code: ad.code,
+      messageId: ad.messageId,
+      content: ad.content
+    });
+  };
+  return /* @__PURE__ */ jsx(
+    AdsContext.Provider,
+    {
+      value: {
+        adserverUrl: adServerUrlOrDefault,
+        streamAdServerUrl,
+        children,
+        messages,
+        publisherToken,
+        isLoading,
+        ads,
+        sessionId,
+        isInitialised,
+        isDisabled,
+        onAdClickInternal,
+        enabledPlacements,
+        userId,
+        markAdAsViewed,
+        onlyStream,
+        styles
+      },
+      children
+    }
+  );
+};
+
+// src/hooks/useAdViewed.tsx
+import { useContext } from "react";
+import log5 from "loglevel";
+function useAdViewed(ad) {
+  const context = useContext(AdsContext);
+  const [stillMounted, setStillMounted] = useState5(false);
+  const sendRequest = async () => {
+    if (!context?.adserverUrl || !ad?.id) {
+      return;
+    }
+    context.markAdAsViewed(ad);
+    let serverUrl = context.adserverUrl;
+    if (context.onlyStream && context.streamAdServerUrl) {
+      serverUrl = context.streamAdServerUrl;
+    }
+    try {
+      const response = await fetch(`${serverUrl}/ad/${ad.id}/view`, {
+        method: "POST"
+      });
+      if (!response.ok) {
+        throw new Error("Error sending view request");
+      }
+      log5.log("[BRAIN] ad marked as viewed", ad.id, ad.code);
+    } catch (e) {
+      log5.error("[BRAIN] Error sending view request", e);
+    }
+  };
+  useEffect5(() => {
+    if (!ad || ad.isError || ad.isLoading || ad.isStreaming || ad.viewed || stillMounted) {
+      return;
+    }
+    log5.log("[BRAIN] setting timeout", ad.id, ad.code);
+    setTimeout(() => {
+      log5.log("[BRAIN] setting setStillMounted", ad.id, ad.code);
+      setStillMounted(true);
+    }, 1e3);
+  }, [ad]);
+  useEffect5(() => {
+    if (stillMounted) {
+      log5.log("[BRAIN] sending request");
+      sendRequest();
+    }
+  }, [stillMounted]);
+}
+
+// src/formats/InlineAd.tsx
+import log8 from "loglevel";
+
+// src/components/MarkdownText.tsx
+import log6 from "loglevel";
+import { useContext as useContext2 } from "react";
+import {
+  Linking,
+  Text
+} from "react-native";
+import { Fragment, jsx as jsx2 } from "react/jsx-runtime";
+function MarkdownText({
+  content,
+  onLinkClick
+}) {
+  const context = useContext2(AdsContext);
+  const textParts = parseMessageText(content);
+  const styles = context?.styles?.markdownText;
+  const linkClickHandler = (href) => {
+    onLinkClick();
+    Linking.openURL(href).catch(
+      (err) => log6.error("Failed to open URL:", err)
+    );
+    return false;
+  };
+  return /* @__PURE__ */ jsx2(Fragment, { children: textParts.map((t, i) => {
+    if (t.textType === "link") {
+      return /* @__PURE__ */ jsx2(
+        Text,
+        {
+          style: styles?.link,
+          onPress: () => {
+            linkClickHandler(t.url);
+          },
+          children: t.text
+        },
+        i + "link"
+      );
+    } else if (t.textType === "themed") {
+      return /* @__PURE__ */ jsx2(Text, { style: styles?.em, children: t.text }, i + "em");
+    } else {
+      return /* @__PURE__ */ jsx2(Text, { style: styles?.normal, children: t.text }, i + "normal");
+    }
+  }) });
+}
+
+// src/components/VideoPlayer.tsx
+import { ResizeMode, Video } from "expo-av";
+import log7 from "loglevel";
+import { useContext as useContext4, useEffect as useEffect7, useRef, useState as useState7 } 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 useEffect6, useContext as useContext3 } 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;
+  useEffect6(() => {
+    const interval = setInterval(() => {
+      if (!videoRef.current) {
+        return;
+      }
+      videoRef.current.getStatusAsync().then((status) => {
+        if (status.isLoaded) {
+          const currentTime = status.positionMillis;
+          const duration = status.durationMillis;
+          const percentage = currentTime / duration * 100;
+          setProgress(percentage);
+        }
+      });
+    }, 1e3);
+    return () => clearInterval(interval);
+  }, [videoRef.current]);
+  return /* @__PURE__ */ jsx3(View, { style: styles?.progressContainer, children: /* @__PURE__ */ jsx3(View, { style: [styles?.progressBar, { width: `${progress}%` }] }) });
+}
+
+// src/components/VideoPlayer.tsx
+import { jsx as jsx4, jsxs } from "react/jsx-runtime";
+var VideoPlayer = ({
+  src,
+  onProgress,
+  endText,
+  badgeText,
+  videoPosterUrl,
+  videoOrientation,
+  ctaText,
+  clickUrl,
+  mediaPlacement,
+  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 lastCallbackTimeRef = useRef(0);
+  const styles = useContext4(AdsContext)?.styles?.videoPlayer;
+  useEffect7(() => {
+    const interval = setInterval(() => {
+      if (videoRef.current) {
+        videoRef.current.getStatusAsync().then((status) => {
+          if (status.isLoaded) {
+            const progress = status.positionMillis / status.durationMillis * 100;
+            const now = Date.now();
+            if (now - lastCallbackTimeRef.current >= 3e3) {
+              lastCallbackTimeRef.current = now;
+              onProgress(progress);
+            }
+            if (status.positionMillis >= 5e3 && !showDownloadBadge) {
+              setShowDownloadBadge(true);
+            }
+          }
+        });
+      }
+    }, 1e3);
+    return () => clearInterval(interval);
+  }, [showDownloadBadge]);
+  const handlePlayPause = () => {
+    if (videoRef.current) {
+      if (isPlaying) {
+        videoRef.current.pauseAsync();
+        setIsPaused(true);
+        handleLinkClick(clickUrl);
+      } else {
+        videoRef.current.playAsync();
+        setIsPaused(false);
+        setIsEnded(false);
+      }
+      setIsPlaying(!isPlaying);
+    }
+  };
+  const handleBadgeClick = () => {
+    if (isPlaying) {
+      videoRef.current?.pauseAsync();
+      setIsPaused(true);
+      setIsPlaying(false);
+    }
+    handleLinkClick(clickUrl);
+  };
+  const handleLinkClick = (url) => {
+    if (url) {
+      Linking2.openURL(url).catch((err) => log7.error("Failed to open URL:", err));
+      onLinkClick();
+    }
+  };
+  const handleEnded = () => {
+    setIsPlaying(false);
+    setIsEnded(true);
+    setIsPaused(false);
+    onProgress(100);
+  };
+  return /* @__PURE__ */ jsxs(View2, { style: [videoOrientation === "horizontal" ? styles?.videoOuterContainerHorizontal : styles?.videoOuterContainerVertical, mediaPlacement === "top" && styles?.videoPlacementBottom, mediaPlacement === "bottom" && styles?.videoPlacementBottom], children: [
+    /* @__PURE__ */ jsx4(
+      Video,
+      {
+        ref: videoRef,
+        source: { uri: src },
+        resizeMode: ResizeMode.CONTAIN,
+        shouldPlay: false,
+        onTouchStart: handlePlayPause,
+        style: videoOrientation === "horizontal" ? styles?.videoInnerContainerHorizontal : styles?.videoInnerContainerVertical,
+        videoStyle: videoOrientation === "horizontal" ? styles?.videoElementHorizontal : styles?.videoElementVertical,
+        onPlaybackStatusUpdate: (status) => {
+          if (status.isLoaded && status.didJustFinish && !status.isLooping) {
+            handleEnded();
+          }
+        }
+      }
+    ),
+    /* @__PURE__ */ jsx4(VideoProgressBar, { videoRef }),
+    !isEnded && /* @__PURE__ */ jsx4(TouchableOpacity, { style: isPlaying ? styles?.playOverlay : styles?.pauseOverlay, onPress: handlePlayPause, children: !isPlaying && /* @__PURE__ */ jsx4(Text2, { style: styles?.playButton, children: "\u25B6" }) }),
+    (isPaused && !isEnded || showDownloadBadge && !isEnded) && badgeText && /* @__PURE__ */ jsx4(TouchableOpacity, { style: styles?.videoBadge, onPress: handleBadgeClick, children: /* @__PURE__ */ jsx4(Text2, { style: styles?.videoBadgeText, children: showDownloadBadge && !isPaused && !isEnded ? ctaText : badgeText }) }),
+    isEnded && /* @__PURE__ */ jsxs(View2, { style: styles?.endOverlay, children: [
+      /* @__PURE__ */ jsx4(TouchableOpacity, { style: styles?.endOverlayTouch, onPress: () => handleLinkClick(clickUrl), children: /* @__PURE__ */ jsx4(Text2, { style: styles?.endButton, children: ctaText }) }),
+      /* @__PURE__ */ jsx4(Text2, { style: styles?.endText, children: endText })
+    ] })
+  ] });
+};
+
+// 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 context = useContext6(AdsContext);
+  const styles = context?.styles?.inlineAd;
+  useAdViewed(ad);
+  useEffect8(() => {
+    if (ad?.content && !ad.isStreaming && !ad.content.match(/\[.*?\]\(.*?\)/) && !linkIncluded) {
+      setLinkIncluded(true);
+    }
+  }, [ad]);
+  if (!ad || !ad.content || context?.isDisabled) return null;
+  if (ad.isLoading || ad.content?.trim().toLowerCase().includes("none"))
+    return null;
+  const onProgress = (progress) => {
+    log8.log(`Progress: ${progress}`);
+  };
+  const handleImageClick = (url) => {
+    if (url) {
+      context?.onAdClickInternal(ad);
+      if (Platform2.OS === "web") {
+        window.open(url, "_blank");
+      } else {
+        Linking3.openURL(url).catch(
+          (err) => log8.error("Failed to open URL:", err)
+        );
+      }
+    }
+  };
+  const content = /* @__PURE__ */ jsxs2(View3, { style: styles?.container, children: [
+    /* @__PURE__ */ jsx5(View3, { style: styles?.adBadgeContainer, children: /* @__PURE__ */ jsx5(Text3, { style: styles?.adBadgeText, children: "Ad" }) }),
+    ad.imageUrl && ad.mediaPlacement === "top" && !ad.isStreaming && /* @__PURE__ */ jsx5(
+      TouchableOpacity2,
+      {
+        style: styles?.imageContainer,
+        onPress: () => handleImageClick(ad.url),
+        children: /* @__PURE__ */ jsx5(Image, { source: { uri: ad.imageUrl }, style: styles?.image })
+      }
+    ),
+    ad.videoUrl && ad.mediaPlacement === "top" && !ad.isStreaming && /* @__PURE__ */ jsx5(
+      VideoPlayer,
+      {
+        src: ad.videoUrl,
+        onProgress,
+        endText: ad.videoEndText,
+        badgeText: ad.videoBadgeText,
+        videoPosterUrl: ad.videoPosterUrl,
+        videoOrientation: ad.videoOrientation,
+        mediaPlacement: ad.mediaPlacement,
+        ctaText: ad.videoCtaText,
+        onLinkClick: () => context?.onAdClickInternal(ad),
+        clickUrl: ad.url
+      }
+    ),
+    /* @__PURE__ */ jsx5(Text3, { style: styles?.contentContainer, children: /* @__PURE__ */ jsx5(
+      MarkdownText,
+      {
+        onLinkClick: () => context?.onAdClickInternal(ad),
+        content: ad.content
+      }
+    ) }),
+    ad.imageUrl && ad.mediaPlacement === "bottom" && !ad.isStreaming && /* @__PURE__ */ jsx5(
+      TouchableOpacity2,
+      {
+        style: styles?.imageContainer,
+        onPress: () => handleImageClick(ad.url),
+        children: /* @__PURE__ */ jsx5(Image, { source: { uri: ad.imageUrl }, style: styles?.image })
+      }
+    ),
+    ad.videoUrl && ad.mediaPlacement === "bottom" && !ad.isStreaming && /* @__PURE__ */ jsx5(
+      VideoPlayer,
+      {
+        src: ad.videoUrl,
+        onProgress,
+        endText: ad.videoEndText,
+        badgeText: ad.videoBadgeText,
+        videoPosterUrl: ad.videoPosterUrl,
+        videoOrientation: ad.videoOrientation,
+        mediaPlacement: ad.mediaPlacement,
+        ctaText: ad.videoCtaText,
+        onLinkClick: () => context?.onAdClickInternal(ad),
+        clickUrl: ad.url
+      }
+    )
+  ] });
+  return wrapper ? wrapper(content) : content;
+};
+var InlineAd_default = InlineAd;
+export {
+  AdsContext,
+  AdsProvider,
+  InlineAd_default as InlineAd,
+  VISITOR_ID_KEY,
+  useAd
+};