@kontextso/sdk-react-native 0.0.4

package/dist/index.js

@@ -0,0 +1,1229 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AdsContext: () => AdsContext,
+  AdsProvider: () => AdsProvider,
+  InlineAd: () => InlineAd_default,
+  VISITOR_ID_KEY: () => VISITOR_ID_KEY,
+  useAd: () => useAd
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/formats/InlineAd.tsx
+var import_react11 = require("react");
+var import_react_native5 = require("react-native");
+
+// src/hooks/useAdViewed.tsx
+var import_react5 = require("react");
+
+// src/context/AdsProvider.tsx
+var import_react4 = __toESM(require("react"));
+
+// src/hooks/useInitializeAds.tsx
+var import_react = require("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
+var import_loglevel = __toESM(require("loglevel"));
+
+// package.json
+var version = "0.0.4";
+
+// src/hooks/useInitializeAds.tsx
+async function initialize(adServerUrl, publisherToken, userId, conversationId, legacyVisitorId, character) {
+  import_loglevel.default.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);
+  });
+  import_loglevel.default.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] = (0, import_react.useState)([]);
+  const [ads, setAds] = (0, import_react.useState)([]);
+  const [error, setError] = (0, import_react.useState)();
+  const [streamAdServerUrl, setStreamAdServerUrl] = (0, import_react.useState)();
+  const [onlyStream, setOnlyStream] = (0, import_react.useState)(false);
+  const [sessionId, setSessionId] = (0, import_react.useState)();
+  const [defaultReactNativeStyles, setDefaultReactNativeStyles] = (0, import_react.useState)();
+  const [overridingReactNativeStyles, setOverridingReactNativeStyles] = (0, import_react.useState)();
+  (0, import_react.useEffect)(() => {
+    setSessionId(void 0);
+    if (!isDisabled && userId) {
+      import_loglevel.default.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 {
+            import_loglevel.default.debug("[BRAIN] Session is disabled by server.");
+          }
+        }
+      ).catch((e) => {
+        import_loglevel.default.error("[BRAIN] Error initializing ads", e);
+        setError(e.message);
+      });
+    } else {
+      import_loglevel.default.debug("[BRAIN] Ads are disabled.");
+    }
+  }, [
+    adServerUrl,
+    publisherToken,
+    userId,
+    conversationId,
+    isDisabled
+  ]);
+  return {
+    ads,
+    sessionId,
+    enabledPlacements,
+    error,
+    streamAdServerUrl,
+    onlyStream,
+    defaultReactNativeStyles,
+    overridingReactNativeStyles
+  };
+}
+
+// src/hooks/usePreloadAds.tsx
+var import_react2 = require("react");
+var import_loglevel2 = __toESM(require("loglevel"));
+function usePreloadAds({
+  userId,
+  sessionId,
+  conversationId,
+  adserverUrl,
+  messages,
+  publisherToken,
+  character,
+  onlyStream
+}) {
+  const [preloadDone, setPreloadDone] = (0, import_react2.useState)(false);
+  const [ads, setAds] = (0, import_react2.useState)([]);
+  const userMessagesContent = messages.filter((m) => m.role === "user").map((m) => m.content).join(" ");
+  (0, import_react2.useEffect)(() => {
+    if (onlyStream) {
+      setPreloadDone(true);
+      import_loglevel2.default.log("[BRAIN] skipping preload ads");
+      return;
+    }
+    async function preload() {
+      setPreloadDone(false);
+      if (!sessionId) {
+        return;
+      }
+      import_loglevel2.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();
+        setAds((oldAds) => {
+          const newAds = ads2.map((ad) => fixUrl(adserverUrl, ad));
+          return [...oldAds, ...newAds];
+        });
+        setPreloadDone(true);
+        import_loglevel2.default.log("[BRAIN] preload ads finished");
+      } catch (e) {
+        import_loglevel2.default.error("[BRAIN] Error preloading ads", e);
+        setPreloadDone(true);
+      }
+    }
+    preload();
+  }, [sessionId, userMessagesContent, conversationId]);
+  return { preloadDone, ads };
+}
+
+// src/hooks/useStreamAds.tsx
+var import_react3 = require("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
+var import_encoding = require("react-native-polyfill-globals/src/encoding");
+var import_readable_stream = require("react-native-polyfill-globals/src/readable-stream");
+var import_react_native = require("react-native");
+var import_loglevel3 = __toESM(require("loglevel"));
+var patchFetch = fetch;
+if (import_react_native.Platform.OS !== "web") {
+  (0, import_encoding.polyfill)();
+  (0, import_readable_stream.polyfill)();
+  patchFetch = require("react-native-fetch-api").fetch;
+}
+ErrorUtils.setGlobalHandler((error, isFatal) => {
+  import_loglevel3.default.error(error);
+});
+function useStreamAds({
+  userId,
+  sessionId,
+  conversationId,
+  adserverUrl,
+  messages,
+  isLoading,
+  preloadDone,
+  enabledPlacements,
+  character,
+  publisherToken
+}) {
+  const [ads, setAds] = (0, import_react3.useState)([]);
+  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 = {};
+      import_loglevel3.default.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
+        )
+      );
+      import_loglevel3.default.log(`[BRAIN] streaming ${code} ad done`);
+    } catch (e) {
+      import_loglevel3.default.error("[BRAIN] Error streaming ad", e);
+      setAds((oldAds) => [...oldAds, { isError: true, code }]);
+    }
+  };
+  (0, import_react3.useEffect)(() => {
+    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
+var import_loglevel4 = __toESM(require("loglevel"));
+var import_jsx_runtime = require("react/jsx-runtime");
+var AdsContext = import_react4.default.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] = (0, import_react4.useState)([]);
+  const adServerUrlOrDefault = adserverUrl || "https://server.megabrain.co";
+  import_loglevel4.default.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) => {
+    import_loglevel4.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;
+    setViewedAds((old) => [...old, ad.id]);
+  };
+  const onAdClickInternal = (ad) => {
+    import_loglevel4.default.debug("[Brain] Calling onAdClick");
+    onAdClick && onAdClick({
+      id: ad.id,
+      code: ad.code,
+      messageId: ad.messageId,
+      content: ad.content
+    });
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime.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
+var import_react6 = require("react");
+var import_loglevel5 = __toESM(require("loglevel"));
+function useAdViewed(ad) {
+  const context = (0, import_react6.useContext)(AdsContext);
+  const [stillMounted, setStillMounted] = (0, import_react5.useState)(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");
+      }
+      import_loglevel5.default.log("[BRAIN] ad marked as viewed", ad.id, ad.code);
+    } catch (e) {
+      import_loglevel5.default.error("[BRAIN] Error sending view request", e);
+    }
+  };
+  (0, import_react5.useEffect)(() => {
+    if (!ad || ad.isError || ad.isLoading || ad.isStreaming || ad.viewed || stillMounted) {
+      return;
+    }
+    import_loglevel5.default.log("[BRAIN] setting timeout", ad.id, ad.code);
+    setTimeout(() => {
+      import_loglevel5.default.log("[BRAIN] setting setStillMounted", ad.id, ad.code);
+      setStillMounted(true);
+    }, 1e3);
+  }, [ad]);
+  (0, import_react5.useEffect)(() => {
+    if (stillMounted) {
+      import_loglevel5.default.log("[BRAIN] sending request");
+      sendRequest();
+    }
+  }, [stillMounted]);
+}
+
+// src/formats/InlineAd.tsx
+var import_loglevel8 = __toESM(require("loglevel"));
+
+// src/components/MarkdownText.tsx
+var import_loglevel6 = __toESM(require("loglevel"));
+var import_react7 = require("react");
+var import_react_native2 = require("react-native");
+var import_jsx_runtime2 = require("react/jsx-runtime");
+function MarkdownText({
+  content,
+  onLinkClick
+}) {
+  const context = (0, import_react7.useContext)(AdsContext);
+  const textParts = parseMessageText(content);
+  const styles = context?.styles?.markdownText;
+  const linkClickHandler = (href) => {
+    onLinkClick();
+    import_react_native2.Linking.openURL(href).catch(
+      (err) => import_loglevel6.default.error("Failed to open URL:", err)
+    );
+    return false;
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_jsx_runtime2.Fragment, { children: textParts.map((t, i) => {
+    if (t.textType === "link") {
+      return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+        import_react_native2.Text,
+        {
+          style: styles?.link,
+          onPress: () => {
+            linkClickHandler(t.url);
+          },
+          children: t.text
+        },
+        i + "link"
+      );
+    } else if (t.textType === "themed") {
+      return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_native2.Text, { style: styles?.em, children: t.text }, i + "em");
+    } else {
+      return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_native2.Text, { style: styles?.normal, children: t.text }, i + "normal");
+    }
+  }) });
+}
+
+// src/components/VideoPlayer.tsx
+var import_expo_av = require("expo-av");
+var import_loglevel7 = __toESM(require("loglevel"));
+var import_react9 = require("react");
+var import_react_native4 = require("react-native");
+
+// src/components/VideoProgressBar.tsx
+var import_react8 = require("react");
+var import_react_native3 = require("react-native");
+var import_jsx_runtime3 = require("react/jsx-runtime");
+function VideoProgressBar({ videoRef }) {
+  const [progress, setProgress] = (0, import_react8.useState)(0);
+  const styles = (0, import_react8.useContext)(AdsContext)?.styles?.videoPlayer?.videoProgress;
+  (0, import_react8.useEffect)(() => {
+    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__ */ (0, import_jsx_runtime3.jsx)(import_react_native3.View, { style: styles?.progressContainer, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react_native3.View, { style: [styles?.progressBar, { width: `${progress}%` }] }) });
+}
+
+// src/components/VideoPlayer.tsx
+var import_jsx_runtime4 = require("react/jsx-runtime");
+var VideoPlayer = ({
+  src,
+  onProgress,
+  endText,
+  badgeText,
+  videoPosterUrl,
+  videoOrientation,
+  ctaText,
+  clickUrl,
+  mediaPlacement,
+  onLinkClick
+}) => {
+  const videoRef = (0, import_react9.useRef)(null);
+  const [isPlaying, setIsPlaying] = (0, import_react9.useState)(false);
+  const [isPaused, setIsPaused] = (0, import_react9.useState)(true);
+  const [isEnded, setIsEnded] = (0, import_react9.useState)(false);
+  const [showDownloadBadge, setShowDownloadBadge] = (0, import_react9.useState)(false);
+  const lastCallbackTimeRef = (0, import_react9.useRef)(0);
+  const styles = (0, import_react9.useContext)(AdsContext)?.styles?.videoPlayer;
+  (0, import_react9.useEffect)(() => {
+    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) {
+      import_react_native4.Linking.openURL(url).catch((err) => import_loglevel7.default.error("Failed to open URL:", err));
+      onLinkClick();
+    }
+  };
+  const handleEnded = () => {
+    setIsPlaying(false);
+    setIsEnded(true);
+    setIsPaused(false);
+    onProgress(100);
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_react_native4.View, { style: [videoOrientation === "horizontal" ? styles?.videoOuterContainerHorizontal : styles?.videoOuterContainerVertical, mediaPlacement === "top" && styles?.videoPlacementBottom, mediaPlacement === "bottom" && styles?.videoPlacementBottom], children: [
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+      import_expo_av.Video,
+      {
+        ref: videoRef,
+        source: { uri: src },
+        resizeMode: import_expo_av.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__ */ (0, import_jsx_runtime4.jsx)(VideoProgressBar, { videoRef }),
+    !isEnded && /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_native4.TouchableOpacity, { style: isPlaying ? styles?.playOverlay : styles?.pauseOverlay, onPress: handlePlayPause, children: !isPlaying && /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_native4.Text, { style: styles?.playButton, children: "\u25B6" }) }),
+    (isPaused && !isEnded || showDownloadBadge && !isEnded) && badgeText && /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_native4.TouchableOpacity, { style: styles?.videoBadge, onPress: handleBadgeClick, children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_native4.Text, { style: styles?.videoBadgeText, children: showDownloadBadge && !isPaused && !isEnded ? ctaText : badgeText }) }),
+    isEnded && /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_react_native4.View, { style: styles?.endOverlay, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_native4.TouchableOpacity, { style: styles?.endOverlayTouch, onPress: () => handleLinkClick(clickUrl), children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_native4.Text, { style: styles?.endButton, children: ctaText }) }),
+      /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_native4.Text, { style: styles?.endText, children: endText })
+    ] })
+  ] });
+};
+
+// src/hooks/useAd.tsx
+var import_react10 = require("react");
+function useAd({ code, messageId }) {
+  const context = (0, import_react10.useContext)(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
+var import_jsx_runtime5 = require("react/jsx-runtime");
+var InlineAd = ({ code, messageId, wrapper }) => {
+  const ad = useAd({ code, messageId });
+  const [linkIncluded, setLinkIncluded] = (0, import_react11.useState)(false);
+  const context = (0, import_react11.useContext)(AdsContext);
+  const styles = context?.styles?.inlineAd;
+  useAdViewed(ad);
+  (0, import_react11.useEffect)(() => {
+    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) => {
+    import_loglevel8.default.log(`Progress: ${progress}`);
+  };
+  const handleImageClick = (url) => {
+    if (url) {
+      context?.onAdClickInternal(ad);
+      if (import_react_native5.Platform.OS === "web") {
+        window.open(url, "_blank");
+      } else {
+        import_react_native5.Linking.openURL(url).catch(
+          (err) => import_loglevel8.default.error("Failed to open URL:", err)
+        );
+      }
+    }
+  };
+  const content = /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(import_react_native5.View, { style: styles?.container, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_react_native5.View, { style: styles?.adBadgeContainer, children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_react_native5.Text, { style: styles?.adBadgeText, children: "Ad" }) }),
+    ad.imageUrl && ad.mediaPlacement === "top" && !ad.isStreaming && /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+      import_react_native5.TouchableOpacity,
+      {
+        style: styles?.imageContainer,
+        onPress: () => handleImageClick(ad.url),
+        children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_react_native5.Image, { source: { uri: ad.imageUrl }, style: styles?.image })
+      }
+    ),
+    ad.videoUrl && ad.mediaPlacement === "top" && !ad.isStreaming && /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+      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__ */ (0, import_jsx_runtime5.jsx)(import_react_native5.Text, { style: styles?.contentContainer, children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+      MarkdownText,
+      {
+        onLinkClick: () => context?.onAdClickInternal(ad),
+        content: ad.content
+      }
+    ) }),
+    ad.imageUrl && ad.mediaPlacement === "bottom" && !ad.isStreaming && /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+      import_react_native5.TouchableOpacity,
+      {
+        style: styles?.imageContainer,
+        onPress: () => handleImageClick(ad.url),
+        children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_react_native5.Image, { source: { uri: ad.imageUrl }, style: styles?.image })
+      }
+    ),
+    ad.videoUrl && ad.mediaPlacement === "bottom" && !ad.isStreaming && /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+      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;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AdsContext,
+  AdsProvider,
+  InlineAd,
+  VISITOR_ID_KEY,
+  useAd
+});