@djangocfg/ui-tools 2.1.381 → 2.1.383

package/dist/chunk-UWVP6LCW.mjs

@@ -0,0 +1,2447 @@
+import { TOOL_CALL, DESTRUCTIVE_SURFACE, TOGGLE, ANCHOR, BUBBLE_SURFACE, MarkdownMessage } from './chunk-HIK6BPL7.mjs';
+import { __name } from './chunk-N2XQF2OL.mjs';
+import { createContext, forwardRef, useRef, useEffect, memo, useState, useCallback, useImperativeHandle, useMemo, useReducer, useContext } from 'react';
+import { cn, isDev } from '@djangocfg/ui-core/lib';
+import { consola } from 'consola';
+import { useCopy, useLocalStorage, useMediaQuery, useNotificationSounds } from '@djangocfg/ui-core/hooks';
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+import { Paperclip, Square, Send, ChevronDown, ChevronRight, Loader2, File, X, Sparkles, AlertCircle, RefreshCw, ArrowDown, ExternalLink, Copy, Pencil, Trash } from 'lucide-react';
+import { Button, Textarea, Spinner, Avatar, AvatarImage, AvatarFallback } from '@djangocfg/ui-core/components';
+import { Virtuoso } from 'react-virtuoso';
+
+// src/tools/Chat/types/labels.ts
+var DEFAULT_LABELS = {
+  send: "Send",
+  cancel: "Stop",
+  copy: "Copy",
+  regenerate: "Regenerate",
+  edit: "Edit",
+  delete: "Delete",
+  retry: "Retry",
+  newChat: "New chat",
+  loadMore: "Load more",
+  jumpToLatest: "Jump to latest",
+  attach: "Attach files",
+  voice: "Voice input",
+  errorGeneric: "Something went wrong",
+  cancelledSuffix: "[cancelled]"
+};
+
+// src/tools/Chat/config.ts
+var STORAGE_KEYS = {
+  mode: "djc-chat-mode",
+  sidebarWidth: "djc-chat-sidebar-width",
+  composerHistory: "djc-chat-composer-history"
+};
+var CSS_VARS = {
+  reserve: "--djc-chat-reserve"
+};
+var DEFAULT_Z_INDEX = 9e3;
+var LIMITS = {
+  /** Max characters per single message. */
+  messageMaxLength: 8e3,
+  /** Max attachments per message. */
+  attachmentsMax: 10,
+  /** Composer history slots. */
+  composerHistorySize: 50,
+  /** Coalesce stream tokens within this window before dispatching. */
+  streamCoalesceMs: 16,
+  /** Default history page size. */
+  pageSize: 50,
+  /** Virtualize list when >= this many messages (host-controlled threshold). */
+  virtualizeThreshold: 50,
+  /** SSE idle timeout. */
+  sseIdleMs: 45e3
+};
+var DEFAULT_SIDEBAR = {
+  width: 420,
+  min: 320,
+  max: 720
+};
+var HOTKEYS = {
+  send: "mod+enter",
+  cancel: "esc",
+  newChat: "mod+shift+n",
+  toggleOpen: "mod+/",
+  focusComposer: "mod+l"
+};
+var CHAT_EVENT_NAME = "djc:chat:send";
+
+// src/tools/Chat/core/reducer.ts
+var initialState = {
+  sessionId: null,
+  messages: [],
+  isLoading: false,
+  isStreaming: false,
+  isLoadingMore: false,
+  hasMore: true,
+  oldestCursor: null,
+  error: null
+};
+function updateLastStreaming(messages, patch) {
+  const idx = findLastStreamingIndex(messages);
+  if (idx === -1) return messages;
+  const next = messages.slice();
+  next[idx] = patch(messages[idx]);
+  return next;
+}
+__name(updateLastStreaming, "updateLastStreaming");
+function findLastStreamingIndex(messages) {
+  for (let i = messages.length - 1; i >= 0; i -= 1) {
+    if (messages[i].isStreaming) return i;
+  }
+  return -1;
+}
+__name(findLastStreamingIndex, "findLastStreamingIndex");
+function patchMessageById(messages, id, patch) {
+  const idx = messages.findIndex((m) => m.id === id);
+  if (idx === -1) return messages;
+  const next = messages.slice();
+  next[idx] = patch(messages[idx]);
+  return next;
+}
+__name(patchMessageById, "patchMessageById");
+function reducer(state, action) {
+  switch (action.type) {
+    case "SESSION_SET":
+      return {
+        ...state,
+        sessionId: action.sessionId,
+        messages: action.messages ?? state.messages,
+        hasMore: action.hasMore ?? state.hasMore,
+        oldestCursor: action.cursor ?? state.oldestCursor,
+        error: null
+      };
+    case "HISTORY_LOAD_START":
+      return { ...state, isLoading: true, error: null };
+    case "HISTORY_LOAD_DONE":
+      return {
+        ...state,
+        isLoading: false,
+        messages: action.messages,
+        hasMore: action.hasMore,
+        oldestCursor: action.cursor
+      };
+    case "HISTORY_MORE_START":
+      return { ...state, isLoadingMore: true };
+    case "HISTORY_MORE_DONE":
+      return {
+        ...state,
+        isLoadingMore: false,
+        // Older messages prepend to the top.
+        messages: [...action.messages, ...state.messages],
+        hasMore: action.hasMore,
+        oldestCursor: action.cursor
+      };
+    case "MESSAGE_USER_ADD":
+      return {
+        ...state,
+        messages: [...state.messages, action.message],
+        error: null
+      };
+    case "STREAM_START": {
+      if (state.isStreaming) {
+        if (typeof console !== "undefined") {
+          console.warn("[chat] STREAM_START while already streaming, ignoring");
+        }
+        return state;
+      }
+      const placeholder = {
+        id: action.id,
+        role: "assistant",
+        content: "",
+        createdAt: action.createdAt ?? Date.now(),
+        isStreaming: true
+      };
+      return {
+        ...state,
+        isStreaming: true,
+        messages: [...state.messages, placeholder]
+      };
+    }
+    case "STREAM_CHUNK": {
+      const messages = updateLastStreaming(state.messages, (m) => ({
+        ...m,
+        content: m.content + action.delta
+      }));
+      return { ...state, messages };
+    }
+    case "STREAM_TOOL_ACTIVITY": {
+      const messages = updateLastStreaming(state.messages, (m) => ({
+        ...m,
+        toolActivity: action.tool
+      }));
+      return { ...state, messages };
+    }
+    case "TOOL_CALL_START": {
+      const messages = patchMessageById(state.messages, action.messageId, (m) => ({
+        ...m,
+        toolCalls: [...m.toolCalls ?? [], action.toolCall]
+      }));
+      return { ...state, messages };
+    }
+    case "TOOL_CALL_DELTA": {
+      const messages = patchMessageById(state.messages, action.messageId, (m) => {
+        if (!m.toolCalls) return m;
+        return {
+          ...m,
+          toolCalls: m.toolCalls.map(
+            (tc) => tc.id === action.toolId ? { ...tc, streamingText: (tc.streamingText ?? "") + action.delta } : tc
+          )
+        };
+      });
+      return { ...state, messages };
+    }
+    case "TOOL_CALL_END": {
+      const messages = patchMessageById(state.messages, action.messageId, (m) => {
+        if (!m.toolCalls) return m;
+        return {
+          ...m,
+          toolCalls: m.toolCalls.map(
+            (tc) => tc.id === action.toolId ? {
+              ...tc,
+              output: action.output,
+              status: action.status,
+              streamingText: void 0,
+              endedAt: Date.now()
+            } : tc
+          )
+        };
+      });
+      return { ...state, messages };
+    }
+    case "STREAM_DONE": {
+      const patched = patchMessageById(state.messages, action.id, (m) => ({
+        ...m,
+        isStreaming: false,
+        tokensIn: action.tokensIn ?? m.tokensIn,
+        tokensOut: action.tokensOut ?? m.tokensOut,
+        sources: action.sources ?? m.sources
+      }));
+      const msg = patched.find((m) => m.id === action.id);
+      const messages = msg && !msg.content && !msg.toolCalls?.length ? patched.filter((m) => m.id !== action.id) : patched;
+      return { ...state, isStreaming: false, messages };
+    }
+    case "STREAM_CANCELLED": {
+      const suffix = action.label ?? "[cancelled]";
+      const messages = patchMessageById(state.messages, action.id, (m) => ({
+        ...m,
+        isStreaming: false,
+        content: action.partialText + (action.partialText ? `
+
+_${suffix}_` : `_${suffix}_`)
+      }));
+      return { ...state, isStreaming: false, messages };
+    }
+    case "STREAM_ERROR": {
+      const messages = action.id ? patchMessageById(state.messages, action.id, (m) => ({
+        ...m,
+        isStreaming: false,
+        isError: true
+      })) : state.messages;
+      return { ...state, isStreaming: false, error: action.message, messages };
+    }
+    case "STREAM_CANCEL_PLACEHOLDER":
+      return {
+        ...state,
+        isStreaming: false,
+        messages: state.messages.filter((m) => m.id !== action.id)
+      };
+    case "STREAM_RESUME_EXISTING": {
+      const lastIdx = (() => {
+        for (let i = state.messages.length - 1; i >= 0; i--) {
+          if (state.messages[i].role === "assistant") return i;
+        }
+        return -1;
+      })();
+      if (lastIdx === -1) return { ...state, isStreaming: true };
+      const msgs = state.messages.slice();
+      msgs[lastIdx] = { ...msgs[lastIdx], isStreaming: true };
+      return { ...state, isStreaming: true, messages: msgs };
+    }
+    case "MESSAGE_EDIT": {
+      const messages = patchMessageById(state.messages, action.id, (m) => ({
+        ...m,
+        content: action.content,
+        version: (m.version ?? 0) + 1
+      }));
+      return { ...state, messages };
+    }
+    case "MESSAGE_DELETE":
+      return {
+        ...state,
+        messages: state.messages.filter((m) => m.id !== action.id)
+      };
+    case "MESSAGE_INJECT": {
+      const existingIdx = state.messages.findIndex((m) => m.id === action.message.id);
+      if (existingIdx >= 0) {
+        const messages = state.messages.slice();
+        const prev = messages[existingIdx];
+        messages[existingIdx] = {
+          ...prev,
+          ...action.message,
+          version: (prev.version ?? 0) + 1
+        };
+        return { ...state, messages };
+      }
+      const next = action.position === "prepend" ? [action.message, ...state.messages] : [...state.messages, action.message];
+      return { ...state, messages: next };
+    }
+    case "MESSAGE_PATCH": {
+      const messages = patchMessageById(state.messages, action.id, (m) => ({
+        ...m,
+        ...action.patch,
+        version: (m.version ?? 0) + 1
+      }));
+      return { ...state, messages };
+    }
+    case "MESSAGES_CLEAR":
+      return {
+        ...state,
+        messages: [],
+        isStreaming: false,
+        error: null
+      };
+    case "ERROR_SET":
+      return { ...state, error: action.error };
+    case "ATTACHMENT_PROGRESS": {
+      const messages = patchMessageById(state.messages, action.messageId, (m) => {
+        if (!m.attachments) return m;
+        return {
+          ...m,
+          attachments: m.attachments.map(
+            (a) => a.id === action.attachmentId ? {
+              ...a,
+              progress: action.progress ?? a.progress,
+              status: action.status ?? a.status
+            } : a
+          )
+        };
+      });
+      return { ...state, messages };
+    }
+    default: {
+      return state;
+    }
+  }
+}
+__name(reducer, "reducer");
+
+// src/tools/Chat/core/ids.ts
+var counter = 0;
+function createId(prefix = "m") {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return `${prefix}_${crypto.randomUUID()}`;
+  }
+  counter += 1;
+  return `${prefix}_${Date.now().toString(36)}_${counter.toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+__name(createId, "createId");
+var SCOPES = ["bootstrap", "transport", "stream", "lifecycle", "tools", "error"];
+var cache = /* @__PURE__ */ new Map();
+function buildLogger(enabled) {
+  const root = consola.withTag("chat");
+  const subs = Object.fromEntries(
+    SCOPES.map((scope) => [scope, root.withTag(scope)])
+  );
+  if (!enabled) {
+    for (const scope of SCOPES) {
+      if (scope === "error") continue;
+      subs[scope].level = -999;
+    }
+  }
+  return { ...subs, enabled };
+}
+__name(buildLogger, "buildLogger");
+function getChatLogger(debug) {
+  const enabled = debug ?? isDev;
+  let logger = cache.get(enabled);
+  if (!logger) {
+    logger = buildLogger(enabled);
+    cache.set(enabled, logger);
+  }
+  return logger;
+}
+__name(getChatLogger, "getChatLogger");
+
+// src/tools/Chat/core/markdown.ts
+function createTokenBuffer(onFlush, windowMs = LIMITS.streamCoalesceMs) {
+  let pending = "";
+  let timer = null;
+  let closed = false;
+  const flush = /* @__PURE__ */ __name(() => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    if (pending) {
+      const out = pending;
+      pending = "";
+      onFlush(out);
+    }
+  }, "flush");
+  return {
+    push(delta) {
+      if (closed || !delta) return;
+      pending += delta;
+      if (windowMs <= 0) {
+        flush();
+        return;
+      }
+      if (timer === null) {
+        timer = setTimeout(flush, windowMs);
+      }
+    },
+    flush,
+    close() {
+      closed = true;
+      flush();
+    }
+  };
+}
+__name(createTokenBuffer, "createTokenBuffer");
+
+// src/tools/Chat/hooks/useChat.ts
+function useChat(config) {
+  const [state, dispatch] = useReducer(reducer, initialState);
+  const stateRef = useRef(state);
+  stateRef.current = state;
+  const abortRef = useRef(null);
+  const lastErrorRef = useRef(null);
+  const streamingMsgIdRef = useRef(null);
+  const bootstrapRef = useRef(null);
+  const { transport, autoCreateSession = true, streaming = true, pageSize = LIMITS.pageSize } = config;
+  const log = getChatLogger(config.debug);
+  useEffect(() => {
+    let cancelled = false;
+    if (stateRef.current.sessionId) {
+      return;
+    }
+    if (config.initialSessionId || autoCreateSession) {
+      dispatch({ type: "HISTORY_LOAD_START" });
+    }
+    log.bootstrap.info("start", {
+      mode: config.initialSessionId ? "resume" : autoCreateSession ? "create" : "idle",
+      initialSessionId: config.initialSessionId
+    });
+    const run = /* @__PURE__ */ __name(async () => {
+      const t0 = performance.now();
+      try {
+        if (config.initialSessionId) {
+          if (!cancelled) {
+            dispatch({
+              type: "SESSION_SET",
+              sessionId: config.initialSessionId
+            });
+          }
+          const page = await transport.loadHistory(config.initialSessionId, null, pageSize);
+          if (cancelled) {
+            log.bootstrap.debug("cancelled (post-loadHistory)");
+            return config.initialSessionId;
+          }
+          dispatch({
+            type: "HISTORY_LOAD_DONE",
+            messages: page.messages,
+            hasMore: page.hasMore,
+            cursor: page.nextCursor
+          });
+          log.bootstrap.success("resumed", {
+            sessionId: config.initialSessionId,
+            messages: page.messages.length,
+            hasMore: page.hasMore,
+            elapsedMs: Math.round(performance.now() - t0)
+          });
+          return config.initialSessionId;
+        }
+        if (autoCreateSession) {
+          const info = await transport.createSession({ metadata: config.metadata });
+          dispatch({
+            type: "SESSION_SET",
+            sessionId: info.sessionId,
+            messages: info.messages ?? [],
+            hasMore: info.hasMore ?? false,
+            cursor: info.cursor ?? null
+          });
+          dispatch({
+            type: "HISTORY_LOAD_DONE",
+            messages: info.messages ?? [],
+            hasMore: info.hasMore ?? false,
+            cursor: info.cursor ?? null
+          });
+          log.bootstrap.success(cancelled ? "created (post-cancel)" : "created", {
+            sessionId: info.sessionId,
+            resumed: info.resumed ?? false,
+            cancelled,
+            elapsedMs: Math.round(performance.now() - t0)
+          });
+          return info.sessionId;
+        }
+        log.bootstrap.debug("idle (no initialSessionId, autoCreateSession=false)");
+        return null;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        if (cancelled) {
+          log.bootstrap.debug("cancelled (in catch)", { message: e.message });
+          return null;
+        }
+        lastErrorRef.current = e;
+        dispatch({ type: "ERROR_SET", error: e.message });
+        config.onError?.(e);
+        log.error.error("bootstrap failed", { message: e.message, elapsedMs: Math.round(performance.now() - t0) });
+        return null;
+      }
+    }, "run");
+    bootstrapRef.current = run();
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+  const awaitSession = useCallback(async () => {
+    if (stateRef.current.sessionId) return stateRef.current.sessionId;
+    if (bootstrapRef.current) {
+      const id = await bootstrapRef.current;
+      if (id) return id;
+    }
+    return stateRef.current.sessionId;
+  }, []);
+  const consumeStream = useCallback(
+    async (sessionId, content, attachments) => {
+      const ctrl = new AbortController();
+      abortRef.current = ctrl;
+      const assistantId = createId("a");
+      streamingMsgIdRef.current = assistantId;
+      const iterator = transport.stream(sessionId, content, {
+        signal: ctrl.signal,
+        attachments,
+        metadata: config.metadata
+      });
+      let peekedEvent = null;
+      dispatch({ type: "STREAM_START", id: assistantId });
+      config.onStreamStart?.(assistantId);
+      log.stream.info("start", { sessionId, assistantId, chars: content.length });
+      const tokenBuffer = createTokenBuffer(
+        (delta) => dispatch({ type: "STREAM_CHUNK", delta })
+      );
+      let chunkCount = 0;
+      let charsReceived = 0;
+      const t0 = performance.now();
+      try {
+        const firstResult = await iterator.next();
+        if (!firstResult.done) {
+          const ev = firstResult.value;
+          if (ev.type === "resume_start") {
+            dispatch({ type: "STREAM_CANCEL_PLACEHOLDER", id: assistantId });
+            dispatch({ type: "STREAM_RESUME_EXISTING" });
+          } else {
+            peekedEvent = ev;
+          }
+        }
+        if (peekedEvent) handleEvent(peekedEvent);
+        for await (const ev of iterator) {
+          if (ctrl.signal.aborted) break;
+          handleEvent(ev);
+        }
+        tokenBuffer.flush();
+        if (stateRef.current.isStreaming) {
+          dispatch({ type: "STREAM_DONE", id: assistantId });
+        }
+        const finalMsg = stateRef.current.messages.find((m) => m.id === assistantId);
+        if (finalMsg) config.onMessageEnd?.(finalMsg);
+        log.stream.success("done", {
+          assistantId,
+          chunks: chunkCount,
+          chars: charsReceived,
+          elapsedMs: Math.round(performance.now() - t0)
+        });
+      } catch (err) {
+        tokenBuffer.close();
+        if (ctrl.signal.aborted) {
+          const partial = stateRef.current.messages.find((m) => m.id === assistantId)?.content ?? "";
+          dispatch({ type: "STREAM_CANCELLED", id: assistantId, partialText: partial });
+          log.stream.warn("cancelled", { assistantId, partialChars: partial.length });
+          return;
+        }
+        const e = err instanceof Error ? err : new Error(String(err));
+        lastErrorRef.current = e;
+        dispatch({ type: "STREAM_ERROR", id: assistantId, message: e.message });
+        config.onError?.(e);
+        log.error.error("stream failed", { assistantId, message: e.message });
+      } finally {
+        tokenBuffer.close();
+        if (abortRef.current === ctrl) abortRef.current = null;
+        streamingMsgIdRef.current = null;
+      }
+      function handleEvent(ev) {
+        switch (ev.type) {
+          case "message_start":
+            ev.messageId;
+            log.stream.debug("message_start", { messageId: ev.messageId });
+            return;
+          case "chunk":
+            tokenBuffer.push(ev.delta);
+            chunkCount += 1;
+            charsReceived += ev.delta.length;
+            return;
+          case "tool_activity":
+            tokenBuffer.flush();
+            dispatch({ type: "STREAM_TOOL_ACTIVITY", tool: ev.tool });
+            log.tools.debug("activity", { tool: ev.tool, status: ev.status });
+            return;
+          case "tool_call_start": {
+            tokenBuffer.flush();
+            const toolCall = {
+              id: ev.toolId,
+              name: ev.name,
+              input: ev.input,
+              status: "running",
+              startedAt: Date.now(),
+              sourceHostname: ev.sourceHostname
+            };
+            dispatch({
+              type: "TOOL_CALL_START",
+              messageId: assistantId,
+              toolCall
+            });
+            log.tools.info("call_start", { toolId: ev.toolId, name: ev.name });
+            return;
+          }
+          case "tool_call_delta":
+            dispatch({
+              type: "TOOL_CALL_DELTA",
+              messageId: assistantId,
+              toolId: ev.toolId,
+              delta: ev.delta
+            });
+            return;
+          case "tool_call_end":
+            dispatch({
+              type: "TOOL_CALL_END",
+              messageId: assistantId,
+              toolId: ev.toolId,
+              output: ev.output,
+              status: ev.status
+            });
+            log.tools.info("call_end", { toolId: ev.toolId, status: ev.status });
+            return;
+          case "message_end":
+            tokenBuffer.flush();
+            dispatch({
+              type: "STREAM_DONE",
+              id: assistantId,
+              tokensIn: ev.tokensIn,
+              tokensOut: ev.tokensOut,
+              sources: ev.sources
+            });
+            log.stream.debug("message_end", {
+              tokensIn: ev.tokensIn,
+              tokensOut: ev.tokensOut,
+              sources: ev.sources?.length ?? 0
+            });
+            return;
+          case "error":
+            tokenBuffer.flush();
+            dispatch({
+              type: "STREAM_ERROR",
+              id: assistantId,
+              message: ev.message
+            });
+            log.error.error("stream event error", { code: ev.code, message: ev.message });
+            return;
+        }
+      }
+      __name(handleEvent, "handleEvent");
+    },
+    [transport, config]
+  );
+  const consumeBuffered = useCallback(
+    async (sessionId, content, attachments) => {
+      const ctrl = new AbortController();
+      abortRef.current = ctrl;
+      try {
+        const reply = await transport.send(sessionId, content, {
+          signal: ctrl.signal,
+          attachments,
+          metadata: config.metadata
+        });
+        const placeholderId = createId("a");
+        dispatch({ type: "STREAM_START", id: placeholderId });
+        config.onStreamStart?.(placeholderId);
+        dispatch({ type: "STREAM_CHUNK", delta: reply.content });
+        dispatch({ type: "STREAM_DONE", id: placeholderId });
+        config.onMessageEnd?.(reply);
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        lastErrorRef.current = e;
+        dispatch({ type: "STREAM_ERROR", message: e.message });
+        config.onError?.(e);
+      } finally {
+        if (abortRef.current === ctrl) abortRef.current = null;
+      }
+    },
+    [transport, config]
+  );
+  const sendMessage = useCallback(
+    async (content, attachments) => {
+      log.lifecycle.info("sendMessage", {
+        chars: content.length,
+        attachments: attachments?.length ?? 0,
+        hasSession: !!stateRef.current.sessionId
+      });
+      const sessionId = await awaitSession();
+      if (!sessionId) {
+        const e = new Error("No active session");
+        lastErrorRef.current = e;
+        dispatch({ type: "ERROR_SET", error: e.message });
+        config.onError?.(e);
+        log.error.error("sendMessage aborted: no session");
+        return;
+      }
+      if (!content.trim() && !(attachments && attachments.length > 0)) {
+        log.lifecycle.debug("sendMessage skipped (empty)");
+        return;
+      }
+      if (stateRef.current.isStreaming) {
+        log.lifecycle.debug("sendMessage skipped (already streaming)");
+        return;
+      }
+      const userMsg = {
+        id: createId("u"),
+        role: "user",
+        content,
+        createdAt: Date.now(),
+        attachments,
+        sender: config.userPersona
+      };
+      dispatch({ type: "MESSAGE_USER_ADD", message: userMsg });
+      config.onMessageSent?.(userMsg);
+      let outbound = content;
+      if (config.onBeforeSend) {
+        try {
+          outbound = await config.onBeforeSend(content);
+        } catch (err) {
+          log.error.error("onBeforeSend threw \u2014 falling back to original content", err);
+        }
+      }
+      if (streaming) {
+        await consumeStream(sessionId, outbound, attachments);
+      } else {
+        await consumeBuffered(sessionId, outbound, attachments);
+      }
+    },
+    [streaming, consumeStream, consumeBuffered, config, awaitSession, log]
+  );
+  const cancelStream = useCallback(() => {
+    abortRef.current?.abort();
+  }, []);
+  const regenerate = useCallback(
+    async (messageId) => {
+      log.lifecycle.info("regenerate", { messageId: messageId ?? "(last)" });
+      const messages = stateRef.current.messages;
+      let targetUserIdx = -1;
+      if (messageId) {
+        const idx = messages.findIndex((m) => m.id === messageId);
+        if (idx !== -1) {
+          targetUserIdx = messages[idx].role === "user" ? idx : findPreviousUserIndex(messages, idx);
+        }
+      } else {
+        targetUserIdx = findLastUserIndex(messages);
+      }
+      if (targetUserIdx === -1) return;
+      const userMsg = messages[targetUserIdx];
+      for (let i = messages.length - 1; i > targetUserIdx; i -= 1) {
+        dispatch({ type: "MESSAGE_DELETE", id: messages[i].id });
+      }
+      const sessionId = await awaitSession();
+      if (!sessionId) return;
+      if (streaming) {
+        await consumeStream(sessionId, userMsg.content, userMsg.attachments);
+      } else {
+        await consumeBuffered(sessionId, userMsg.content, userMsg.attachments);
+      }
+    },
+    [streaming, consumeStream, consumeBuffered, awaitSession]
+  );
+  const editMessage = useCallback(
+    async (id, content) => {
+      dispatch({ type: "MESSAGE_EDIT", id, content });
+      const msg = stateRef.current.messages.find((m) => m.id === id);
+      if (msg?.role === "user") {
+        await regenerate(id);
+      }
+    },
+    [regenerate]
+  );
+  const deleteMessage = useCallback((id) => {
+    dispatch({ type: "MESSAGE_DELETE", id });
+  }, []);
+  const injectMessage = useCallback(
+    (message, position) => {
+      dispatch({ type: "MESSAGE_INJECT", message, position });
+    },
+    []
+  );
+  const updateMessage = useCallback(
+    (id, patch) => {
+      dispatch({ type: "MESSAGE_PATCH", id, patch });
+    },
+    []
+  );
+  const clearMessages = useCallback(() => {
+    abortRef.current?.abort();
+    dispatch({ type: "MESSAGES_CLEAR" });
+  }, []);
+  const loadMore = useCallback(async () => {
+    const sessionId = stateRef.current.sessionId;
+    if (!sessionId) return;
+    if (stateRef.current.isLoadingMore || !stateRef.current.hasMore) return;
+    dispatch({ type: "HISTORY_MORE_START" });
+    try {
+      const page = await transport.loadHistory(
+        sessionId,
+        stateRef.current.oldestCursor,
+        pageSize
+      );
+      dispatch({
+        type: "HISTORY_MORE_DONE",
+        messages: page.messages,
+        hasMore: page.hasMore,
+        cursor: page.nextCursor
+      });
+    } catch (err) {
+      const e = err instanceof Error ? err : new Error(String(err));
+      lastErrorRef.current = e;
+      dispatch({ type: "ERROR_SET", error: e.message });
+      config.onError?.(e);
+    }
+  }, [transport, pageSize, config]);
+  const newSession = useCallback(async () => {
+    log.lifecycle.info("newSession", { previous: stateRef.current.sessionId });
+    abortRef.current?.abort();
+    const previous = stateRef.current.sessionId;
+    if (previous) {
+      try {
+        await transport.closeSession(previous);
+      } catch {
+      }
+    }
+    dispatch({ type: "MESSAGES_CLEAR" });
+    try {
+      const info = await transport.createSession({ metadata: config.metadata });
+      dispatch({
+        type: "SESSION_SET",
+        sessionId: info.sessionId,
+        messages: info.messages ?? [],
+        hasMore: info.hasMore ?? false,
+        cursor: info.cursor ?? null
+      });
+      log.lifecycle.success("newSession ok", { sessionId: info.sessionId });
+    } catch (err) {
+      const e = err instanceof Error ? err : new Error(String(err));
+      lastErrorRef.current = e;
+      dispatch({ type: "ERROR_SET", error: e.message });
+      config.onError?.(e);
+      log.error.error("newSession failed", { message: e.message });
+    }
+  }, [transport, config]);
+  return {
+    ...state,
+    sendMessage,
+    cancelStream,
+    regenerate,
+    editMessage,
+    deleteMessage,
+    clearMessages,
+    loadMore,
+    newSession,
+    lastError: lastErrorRef.current,
+    injectMessage,
+    updateMessage
+  };
+}
+__name(useChat, "useChat");
+function findLastUserIndex(messages) {
+  for (let i = messages.length - 1; i >= 0; i -= 1) {
+    if (messages[i].role === "user") return i;
+  }
+  return -1;
+}
+__name(findLastUserIndex, "findLastUserIndex");
+function findPreviousUserIndex(messages, from) {
+  for (let i = from - 1; i >= 0; i -= 1) {
+    if (messages[i].role === "user") return i;
+  }
+  return -1;
+}
+__name(findPreviousUserIndex, "findPreviousUserIndex");
+var DEFAULT_MOBILE_QUERY = "(max-width: 640px)";
+function useChatLayout(config = {}) {
+  const {
+    defaultMode = "closed",
+    storageKey = STORAGE_KEYS.mode,
+    sidebarStorageKey = STORAGE_KEYS.sidebarWidth,
+    reserveCssVar = CSS_VARS.reserve,
+    defaultSidebarWidth = DEFAULT_SIDEBAR.width,
+    minSidebarWidth = DEFAULT_SIDEBAR.min,
+    maxSidebarWidth = DEFAULT_SIDEBAR.max,
+    mobileQuery = DEFAULT_MOBILE_QUERY
+  } = config;
+  const [mode, setMode] = useLocalStorage(storageKey, defaultMode);
+  const [sidebarWidthRaw, setSidebarWidthRaw] = useLocalStorage(
+    sidebarStorageKey,
+    defaultSidebarWidth
+  );
+  const isMobile = useMediaQuery(mobileQuery);
+  const setSidebarWidth = useCallback(
+    (w) => {
+      const clamped = Math.max(minSidebarWidth, Math.min(maxSidebarWidth, w));
+      setSidebarWidthRaw(clamped);
+    },
+    [setSidebarWidthRaw, minSidebarWidth, maxSidebarWidth]
+  );
+  const [previousOpenMode, setPreviousOpenMode] = useState(
+    mode === "closed" ? "embedded" : mode
+  );
+  useEffect(() => {
+    if (mode !== "closed") setPreviousOpenMode(mode);
+  }, [mode]);
+  const open = useCallback(() => {
+    setMode(previousOpenMode === "closed" ? "embedded" : previousOpenMode);
+  }, [setMode, previousOpenMode]);
+  const close = useCallback(() => setMode("closed"), [setMode]);
+  const toggle = useCallback(() => {
+    setMode(mode === "closed" ? previousOpenMode : "closed");
+  }, [setMode, mode, previousOpenMode]);
+  const effectiveMode = useMemo(() => {
+    if (mode === "closed") return "closed";
+    if (isMobile && (mode === "sidebar" || mode === "floating")) return "fullscreen";
+    return mode;
+  }, [mode, isMobile]);
+  useEffect(() => {
+    if (typeof document === "undefined") return;
+    const root = document.documentElement;
+    if (effectiveMode === "sidebar") {
+      root.style.setProperty(reserveCssVar, `${sidebarWidthRaw}px`);
+    } else {
+      root.style.removeProperty(reserveCssVar);
+    }
+    return () => {
+      root.style.removeProperty(reserveCssVar);
+    };
+  }, [effectiveMode, sidebarWidthRaw, reserveCssVar]);
+  return {
+    mode,
+    setMode,
+    open,
+    close,
+    toggle,
+    sidebarWidth: sidebarWidthRaw,
+    setSidebarWidth,
+    isMobile,
+    effectiveMode
+  };
+}
+__name(useChatLayout, "useChatLayout");
+
+// src/tools/Chat/core/audio/sounds/sent.mp3
+var sent_default = "data:audio/mpeg;base64,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";
+
+// src/tools/Chat/core/audio/sounds/received.mp3
+var received_default = "data:audio/mpeg;base64,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";
+
+// src/tools/Chat/core/audio/sounds/start.mp3
+var start_default = "data:audio/mpeg;base64,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";
+
+// src/tools/Chat/core/audio/sounds/error.mp3
+var error_default = "data:audio/mpeg;base64,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";
+
+// src/tools/Chat/core/audio/sounds/mention.mp3
+var mention_default = "data:audio/mpeg;base64,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";
+
+// src/tools/Chat/core/audio/sounds/notification.mp3
+var notification_default = "data:audio/mpeg;base64,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";
+
+// src/tools/Chat/core/audio/defaults.ts
+var DEFAULT_CHAT_SOUNDS = {
+  messageSent: sent_default,
+  messageReceived: received_default,
+  streamStart: start_default,
+  error: error_default,
+  mention: mention_default,
+  notification: notification_default
+};
+
+// src/tools/Chat/hooks/useChatAudio.ts
+var STORAGE_KEY = "djangocfg-chat-audio:prefs";
+var DEFAULT_EVENT_VOLUMES = {
+  error: 0.25,
+  mention: 1,
+  messageSent: 0.5,
+  messageReceived: 0.7,
+  streamStart: 0.3,
+  notification: 0.9
+};
+function useChatAudio(config = {}) {
+  const resolvedSounds = config.sounds === void 0 && !config.silenced ? DEFAULT_CHAT_SOUNDS : config.sounds;
+  const api = useNotificationSounds({
+    storageKey: STORAGE_KEY,
+    sounds: resolvedSounds,
+    volume: config.volume,
+    eventVolumes: config.eventVolumes ?? DEFAULT_EVENT_VOLUMES,
+    muted: config.muted,
+    shouldPlay: config.shouldPlay,
+    respectReducedMotion: config.respectReducedMotion,
+    respectReducedData: config.respectReducedData,
+    muteWhenHidden: config.muteWhenHidden,
+    silenced: config.silenced,
+    onSoundEvent: config.onSoundEvent
+  });
+  return {
+    play: api.play,
+    preload: api.preload,
+    unlock: api.unlock,
+    isUnlocked: api.isUnlocked,
+    muted: api.muted,
+    setMuted: api.setMuted,
+    toggleMute: api.toggleMute,
+    volume: api.volume,
+    setVolume: api.setVolume,
+    isEventEnabled: api.isEventEnabled,
+    setEventEnabled: api.setEventEnabled,
+    isSilent: api.isSilent
+  };
+}
+__name(useChatAudio, "useChatAudio");
+var Ctx = createContext(null);
+function ChatProvider({
+  transport,
+  config = {},
+  initialSessionId,
+  autoCreateSession,
+  streaming,
+  audio,
+  debug,
+  onBeforeSend,
+  children
+}) {
+  const audioApi = useChatAudio(audio ?? {});
+  const audioRef = useRef(audioApi);
+  audioRef.current = audioApi;
+  const onMessageSent = useCallback(() => audioRef.current.play("messageSent"), []);
+  const onMessageEnd = useCallback(() => audioRef.current.play("messageReceived"), []);
+  const onStreamStart = useCallback(() => audioRef.current.play("streamStart"), []);
+  const onError = useCallback(() => audioRef.current.play("error"), []);
+  const chat = useChat({
+    transport,
+    initialSessionId,
+    autoCreateSession,
+    streaming,
+    debug,
+    metadata: {
+      locale: config.locale ?? config.prefs?.locale,
+      slug: config.slug
+    },
+    userPersona: config.user,
+    onMessageSent,
+    onMessageEnd,
+    onStreamStart,
+    onError,
+    onBeforeSend
+  });
+  const layout = useChatLayout({ defaultMode: "embedded" });
+  const rootRef = useRef(null);
+  useEffect(() => {
+    if (audioApi.isUnlocked) return;
+    const root = rootRef.current;
+    if (!root) return;
+    const handler = /* @__PURE__ */ __name(() => {
+      audioApi.unlock();
+    }, "handler");
+    root.addEventListener("pointerdown", handler, { once: true, capture: true });
+    root.addEventListener("keydown", handler, { once: true, capture: true });
+    return () => {
+      root.removeEventListener("pointerdown", handler, { capture: true });
+      root.removeEventListener("keydown", handler, { capture: true });
+    };
+  }, [audioApi]);
+  const labels = useMemo(
+    () => ({ ...DEFAULT_LABELS, ...config.labels ?? {} }),
+    [config.labels]
+  );
+  const hasAudio = useMemo(() => {
+    const sounds = audio?.sounds;
+    if (!sounds) return false;
+    return Object.values(sounds).some(
+      (v) => typeof v === "string" && v.length > 0
+    );
+  }, [audio]);
+  const [composer, setComposer] = useState(null);
+  const registerComposer = useCallback((handle) => {
+    setComposer(handle);
+  }, []);
+  const value = useMemo(
+    () => ({ ...chat, layout, config, labels, audio: audioApi, hasAudio, composer, registerComposer }),
+    [chat, layout, config, labels, audioApi, hasAudio, composer, registerComposer]
+  );
+  return /* @__PURE__ */ jsx(Ctx.Provider, { value, children: /* @__PURE__ */ jsx("div", { ref: rootRef, style: { display: "contents" }, children }) });
+}
+__name(ChatProvider, "ChatProvider");
+function useChatContext() {
+  const v = useContext(Ctx);
+  if (!v) throw new Error("useChatContext must be used inside <ChatProvider>");
+  return v;
+}
+__name(useChatContext, "useChatContext");
+function useChatContextOptional() {
+  return useContext(Ctx);
+}
+__name(useChatContextOptional, "useChatContextOptional");
+function useAutoFocusOnStreamEnd(options = {}) {
+  const { isStreaming: isStreamingProp, targetRef, enabled = true, delayMs = 0 } = options;
+  const ctx = useChatContextOptional();
+  const isStreaming = isStreamingProp ?? ctx?.isStreaming ?? false;
+  const composerHandleRef = useRef(null);
+  composerHandleRef.current = ctx?.composer ?? null;
+  const prevStreamingRef = useRef(isStreaming);
+  useEffect(() => {
+    const wasStreaming = prevStreamingRef.current;
+    prevStreamingRef.current = isStreaming;
+    if (!enabled) return;
+    if (!(wasStreaming && !isStreaming)) return;
+    const focusNow = /* @__PURE__ */ __name(() => {
+      const explicit = targetRef?.current;
+      const target = explicit ?? composerHandleRef.current;
+      target?.focus();
+    }, "focusNow");
+    if (delayMs > 0) {
+      const id = window.setTimeout(focusNow, delayMs);
+      return () => window.clearTimeout(id);
+    }
+    const raf = requestAnimationFrame(focusNow);
+    return () => cancelAnimationFrame(raf);
+  }, [isStreaming, enabled, delayMs, targetRef]);
+}
+__name(useAutoFocusOnStreamEnd, "useAutoFocusOnStreamEnd");
+function useRegisterComposer(handle) {
+  const ctx = useChatContextOptional();
+  const register = ctx?.registerComposer;
+  const focus = handle.focus;
+  const moveCursorToEnd = handle.moveCursorToEnd;
+  useEffect(() => {
+    if (!register) return;
+    register({ focus, moveCursorToEnd });
+    return () => register(null);
+  }, [register, focus, moveCursorToEnd]);
+}
+__name(useRegisterComposer, "useRegisterComposer");
+
+// src/tools/Chat/utils/sanitizeDraft.ts
+function sanitizeDraft(input) {
+  if (!input) return "";
+  let s = input.replace(/[​‌‍]/g, "");
+  s = s.replace(/\r\n?/g, "\n");
+  s = s.trim();
+  return s;
+}
+__name(sanitizeDraft, "sanitizeDraft");
+function isSubmittableDraft(input) {
+  return sanitizeDraft(input).length > 0;
+}
+__name(isSubmittableDraft, "isSubmittableDraft");
+
+// src/tools/Chat/hooks/useChatComposer.ts
+var MAX_TEXTAREA_HEIGHT = 240;
+function useChatComposer(options) {
+  const {
+    onSubmit,
+    initialValue = "",
+    maxLength = LIMITS.messageMaxLength,
+    maxAttachments = LIMITS.attachmentsMax,
+    disabled = false,
+    submitOn = "enter",
+    history = { enabled: true, size: LIMITS.composerHistorySize },
+    onPasteFiles,
+    persistKey,
+    preserveExactValue = false
+  } = options;
+  const initialFromStorage = (() => {
+    if (!persistKey || typeof window === "undefined") return initialValue;
+    try {
+      const stored = window.sessionStorage.getItem(`chat:draft:${persistKey}`);
+      return stored && stored.length > 0 ? stored : initialValue;
+    } catch {
+      return initialValue;
+    }
+  })();
+  const [value, setValueState] = useState(initialFromStorage);
+  useEffect(() => {
+    if (!persistKey || typeof window === "undefined") return;
+    try {
+      const k = `chat:draft:${persistKey}`;
+      if (value.length > 0) window.sessionStorage.setItem(k, value);
+      else window.sessionStorage.removeItem(k);
+    } catch {
+    }
+  }, [value, persistKey]);
+  const [attachments, setAttachments] = useState([]);
+  const [isSubmitting, setIsSubmitting] = useState(false);
+  const textareaRef = useRef(null);
+  const historyRef = useRef({ items: [], index: -1 });
+  const setValue = useCallback(
+    (next) => {
+      setValueState(next.length > maxLength ? next.slice(0, maxLength) : next);
+    },
+    [maxLength]
+  );
+  useEffect(() => {
+    const el = textareaRef.current;
+    if (!el) return;
+    el.style.height = "auto";
+    el.style.height = `${Math.min(el.scrollHeight, MAX_TEXTAREA_HEIGHT)}px`;
+  }, [value]);
+  const reset = useCallback(() => {
+    setValueState("");
+    setAttachments([]);
+    historyRef.current.index = -1;
+  }, []);
+  const focus = useCallback(() => {
+    requestAnimationFrame(() => textareaRef.current?.focus());
+  }, []);
+  const submit = useCallback(async () => {
+    const cleaned = preserveExactValue ? value : sanitizeDraft(value);
+    if (!cleaned && attachments.length === 0 || isSubmitting || disabled) return;
+    setIsSubmitting(true);
+    try {
+      if (history.enabled !== false && cleaned) {
+        const buf = historyRef.current.items;
+        if (buf[buf.length - 1] !== cleaned) {
+          buf.push(cleaned);
+          if (buf.length > (history.size ?? LIMITS.composerHistorySize)) buf.shift();
+        }
+        historyRef.current.index = -1;
+      }
+      const snapshot = [...attachments];
+      reset();
+      await onSubmit(cleaned, snapshot);
+    } finally {
+      setIsSubmitting(false);
+    }
+  }, [value, attachments, isSubmitting, disabled, history, onSubmit, reset, preserveExactValue]);
+  const addAttachment = useCallback(
+    (a) => {
+      setAttachments((prev) => {
+        if (prev.some((p) => p.id === a.id)) {
+          return prev.map((p) => p.id === a.id ? a : p);
+        }
+        if (prev.length >= maxAttachments) return prev;
+        return [...prev, a];
+      });
+    },
+    [maxAttachments]
+  );
+  const removeAttachment = useCallback((id) => {
+    setAttachments((prev) => prev.filter((a) => a.id !== id));
+  }, []);
+  const recallPrevious = useCallback(() => {
+    const { items } = historyRef.current;
+    if (!items.length) return;
+    const next = historyRef.current.index < 0 ? items.length - 1 : Math.max(0, historyRef.current.index - 1);
+    historyRef.current.index = next;
+    setValueState(items[next]);
+  }, []);
+  const recallNext = useCallback(() => {
+    const { items } = historyRef.current;
+    if (!items.length || historyRef.current.index < 0) return;
+    const next = historyRef.current.index + 1;
+    if (next >= items.length) {
+      historyRef.current.index = -1;
+      setValueState("");
+      return;
+    }
+    historyRef.current.index = next;
+    setValueState(items[next]);
+  }, []);
+  const onChange = useCallback(
+    (e) => {
+      setValue(e.target.value);
+    },
+    [setValue]
+  );
+  const onKeyDown = useCallback(
+    (e) => {
+      if (e.key === "Enter") {
+        const isCmd = e.metaKey || e.ctrlKey;
+        const shouldSend = submitOn === "cmd+enter" ? isCmd : !e.shiftKey;
+        if (shouldSend) {
+          e.preventDefault();
+          void submit();
+        }
+        return;
+      }
+      if (history.enabled !== false && value === "" && attachments.length === 0) {
+        if (e.key === "ArrowUp") {
+          e.preventDefault();
+          recallPrevious();
+        } else if (e.key === "ArrowDown" && historyRef.current.index >= 0) {
+          e.preventDefault();
+          recallNext();
+        }
+      }
+    },
+    [submitOn, submit, history, value, attachments.length, recallPrevious, recallNext]
+  );
+  const onPaste = useCallback(
+    (e) => {
+      const files = Array.from(e.clipboardData?.files ?? []);
+      if (files.length && onPasteFiles) {
+        e.preventDefault();
+        onPasteFiles(files);
+      }
+    },
+    [onPasteFiles]
+  );
+  const canSubmit = !disabled && !isSubmitting && ((preserveExactValue ? value.trim().length : sanitizeDraft(value).length) > 0 || attachments.length > 0);
+  return {
+    value,
+    setValue,
+    attachments,
+    addAttachment,
+    removeAttachment,
+    isSubmitting,
+    canSubmit,
+    submit,
+    reset,
+    focus,
+    textareaRef,
+    textareaProps: {
+      ref: textareaRef,
+      value,
+      disabled,
+      onChange,
+      onKeyDown,
+      onPaste
+    },
+    recallPrevious,
+    recallNext
+  };
+}
+__name(useChatComposer, "useChatComposer");
+function useFocusOnEmptyClick(options = {}) {
+  const { targetRef, enabled = true, skipWhileStreaming = true } = options;
+  const ctx = useChatContextOptional();
+  const composerHandleRef = useRef(null);
+  composerHandleRef.current = ctx?.composer ?? null;
+  const isStreamingRef = useRef(false);
+  isStreamingRef.current = ctx?.isStreaming ?? false;
+  return useCallback(
+    (event) => {
+      if (!enabled) return;
+      if (skipWhileStreaming && isStreamingRef.current) return;
+      const pointerType = event.nativeEvent.pointerType;
+      if (pointerType && pointerType !== "mouse") return;
+      const selection = typeof window !== "undefined" ? window.getSelection?.() : null;
+      if (selection && !selection.isCollapsed && selection.toString().length > 0) {
+        return;
+      }
+      const target = event.target;
+      if (!target) return;
+      if (isInteractive(target)) return;
+      const explicit = targetRef?.current;
+      if (explicit) {
+        explicit.focus?.();
+        return;
+      }
+      composerHandleRef.current?.focus?.();
+    },
+    [enabled, skipWhileStreaming, targetRef]
+  );
+}
+__name(useFocusOnEmptyClick, "useFocusOnEmptyClick");
+var INTERACTIVE_SELECTORS = [
+  "a[href]",
+  "button",
+  "input",
+  "textarea",
+  "select",
+  "label",
+  "summary",
+  '[role="button"]',
+  '[role="link"]',
+  '[role="menuitem"]',
+  '[role="tab"]',
+  '[contenteditable]:not([contenteditable="false"])',
+  "[data-no-autofocus]"
+].join(",");
+function isInteractive(el) {
+  if (!el) return false;
+  return !!el.closest(INTERACTIVE_SELECTORS);
+}
+__name(isInteractive, "isInteractive");
+function useChatBubbleStyles(role, isError) {
+  return useMemo(() => {
+    const isUser = role === "user";
+    const variant = isUser ? "user" : isError ? "error" : "assistant";
+    return {
+      surface: BUBBLE_SURFACE[variant],
+      anchor: isUser ? ANCHOR.user : ANCHOR.assistant,
+      toggle: isUser ? TOGGLE.user : TOGGLE.assistant
+    };
+  }, [role, isError]);
+}
+__name(useChatBubbleStyles, "useChatBubbleStyles");
+function useChatRoleStyles(isUser) {
+  return useMemo(
+    () => ({
+      anchor: isUser ? ANCHOR.user : ANCHOR.assistant,
+      toggle: isUser ? TOGGLE.user : TOGGLE.assistant
+    }),
+    [isUser]
+  );
+}
+__name(useChatRoleStyles, "useChatRoleStyles");
+function useChatDestructiveStyles() {
+  return DESTRUCTIVE_STYLES;
+}
+__name(useChatDestructiveStyles, "useChatDestructiveStyles");
+var DESTRUCTIVE_STYLES = {
+  banner: DESTRUCTIVE_SURFACE.banner,
+  hover: DESTRUCTIVE_SURFACE.hover,
+  hoverStrong: DESTRUCTIVE_SURFACE.hoverStrong,
+  text: DESTRUCTIVE_SURFACE.text,
+  menuItem: DESTRUCTIVE_SURFACE.menuItem,
+  toolErrorText: TOOL_CALL.errorText
+};
+function AttachmentsGrid({
+  attachments,
+  maxVisible,
+  onClick,
+  onRemove,
+  isInComposer = false,
+  layout = "wrap",
+  className
+}) {
+  if (!attachments?.length) return null;
+  const visible = maxVisible ? attachments.slice(0, maxVisible) : attachments;
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: cn(
+        layout === "grid" ? "grid grid-cols-3 gap-2" : "flex flex-wrap gap-2",
+        className
+      ),
+      children: visible.map((a) => /* @__PURE__ */ jsx(
+        AttachmentTile,
+        {
+          attachment: a,
+          isInComposer,
+          onClick: onClick ? () => onClick(a) : void 0,
+          onRemove: onRemove ? () => onRemove(a) : void 0
+        },
+        a.id
+      ))
+    }
+  );
+}
+__name(AttachmentsGrid, "AttachmentsGrid");
+function AttachmentsList({
+  attachments,
+  maxVisible,
+  onClick,
+  onRemove,
+  renderers,
+  isInComposer = false,
+  className
+}) {
+  if (!attachments?.length) return null;
+  const visible = maxVisible ? attachments.slice(0, maxVisible) : attachments;
+  return /* @__PURE__ */ jsx("div", { className: cn("flex w-full flex-col gap-2", className), children: visible.map((a) => {
+    const renderer = renderers?.[a.type] ?? renderers?.default;
+    const args = {
+      attachment: a,
+      isInComposer,
+      onClick: onClick ? () => onClick(a) : void 0,
+      onRemove: onRemove ? () => onRemove(a) : void 0
+    };
+    if (renderer) {
+      return /* @__PURE__ */ jsxs("div", { className: "relative w-full min-w-0", children: [
+        renderer(args),
+        args.onRemove ? /* @__PURE__ */ jsx(RemoveBtn, { onRemove: args.onRemove }) : null
+      ] }, a.id);
+    }
+    return /* @__PURE__ */ jsx(AttachmentTile, { ...args }, a.id);
+  }) });
+}
+__name(AttachmentsList, "AttachmentsList");
+function Attachments(props) {
+  const { renderers, layout, ...rest } = props;
+  if (renderers) {
+    return /* @__PURE__ */ jsx(AttachmentsList, { ...rest, renderers });
+  }
+  return /* @__PURE__ */ jsx(AttachmentsGrid, { ...rest, layout: layout === "grid" ? "grid" : "wrap" });
+}
+__name(Attachments, "Attachments");
+function AttachmentTile({ attachment, onClick, onRemove }) {
+  const isImage = attachment.type === "image";
+  const isUploading = attachment.status === "uploading";
+  const inner = isImage ? /* @__PURE__ */ jsx(
+    "img",
+    {
+      src: attachment.thumbnailUrl ?? attachment.url,
+      alt: attachment.name ?? "attachment",
+      className: "h-16 w-16 rounded-md object-cover",
+      loading: "lazy"
+    }
+  ) : /* @__PURE__ */ jsxs("div", { className: "flex max-w-44 items-center gap-2 rounded-md border border-border bg-background/60 px-2 py-1.5 text-xs", children: [
+    /* @__PURE__ */ jsx(File, { "aria-hidden": true, className: "size-4 shrink-0 text-muted-foreground" }),
+    /* @__PURE__ */ jsx("span", { className: "truncate", children: attachment.name ?? "file" })
+  ] });
+  return /* @__PURE__ */ jsxs("div", { className: "relative", children: [
+    onClick ? /* @__PURE__ */ jsx("button", { type: "button", onClick, className: "block", children: inner }) : inner,
+    isUploading ? /* @__PURE__ */ jsx("div", { className: "pointer-events-none absolute inset-0 flex items-center justify-center rounded-md bg-background/70 text-[10px] font-medium", children: attachment.progress != null ? `${Math.round(attachment.progress * 100)}%` : "\u2026" }) : null,
+    onRemove ? /* @__PURE__ */ jsx(RemoveBtn, { onRemove }) : null
+  ] });
+}
+__name(AttachmentTile, "AttachmentTile");
+function RemoveBtn({ onRemove }) {
+  const styles = useChatDestructiveStyles();
+  return /* @__PURE__ */ jsx(
+    "button",
+    {
+      type: "button",
+      "aria-label": "Remove attachment",
+      onClick: onRemove,
+      className: cn(
+        "absolute -right-1.5 -top-1.5 grid h-4 w-4 place-items-center rounded-full border border-border bg-background text-muted-foreground",
+        styles.hoverStrong
+      ),
+      children: /* @__PURE__ */ jsx(X, { "aria-hidden": true, className: "size-2.5" })
+    }
+  );
+}
+__name(RemoveBtn, "RemoveBtn");
+var SIZE_CLASSES = {
+  sm: {
+    slot: "[&>:not(textarea)]:h-8",
+    button: "h-8 w-8",
+    iconButton: "size-3.5",
+    textarea: "min-h-8 max-h-48 px-3 py-1.5",
+    text: "text-sm",
+    padding: "gap-1.5",
+    containerPadding: "px-2 pt-1.5 pb-[max(0.375rem,env(safe-area-inset-bottom))]"
+  },
+  md: {
+    slot: "[&>:not(textarea)]:h-9",
+    button: "h-9 w-9",
+    iconButton: "size-4",
+    textarea: "min-h-9 max-h-60 px-3.5 py-2",
+    text: "text-base sm:text-sm",
+    padding: "gap-1.5",
+    containerPadding: "px-2.5 pt-2 pb-[max(0.5rem,env(safe-area-inset-bottom))]"
+  },
+  lg: {
+    slot: "[&>:not(textarea)]:h-12",
+    button: "h-12 w-12",
+    iconButton: "size-5",
+    textarea: "min-h-12 max-h-72 px-4 py-3",
+    text: "text-base",
+    padding: "gap-2",
+    containerPadding: "px-3.5 pt-3 pb-[max(0.875rem,env(safe-area-inset-bottom))]"
+  }
+};
+var Composer = forwardRef(/* @__PURE__ */ __name(function Composer2({
+  composer,
+  placeholder = "Type a message...",
+  disabled,
+  showAttachmentButton = false,
+  onPickFiles,
+  toolbarStart,
+  toolbarEnd,
+  attachmentTray,
+  className,
+  textareaClassName,
+  size = "md",
+  isStreaming: isStreamingProp,
+  onCancel: onCancelProp
+}, ref) {
+  const ctx = useChatContextOptional();
+  const isStreaming = isStreamingProp ?? ctx?.isStreaming ?? false;
+  const onCancel = onCancelProp ?? ctx?.cancelStream;
+  const isDisabled = disabled ?? isStreaming;
+  const sz = SIZE_CLASSES[size];
+  const register = ctx?.registerComposer;
+  const composerFocus = composer.focus;
+  const composerSetValue = composer.setValue;
+  const textareaRef = composer.textareaRef;
+  const getValueRef = useRef(() => composer.value);
+  getValueRef.current = () => composer.value;
+  useEffect(() => {
+    if (!register) return;
+    register({
+      focus: composerFocus,
+      moveCursorToEnd: /* @__PURE__ */ __name(() => {
+        const el = textareaRef.current;
+        if (!el) return;
+        const end = el.value.length;
+        el.setSelectionRange(end, end);
+      }, "moveCursorToEnd"),
+      getValue: /* @__PURE__ */ __name(() => getValueRef.current(), "getValue"),
+      setValue: composerSetValue
+    });
+    return () => register(null);
+  }, [register, composerFocus, composerSetValue, textareaRef]);
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      ref,
+      className: cn(
+        "border-t border-border bg-background/95",
+        sz.containerPadding,
+        className
+      ),
+      children: [
+        composer.attachments.length > 0 ? /* @__PURE__ */ jsx("div", { className: "mb-1.5", children: attachmentTray ?? /* @__PURE__ */ jsx(
+          Attachments,
+          {
+            attachments: composer.attachments,
+            onRemove: (a) => composer.removeAttachment(a.id)
+          }
+        ) }) : null,
+        /* @__PURE__ */ jsxs("div", { className: cn("flex items-end [&>:not(textarea)]:shrink-0", sz.padding, sz.slot), children: [
+          showAttachmentButton ? /* @__PURE__ */ jsx(
+            Button,
+            {
+              type: "button",
+              variant: "ghost",
+              size: "icon",
+              onClick: onPickFiles,
+              "aria-label": "Attach files",
+              disabled: isDisabled,
+              className: sz.button,
+              children: /* @__PURE__ */ jsx(Paperclip, { "aria-hidden": true, className: sz.iconButton })
+            }
+          ) : null,
+          toolbarStart,
+          /* @__PURE__ */ jsx(
+            Textarea,
+            {
+              ...composer.textareaProps,
+              rows: 1,
+              placeholder,
+              "aria-label": placeholder,
+              "aria-multiline": "true",
+              disabled: isDisabled,
+              className: cn(
+                "flex-1 resize-none rounded-2xl",
+                sz.textarea,
+                sz.text,
+                textareaClassName
+              )
+            }
+          ),
+          toolbarEnd,
+          isStreaming ? /* @__PURE__ */ jsx(
+            Button,
+            {
+              type: "button",
+              variant: "secondary",
+              size: "icon",
+              onClick: onCancel,
+              "aria-label": "Stop",
+              "aria-keyshortcuts": "Escape",
+              className: sz.button,
+              children: /* @__PURE__ */ jsx(Square, { "aria-hidden": true, className: sz.iconButton })
+            }
+          ) : /* @__PURE__ */ jsx(
+            Button,
+            {
+              type: "button",
+              size: "icon",
+              onClick: () => void composer.submit(),
+              disabled: !composer.canSubmit,
+              "aria-label": "Send",
+              "aria-keyshortcuts": "Enter",
+              className: sz.button,
+              children: /* @__PURE__ */ jsx(Send, { "aria-hidden": true, className: sz.iconButton })
+            }
+          )
+        ] })
+      ]
+    }
+  );
+}, "Composer"));
+function EmptyState({
+  greeting,
+  description,
+  suggestions,
+  onPickSuggestion,
+  className
+}) {
+  return /* @__PURE__ */ jsxs("div", { className: cn("flex flex-col items-center gap-3 px-4 py-12 text-center", className), children: [
+    /* @__PURE__ */ jsx("div", { className: "grid size-10 place-items-center rounded-full bg-muted", children: /* @__PURE__ */ jsx(Sparkles, { "aria-hidden": true, className: "size-5 text-muted-foreground" }) }),
+    greeting ? /* @__PURE__ */ jsx("h2", { className: "text-base font-semibold", children: greeting }) : null,
+    description ? /* @__PURE__ */ jsx("p", { className: "max-w-md text-sm text-muted-foreground", children: description }) : null,
+    suggestions?.length ? /* @__PURE__ */ jsx("div", { className: "mt-2 grid w-full max-w-md grid-cols-1 gap-2 sm:grid-cols-2", children: suggestions.map((s) => /* @__PURE__ */ jsx(
+      "button",
+      {
+        type: "button",
+        onClick: () => onPickSuggestion?.(s.prompt),
+        className: "rounded-lg border border-border bg-background/60 px-3 py-2 text-left text-xs hover:bg-accent",
+        children: s.label
+      },
+      s.prompt
+    )) }) : null
+  ] });
+}
+__name(EmptyState, "EmptyState");
+function ErrorBanner({ error, onDismiss, onRetry, className }) {
+  const styles = useChatDestructiveStyles();
+  if (!error) return null;
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      role: "alert",
+      className: cn(
+        "mx-2.5 my-2 flex items-start gap-2 rounded-md px-3 py-2 text-xs",
+        styles.banner,
+        className
+      ),
+      children: [
+        /* @__PURE__ */ jsx(AlertCircle, { "aria-hidden": true, className: "mt-0.5 size-3.5 shrink-0" }),
+        /* @__PURE__ */ jsx("p", { className: "min-w-0 flex-1 break-words", children: error }),
+        onRetry ? /* @__PURE__ */ jsxs(
+          "button",
+          {
+            type: "button",
+            onClick: onRetry,
+            className: cn("inline-flex items-center gap-1 rounded px-1.5 py-0.5", styles.hover),
+            children: [
+              /* @__PURE__ */ jsx(RefreshCw, { "aria-hidden": true, className: "size-3" }),
+              " Retry"
+            ]
+          }
+        ) : null,
+        onDismiss ? /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            "aria-label": "Dismiss",
+            onClick: onDismiss,
+            className: cn("rounded p-0.5", styles.hover),
+            children: /* @__PURE__ */ jsx(X, { "aria-hidden": true, className: "size-3" })
+          }
+        ) : null
+      ]
+    }
+  );
+}
+__name(ErrorBanner, "ErrorBanner");
+function JumpToLatest({ visible, unreadCount = 0, onClick, className }) {
+  if (!visible) return null;
+  return /* @__PURE__ */ jsxs(
+    "button",
+    {
+      type: "button",
+      onClick,
+      "aria-live": "polite",
+      className: cn(
+        "pointer-events-auto inline-flex items-center gap-1.5 rounded-full border border-border bg-background px-3 py-1 text-xs shadow-md hover:bg-accent",
+        className
+      ),
+      children: [
+        /* @__PURE__ */ jsx(ArrowDown, { "aria-hidden": true, className: "size-3.5" }),
+        unreadCount > 0 ? `${unreadCount} new` : "Jump to latest"
+      ]
+    }
+  );
+}
+__name(JumpToLatest, "JumpToLatest");
+
+// src/tools/Chat/core/persona.ts
+var FALLBACK_USER = { name: "You", initials: "You" };
+var FALLBACK_ASSISTANT = { name: "AI", initials: "AI" };
+function resolvePersona(message, user, assistant) {
+  if (message.sender) return message.sender;
+  if (message.role === "user") return user ?? FALLBACK_USER;
+  if (message.role === "assistant") return assistant ?? FALLBACK_ASSISTANT;
+  return { name: message.role };
+}
+__name(resolvePersona, "resolvePersona");
+function deriveInitials(persona, role) {
+  if (persona.initials) return persona.initials;
+  if (persona.name) {
+    const parts = persona.name.trim().split(/\s+/);
+    if (parts.length === 1) return parts[0].slice(0, 2).toUpperCase();
+    return (parts[0][0] + parts[parts.length - 1][0]).toUpperCase();
+  }
+  if (role === "user") return "You";
+  if (role === "assistant") return "AI";
+  return "?";
+}
+__name(deriveInitials, "deriveInitials");
+function StreamingIndicatorRaw({ variant = "dots", label, className }) {
+  return /* @__PURE__ */ jsxs(
+    "span",
+    {
+      className: cn("inline-flex items-center gap-1.5 text-xs text-muted-foreground", className),
+      "aria-live": "off",
+      children: [
+        variant === "dots" ? /* @__PURE__ */ jsxs("span", { className: "inline-flex gap-0.5", "aria-hidden": true, children: [
+          /* @__PURE__ */ jsx("span", { className: "size-1 animate-bounce rounded-full bg-current [animation-delay:-0.2s]" }),
+          /* @__PURE__ */ jsx("span", { className: "size-1 animate-bounce rounded-full bg-current [animation-delay:-0.1s]" }),
+          /* @__PURE__ */ jsx("span", { className: "size-1 animate-bounce rounded-full bg-current" })
+        ] }) : /* @__PURE__ */ jsx("span", { className: "inline-block size-1.5 animate-pulse rounded-full bg-current", "aria-hidden": true }),
+        label ? /* @__PURE__ */ jsx("span", { className: "italic", children: label }) : null
+      ]
+    }
+  );
+}
+__name(StreamingIndicatorRaw, "StreamingIndicatorRaw");
+var StreamingIndicator = memo(StreamingIndicatorRaw);
+function Sources({ sources, layout = "inline", maxVisible, onClick, className }) {
+  if (!sources?.length) return null;
+  const visible = maxVisible ? sources.slice(0, maxVisible) : sources;
+  const remaining = maxVisible ? Math.max(0, sources.length - maxVisible) : 0;
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: cn(
+        "mt-2 flex flex-wrap gap-1.5",
+        layout === "grid" && "grid grid-cols-2",
+        className
+      ),
+      children: [
+        visible.map((s, i) => {
+          const handle = onClick ? () => onClick(s) : void 0;
+          const Tag = handle ? "button" : "a";
+          const props = handle ? { type: "button", onClick: handle } : { href: s.url, target: "_blank", rel: "noopener noreferrer" };
+          return /* @__PURE__ */ jsxs(
+            Tag,
+            {
+              ...props,
+              className: "inline-flex max-w-full items-center gap-1 rounded-md border border-border bg-background/60 px-2 py-1 text-xs text-foreground/80 hover:bg-accent hover:text-foreground",
+              title: s.snippet ?? s.title,
+              children: [
+                /* @__PURE__ */ jsx("span", { className: "truncate", children: s.title || s.url }),
+                /* @__PURE__ */ jsx(ExternalLink, { "aria-hidden": true, className: "size-3 shrink-0 opacity-60" })
+              ]
+            },
+            `${s.url}-${i}`
+          );
+        }),
+        remaining > 0 ? /* @__PURE__ */ jsxs("span", { className: "inline-flex items-center rounded-md border border-dashed border-border px-2 py-1 text-xs text-muted-foreground", children: [
+          "+",
+          remaining
+        ] }) : null
+      ]
+    }
+  );
+}
+__name(Sources, "Sources");
+function ToolCalls({
+  calls,
+  defaultExpanded = false,
+  expandWhileStreaming = true,
+  renderInput,
+  renderOutput,
+  renderStreaming,
+  renderPayload,
+  renderAfterCalls,
+  renderToolCall,
+  hideToolCalls = false,
+  className
+}) {
+  if (!calls?.length) return null;
+  return /* @__PURE__ */ jsxs("div", { className: cn("mt-2 space-y-1.5", className), children: [
+    !hideToolCalls && calls.map(
+      (call) => renderToolCall ? /* @__PURE__ */ jsx("div", { children: renderToolCall(call) }, call.id) : /* @__PURE__ */ jsx(
+        ToolCallItem,
+        {
+          call,
+          defaultExpanded,
+          expandWhileStreaming,
+          renderInput,
+          renderOutput,
+          renderStreaming,
+          renderPayload
+        },
+        call.id
+      )
+    ),
+    renderAfterCalls ? renderAfterCalls(calls) : null
+  ] });
+}
+__name(ToolCalls, "ToolCalls");
+var ToolCallItem = memo(/* @__PURE__ */ __name(function ToolCallItem2({
+  call,
+  defaultExpanded,
+  expandWhileStreaming,
+  renderInput,
+  renderOutput,
+  renderStreaming,
+  renderPayload
+}) {
+  const isRunning = call.status === "running";
+  const initialOpen = defaultExpanded || expandWhileStreaming && isRunning;
+  const [open, setOpen] = useState(initialOpen);
+  const userToggledRef = useRef(false);
+  const wasRunningRef = useRef(isRunning);
+  useEffect(() => {
+    if (wasRunningRef.current && !isRunning) {
+      if (!userToggledRef.current && !defaultExpanded) {
+        setOpen(false);
+      }
+    }
+    wasRunningRef.current = isRunning;
+  }, [isRunning, defaultExpanded]);
+  const handleToggle = /* @__PURE__ */ __name(() => {
+    userToggledRef.current = true;
+    setOpen((v) => !v);
+  }, "handleToggle");
+  const Icon = open ? ChevronDown : ChevronRight;
+  const statusColor = call.status === "success" ? "text-emerald-500" : call.status === "error" ? "text-destructive" : call.status === "cancelled" ? "text-muted-foreground" : "text-amber-500";
+  const renderValue = /* @__PURE__ */ __name((value, kind) => {
+    if (kind === "input" && renderInput) return renderInput(value, call);
+    if (kind === "output" && renderOutput) return renderOutput(value, call);
+    if (kind === "streaming" && renderStreaming)
+      return renderStreaming(typeof value === "string" ? value : String(value), call);
+    if (renderPayload) return renderPayload(value, kind, call);
+    return /* @__PURE__ */ jsx(DefaultPayload, { value, kind });
+  }, "renderValue");
+  return /* @__PURE__ */ jsxs("div", { className: "overflow-hidden rounded-md border border-border bg-muted/30", children: [
+    /* @__PURE__ */ jsxs(
+      "button",
+      {
+        type: "button",
+        onClick: handleToggle,
+        "aria-expanded": open,
+        className: "flex w-full items-center gap-2 px-2 py-1.5 text-left text-xs hover:bg-muted/60",
+        children: [
+          /* @__PURE__ */ jsx(Icon, { "aria-hidden": true, className: "size-3 shrink-0 text-muted-foreground" }),
+          isRunning ? /* @__PURE__ */ jsx(Loader2, { "aria-hidden": true, className: "size-3 shrink-0 animate-spin text-amber-500" }) : /* @__PURE__ */ jsx("span", { className: cn("size-2 shrink-0 rounded-full", statusColor.replace("text-", "bg-")) }),
+          /* @__PURE__ */ jsx("span", { className: "font-mono text-foreground", children: call.name }),
+          /* @__PURE__ */ jsx("span", { className: cn("ml-auto", statusColor), children: call.status })
+        ]
+      }
+    ),
+    open ? /* @__PURE__ */ jsxs("div", { className: "space-y-1 border-t border-border px-2 py-1.5 text-[11px]", children: [
+      call.input != null ? renderValue(call.input, "input") : null,
+      call.streamingText != null ? renderValue(call.streamingText, "streaming") : call.output !== void 0 ? renderValue(call.output, "output") : null
+    ] }) : null
+  ] });
+}, "ToolCallItem"), (prev, next) => {
+  const a = prev.call;
+  const b = next.call;
+  return a.id === b.id && a.status === b.status && a.output === b.output && a.streamingText === b.streamingText && prev.defaultExpanded === next.defaultExpanded && prev.expandWhileStreaming === next.expandWhileStreaming && prev.renderInput === next.renderInput && prev.renderOutput === next.renderOutput && prev.renderStreaming === next.renderStreaming && prev.renderPayload === next.renderPayload;
+});
+function DefaultPayload({ value, kind }) {
+  const isStreamingOrString = kind === "streaming" || typeof value === "string";
+  const muted = kind === "input";
+  return /* @__PURE__ */ jsx(
+    "pre",
+    {
+      className: cn(
+        "overflow-auto rounded bg-background/60 p-1.5 font-mono",
+        kind === "input" ? "max-h-32" : "max-h-48",
+        muted ? "text-muted-foreground" : "text-foreground/90"
+      ),
+      children: isStreamingOrString ? String(value) : safeStringify(value)
+    }
+  );
+}
+__name(DefaultPayload, "DefaultPayload");
+function safeStringify(value) {
+  try {
+    return JSON.stringify(value, null, 2);
+  } catch {
+    return String(value);
+  }
+}
+__name(safeStringify, "safeStringify");
+function MessageActionsRaw({
+  role,
+  onCopy,
+  onRegenerate,
+  onEdit,
+  onDelete,
+  hideOn,
+  className
+}) {
+  if (hideOn?.includes(role)) return null;
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: cn(
+        "mt-1 flex items-center gap-0.5 opacity-0 transition-opacity group-hover/msg:opacity-100 focus-within:opacity-100",
+        className
+      ),
+      children: [
+        onCopy ? /* @__PURE__ */ jsx(ActionButton, { onClick: onCopy, label: "Copy", icon: Copy }) : null,
+        onRegenerate && role === "assistant" ? /* @__PURE__ */ jsx(ActionButton, { onClick: onRegenerate, label: "Regenerate", icon: RefreshCw }) : null,
+        onEdit && role === "user" ? /* @__PURE__ */ jsx(ActionButton, { onClick: onEdit, label: "Edit", icon: Pencil }) : null,
+        onDelete ? /* @__PURE__ */ jsx(ActionButton, { onClick: onDelete, label: "Delete", icon: Trash, destructive: true }) : null
+      ]
+    }
+  );
+}
+__name(MessageActionsRaw, "MessageActionsRaw");
+var ActionButton = memo(/* @__PURE__ */ __name(function ActionButton2({
+  onClick,
+  label,
+  icon: Icon,
+  destructive
+}) {
+  const styles = useChatDestructiveStyles();
+  return /* @__PURE__ */ jsx(
+    "button",
+    {
+      type: "button",
+      onClick,
+      "aria-label": label,
+      className: cn(
+        "rounded p-1 text-muted-foreground hover:bg-accent hover:text-foreground",
+        destructive && cn(styles.hover, "hover:text-destructive")
+      ),
+      children: /* @__PURE__ */ jsx(Icon, { "aria-hidden": true, className: "size-3" })
+    }
+  );
+}, "ActionButton"));
+var MessageActions = memo(MessageActionsRaw);
+var MessageBubbleInner = /* @__PURE__ */ __name(({
+  message,
+  isUser: isUserProp,
+  showAvatar = true,
+  avatarSrc,
+  avatarFallback,
+  user,
+  assistant,
+  showTimestamp = false,
+  showActions = true,
+  isCompact = false,
+  className,
+  beforeContent,
+  afterContent,
+  toolCallsRenderer,
+  toolCallsProps,
+  sourcesRenderer,
+  attachmentsRenderer,
+  attachmentRenderers,
+  onAttachmentOpen,
+  onCopy,
+  onRegenerate,
+  onEdit,
+  onDelete,
+  messageActionsExtra,
+  streamingIndicator
+}) => {
+  const isUser = isUserProp ?? message.role === "user";
+  const isStreaming = !!message.isStreaming;
+  const isErr = !!message.isError;
+  const { surface: bubbleSurface } = useChatBubbleStyles(
+    isUser ? "user" : "assistant",
+    isErr
+  );
+  const ctx = useChatContextOptional();
+  const persona = resolvePersona(
+    message,
+    user ?? ctx?.config.user,
+    assistant ?? ctx?.config.assistant
+  );
+  const initials = deriveInitials(persona, message.role);
+  const personaName = persona.name ?? (isUser ? "You" : "Assistant");
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      role: "article",
+      "aria-label": `${personaName} said: ${message.content.slice(0, 80)}`,
+      "aria-busy": isStreaming || void 0,
+      "data-role": message.role,
+      className: cn(
+        "group/msg flex gap-2.5 px-2.5 py-2",
+        isUser ? "flex-row-reverse" : "flex-row",
+        className
+      ),
+      children: [
+        showAvatar ? /* @__PURE__ */ jsxs(
+          Avatar,
+          {
+            className: "size-7 shrink-0",
+            title: persona.description ?? personaName,
+            children: [
+              avatarSrc || persona.avatarUrl ? /* @__PURE__ */ jsx(AvatarImage, { src: avatarSrc ?? persona.avatarUrl, alt: personaName }) : null,
+              /* @__PURE__ */ jsx(AvatarFallback, { className: "text-[10px]", children: avatarFallback ?? initials })
+            ]
+          }
+        ) : null,
+        /* @__PURE__ */ jsxs("div", { className: cn("min-w-0 flex-1", isUser && "flex flex-col items-end"), children: [
+          beforeContent,
+          message.attachments?.length ? attachmentsRenderer ? attachmentsRenderer(message.attachments) : /* @__PURE__ */ jsx("div", { className: "mb-1.5 w-full", children: attachmentRenderers ? /* @__PURE__ */ jsx(
+            AttachmentsList,
+            {
+              attachments: message.attachments,
+              renderers: attachmentRenderers,
+              onClick: onAttachmentOpen,
+              className: isUser ? "items-end" : void 0
+            }
+          ) : /* @__PURE__ */ jsx(
+            AttachmentsGrid,
+            {
+              attachments: message.attachments,
+              onClick: onAttachmentOpen,
+              className: isUser ? "justify-end" : void 0
+            }
+          ) }) : null,
+          /* @__PURE__ */ jsxs(
+            "div",
+            {
+              className: cn(
+                "inline-block max-w-full rounded-2xl px-3.5 py-2 text-sm",
+                bubbleSurface
+              ),
+              children: [
+                isStreaming && message.toolActivity ? /* @__PURE__ */ jsx("div", { className: "mb-1.5", children: streamingIndicator ? streamingIndicator(message) : /* @__PURE__ */ jsx(StreamingIndicator, { label: message.toolActivity }) }) : null,
+                message.content || !isStreaming ? /* @__PURE__ */ jsx(
+                  MarkdownMessage,
+                  {
+                    content: message.content || (isErr ? "*Failed to generate a response.*" : ""),
+                    isUser,
+                    isCompact,
+                    plainText: isStreaming
+                  }
+                ) : streamingIndicator ? streamingIndicator(message) : /* @__PURE__ */ jsx(StreamingIndicator, {})
+              ]
+            }
+          ),
+          message.toolCalls?.length ? toolCallsRenderer ? toolCallsRenderer(message.toolCalls) : /* @__PURE__ */ jsx(ToolCalls, { calls: message.toolCalls, ...toolCallsProps }) : null,
+          message.sources?.length && !isStreaming ? sourcesRenderer ? sourcesRenderer(message.sources) : /* @__PURE__ */ jsx(Sources, { sources: message.sources }) : null,
+          showActions && !isStreaming ? /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-0.5", children: [
+            /* @__PURE__ */ jsx(
+              MessageActions,
+              {
+                role: message.role,
+                onCopy,
+                onRegenerate,
+                onEdit,
+                onDelete
+              }
+            ),
+            messageActionsExtra ? messageActionsExtra(message) : null
+          ] }) : null,
+          showTimestamp ? /* @__PURE__ */ jsx("div", { className: "mt-1 text-[10px] text-muted-foreground", children: new Date(message.createdAt).toLocaleTimeString() }) : null,
+          afterContent
+        ] })
+      ]
+    }
+  );
+}, "MessageBubbleInner");
+var MessageBubble = memo(MessageBubbleInner, (prev, next) => {
+  const a = prev.message;
+  const b = next.message;
+  return a.id === b.id && a.content === b.content && a.isStreaming === b.isStreaming && a.isError === b.isError && (a.version ?? 0) === (b.version ?? 0) && a.toolActivity === b.toolActivity && a.toolCalls === b.toolCalls && a.sources === b.sources && a.attachments === b.attachments;
+});
+MessageBubble.displayName = "MessageBubble";
+var MessageList = forwardRef(/* @__PURE__ */ __name(function MessageList2({
+  messages: messagesProp,
+  renderItem,
+  renderEmpty,
+  isLoadingMore: isLoadingMoreProp,
+  onStartReached,
+  className,
+  itemClassName,
+  noVirtualize = false,
+  defaultItemHeight: _deprecatedDefaultItemHeight,
+  onAtBottomChange,
+  atBottomThreshold = 120,
+  scrollAnchorId
+}, ref) {
+  const ctx = useChatContextOptional();
+  const messages = messagesProp ?? ctx?.messages ?? [];
+  const isLoadingMore = isLoadingMoreProp ?? ctx?.isLoadingMore ?? false;
+  const { copyToClipboard } = useCopy();
+  const virtuosoRef = useRef(null);
+  const scrollerRef = useRef(null);
+  const [isScrollable, setIsScrollable] = useState(false);
+  const lastReportedAtBottomRef = useRef(null);
+  const reportAtBottom = useCallback(
+    (value) => {
+      if (lastReportedAtBottomRef.current === value) return;
+      lastReportedAtBottomRef.current = value;
+      onAtBottomChange?.(value);
+    },
+    [onAtBottomChange]
+  );
+  const didInitialScrollRef = useRef(false);
+  useImperativeHandle(
+    ref,
+    () => ({
+      scrollToBottom: /* @__PURE__ */ __name((smooth = false) => {
+        virtuosoRef.current?.scrollToIndex({
+          index: "LAST",
+          behavior: smooth ? "smooth" : "auto",
+          align: "end"
+        });
+      }, "scrollToBottom"),
+      scrollToIndex: /* @__PURE__ */ __name((index, smooth = false) => {
+        virtuosoRef.current?.scrollToIndex({
+          index,
+          behavior: smooth ? "smooth" : "auto"
+        });
+      }, "scrollToIndex")
+    }),
+    []
+  );
+  const defaultRenderItem = useCallback(
+    (m) => /* @__PURE__ */ jsx("div", { className: itemClassName, children: /* @__PURE__ */ jsx(
+      MessageBubble,
+      {
+        message: m,
+        onCopy: () => void copyToClipboard(m.content),
+        onRegenerate: ctx ? () => void ctx.regenerate(m.id) : void 0,
+        onDelete: ctx ? () => ctx.deleteMessage(m.id) : void 0
+      }
+    ) }),
+    [itemClassName, ctx, copyToClipboard]
+  );
+  const itemRenderer = renderItem ?? defaultRenderItem;
+  useEffect(() => {
+    if (didInitialScrollRef.current) return;
+    if (messages.length === 0) return;
+    didInitialScrollRef.current = true;
+    const id = requestAnimationFrame(() => {
+      virtuosoRef.current?.scrollToIndex({
+        index: "LAST",
+        align: "end",
+        behavior: "auto"
+      });
+    });
+    return () => cancelAnimationFrame(id);
+  }, [messages.length]);
+  useEffect(() => {
+    if (scrollAnchorId == null) return;
+    if (!didInitialScrollRef.current) return;
+    let raf1 = 0;
+    let raf2 = 0;
+    raf1 = requestAnimationFrame(() => {
+      raf2 = requestAnimationFrame(() => {
+        virtuosoRef.current?.scrollToIndex({
+          index: "LAST",
+          align: "end",
+          behavior: "smooth"
+        });
+      });
+    });
+    return () => {
+      cancelAnimationFrame(raf1);
+      cancelAnimationFrame(raf2);
+    };
+  }, [scrollAnchorId]);
+  useEffect(() => {
+    const el = scrollerRef.current;
+    if (!el || el === window || !(el instanceof HTMLElement)) return;
+    const probe = /* @__PURE__ */ __name(() => {
+      const scrollable = el.scrollHeight > el.clientHeight + 1;
+      setIsScrollable(scrollable);
+      if (!scrollable) reportAtBottom(true);
+    }, "probe");
+    probe();
+    const ro = new ResizeObserver(probe);
+    ro.observe(el);
+    return () => ro.disconnect();
+  }, [reportAtBottom, messages.length]);
+  const computeItemKey = useCallback(
+    (index, m) => m?.id ?? index,
+    []
+  );
+  const startReachedHandler = useMemo(() => {
+    if (!onStartReached) return void 0;
+    let inFlight = false;
+    return () => {
+      if (inFlight || isLoadingMore) return;
+      inFlight = true;
+      try {
+        onStartReached();
+      } finally {
+        queueMicrotask(() => {
+          inFlight = false;
+        });
+      }
+    };
+  }, [onStartReached, isLoadingMore]);
+  if (messages.length === 0) {
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        role: "log",
+        "aria-live": "polite",
+        "aria-atomic": "false",
+        className: cn("flex-1 overflow-y-auto", className),
+        children: renderEmpty?.() ?? null
+      }
+    );
+  }
+  if (noVirtualize) {
+    return /* @__PURE__ */ jsxs(
+      "div",
+      {
+        role: "log",
+        "aria-live": "polite",
+        "aria-atomic": "false",
+        className: cn("flex-1 overflow-y-auto", className),
+        children: [
+          isLoadingMore ? /* @__PURE__ */ jsx("div", { className: "flex justify-center py-2", children: /* @__PURE__ */ jsx(Spinner, { className: "size-4 text-muted-foreground" }) }) : null,
+          messages.map((m, i) => /* @__PURE__ */ jsx("div", { children: itemRenderer(m, i) }, m.id ?? i))
+        ]
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx(
+    Virtuoso,
+    {
+      ref: virtuosoRef,
+      role: "log",
+      "aria-live": "polite",
+      "aria-atomic": "false",
+      className: cn("flex-1", className),
+      data: messages,
+      computeItemKey,
+      itemContent: (index, m) => m ? itemRenderer(m, index) : null,
+      initialTopMostItemIndex: messages.length > 0 ? messages.length - 1 : 0,
+      atBottomThreshold,
+      followOutput: (isAtBottom) => isAtBottom ? "auto" : false,
+      scrollerRef: (el) => {
+        scrollerRef.current = el;
+      },
+      atBottomStateChange: (atBottom) => {
+        reportAtBottom(!isScrollable ? true : atBottom);
+      },
+      startReached: startReachedHandler,
+      components: isLoadingMore ? {
+        Header: /* @__PURE__ */ __name(() => /* @__PURE__ */ jsx("div", { className: "flex justify-center py-2", children: /* @__PURE__ */ jsx(Spinner, { className: "size-4 text-muted-foreground" }) }), "Header")
+      } : EMPTY_COMPONENTS
+    }
+  );
+}, "MessageList"));
+var EMPTY_COMPONENTS = {};
+function ChatRoot(props) {
+  const { transport, config, initialSessionId, autoCreateSession, streaming, audio, debug, className, listClassName, ...slots } = props;
+  return /* @__PURE__ */ jsx(
+    ChatProvider,
+    {
+      transport,
+      config,
+      initialSessionId,
+      autoCreateSession,
+      streaming,
+      audio,
+      debug,
+      children: /* @__PURE__ */ jsx(ChatRootShell, { className, listClassName, slots })
+    }
+  );
+}
+__name(ChatRoot, "ChatRoot");
+function ChatRootShell({ className, listClassName, slots }) {
+  const chat = useChatContext();
+  const composer = useChatComposer({
+    onSubmit: /* @__PURE__ */ __name((content, attachments) => chat.sendMessage(content, attachments), "onSubmit"),
+    disabled: chat.isStreaming
+  });
+  const onMessagesMouseUp = useFocusOnEmptyClick({
+    enabled: slots.focusOnEmptyClick !== false
+  });
+  useAutoFocusOnStreamEnd();
+  const listRef = useRef(null);
+  const [isAtBottom, setIsAtBottom] = useState(true);
+  const lastUserMessageId = useMemo(() => {
+    const msgs = chat.messages;
+    for (let i = msgs.length - 1; i >= 0; i -= 1) {
+      if (msgs[i].role === "user") return msgs[i].id;
+    }
+    return null;
+  }, [chat.messages]);
+  const handleStartReached = chat.hasMore && !chat.isLoadingMore ? () => void chat.loadMore() : void 0;
+  const greeting = chat.config.greeting ?? "How can I help?";
+  const description = chat.config.description;
+  const suggestions = chat.config.suggestions;
+  const headerNode = slots.renderHeader ? slots.renderHeader(chat) : slots.header;
+  const emptyNode = slots.empty ?? (slots.renderEmpty ? slots.renderEmpty({ setValue: composer.setValue, focus: composer.focus }) : /* @__PURE__ */ jsx(
+    EmptyState,
+    {
+      greeting,
+      description,
+      suggestions,
+      onPickSuggestion: (prompt) => {
+        composer.setValue(prompt);
+        composer.focus();
+      }
+    }
+  ));
+  const renderItem = slots.renderMessage ?? ((m) => /* @__PURE__ */ jsx(
+    MessageBubble,
+    {
+      message: m,
+      toolCallsProps: slots.toolCallsProps,
+      attachmentRenderers: slots.attachmentRenderers,
+      onAttachmentOpen: slots.onAttachmentOpen,
+      onCopy: () => copy(m.content),
+      onRegenerate: () => void chat.regenerate(m.id),
+      onDelete: () => chat.deleteMessage(m.id)
+    },
+    m.id
+  ));
+  return /* @__PURE__ */ jsxs("div", { className: cn("relative flex h-full min-h-0 flex-col overflow-hidden", className), children: [
+    slots.banner ?? null,
+    headerNode ?? null,
+    /* @__PURE__ */ jsxs("div", { className: "relative flex min-h-0 flex-1 flex-col", onMouseUp: onMessagesMouseUp, children: [
+      /* @__PURE__ */ jsx(
+        ErrorBanner,
+        {
+          error: chat.error,
+          onDismiss: chat.error ? () => chat.clearMessages() : void 0,
+          onRetry: chat.error ? () => void chat.regenerate() : void 0
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        MessageList,
+        {
+          ref: listRef,
+          renderItem,
+          renderEmpty: () => /* @__PURE__ */ jsx(Fragment, { children: emptyNode }),
+          className: listClassName,
+          onStartReached: handleStartReached,
+          onAtBottomChange: setIsAtBottom,
+          scrollAnchorId: lastUserMessageId
+        }
+      ),
+      /* @__PURE__ */ jsx("div", { className: "pointer-events-none absolute inset-x-0 bottom-2 flex justify-center", children: slots.jumpToLatest ?? /* @__PURE__ */ jsx(
+        JumpToLatest,
+        {
+          visible: !isAtBottom,
+          onClick: () => listRef.current?.scrollToBottom(true)
+        }
+      ) })
+    ] }),
+    !slots.hideComposer && /* @__PURE__ */ jsx(
+      Composer,
+      {
+        composer,
+        placeholder: chat.config.placeholder,
+        showAttachmentButton: slots.showAttachmentButton,
+        onPickFiles: slots.onPickFiles,
+        toolbarStart: slots.composerToolbarStart,
+        toolbarEnd: slots.composerToolbarEnd,
+        attachmentTray: slots.composerAttachmentTray,
+        size: slots.composerSize
+      }
+    ),
+    slots.footer ?? null
+  ] });
+}
+__name(ChatRootShell, "ChatRootShell");
+function copy(text) {
+  if (typeof navigator !== "undefined" && navigator.clipboard) {
+    void navigator.clipboard.writeText(text);
+  }
+}
+__name(copy, "copy");
+
+export { Attachments, AttachmentsGrid, AttachmentsList, CHAT_EVENT_NAME, CSS_VARS, ChatProvider, ChatRoot, Composer, DEFAULT_CHAT_SOUNDS, DEFAULT_LABELS, DEFAULT_SIDEBAR, DEFAULT_Z_INDEX, EmptyState, ErrorBanner, HOTKEYS, JumpToLatest, LIMITS, MessageActions, MessageBubble, MessageList, STORAGE_KEYS, Sources, StreamingIndicator, ToolCalls, createId, createTokenBuffer, deriveInitials, getChatLogger, initialState, isSubmittableDraft, reducer, resolvePersona, sanitizeDraft, useAutoFocusOnStreamEnd, useChat, useChatAudio, useChatBubbleStyles, useChatComposer, useChatContext, useChatContextOptional, useChatDestructiveStyles, useChatLayout, useChatRoleStyles, useFocusOnEmptyClick, useRegisterComposer };
+//# sourceMappingURL=chunk-UWVP6LCW.mjs.map
+//# sourceMappingURL=chunk-UWVP6LCW.mjs.map