@nickle/chatbot-react 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1633 @@
+// src/chatbot/context/chatbot-context.tsx
+import {
+  createContext,
+  useCallback,
+  useContext,
+  useMemo,
+  useEffect,
+  useRef,
+  useState
+} from "react";
+
+// src/chatbot/lib/defaults.ts
+import {
+  Bot,
+  ChevronDown,
+  Download,
+  Ellipsis,
+  Maximize2,
+  MessageSquare,
+  Paperclip,
+  SendHorizontal,
+  X
+} from "lucide-react";
+var DEFAULT_THEME = {
+  primary: "#ffffff",
+  primaryForeground: "#111111",
+  background: "#0b0b0b",
+  surface: "#111111",
+  surfaceForeground: "#f5f5f5",
+  muted: "#262626",
+  mutedForeground: "#a3a3a3",
+  border: "#2f2f2f",
+  ring: "#737373",
+  userBubble: "#ffffff",
+  userText: "#111111",
+  assistantBubble: "#2a2a2a",
+  assistantText: "#f5f5f5",
+  radius: "14px",
+  fontFamily: "Inter, var(--font-sans), ui-sans-serif, system-ui, -apple-system, Segoe UI, sans-serif",
+  shadowBubble: "0 18px 40px -16px rgba(0, 0, 0, 0.7)",
+  shadowPanel: "0 34px 80px -36px rgba(0, 0, 0, 0.85)"
+};
+var DEFAULT_ICONS = {
+  launcher: MessageSquare,
+  launcherClosed: MessageSquare,
+  launcherOpen: ChevronDown,
+  close: X,
+  send: SendHorizontal,
+  attach: Paperclip,
+  bot: Bot,
+  menu: Ellipsis,
+  expand: Maximize2,
+  download: Download
+};
+var DEFAULT_AGENT_NAME = "Assistant";
+var DEFAULT_ASSISTANT_NOTE = "Here to help";
+
+// src/chatbot/lib/adapter.ts
+function extractFromRecord(record) {
+  const keys = ["message", "text", "output", "response", "answer", "content"];
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim().length > 0) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function defaultBuildRequest(input) {
+  const { files, metadata, message, headers, sessionId } = input;
+  if (files.length > 0) {
+    const formData = new FormData();
+    formData.set("message", message);
+    formData.set("sessionId", sessionId);
+    formData.set("metadata", JSON.stringify(metadata));
+    files.forEach((file) => {
+      formData.append("files[]", file);
+    });
+    return {
+      method: "POST",
+      headers,
+      body: formData
+    };
+  }
+  return {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...headers
+    },
+    body: JSON.stringify({
+      message,
+      sessionId,
+      metadata
+    })
+  };
+}
+function defaultParseJsonResponse(raw) {
+  if (typeof raw === "string") {
+    return { message: raw };
+  }
+  if (Array.isArray(raw)) {
+    const merged = raw.map((item) => {
+      if (typeof item === "string") {
+        return item;
+      }
+      if (item && typeof item === "object") {
+        return extractFromRecord(item);
+      }
+      return void 0;
+    }).filter(Boolean).join("\n");
+    return { message: merged };
+  }
+  if (raw && typeof raw === "object") {
+    const record = raw;
+    if (record.delta && typeof record.delta === "string") {
+      return {
+        delta: record.delta,
+        done: Boolean(record.done)
+      };
+    }
+    const text = extractFromRecord(record);
+    if (text) {
+      return { message: text, done: true };
+    }
+    if (record.data && typeof record.data === "object") {
+      const nested = extractFromRecord(record.data);
+      if (nested) {
+        return { message: nested, done: true };
+      }
+    }
+  }
+  return { message: "", done: true };
+}
+function defaultParseStreamChunk(chunk) {
+  const trimmed = chunk.trim();
+  if (!trimmed) {
+    return {};
+  }
+  if (trimmed === "[DONE]") {
+    return { done: true };
+  }
+  try {
+    const parsed = JSON.parse(trimmed);
+    return defaultParseJsonResponse(parsed);
+  } catch {
+    return { delta: trimmed };
+  }
+}
+function withDefaultAdapter(adapter) {
+  return {
+    buildRequest: adapter?.buildRequest ?? defaultBuildRequest,
+    parseJsonResponse: adapter?.parseJsonResponse ?? defaultParseJsonResponse,
+    parseStreamChunk: adapter?.parseStreamChunk ?? defaultParseStreamChunk
+  };
+}
+
+// src/chatbot/lib/transport.ts
+function looksLikeStream(contentType) {
+  if (!contentType) {
+    return false;
+  }
+  const normalized = contentType.toLowerCase();
+  return normalized.includes("text/event-stream") || normalized.includes("application/x-ndjson") || normalized.includes("application/stream");
+}
+function parseAndAppend(rawChunk, adapter, onChunk) {
+  const parsed = adapter.parseStreamChunk(rawChunk);
+  onChunk(rawChunk);
+  if (parsed.done && parsed.message) {
+    return { text: parsed.message, done: true };
+  }
+  if (parsed.delta) {
+    return { text: parsed.delta, done: Boolean(parsed.done) };
+  }
+  if (parsed.message) {
+    return { text: parsed.message, done: Boolean(parsed.done) };
+  }
+  return { text: "", done: Boolean(parsed.done) };
+}
+async function consumeEventStream(response, adapter, onDelta, onChunk) {
+  const reader = response.body?.getReader();
+  if (!reader) {
+    return "";
+  }
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let fullText = "";
+  let done = false;
+  while (!done) {
+    const result = await reader.read();
+    if (result.done) {
+      break;
+    }
+    buffer += decoder.decode(result.value, { stream: true });
+    while (buffer.includes("\n\n")) {
+      const index = buffer.indexOf("\n\n");
+      const block = buffer.slice(0, index);
+      buffer = buffer.slice(index + 2);
+      const lines = block.split("\n").filter((line) => line.startsWith("data:"));
+      for (const line of lines) {
+        const data = line.slice(5).trim();
+        const parsed = parseAndAppend(data, adapter, onChunk);
+        if (parsed.text) {
+          fullText += parsed.text;
+          onDelta(parsed.text);
+        }
+        if (parsed.done) {
+          done = true;
+          break;
+        }
+      }
+    }
+  }
+  if (buffer.trim()) {
+    const fallback = parseAndAppend(buffer.trim(), adapter, onChunk);
+    if (fallback.text) {
+      fullText += fallback.text;
+      onDelta(fallback.text);
+    }
+  }
+  return fullText;
+}
+async function consumeLineStream(response, adapter, onDelta, onChunk) {
+  const reader = response.body?.getReader();
+  if (!reader) {
+    return "";
+  }
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let fullText = "";
+  let done = false;
+  while (!done) {
+    const result = await reader.read();
+    if (result.done) {
+      break;
+    }
+    buffer += decoder.decode(result.value, { stream: true });
+    while (buffer.includes("\n")) {
+      const index = buffer.indexOf("\n");
+      const line = buffer.slice(0, index).trim();
+      buffer = buffer.slice(index + 1);
+      if (!line) {
+        continue;
+      }
+      const parsed = parseAndAppend(line, adapter, onChunk);
+      if (parsed.text) {
+        fullText += parsed.text;
+        onDelta(parsed.text);
+      }
+      if (parsed.done) {
+        done = true;
+        break;
+      }
+    }
+  }
+  if (buffer.trim()) {
+    const parsed = parseAndAppend(buffer.trim(), adapter, onChunk);
+    if (parsed.text) {
+      fullText += parsed.text;
+      onDelta(parsed.text);
+    }
+  }
+  return fullText;
+}
+async function parseNonStreaming(response, adapter) {
+  const contentType = response.headers.get("content-type") || "";
+  if (contentType.includes("application/json")) {
+    const payload = await response.json();
+    const parsed = adapter.parseJsonResponse(payload);
+    return parsed.message ?? parsed.delta ?? "";
+  }
+  const rawText = await response.text();
+  try {
+    const parsedPayload = JSON.parse(rawText);
+    const parsed = adapter.parseJsonResponse(parsedPayload);
+    return parsed.message ?? parsed.delta ?? rawText;
+  } catch {
+    const parsed = adapter.parseJsonResponse(rawText);
+    return parsed.message ?? rawText;
+  }
+}
+async function readAssistantResponse({
+  response,
+  adapter,
+  streamingMode,
+  onDelta,
+  onChunk,
+  onRecoverableError
+}) {
+  if (!response.ok) {
+    const body = await response.text();
+    throw new Error(`Webhook request failed (${response.status}): ${body}`);
+  }
+  const contentType = response.headers.get("content-type");
+  const streamEligible = streamingMode !== "off" && Boolean(response.body);
+  const shouldStream = streamEligible && (streamingMode === "on" || looksLikeStream(contentType));
+  if (!shouldStream) {
+    return parseNonStreaming(response, adapter);
+  }
+  try {
+    if ((contentType || "").toLowerCase().includes("text/event-stream")) {
+      return await consumeEventStream(response, adapter, onDelta, onChunk);
+    }
+    return await consumeLineStream(response, adapter, onDelta, onChunk);
+  } catch (error) {
+    onRecoverableError(error);
+    return "";
+  }
+}
+
+// src/chatbot/lib/id.ts
+function createId(prefix = "cb") {
+  if (typeof crypto !== "undefined" && "randomUUID" in crypto) {
+    return `${prefix}-${crypto.randomUUID()}`;
+  }
+  return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+}
+
+// src/chatbot/lib/session.ts
+var SESSION_KEY = "cb:session-id";
+function createSessionId() {
+  if (typeof crypto !== "undefined" && "randomUUID" in crypto) {
+    return crypto.randomUUID();
+  }
+  return `cb-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function getOrCreateSessionId(storage) {
+  if (!storage) {
+    return createSessionId();
+  }
+  const existing = storage.getItem(SESSION_KEY);
+  if (existing) {
+    return existing;
+  }
+  const created = createSessionId();
+  storage.setItem(SESSION_KEY, created);
+  return created;
+}
+function resetSessionId(storage) {
+  const next = createSessionId();
+  if (storage) {
+    storage.setItem(SESSION_KEY, next);
+  }
+  return next;
+}
+function historyKey(sessionId) {
+  return `cb:history:${sessionId}`;
+}
+
+// src/chatbot/lib/theme.ts
+var HOST_TOKEN_MAP = {
+  primary: ["--color-primary", "--primary"],
+  primaryForeground: ["--color-primary-foreground", "--primary-foreground"],
+  background: ["--cb-background", "--color-background", "--color-bg", "--background"],
+  surface: ["--cb-surface", "--color-surface", "--color-card", "--card"],
+  surfaceForeground: ["--cb-surface-foreground", "--color-text", "--color-foreground", "--foreground"],
+  muted: ["--color-muted", "--muted"],
+  mutedForeground: ["--color-muted-foreground", "--muted-foreground"],
+  border: ["--color-border", "--border"],
+  ring: ["--color-ring", "--ring"],
+  userBubble: ["--cb-user-bubble"],
+  userText: ["--cb-user-text"],
+  assistantBubble: ["--cb-assistant-bubble", "--color-muted", "--muted"],
+  assistantText: ["--cb-assistant-text", "--color-text", "--foreground"],
+  radius: ["--radius-md", "--radius", "--rounded"],
+  fontFamily: ["--font-sans", "--font-family"],
+  shadowBubble: ["--shadow-bubble"],
+  shadowPanel: ["--shadow-panel"]
+};
+function readRootVar(name) {
+  if (typeof window === "undefined") {
+    return void 0;
+  }
+  const styles = getComputedStyle(document.documentElement);
+  const value = styles.getPropertyValue(name).trim();
+  return value || void 0;
+}
+function resolveThemeTokens(explicit) {
+  const resolved = { ...DEFAULT_THEME };
+  Object.keys(DEFAULT_THEME).forEach((key) => {
+    if (explicit?.[key]) {
+      resolved[key] = explicit[key];
+      return;
+    }
+    const hostCandidates = HOST_TOKEN_MAP[key] ?? [];
+    for (const candidate of hostCandidates) {
+      const value = readRootVar(candidate);
+      if (value) {
+        resolved[key] = value;
+        break;
+      }
+    }
+  });
+  return resolved;
+}
+function toThemeCssVars(tokens) {
+  return {
+    "--cb-primary": tokens.primary,
+    "--cb-primary-foreground": tokens.primaryForeground,
+    "--cb-background": tokens.background,
+    "--cb-surface": tokens.surface,
+    "--cb-surface-foreground": tokens.surfaceForeground,
+    "--cb-muted": tokens.muted,
+    "--cb-muted-foreground": tokens.mutedForeground,
+    "--cb-border": tokens.border,
+    "--cb-ring": tokens.ring,
+    "--cb-user-bubble": tokens.userBubble,
+    "--cb-user-text": tokens.userText,
+    "--cb-assistant-bubble": tokens.assistantBubble,
+    "--cb-assistant-text": tokens.assistantText,
+    "--cb-radius": tokens.radius,
+    "--cb-font-family": tokens.fontFamily,
+    "--cb-shadow-bubble": tokens.shadowBubble,
+    "--cb-shadow-panel": tokens.shadowPanel
+  };
+}
+
+// src/chatbot/context/chatbot-context.tsx
+import { jsx } from "react/jsx-runtime";
+var ChatbotContext = createContext(void 0);
+var WELCOME_DELAY_MS = 1500;
+var DEFAULT_LOCALE = "en";
+var LOCALE_COPY = {
+  en: {
+    agentName: DEFAULT_AGENT_NAME,
+    assistantNote: DEFAULT_ASSISTANT_NOTE,
+    welcomeMessage: "Hi, how can I help you?",
+    disclaimer: "AI can make mistakes."
+  },
+  de: {
+    agentName: "Assistent",
+    assistantNote: "Wie kann ich helfen?",
+    welcomeMessage: "Hallo, wie kann ich Ihnen helfen?",
+    disclaimer: "KI kann Fehler machen."
+  },
+  es: {
+    agentName: "Asistente",
+    assistantNote: "Como puedo ayudarte?",
+    welcomeMessage: "Hola, como puedo ayudarte?",
+    disclaimer: "La IA puede cometer errores."
+  },
+  fr: {
+    agentName: "Assistant",
+    assistantNote: "Comment puis-je vous aider ?",
+    welcomeMessage: "Bonjour, comment puis-je vous aider ?",
+    disclaimer: "L'IA peut faire des erreurs."
+  },
+  it: {
+    agentName: "Assistente",
+    assistantNote: "Come posso aiutarti?",
+    welcomeMessage: "Ciao, come posso aiutarti?",
+    disclaimer: "L'IA puo commettere errori."
+  },
+  nl: {
+    agentName: "Assistent",
+    assistantNote: "Hoe kan ik je helpen?",
+    welcomeMessage: "Hallo, hoe kan ik je helpen?",
+    disclaimer: "AI kan fouten maken."
+  },
+  pt: {
+    agentName: "Assistente",
+    assistantNote: "Como posso ajudar?",
+    welcomeMessage: "Ola, como posso ajudar?",
+    disclaimer: "A IA pode cometer erros."
+  },
+  pl: {
+    agentName: "Asystent",
+    assistantNote: "Jak moge pomoc?",
+    welcomeMessage: "Czesc, jak moge pomoc?",
+    disclaimer: "AI moze popelniac bledy."
+  },
+  tr: {
+    agentName: "Asistan",
+    assistantNote: "Nasil yardimci olabilirim?",
+    welcomeMessage: "Merhaba, nasil yardimci olabilirim?",
+    disclaimer: "Yapay zeka hata yapabilir."
+  },
+  sv: {
+    agentName: "Assistent",
+    assistantNote: "Hur kan jag hjalpa dig?",
+    welcomeMessage: "Hej, hur kan jag hjalpa dig?",
+    disclaimer: "AI kan gora misstag."
+  },
+  da: {
+    agentName: "Assistent",
+    assistantNote: "Hvordan kan jeg hjaelpe dig?",
+    welcomeMessage: "Hej, hvordan kan jeg hjaelpe dig?",
+    disclaimer: "AI kan lave fejl."
+  },
+  no: {
+    agentName: "Assistent",
+    assistantNote: "Hvordan kan jeg hjelpe deg?",
+    welcomeMessage: "Hei, hvordan kan jeg hjelpe deg?",
+    disclaimer: "AI kan gj\xF8re feil."
+  },
+  fi: {
+    agentName: "Avustaja",
+    assistantNote: "Miten voin auttaa?",
+    welcomeMessage: "Hei, miten voin auttaa?",
+    disclaimer: "Tekoaly voi tehda virheita."
+  }
+};
+function normalizeLocale(input) {
+  if (!input) {
+    return DEFAULT_LOCALE;
+  }
+  return input.trim().toLowerCase().split("-")[0] || DEFAULT_LOCALE;
+}
+function getBrowserLocale() {
+  if (typeof navigator === "undefined") {
+    return DEFAULT_LOCALE;
+  }
+  return navigator.language || DEFAULT_LOCALE;
+}
+function getLocaleCopy(locale) {
+  return LOCALE_COPY[locale] ?? LOCALE_COPY[DEFAULT_LOCALE];
+}
+function readHistory(storage, sessionId) {
+  if (!storage) {
+    return [];
+  }
+  const raw = storage.getItem(historyKey(sessionId));
+  if (!raw) {
+    return [];
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+function ChatbotProvider({
+  children,
+  webhookUrl,
+  locale,
+  agentName,
+  assistantNote,
+  enableUploads = false,
+  streamingMode = "auto",
+  headers,
+  theme,
+  icons,
+  adapter,
+  events,
+  initialOpen = false,
+  position = "bottom-right",
+  classNames
+}) {
+  const [isHydrated, setIsHydrated] = useState(false);
+  const [sessionId, setSessionId] = useState("cb:pending");
+  const [messages, setMessages] = useState([]);
+  const [isOpen, setIsOpen] = useState(initialOpen);
+  const [isAwaiting, setIsAwaiting] = useState(false);
+  const [pageConfigs, setPageConfigs] = useState([]);
+  const messagesRef = useRef([]);
+  useEffect(() => {
+    messagesRef.current = messages;
+  }, [messages]);
+  const activePageConfig = pageConfigs.length > 0 ? pageConfigs[pageConfigs.length - 1].config : void 0;
+  const mergedTheme = useMemo(
+    () => ({
+      ...theme ?? {},
+      ...activePageConfig?.theme ?? {}
+    }),
+    [activePageConfig?.theme, theme]
+  );
+  const resolvedTheme = useMemo(() => {
+    if (!isHydrated) {
+      return { ...DEFAULT_THEME, ...mergedTheme ?? {} };
+    }
+    return resolveThemeTokens(mergedTheme);
+  }, [isHydrated, mergedTheme]);
+  const themeVars = useMemo(() => toThemeCssVars(resolvedTheme), [resolvedTheme]);
+  const mergedIcons = useMemo(() => {
+    const merged = { ...DEFAULT_ICONS, ...icons ?? {} };
+    merged.launcherClosed = icons?.launcherClosed ?? icons?.launcher ?? DEFAULT_ICONS.launcherClosed;
+    merged.launcherOpen = icons?.launcherOpen ?? DEFAULT_ICONS.launcherOpen;
+    return merged;
+  }, [icons]);
+  const resolvedLocale = useMemo(() => normalizeLocale(locale ?? getBrowserLocale()), [locale]);
+  const localeCopy = useMemo(() => getLocaleCopy(resolvedLocale), [resolvedLocale]);
+  const welcomeAssistantMessage = localeCopy.welcomeMessage;
+  const disclaimerText = localeCopy.disclaimer;
+  const resolvedAgentName = activePageConfig?.agentName ?? agentName ?? localeCopy.agentName;
+  const resolvedAssistantNote = activePageConfig?.assistantNote ?? assistantNote ?? localeCopy.assistantNote;
+  const uploadEnabled = activePageConfig?.enableUploads ?? enableUploads;
+  const widgetEnabled = activePageConfig?.enabled ?? true;
+  useEffect(() => {
+    if (typeof window === "undefined") {
+      return;
+    }
+    const storage = window.sessionStorage;
+    const nextSessionId = getOrCreateSessionId(storage);
+    setSessionId(nextSessionId);
+    setMessages(readHistory(storage, nextSessionId));
+    setIsHydrated(true);
+  }, []);
+  useEffect(() => {
+    if (!isHydrated || typeof window === "undefined") {
+      return;
+    }
+    const storage = window.sessionStorage;
+    storage.setItem(historyKey(sessionId), JSON.stringify(messages));
+  }, [isHydrated, messages, sessionId]);
+  useEffect(() => {
+    if (!isHydrated || !isOpen || !widgetEnabled || typeof window === "undefined") {
+      return;
+    }
+    let timeoutId;
+    setMessages((current) => {
+      if (current.length > 0) {
+        return current;
+      }
+      const welcomeId = createId("msg");
+      timeoutId = window.setTimeout(() => {
+        setMessages(
+          (next) => next.map(
+            (message) => message.id === welcomeId ? {
+              ...message,
+              content: welcomeAssistantMessage,
+              status: "complete"
+            } : message
+          )
+        );
+      }, WELCOME_DELAY_MS);
+      return [
+        ...current,
+        {
+          id: welcomeId,
+          role: "assistant",
+          content: "",
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          status: "streaming"
+        }
+      ];
+    });
+    return () => {
+      if (timeoutId) {
+        window.clearTimeout(timeoutId);
+      }
+    };
+  }, [isHydrated, isOpen, welcomeAssistantMessage, widgetEnabled]);
+  const open = useCallback(() => {
+    setIsOpen(true);
+    events?.onOpen?.();
+  }, [events]);
+  const close = useCallback(() => {
+    setIsOpen(false);
+    events?.onClose?.();
+  }, [events]);
+  const toggle = useCallback(() => {
+    setIsOpen((current) => {
+      const next = !current;
+      if (next) {
+        events?.onOpen?.();
+      } else {
+        events?.onClose?.();
+      }
+      return next;
+    });
+  }, [events]);
+  const clearConversation = useCallback(() => {
+    setMessages([]);
+    if (typeof window !== "undefined") {
+      const storage = window.sessionStorage;
+      storage.removeItem(historyKey(sessionId));
+    }
+  }, [sessionId]);
+  const resetSession = useCallback(() => {
+    const storage = typeof window !== "undefined" ? window.sessionStorage : void 0;
+    const next = resetSessionId(storage);
+    setSessionId(next);
+    setMessages([]);
+  }, []);
+  const registerPageConfig = useCallback((id, config) => {
+    setPageConfigs((current) => {
+      const filtered = current.filter((entry) => entry.id !== id);
+      return [...filtered, { id, config }];
+    });
+  }, []);
+  const unregisterPageConfig = useCallback((id) => {
+    setPageConfigs((current) => current.filter((entry) => entry.id !== id));
+  }, []);
+  const sendMessage = useCallback(
+    async ({ text, files = [] }) => {
+      const trimmed = text.trim();
+      if (!trimmed && files.length === 0) {
+        return;
+      }
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const attachmentDtos = files.map((file) => ({
+        id: createId("att"),
+        name: file.name,
+        size: file.size,
+        type: file.type,
+        file
+      }));
+      if (attachmentDtos.length > 0) {
+        events?.onAttachmentAdded?.(attachmentDtos);
+      }
+      const userMessage = {
+        id: createId("msg"),
+        role: "user",
+        content: trimmed,
+        createdAt: now,
+        status: "complete",
+        attachments: attachmentDtos
+      };
+      const ensureWelcomeMessage = (input) => {
+        if (input.some((message) => message.role === "assistant" && message.content === welcomeAssistantMessage)) {
+          return input;
+        }
+        const firstStreamingAssistantIndex = input.findIndex(
+          (message) => message.role === "assistant" && message.status === "streaming" && !message.content
+        );
+        if (firstStreamingAssistantIndex >= 0) {
+          return input.map(
+            (message, index) => index === firstStreamingAssistantIndex ? {
+              ...message,
+              content: welcomeAssistantMessage,
+              status: "complete"
+            } : message
+          );
+        }
+        if (input.some((message) => message.role === "assistant")) {
+          return input;
+        }
+        const welcomeMessage = {
+          id: createId("msg"),
+          role: "assistant",
+          content: welcomeAssistantMessage,
+          createdAt: now,
+          status: "complete"
+        };
+        return [...input, welcomeMessage];
+      };
+      const normalizedHistory = ensureWelcomeMessage(messagesRef.current);
+      const requestHistory = [...normalizedHistory, userMessage].map((message) => ({
+        id: message.id,
+        role: message.role,
+        content: message.content,
+        createdAt: message.createdAt
+      }));
+      setMessages((current) => [...ensureWelcomeMessage(current), userMessage]);
+      events?.onMessageSent?.(userMessage);
+      const assistantId = createId("msg");
+      setMessages((current) => [
+        ...current,
+        {
+          id: assistantId,
+          role: "assistant",
+          content: "",
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          status: "streaming"
+        }
+      ]);
+      setIsAwaiting(true);
+      const resolvedAdapter = withDefaultAdapter(adapter);
+      try {
+        const metadata = {
+          sessionId,
+          pageUrl: typeof window !== "undefined" ? window.location.href : "",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          agentName: resolvedAgentName,
+          locale: resolvedLocale,
+          history: requestHistory
+        };
+        const requestInit = resolvedAdapter.buildRequest({
+          webhookUrl,
+          message: trimmed,
+          sessionId,
+          agentName: resolvedAgentName,
+          files: uploadEnabled ? files : [],
+          metadata,
+          headers
+        });
+        const url = requestInit.url ?? webhookUrl;
+        const response = await fetch(url, requestInit);
+        let streamedContent = "";
+        const responseText = await readAssistantResponse({
+          response,
+          adapter: resolvedAdapter,
+          streamingMode,
+          onDelta: (delta) => {
+            streamedContent += delta;
+            setMessages(
+              (current) => current.map(
+                (message) => message.id === assistantId ? {
+                  ...message,
+                  content: `${message.content}${delta}`,
+                  status: "streaming"
+                } : message
+              )
+            );
+          },
+          onChunk: (chunk) => {
+            events?.onChunkReceived?.(chunk);
+          },
+          onRecoverableError: (error) => {
+            events?.onError?.(error);
+          }
+        });
+        setMessages((current) => {
+          const next = current.map((message) => {
+            if (message.id !== assistantId) {
+              return message;
+            }
+            const hasStreamed = streamedContent.length > 0;
+            const content = hasStreamed ? message.content : responseText;
+            return {
+              ...message,
+              content,
+              status: "complete"
+            };
+          });
+          const completeMessage = next.find((message) => message.id === assistantId);
+          if (completeMessage) {
+            events?.onResponseComplete?.(completeMessage);
+          }
+          return next;
+        });
+      } catch (error) {
+        const typedError = error instanceof Error ? error : new Error(String(error));
+        events?.onError?.(typedError);
+        setMessages(
+          (current) => current.map(
+            (message) => message.id === assistantId ? {
+              ...message,
+              content: message.content || "Sorry, I ran into an issue while generating a response.",
+              status: "error"
+            } : message
+          )
+        );
+      } finally {
+        setIsAwaiting(false);
+      }
+    },
+    [
+      adapter,
+      events,
+      headers,
+      resolvedAgentName,
+      resolvedLocale,
+      sessionId,
+      streamingMode,
+      uploadEnabled,
+      welcomeAssistantMessage,
+      webhookUrl
+    ]
+  );
+  const value = useMemo(
+    () => ({
+      isOpen,
+      isAwaiting,
+      messages,
+      sessionId,
+      uploadEnabled,
+      agentName: resolvedAgentName,
+      assistantNote: resolvedAssistantNote,
+      disclaimerText,
+      position,
+      themeVars,
+      icons: mergedIcons,
+      classNames: classNames ?? {},
+      open,
+      close,
+      toggle,
+      sendMessage,
+      clearConversation,
+      registerPageConfig,
+      unregisterPageConfig,
+      widgetEnabled,
+      resetSession
+    }),
+    [
+      classNames,
+      clearConversation,
+      close,
+      disclaimerText,
+      isAwaiting,
+      isOpen,
+      mergedIcons,
+      messages,
+      open,
+      position,
+      registerPageConfig,
+      resolvedAgentName,
+      resolvedAssistantNote,
+      sendMessage,
+      sessionId,
+      themeVars,
+      toggle,
+      unregisterPageConfig,
+      uploadEnabled,
+      widgetEnabled,
+      resetSession
+    ]
+  );
+  return /* @__PURE__ */ jsx(ChatbotContext.Provider, { value, children });
+}
+function useChatbotContext() {
+  const context = useContext(ChatbotContext);
+  if (!context) {
+    throw new Error("useChatbotContext must be used within ChatbotProvider");
+  }
+  return context;
+}
+
+// src/chatbot/components/chatbot-widget.tsx
+import clsx from "clsx";
+import {
+  useEffect as useEffect2,
+  useMemo as useMemo2,
+  useRef as useRef2,
+  useState as useState2
+} from "react";
+
+// src/chatbot/components/awaiting-dots.tsx
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+function AwaitingDots() {
+  return /* @__PURE__ */ jsxs("div", { className: "cb-inline-flex cb-items-center cb-gap-1 cb-px-1", "aria-label": "Assistant is typing", children: [
+    /* @__PURE__ */ jsx2("span", { className: "cb-h-1.5 cb-w-1.5 cb-rounded-full cb-bg-[var(--cb-muted-foreground)] cb-opacity-70 cb-animate-cb-dots [animation-delay:-0.2s]" }),
+    /* @__PURE__ */ jsx2("span", { className: "cb-h-1.5 cb-w-1.5 cb-rounded-full cb-bg-[var(--cb-muted-foreground)] cb-opacity-70 cb-animate-cb-dots [animation-delay:-0.1s]" }),
+    /* @__PURE__ */ jsx2("span", { className: "cb-h-1.5 cb-w-1.5 cb-rounded-full cb-bg-[var(--cb-muted-foreground)] cb-opacity-70 cb-animate-cb-dots" })
+  ] });
+}
+
+// src/chatbot/components/message-markdown.tsx
+import ReactMarkdown from "react-markdown";
+import rehypeSanitize from "rehype-sanitize";
+import remarkGfm from "remark-gfm";
+import { jsx as jsx3 } from "react/jsx-runtime";
+function MessageMarkdown({ content }) {
+  return /* @__PURE__ */ jsx3("div", { className: "cb-markdown cb-message-text cb-text-base cb-leading-6", children: /* @__PURE__ */ jsx3(ReactMarkdown, { remarkPlugins: [remarkGfm], rehypePlugins: [rehypeSanitize], children: content }) });
+}
+
+// src/chatbot/components/chatbot-widget.tsx
+import { Fragment, jsx as jsx4, jsxs as jsxs2 } from "react/jsx-runtime";
+var PANEL_INSET_REM = 1.5;
+var EXPANDED_MAX_WIDTH_PX = 630;
+var MOBILE_BREAKPOINT_PX = 768;
+var ROOT_BOTTOM_OFFSET_REM = 1.5;
+var PANEL_TO_BUBBLE_GAP_REM = 0.75;
+var BUBBLE_SIZE_REM = 3.5;
+var EXPANDED_BOTTOM_OFFSET_REM = ROOT_BOTTOM_OFFSET_REM + PANEL_TO_BUBBLE_GAP_REM + BUBBLE_SIZE_REM;
+var EXPANDED_TOTAL_VERTICAL_INSET_REM = PANEL_INSET_REM + EXPANDED_BOTTOM_OFFSET_REM;
+function formatFileSize(size) {
+  if (size < 1024) {
+    return `${size} B`;
+  }
+  if (size < 1024 * 1024) {
+    return `${(size / 1024).toFixed(1)} KB`;
+  }
+  return `${(size / (1024 * 1024)).toFixed(1)} MB`;
+}
+function formatGmtOffset(date) {
+  const total = -date.getTimezoneOffset();
+  const sign = total >= 0 ? "+" : "-";
+  const abs = Math.abs(total);
+  const hh = String(Math.floor(abs / 60)).padStart(2, "0");
+  const mm = String(abs % 60).padStart(2, "0");
+  return `GMT${sign}${hh}${mm}`;
+}
+function readTimeZoneName(date, mode) {
+  const parts = new Intl.DateTimeFormat(void 0, { timeZoneName: mode }).formatToParts(date);
+  return parts.find((part) => part.type === "timeZoneName")?.value ?? "";
+}
+function formatTranscriptDateTime(date) {
+  const datePart = new Intl.DateTimeFormat(void 0, {
+    month: "long",
+    day: "numeric",
+    year: "numeric"
+  }).format(date);
+  const timePart = new Intl.DateTimeFormat(void 0, {
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: true
+  }).format(date);
+  const zoneLong = readTimeZoneName(date, "long");
+  const zoneShort = readTimeZoneName(date, "short");
+  const gmtOffset = formatGmtOffset(date);
+  return `${datePart} at ${timePart} ${zoneLong} time ${zoneShort} (${gmtOffset})`.replace(/\s+/g, " ").trim();
+}
+function formatTranscriptMessageTime(value) {
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) {
+    return value;
+  }
+  return new Intl.DateTimeFormat(void 0, {
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: true
+  }).format(date);
+}
+function toTranscript(messages, agentName) {
+  const exportedAt = /* @__PURE__ */ new Date();
+  const firstDate = messages.length > 0 ? new Date(messages[0].createdAt) : exportedAt;
+  const startedAt = Number.isNaN(firstDate.getTime()) ? exportedAt : firstDate;
+  const lines = [
+    `Conversation with ${agentName}`,
+    `Started on ${formatTranscriptDateTime(startedAt)}`,
+    "",
+    "---",
+    ""
+  ];
+  messages.forEach((message) => {
+    const role = message.role === "user" ? "Visitor" : message.role === "assistant" ? agentName : "System";
+    const content = message.content.trim();
+    if (!content) {
+      return;
+    }
+    lines.push(`${formatTranscriptMessageTime(message.createdAt)} | ${role}: ${content}`);
+    lines.push("");
+  });
+  lines.push("---");
+  lines.push(`Exported from ${agentName} on ${formatTranscriptDateTime(exportedAt)}`);
+  return lines.join("\n");
+}
+function toTranscriptFilename(date) {
+  const yyyy = date.getFullYear();
+  const mm = String(date.getMonth() + 1).padStart(2, "0");
+  const dd = String(date.getDate()).padStart(2, "0");
+  const hh = String(date.getHours()).padStart(2, "0");
+  const min = String(date.getMinutes()).padStart(2, "0");
+  const ss = String(date.getSeconds()).padStart(2, "0");
+  return `chat-transcript-${yyyy}${mm}${dd}-${hh}${min}${ss}.txt`;
+}
+function ChatbotWidget() {
+  const {
+    isOpen,
+    isAwaiting,
+    messages,
+    uploadEnabled,
+    position,
+    agentName,
+    assistantNote,
+    disclaimerText,
+    themeVars,
+    icons,
+    classNames,
+    close,
+    open,
+    sendMessage,
+    widgetEnabled
+  } = useChatbotContext();
+  const [inputValue, setInputValue] = useState2("");
+  const [queuedFiles, setQueuedFiles] = useState2([]);
+  const [isMenuOpen, setIsMenuOpen] = useState2(false);
+  const [isExpanded, setIsExpanded] = useState2(false);
+  const [isMobileViewport, setIsMobileViewport] = useState2(false);
+  const panelRef = useRef2(null);
+  const messagesScrollRef = useRef2(null);
+  const inputRef = useRef2(null);
+  const fileInputRef = useRef2(null);
+  const menuRef = useRef2(null);
+  const LauncherClosedIcon = icons.launcherClosed;
+  const LauncherOpenIcon = icons.launcherOpen;
+  const BotIcon = icons.bot;
+  const MenuIcon = icons.menu;
+  const CloseIcon = icons.close;
+  const SendIcon = icons.send;
+  const AttachIcon = icons.attach;
+  const ExpandIcon = icons.expand;
+  const DownloadIcon = icons.download;
+  const alignment = position === "bottom-left" ? "cb-left-6" : "cb-right-6";
+  const stackAlignment = position === "bottom-left" ? "cb-items-start" : "cb-items-end";
+  const panelOrigin = position === "bottom-left" ? "cb-origin-bottom-left" : "cb-origin-bottom-right";
+  const panelLayoutMode = isMobileViewport ? "mobile" : isExpanded ? "desktop-expanded" : "desktop-collapsed";
+  const showExpandAction = !isMobileViewport;
+  const showDownloadAction = messages.length > 0;
+  const hasMenuActions = showExpandAction || showDownloadAction;
+  const canSend = useMemo2(() => {
+    return !isAwaiting && (inputValue.trim().length > 0 || queuedFiles.length > 0);
+  }, [inputValue, isAwaiting, queuedFiles.length]);
+  const resizeComposer = () => {
+    const textarea = inputRef.current;
+    if (!textarea) {
+      return;
+    }
+    if (textarea.value.length === 0) {
+      textarea.style.height = "38px";
+      textarea.style.overflowY = "hidden";
+      return;
+    }
+    const maxHeightPx = 168;
+    textarea.style.height = "auto";
+    const nextHeight = Math.min(textarea.scrollHeight, maxHeightPx);
+    textarea.style.height = `${nextHeight}px`;
+    textarea.style.overflowY = textarea.scrollHeight > maxHeightPx ? "auto" : "hidden";
+  };
+  const scrollMessagesToBottom = () => {
+    const container = messagesScrollRef.current;
+    if (!container) {
+      return;
+    }
+    container.scrollTop = container.scrollHeight;
+  };
+  const panelSize = useMemo2(() => {
+    const inset = `${PANEL_INSET_REM}rem`;
+    if (panelLayoutMode === "mobile") {
+      return {
+        className: "cb-fixed cb-max-h-none cb-max-w-none",
+        style: {
+          top: inset,
+          right: inset,
+          bottom: `${EXPANDED_BOTTOM_OFFSET_REM}rem`,
+          left: inset
+        }
+      };
+    }
+    if (panelLayoutMode === "desktop-expanded") {
+      return {
+        className: "cb-relative cb-max-h-none cb-max-w-none",
+        style: {
+          width: `min(${EXPANDED_MAX_WIDTH_PX}px, calc(100vw - ${PANEL_INSET_REM * 2}rem))`,
+          height: `calc(100vh - ${EXPANDED_TOTAL_VERTICAL_INSET_REM}rem)`
+        }
+      };
+    }
+    return {
+      className: "cb-relative cb-h-[min(680px,calc(100vh-7.5rem))] cb-w-[min(92vw,420px)]",
+      style: void 0
+    };
+  }, [panelLayoutMode]);
+  useEffect2(() => {
+    if (typeof window === "undefined") {
+      return;
+    }
+    const mediaQuery = window.matchMedia(`(max-width: ${MOBILE_BREAKPOINT_PX}px)`);
+    const syncViewportMode = () => {
+      setIsMobileViewport(mediaQuery.matches);
+    };
+    syncViewportMode();
+    if (typeof mediaQuery.addEventListener === "function") {
+      mediaQuery.addEventListener("change", syncViewportMode);
+      return () => mediaQuery.removeEventListener("change", syncViewportMode);
+    }
+    mediaQuery.addListener(syncViewportMode);
+    return () => mediaQuery.removeListener(syncViewportMode);
+  }, []);
+  useEffect2(() => {
+    if (!isOpen) {
+      setIsMenuOpen(false);
+      return;
+    }
+    inputRef.current?.focus();
+    resizeComposer();
+  }, [isOpen]);
+  useEffect2(() => {
+    resizeComposer();
+  }, [inputValue]);
+  useEffect2(() => {
+    if (!isOpen) {
+      return;
+    }
+    const rafId = window.requestAnimationFrame(() => {
+      scrollMessagesToBottom();
+    });
+    return () => window.cancelAnimationFrame(rafId);
+  }, [isOpen, messages, isAwaiting]);
+  useEffect2(() => {
+    if (!isOpen) {
+      return;
+    }
+    const onPointerDown = (event) => {
+      const target = event.target;
+      if (menuRef.current && !menuRef.current.contains(target)) {
+        setIsMenuOpen(false);
+      }
+    };
+    window.addEventListener("mousedown", onPointerDown);
+    return () => window.removeEventListener("mousedown", onPointerDown);
+  }, [isOpen]);
+  useEffect2(() => {
+    if (!isOpen) {
+      return;
+    }
+    const onKeyDown = (event) => {
+      if (event.key === "Escape") {
+        if (isMenuOpen) {
+          setIsMenuOpen(false);
+          return;
+        }
+        close();
+      }
+    };
+    window.addEventListener("keydown", onKeyDown);
+    return () => window.removeEventListener("keydown", onKeyDown);
+  }, [close, isMenuOpen, isOpen]);
+  useEffect2(() => {
+    setIsMenuOpen(false);
+  }, [isMobileViewport]);
+  useEffect2(() => {
+    if (!hasMenuActions) {
+      setIsMenuOpen(false);
+    }
+  }, [hasMenuActions]);
+  const trapFocus = (event) => {
+    if (event.key !== "Tab") {
+      return;
+    }
+    const root = panelRef.current;
+    if (!root) {
+      return;
+    }
+    const focusables = root.querySelectorAll(
+      "button, [href], textarea, input, select, [tabindex]:not([tabindex='-1'])"
+    );
+    if (focusables.length === 0) {
+      return;
+    }
+    const first = focusables[0];
+    const last = focusables[focusables.length - 1];
+    if (event.shiftKey && document.activeElement === first) {
+      last.focus();
+      event.preventDefault();
+    } else if (!event.shiftKey && document.activeElement === last) {
+      first.focus();
+      event.preventDefault();
+    }
+  };
+  const onSubmit = async (event) => {
+    event.preventDefault();
+    if (!canSend) {
+      return;
+    }
+    const submittedText = inputValue;
+    setInputValue("");
+    scrollMessagesToBottom();
+    await sendMessage({
+      text: submittedText,
+      files: uploadEnabled ? queuedFiles : []
+    });
+    setQueuedFiles([]);
+    if (fileInputRef.current) {
+      fileInputRef.current.value = "";
+    }
+  };
+  const onPickFiles = (event) => {
+    const list = event.target.files;
+    if (!list || !uploadEnabled) {
+      return;
+    }
+    const files = Array.from(list);
+    setQueuedFiles((current) => {
+      const seen = new Set(current.map((file) => `${file.name}:${file.size}:${file.lastModified}`));
+      const next = [...current];
+      files.forEach((file) => {
+        const key = `${file.name}:${file.size}:${file.lastModified}`;
+        if (!seen.has(key)) {
+          seen.add(key);
+          next.push(file);
+        }
+      });
+      return next;
+    });
+  };
+  const createIdFromFile = (file) => `${file.name}:${file.size}:${file.lastModified}`;
+  const removeQueuedFile = (fileId) => {
+    setQueuedFiles((current) => current.filter((file) => createIdFromFile(file) !== fileId));
+  };
+  const downloadTranscript = () => {
+    if (messages.length === 0) {
+      return;
+    }
+    const now = /* @__PURE__ */ new Date();
+    const fileContent = toTranscript(messages, agentName);
+    const blob = new Blob([fileContent], { type: "text/plain;charset=utf-8" });
+    const objectUrl = URL.createObjectURL(blob);
+    const anchor = document.createElement("a");
+    anchor.href = objectUrl;
+    anchor.download = toTranscriptFilename(now);
+    document.body.appendChild(anchor);
+    anchor.click();
+    document.body.removeChild(anchor);
+    URL.revokeObjectURL(objectUrl);
+    setIsMenuOpen(false);
+  };
+  const toggleExpanded = () => {
+    if (isMobileViewport) {
+      return;
+    }
+    setIsExpanded((current) => !current);
+    setIsMenuOpen(false);
+  };
+  if (!widgetEnabled) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx4(
+    "div",
+    {
+      className: clsx(
+        "cb-fixed cb-bottom-6 cb-z-[2147483640] cb-text-[var(--cb-surface-foreground)]",
+        alignment,
+        classNames.root
+      ),
+      style: themeVars,
+      "data-chatbot-root": true,
+      children: /* @__PURE__ */ jsxs2("div", { className: clsx("cb-pointer-events-none cb-relative cb-flex cb-flex-col cb-gap-3", stackAlignment), children: [
+        /* @__PURE__ */ jsxs2(
+          "div",
+          {
+            ref: panelRef,
+            className: clsx(
+              "cb-pointer-events-auto cb-flex cb-flex-col cb-overflow-hidden cb-rounded-[var(--cb-radius)] cb-border cb-border-[var(--cb-border)] cb-bg-[var(--cb-surface)] cb-shadow-[var(--cb-shadow-panel)] cb-transition-[opacity,transform,width,height,top,left,right,bottom] cb-duration-[380ms] cb-ease-[cubic-bezier(0.22,1,0.36,1)]",
+              panelOrigin,
+              panelSize.className,
+              isOpen ? "cb-translate-y-0 cb-scale-100 cb-opacity-100" : "cb-translate-y-3 cb-scale-90 cb-opacity-0 cb-pointer-events-none",
+              classNames.panel
+            ),
+            style: panelSize.style,
+            "aria-hidden": !isOpen,
+            onKeyDown: trapFocus,
+            children: [
+              /* @__PURE__ */ jsxs2(
+                "header",
+                {
+                  className: clsx(
+                    "cb-flex cb-items-center cb-justify-between cb-gap-2 cb-border-b cb-border-[var(--cb-border)] cb-bg-[var(--cb-surface)] cb-px-4 cb-py-3.5",
+                    classNames.header
+                  ),
+                  style: {
+                    borderBottomWidth: "1px",
+                    borderBottomStyle: "solid",
+                    borderBottomColor: "var(--cb-border)"
+                  },
+                  children: [
+                    /* @__PURE__ */ jsxs2("div", { className: clsx("cb-flex cb-min-w-0 cb-items-center cb-gap-2.5", classNames.headerMeta), children: [
+                      /* @__PURE__ */ jsx4("span", { className: "cb-inline-flex cb-h-9 cb-w-9 cb-shrink-0 cb-items-center cb-justify-center cb-self-center cb-text-[var(--cb-surface-foreground)]", children: /* @__PURE__ */ jsx4(BotIcon, { size: 34 }) }),
+                      /* @__PURE__ */ jsxs2("div", { className: "cb-min-w-0 cb-space-y-0", children: [
+                        /* @__PURE__ */ jsx4("p", { className: "cb-m-0 cb-truncate cb-text-lg cb-font-semibold cb-leading-6 cb-text-[var(--cb-surface-foreground)]", children: agentName }),
+                        /* @__PURE__ */ jsx4("p", { className: "cb-m-0 cb-text-base cb-leading-5 cb-text-[var(--cb-muted-foreground)]", children: assistantNote })
+                      ] })
+                    ] }),
+                    /* @__PURE__ */ jsxs2("div", { ref: menuRef, className: "cb-relative cb-flex cb-items-center cb-gap-1", children: [
+                      hasMenuActions && /* @__PURE__ */ jsx4(
+                        "button",
+                        {
+                          type: "button",
+                          onClick: () => setIsMenuOpen((current) => !current),
+                          className: clsx(
+                            "cb-flex cb-h-9 cb-w-9 cb-shrink-0 cb-items-center cb-justify-center cb-rounded-lg cb-bg-transparent cb-p-0 cb-text-[var(--cb-muted-foreground)] cb-transition hover:cb-bg-[var(--cb-muted)] hover:cb-text-white focus-visible:cb-bg-[var(--cb-muted)] focus-visible:cb-text-white",
+                            isMenuOpen && "cb-bg-[var(--cb-muted)] cb-text-white"
+                          ),
+                          "aria-label": "More options",
+                          "aria-expanded": isMenuOpen,
+                          children: /* @__PURE__ */ jsx4(MenuIcon, { size: 18 })
+                        }
+                      ),
+                      isMenuOpen && hasMenuActions && /* @__PURE__ */ jsxs2(
+                        "div",
+                        {
+                          className: clsx(
+                            "cb-absolute cb-right-0 cb-top-full cb-z-20 cb-mt-2 cb-flex cb-min-w-[220px] cb-flex-col cb-gap-1 cb-rounded-xl cb-border cb-border-[var(--cb-border)] cb-bg-[var(--cb-surface)] cb-p-1.5 cb-shadow-[var(--cb-shadow-panel)]",
+                            classNames.menu
+                          ),
+                          children: [
+                            showExpandAction && /* @__PURE__ */ jsxs2(
+                              "button",
+                              {
+                                type: "button",
+                                onClick: toggleExpanded,
+                                className: clsx(
+                                  "cb-flex cb-w-full cb-items-center cb-gap-2 cb-rounded-lg cb-bg-transparent cb-px-3.5 cb-py-2.5 cb-text-left cb-text-sm cb-text-[var(--cb-muted-foreground)] cb-transition hover:cb-bg-[var(--cb-muted)] hover:cb-text-white focus-visible:cb-bg-[var(--cb-muted)] focus-visible:cb-text-white",
+                                  classNames.menuItem
+                                ),
+                                children: [
+                                  /* @__PURE__ */ jsx4(ExpandIcon, { size: 16 }),
+                                  /* @__PURE__ */ jsx4("span", { children: isExpanded ? "Restore window" : "Expand window" })
+                                ]
+                              }
+                            ),
+                            showDownloadAction && /* @__PURE__ */ jsxs2(
+                              "button",
+                              {
+                                type: "button",
+                                onClick: downloadTranscript,
+                                className: clsx(
+                                  "cb-flex cb-w-full cb-items-center cb-gap-2 cb-rounded-lg cb-bg-transparent cb-px-3.5 cb-py-2.5 cb-text-left cb-text-sm cb-text-[var(--cb-muted-foreground)] cb-transition hover:cb-bg-[var(--cb-muted)] hover:cb-text-white focus-visible:cb-bg-[var(--cb-muted)] focus-visible:cb-text-white",
+                                  classNames.menuItem
+                                ),
+                                children: [
+                                  /* @__PURE__ */ jsx4(DownloadIcon, { size: 16 }),
+                                  /* @__PURE__ */ jsx4("span", { children: "Download transcript" })
+                                ]
+                              }
+                            )
+                          ]
+                        }
+                      ),
+                      /* @__PURE__ */ jsx4(
+                        "button",
+                        {
+                          type: "button",
+                          onClick: close,
+                          className: "cb-flex cb-h-9 cb-w-9 cb-shrink-0 cb-items-center cb-justify-center cb-rounded-lg cb-bg-transparent cb-p-0 cb-text-[var(--cb-muted-foreground)] cb-transition hover:cb-bg-[var(--cb-muted)] hover:cb-text-white focus-visible:cb-bg-[var(--cb-muted)] focus-visible:cb-text-white",
+                          "aria-label": "Close chatbot",
+                          children: /* @__PURE__ */ jsx4(CloseIcon, { size: 18 })
+                        }
+                      )
+                    ] })
+                  ]
+                }
+              ),
+              /* @__PURE__ */ jsx4(
+                "section",
+                {
+                  ref: messagesScrollRef,
+                  className: clsx(
+                    "cb-chat-scroll cb-flex-1 cb-overflow-y-auto cb-scroll-smooth cb-bg-[var(--cb-background)] cb-px-4 cb-pt-4 cb-pb-36",
+                    classNames.body
+                  ),
+                  children: /* @__PURE__ */ jsxs2("div", { className: "cb-space-y-3.5", children: [
+                    messages.length === 0 && /* @__PURE__ */ jsx4("div", { className: "cb-rounded-xl cb-bg-[var(--cb-muted)] cb-p-3 cb-text-sm cb-text-[var(--cb-muted-foreground)]", children: "Ask anything about this company and the assistant will answer using your RAG knowledge base." }),
+                    messages.map((message) => {
+                      const isUser = message.role === "user";
+                      return /* @__PURE__ */ jsx4(
+                        "article",
+                        {
+                          className: clsx(
+                            "cb-flex",
+                            isUser ? "cb-justify-end cb-animate-cb-slide-fade-in-right" : "cb-justify-start cb-animate-cb-slide-fade-in-left"
+                          ),
+                          children: /* @__PURE__ */ jsxs2(
+                            "div",
+                            {
+                              className: clsx(
+                                "cb-max-w-[85%] cb-rounded-2xl cb-px-4 cb-py-2",
+                                isUser ? "cb-rounded-br-md cb-bg-[var(--cb-user-bubble)] cb-text-[var(--cb-user-text)]" : "cb-rounded-bl-md cb-bg-[var(--cb-assistant-bubble)] cb-text-[var(--cb-assistant-text)]"
+                              ),
+                              children: [
+                                message.role === "assistant" && message.status === "streaming" && !message.content ? /* @__PURE__ */ jsx4(AwaitingDots, {}) : message.role === "assistant" ? /* @__PURE__ */ jsx4(MessageMarkdown, { content: message.content }) : /* @__PURE__ */ jsx4("p", { className: "cb-message-text cb-m-0 cb-whitespace-pre-wrap cb-text-base cb-leading-6", children: message.content }),
+                                message.attachments && message.attachments.length > 0 && /* @__PURE__ */ jsx4("div", { className: "cb-mt-2 cb-flex cb-flex-wrap cb-gap-2", children: message.attachments.map((attachment) => /* @__PURE__ */ jsxs2(
+                                  "span",
+                                  {
+                                    className: "cb-inline-flex cb-items-center cb-gap-2 cb-rounded-full cb-bg-black/10 cb-px-2 cb-py-1 cb-text-xs",
+                                    children: [
+                                      /* @__PURE__ */ jsx4("span", { children: attachment.name }),
+                                      /* @__PURE__ */ jsx4("span", { className: "cb-opacity-70", children: formatFileSize(attachment.size) })
+                                    ]
+                                  },
+                                  attachment.id
+                                )) })
+                              ]
+                            }
+                          )
+                        },
+                        message.id
+                      );
+                    }),
+                    /* @__PURE__ */ jsx4("div", {})
+                  ] })
+                }
+              ),
+              /* @__PURE__ */ jsxs2(
+                "footer",
+                {
+                  className: clsx(
+                    "cb-absolute cb-bottom-4 cb-left-4 cb-right-4 cb-z-10 cb-bg-transparent cb-p-0",
+                    classNames.footer
+                  ),
+                  children: [
+                    uploadEnabled && queuedFiles.length > 0 && /* @__PURE__ */ jsx4("div", { className: "cb-mb-2 cb-flex cb-flex-wrap cb-gap-2", children: queuedFiles.map((file) => {
+                      const fileId = createIdFromFile(file);
+                      return /* @__PURE__ */ jsxs2(
+                        "button",
+                        {
+                          type: "button",
+                          className: "cb-inline-flex cb-items-center cb-gap-2 cb-rounded-full cb-bg-[var(--cb-muted)] cb-px-3 cb-py-1 cb-text-xs cb-text-[var(--cb-muted-foreground)]",
+                          onClick: () => removeQueuedFile(fileId),
+                          "aria-label": `Remove ${file.name}`,
+                          children: [
+                            /* @__PURE__ */ jsx4("span", { className: "cb-max-w-[140px] cb-truncate", children: file.name }),
+                            /* @__PURE__ */ jsx4("span", { children: "x" })
+                          ]
+                        },
+                        fileId
+                      );
+                    }) }),
+                    /* @__PURE__ */ jsxs2("form", { onSubmit, children: [
+                      /* @__PURE__ */ jsxs2(
+                        "div",
+                        {
+                          className: clsx(
+                            "cb-flex cb-items-end cb-gap-2 cb-rounded-2xl cb-bg-[var(--cb-surface)] cb-p-2 cb-shadow-[0_18px_35px_-24px_rgba(0,0,0,0.85)] cb-transition",
+                            classNames.composer
+                          ),
+                          children: [
+                            uploadEnabled && /* @__PURE__ */ jsxs2(Fragment, { children: [
+                              /* @__PURE__ */ jsx4(
+                                "input",
+                                {
+                                  type: "file",
+                                  multiple: true,
+                                  ref: fileInputRef,
+                                  className: "cb-hidden",
+                                  onChange: onPickFiles,
+                                  "aria-label": "Add attachments"
+                                }
+                              ),
+                              /* @__PURE__ */ jsx4(
+                                "button",
+                                {
+                                  type: "button",
+                                  className: "cb-flex cb-h-10 cb-w-10 cb-shrink-0 cb-items-center cb-justify-center cb-rounded-lg cb-bg-transparent cb-p-0 cb-text-[var(--cb-muted-foreground)] cb-transition hover:cb-bg-[var(--cb-muted)] hover:cb-text-white focus-visible:cb-bg-[var(--cb-muted)] focus-visible:cb-text-white",
+                                  onClick: () => fileInputRef.current?.click(),
+                                  "aria-label": "Attach files",
+                                  children: /* @__PURE__ */ jsx4(AttachIcon, { size: 18 })
+                                }
+                              )
+                            ] }),
+                            /* @__PURE__ */ jsx4("div", { className: "cb-flex-1", children: /* @__PURE__ */ jsx4(
+                              "textarea",
+                              {
+                                ref: inputRef,
+                                value: inputValue,
+                                onChange: (event) => setInputValue(event.target.value),
+                                onKeyDown: (event) => {
+                                  if (event.key === "Enter" && !event.shiftKey) {
+                                    event.preventDefault();
+                                    void onSubmit(event);
+                                  }
+                                },
+                                rows: 1,
+                                placeholder: "Ask a question...",
+                                className: clsx(
+                                  "cb-composer-input cb-min-h-[38px] cb-w-full cb-resize-none cb-bg-transparent cb-px-2 cb-py-1.5 cb-text-sm cb-leading-6 cb-text-[var(--cb-surface-foreground)] cb-outline-none placeholder:cb-text-[var(--cb-muted-foreground)]",
+                                  classNames.input
+                                )
+                              }
+                            ) }),
+                            /* @__PURE__ */ jsx4(
+                              "button",
+                              {
+                                type: "submit",
+                                disabled: !canSend,
+                                className: clsx(
+                                  "cb-flex cb-h-10 cb-w-10 cb-shrink-0 cb-items-center cb-justify-center cb-rounded-full cb-bg-white cb-p-0 cb-text-[#111111] cb-transition cb-duration-200 hover:cb-scale-105 hover:cb-brightness-95 hover:cb-text-[#111111] active:cb-scale-95 focus-visible:cb-text-[#111111] disabled:cb-cursor-not-allowed disabled:cb-bg-white/70 disabled:cb-text-[#111111] disabled:cb-opacity-100",
+                                  classNames.sendButton
+                                ),
+                                "aria-label": "Send message",
+                                children: /* @__PURE__ */ jsx4(SendIcon, { size: 18 })
+                              }
+                            )
+                          ]
+                        }
+                      ),
+                      /* @__PURE__ */ jsx4("p", { className: "cb-m-0 cb-mt-1 cb-px-1 cb-text-center cb-text-xs cb-leading-4 cb-text-[var(--cb-muted-foreground)]", children: disclaimerText })
+                    ] })
+                  ]
+                }
+              )
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsx4(
+          "button",
+          {
+            type: "button",
+            onClick: isOpen ? close : open,
+            className: clsx(
+              "cb-pointer-events-auto cb-group cb-flex cb-h-14 cb-w-14 cb-items-center cb-justify-center cb-rounded-full cb-border cb-border-[var(--cb-border)] cb-bg-[#111111] cb-text-[#f5f5f5] cb-shadow-[var(--cb-shadow-bubble)] cb-transition cb-duration-300 hover:cb-scale-110 hover:cb-bg-[#262626] hover:cb-shadow-[0_24px_50px_-18px_rgba(0,0,0,0.9)] active:cb-scale-95",
+              classNames.bubble
+            ),
+            "aria-label": isOpen ? "Close chatbot" : "Open chatbot",
+            children: /* @__PURE__ */ jsxs2("span", { className: "cb-relative cb-flex cb-h-6 cb-w-6 cb-items-center cb-justify-center", children: [
+              /* @__PURE__ */ jsx4(
+                LauncherClosedIcon,
+                {
+                  size: 22,
+                  className: clsx(
+                    "cb-absolute cb-fill-current cb-transition-all cb-duration-300 cb-ease-out",
+                    isOpen ? "cb-rotate-90 cb-opacity-0" : "cb-rotate-0 cb-opacity-100"
+                  )
+                }
+              ),
+              /* @__PURE__ */ jsx4(
+                LauncherOpenIcon,
+                {
+                  size: 22,
+                  className: clsx(
+                    "cb-absolute cb-transition-all cb-duration-300 cb-ease-out",
+                    isOpen ? "cb-rotate-0 cb-opacity-100" : "-cb-rotate-90 cb-opacity-0"
+                  )
+                }
+              )
+            ] })
+          }
+        )
+      ] })
+    }
+  );
+}
+
+// src/chatbot/components/chatbot-page-config.tsx
+import { useEffect as useEffect3, useMemo as useMemo3, useRef as useRef3 } from "react";
+function ChatbotPageConfig(props) {
+  const { registerPageConfig, unregisterPageConfig } = useChatbotContext();
+  const configId = useRef3(createId("pagecfg"));
+  const stableConfig = useMemo3(() => props, [props]);
+  useEffect3(() => {
+    registerPageConfig(configId.current, stableConfig);
+    return () => unregisterPageConfig(configId.current);
+  }, [registerPageConfig, stableConfig, unregisterPageConfig]);
+  return null;
+}
+
+// src/chatbot/hooks/use-chatbot.ts
+function useChatbot() {
+  return useChatbotContext();
+}
+
+// src/chatbot/hooks/use-chatbot-session.ts
+import { useMemo as useMemo4 } from "react";
+function useChatbotSession() {
+  const { sessionId, resetSession } = useChatbotContext();
+  return useMemo4(
+    () => ({
+      sessionId,
+      resetSession
+    }),
+    [resetSession, sessionId]
+  );
+}
+export {
+  ChatbotPageConfig,
+  ChatbotProvider,
+  ChatbotWidget,
+  useChatbot,
+  useChatbotSession
+};
+//# sourceMappingURL=index.mjs.map