@xinghunm/ai-chat 0.1.0

package/dist/index.mjs

@@ -0,0 +1,4004 @@
+// src/components/ai-chat/index.tsx
+import styled18 from "@emotion/styled";
+import { ConfigProvider } from "@xinghunm/compass-ui";
+
+// src/components/ai-chat-provider/index.tsx
+import { useRef, useMemo, useState } from "react";
+import axios2 from "axios";
+
+// src/context/chat-context.ts
+import { createContext } from "react";
+var ChatContext = createContext(null);
+
+// src/store/chat-store.ts
+import { createStore } from "zustand/vanilla";
+
+// src/types/index.ts
+var CHAT_AGENT_MODES = ["ask", "plan", "agent"];
+var DEFAULT_CHAT_AGENT_MODE = "agent";
+var DEFAULT_AI_CHAT_LABELS = {
+  sendButton: "Send",
+  stopButton: "Stop",
+  retryButton: "Retry",
+  placeholder: "Ask something...",
+  modeLabelAsk: "Ask",
+  modeLabelPlan: "Plan",
+  modeLabelAgent: "Agent",
+  newChat: "New Chat",
+  emptyStateTitle: "How can I help you?",
+  emptyStateSubtitle: "Start a conversation",
+  attachmentLimitNotice: "Images exceeded the limit. Only the first 10 images were kept.",
+  userRoleLabel: "User",
+  assistantRoleLabel: "Assistant",
+  stoppedResponse: "Response stopped",
+  assistantStreamingAriaLabel: "assistant streaming",
+  networkError: "Network request failed. Please try again.",
+  genericError: "Something went wrong. Please try again."
+};
+
+// src/store/chat-store.ts
+var DEFAULT_CHAT_SESSION_TITLE = "New Chat";
+var IMAGE_MESSAGE_SESSION_TITLE = "Image message";
+var resolveSessionTitleFromMessage = (message) => {
+  const trimmedContent = message.content.trim();
+  if (trimmedContent) {
+    return trimmedContent.slice(0, 30);
+  }
+  if ((message.attachments?.length ?? 0) > 0) {
+    return IMAGE_MESSAGE_SESSION_TITLE;
+  }
+  return DEFAULT_CHAT_SESSION_TITLE;
+};
+var finalizeStreamingMessage = (state, sessionId, status, clearError = false) => {
+  const message = state.streamingMessageBySession[sessionId];
+  const hasRenderableMessagePayload = Boolean(
+    message?.content || message?.blocks?.length || message?.attachments?.length
+  );
+  const nextMessages = [...state.messagesBySession[sessionId] ?? []];
+  if (message && (!status || hasRenderableMessagePayload)) {
+    nextMessages.push({ ...message, status: status ?? message.status });
+  }
+  return {
+    ...state,
+    messagesBySession: {
+      ...state.messagesBySession,
+      [sessionId]: nextMessages
+    },
+    streamingMessageBySession: {
+      ...state.streamingMessageBySession,
+      [sessionId]: void 0
+    },
+    isStreamingBySession: {
+      ...state.isStreamingBySession,
+      [sessionId]: false
+    },
+    isStoppingBySession: {
+      ...state.isStoppingBySession,
+      [sessionId]: false
+    },
+    errorBySession: clearError ? { ...state.errorBySession, [sessionId]: null } : state.errorBySession
+  };
+};
+var createChatStore = (initialState) => createStore((set, get) => ({
+  activeSessionId: null,
+  preferredMode: initialState?.preferredMode ?? DEFAULT_CHAT_AGENT_MODE,
+  sessions: [],
+  messagesBySession: {},
+  streamingMessageBySession: {},
+  isStreamingBySession: {},
+  isStoppingBySession: {},
+  errorBySession: {},
+  // ---- Session management ------------------------------------------------
+  createSession: (session) => {
+    const state = get();
+    const exists = state.sessions.some((s) => s.sessionId === session.sessionId);
+    const nextSession = {
+      ...session,
+      mode: session.mode ?? DEFAULT_CHAT_AGENT_MODE
+    };
+    const nextSessions = exists ? state.sessions : [nextSession, ...state.sessions];
+    const nextMessagesBySession = { ...state.messagesBySession };
+    const nextErrorBySession = { ...state.errorBySession };
+    const nextIsStreamingBySession = { ...state.isStreamingBySession };
+    const nextIsStoppingBySession = { ...state.isStoppingBySession };
+    const sid = session.sessionId;
+    if (nextMessagesBySession[sid] === void 0)
+      nextMessagesBySession[sid] = [];
+    if (nextErrorBySession[sid] === void 0)
+      nextErrorBySession[sid] = null;
+    if (nextIsStreamingBySession[sid] === void 0)
+      nextIsStreamingBySession[sid] = false;
+    if (nextIsStoppingBySession[sid] === void 0)
+      nextIsStoppingBySession[sid] = false;
+    set({
+      sessions: nextSessions,
+      activeSessionId: sid,
+      messagesBySession: nextMessagesBySession,
+      errorBySession: nextErrorBySession,
+      isStreamingBySession: nextIsStreamingBySession,
+      isStoppingBySession: nextIsStoppingBySession
+    });
+  },
+  setActiveSession: (sessionId) => {
+    set({ activeSessionId: sessionId });
+  },
+  replaceSessionId: (previousSessionId, nextSessionId) => {
+    if (!previousSessionId || !nextSessionId || previousSessionId === nextSessionId) {
+      return;
+    }
+    const state = get();
+    const nextSessions = state.sessions.map(
+      (s) => s.sessionId === previousSessionId ? { ...s, sessionId: nextSessionId } : s
+    );
+    const nextMessagesBySession = { ...state.messagesBySession };
+    if (previousSessionId in nextMessagesBySession) {
+      nextMessagesBySession[nextSessionId] = (nextMessagesBySession[previousSessionId] ?? []).map(
+        (m) => ({ ...m, sessionId: nextSessionId })
+      );
+      delete nextMessagesBySession[previousSessionId];
+    }
+    const nextStreamingMessageBySession = { ...state.streamingMessageBySession };
+    if (previousSessionId in nextStreamingMessageBySession) {
+      const prev = nextStreamingMessageBySession[previousSessionId];
+      if (prev) {
+        nextStreamingMessageBySession[nextSessionId] = { ...prev, sessionId: nextSessionId };
+      } else if (!(nextSessionId in nextStreamingMessageBySession)) {
+        nextStreamingMessageBySession[nextSessionId] = void 0;
+      }
+      delete nextStreamingMessageBySession[previousSessionId];
+    }
+    const nextIsStreamingBySession = { ...state.isStreamingBySession };
+    if (previousSessionId in nextIsStreamingBySession) {
+      nextIsStreamingBySession[nextSessionId] = nextIsStreamingBySession[previousSessionId] ?? false;
+      delete nextIsStreamingBySession[previousSessionId];
+    }
+    const nextIsStoppingBySession = { ...state.isStoppingBySession };
+    if (previousSessionId in nextIsStoppingBySession) {
+      nextIsStoppingBySession[nextSessionId] = nextIsStoppingBySession[previousSessionId] ?? false;
+      delete nextIsStoppingBySession[previousSessionId];
+    }
+    const nextErrorBySession = { ...state.errorBySession };
+    if (previousSessionId in nextErrorBySession) {
+      nextErrorBySession[nextSessionId] = nextErrorBySession[previousSessionId] ?? null;
+      delete nextErrorBySession[previousSessionId];
+    }
+    const nextActiveSessionId = state.activeSessionId === previousSessionId ? nextSessionId : state.activeSessionId;
+    set({
+      sessions: nextSessions,
+      messagesBySession: nextMessagesBySession,
+      streamingMessageBySession: nextStreamingMessageBySession,
+      isStreamingBySession: nextIsStreamingBySession,
+      isStoppingBySession: nextIsStoppingBySession,
+      errorBySession: nextErrorBySession,
+      activeSessionId: nextActiveSessionId
+    });
+  },
+  setPreferredMode: (mode) => {
+    set({ preferredMode: mode });
+  },
+  setSessionMode: (sessionId, mode) => {
+    const state = get();
+    const nextSessions = state.sessions.map(
+      (s) => s.sessionId === sessionId ? { ...s, mode } : s
+    );
+    set({ sessions: nextSessions });
+  },
+  // ---- Message operations ------------------------------------------------
+  appendMessage: (sessionId, message) => {
+    const state = get();
+    const nextMessagesBySession = { ...state.messagesBySession };
+    if (!nextMessagesBySession[sessionId]) {
+      nextMessagesBySession[sessionId] = [];
+    }
+    nextMessagesBySession[sessionId] = [...nextMessagesBySession[sessionId], message];
+    const nextSessions = state.sessions.map((s) => {
+      if (s.sessionId !== sessionId)
+        return s;
+      const updated = { ...s, updatedAt: message.createdAt };
+      if (message.role === "user" && s.title === DEFAULT_CHAT_SESSION_TITLE) {
+        updated.title = resolveSessionTitleFromMessage(message);
+      }
+      return updated;
+    });
+    const nextErrorBySession = state.errorBySession[sessionId] === void 0 ? { ...state.errorBySession, [sessionId]: null } : state.errorBySession;
+    const nextIsStreamingBySession = state.isStreamingBySession[sessionId] === void 0 ? { ...state.isStreamingBySession, [sessionId]: false } : state.isStreamingBySession;
+    set({
+      messagesBySession: nextMessagesBySession,
+      sessions: nextSessions,
+      errorBySession: nextErrorBySession,
+      isStreamingBySession: nextIsStreamingBySession
+    });
+  },
+  startStreamingMessage: (sessionId, message) => {
+    const state = get();
+    set({
+      streamingMessageBySession: {
+        ...state.streamingMessageBySession,
+        [sessionId]: message
+      },
+      isStreamingBySession: {
+        ...state.isStreamingBySession,
+        [sessionId]: true
+      },
+      isStoppingBySession: {
+        ...state.isStoppingBySession,
+        [sessionId]: false
+      },
+      errorBySession: {
+        ...state.errorBySession,
+        [sessionId]: null
+      }
+    });
+  },
+  updateStreamingMessage: (sessionId, content) => {
+    get().patchStreamingMessage(sessionId, { content });
+  },
+  patchStreamingMessage: (sessionId, patch) => {
+    const state = get();
+    const target = state.streamingMessageBySession[sessionId];
+    if (!target)
+      return;
+    set({
+      streamingMessageBySession: {
+        ...state.streamingMessageBySession,
+        [sessionId]: { ...target, ...patch }
+      }
+    });
+  },
+  completeStreamingMessage: (sessionId) => {
+    set((state) => finalizeStreamingMessage(state, sessionId, "done"));
+  },
+  requestStopStreaming: (sessionId) => {
+    const state = get();
+    set({
+      isStoppingBySession: {
+        ...state.isStoppingBySession,
+        [sessionId]: true
+      }
+    });
+  },
+  finalizeStoppedStreamingMessage: (sessionId) => {
+    set((state) => finalizeStreamingMessage(state, sessionId, "stopped", true));
+  },
+  setSessionError: (sessionId, error) => {
+    const state = get();
+    set({
+      errorBySession: { ...state.errorBySession, [sessionId]: error }
+    });
+  },
+  clearSessionError: (sessionId) => {
+    const state = get();
+    set({
+      errorBySession: { ...state.errorBySession, [sessionId]: null }
+    });
+  },
+  updateQuestionnaireAnswers: (sessionId, messageId, questionnaireId, answers) => {
+    const state = get();
+    const sessionMessages = state.messagesBySession[sessionId];
+    const updateBlocks = (message) => {
+      if (!message.blocks?.length)
+        return message;
+      let hasUpdatedBlock = false;
+      const nextBlocks = message.blocks.map((block) => {
+        if (block.type !== "questionnaire" || block.questionnaire.questionnaireId !== questionnaireId) {
+          return block;
+        }
+        hasUpdatedBlock = true;
+        return {
+          ...block,
+          questionnaire: { ...block.questionnaire, answers: { ...answers } }
+        };
+      });
+      if (!hasUpdatedBlock)
+        return message;
+      return { ...message, blocks: nextBlocks };
+    };
+    const nextMessagesBySession = { ...state.messagesBySession };
+    if (sessionMessages) {
+      nextMessagesBySession[sessionId] = sessionMessages.map(
+        (m) => m.id === messageId ? updateBlocks(m) : m
+      );
+    }
+    const currentStreaming = state.streamingMessageBySession[sessionId];
+    const nextStreamingMessageBySession = { ...state.streamingMessageBySession };
+    if (currentStreaming && currentStreaming.id === messageId) {
+      nextStreamingMessageBySession[sessionId] = updateBlocks(currentStreaming);
+    }
+    set({
+      messagesBySession: nextMessagesBySession,
+      streamingMessageBySession: nextStreamingMessageBySession
+    });
+  }
+}));
+
+// src/transport/default-chat-transport.ts
+import axios from "axios";
+
+// src/api/index.ts
+var CHAT_MODELS_PATH = "/models";
+var CHAT_TERMINATE_PATH = "/chat/terminate";
+var getChatModels = async (client, path = CHAT_MODELS_PATH) => {
+  const response = await client.get(path);
+  return response.data;
+};
+var terminateChat = async (client, sessionId, path = CHAT_TERMINATE_PATH) => {
+  const response = await client.post(
+    path,
+    sessionId ? { session_id: sessionId } : {},
+    { headers: sessionId ? { "X-Session-ID": sessionId } : void 0 }
+  );
+  return response.data;
+};
+
+// src/api/chat-stream.ts
+var CHAT_COMPLETIONS_PATH = "/chat/completions";
+var SSE_CONTENT_TYPE = "text/event-stream";
+var isObjectRecord = (value) => typeof value === "object" && value !== null;
+var isPayloadPacketData = (value) => isObjectRecord(value) && Array.isArray(value.payload);
+var isStructuredPacketData = (value) => isObjectRecord(value) && ("content" in value || "message" in value || "blocks" in value);
+var parseSseEvent = (eventText) => {
+  const dataLine = eventText.split("\n").map((line) => line.trim()).find((line) => line.startsWith("data:"));
+  if (!dataLine)
+    return null;
+  const raw = dataLine.slice(5).trim();
+  if (!raw)
+    return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+};
+var extractChatStreamUpdate = (packet) => {
+  if (packet.type !== "delta" && packet.type !== "message_complete") {
+    return null;
+  }
+  if (isPayloadPacketData(packet.data)) {
+    const contentDelta = packet.data.payload[0]?.delta?.content ?? "";
+    return contentDelta ? { contentDelta } : null;
+  }
+  if (!isStructuredPacketData(packet.data)) {
+    return null;
+  }
+  const content = typeof packet.data.content === "string" ? packet.data.content : typeof packet.data.message === "string" ? packet.data.message : void 0;
+  const blocks = Array.isArray(packet.data.blocks) ? packet.data.blocks : void 0;
+  if (content === void 0 && blocks === void 0) {
+    return null;
+  }
+  return {
+    ...content !== void 0 ? { content } : {},
+    ...blocks !== void 0 ? { blocks } : {}
+  };
+};
+var startChatStream = async ({
+  apiBaseUrl,
+  endpointPath = CHAT_COMPLETIONS_PATH,
+  sessionId,
+  authToken,
+  requestHeaders,
+  model,
+  mode,
+  content,
+  signal,
+  onPacket,
+  onSessionId,
+  onDone,
+  onError
+}) => {
+  try {
+    const headers = {
+      Authorization: authToken,
+      "Content-Type": "application/json",
+      ...requestHeaders
+    };
+    if (sessionId) {
+      headers["X-Session-ID"] = sessionId;
+    }
+    const response = await fetch(`${apiBaseUrl}${endpointPath}`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        model,
+        mode,
+        stream: true,
+        messages: [{ role: "user", content }]
+      }),
+      signal
+    });
+    const contentType = response.headers.get("content-type") ?? "";
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`);
+    }
+    if (!response.body || !contentType.includes(SSE_CONTENT_TYPE)) {
+      throw new Error("Expected SSE response");
+    }
+    const responseSessionId = response.headers.get("X-Session-ID")?.trim();
+    if (responseSessionId) {
+      onSessionId?.(responseSessionId);
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder("utf-8");
+    let buffer = "";
+    let isStreamClosed = false;
+    while (!isStreamClosed) {
+      const { value, done } = await reader.read();
+      if (done) {
+        isStreamClosed = true;
+        continue;
+      }
+      buffer += decoder.decode(value, { stream: true });
+      const events = buffer.split("\n\n");
+      buffer = events.pop() ?? "";
+      for (const eventText of events) {
+        const packet = parseSseEvent(eventText);
+        if (!packet)
+          continue;
+        if (packet.type === "stream_end" && packet.data === "[DONE]") {
+          onDone?.();
+          return;
+        }
+        if (packet.type === "error") {
+          throw new Error(
+            typeof packet.data === "string" ? packet.data : "message" in packet.data ? packet.data.message || "stream error" : "stream error"
+          );
+        }
+        onPacket(packet);
+      }
+    }
+  } catch (error) {
+    if (error instanceof DOMException && error.name === "AbortError") {
+      return;
+    }
+    const normalizedError = error instanceof Error ? error : new Error("stream error");
+    onError?.(normalizedError);
+    throw normalizedError;
+  }
+};
+
+// src/transport/default-chat-transport.ts
+var DEFAULT_CHAT_TRANSPORT_ENDPOINTS = {
+  models: "/models",
+  completions: "/chat/completions",
+  terminate: "/chat/terminate"
+};
+var createDefaultChatTransport = ({
+  apiBaseUrl,
+  authToken,
+  streamHeaders,
+  transformStreamPacket,
+  endpoints,
+  axiosInstance
+}) => {
+  const client = axiosInstance ?? axios.create({ baseURL: apiBaseUrl, headers: { Authorization: authToken } });
+  const resolvedEndpoints = {
+    ...DEFAULT_CHAT_TRANSPORT_ENDPOINTS,
+    ...endpoints
+  };
+  return {
+    getModels: () => getChatModels(client, resolvedEndpoints.models),
+    startStream: async ({
+      sessionId,
+      model,
+      mode,
+      content,
+      signal,
+      onUpdate,
+      onSessionId,
+      onDone,
+      onError
+    }) => {
+      await startChatStream({
+        apiBaseUrl,
+        endpointPath: resolvedEndpoints.completions,
+        sessionId,
+        authToken,
+        requestHeaders: streamHeaders,
+        model,
+        mode,
+        content,
+        signal,
+        onSessionId,
+        onDone,
+        onError,
+        onPacket: (packet) => {
+          const defaultUpdate = extractChatStreamUpdate(packet);
+          const nextUpdate = transformStreamPacket?.({ packet, defaultUpdate }) ?? defaultUpdate;
+          if (!nextUpdate) {
+            return;
+          }
+          onUpdate(nextUpdate);
+        }
+      });
+    },
+    terminateStream: (sessionId) => terminateChat(client, sessionId, resolvedEndpoints.terminate)
+  };
+};
+
+// src/components/ai-chat-provider/index.tsx
+import { jsx } from "@emotion/react/jsx-runtime";
+var AiChatProvider = (props) => {
+  const { defaultMode, labels, renderMessageBlock, enableImageAttachments = true, children } = props;
+  const [store] = useState(
+    () => createChatStore(defaultMode ? { preferredMode: defaultMode } : void 0)
+  );
+  const sendRef = useRef(async () => {
+  });
+  const retryRef = useRef(async () => {
+  });
+  const defaultApiBaseUrl = "apiBaseUrl" in props ? props.apiBaseUrl : void 0;
+  const defaultAuthToken = "authToken" in props ? props.authToken : void 0;
+  const defaultTransformStreamPacket = "transformStreamPacket" in props ? props.transformStreamPacket : void 0;
+  const customTransport = "transport" in props ? props.transport : void 0;
+  const axiosInstance = useMemo(() => {
+    if (!defaultApiBaseUrl || !defaultAuthToken) {
+      return void 0;
+    }
+    return axios2.create({
+      baseURL: defaultApiBaseUrl,
+      headers: { Authorization: defaultAuthToken }
+    });
+  }, [defaultApiBaseUrl, defaultAuthToken]);
+  const transport = useMemo(() => {
+    if (customTransport) {
+      return customTransport;
+    }
+    if (!defaultApiBaseUrl || !defaultAuthToken) {
+      throw new Error("AiChatProvider requires either transport or apiBaseUrl + authToken");
+    }
+    return createDefaultChatTransport({
+      apiBaseUrl: defaultApiBaseUrl,
+      authToken: defaultAuthToken,
+      transformStreamPacket: defaultTransformStreamPacket,
+      axiosInstance
+    });
+  }, [
+    axiosInstance,
+    customTransport,
+    defaultApiBaseUrl,
+    defaultAuthToken,
+    defaultTransformStreamPacket
+  ]);
+  const contextValue = useMemo(
+    () => ({
+      store,
+      transport,
+      axios: axiosInstance,
+      apiBaseUrl: defaultApiBaseUrl,
+      authToken: defaultAuthToken,
+      labels: { ...DEFAULT_AI_CHAT_LABELS, ...labels },
+      sendRef,
+      retryRef,
+      renderMessageBlock,
+      transformStreamPacket: defaultTransformStreamPacket,
+      enableImageAttachments
+    }),
+    [
+      axiosInstance,
+      defaultApiBaseUrl,
+      defaultAuthToken,
+      defaultTransformStreamPacket,
+      enableImageAttachments,
+      labels,
+      renderMessageBlock,
+      sendRef,
+      retryRef,
+      store,
+      transport
+    ]
+  );
+  return /* @__PURE__ */ jsx(ChatContext.Provider, { value: contextValue, children });
+};
+
+// src/components/chat-thread/index.tsx
+import { useCallback as useCallback2, useLayoutEffect, useMemo as useMemo3, useRef as useRef4, useState as useState5 } from "react";
+import styled10 from "@emotion/styled";
+
+// src/context/use-chat-context.ts
+import { useContext } from "react";
+import { useStore } from "zustand/react";
+var useChatContext = () => {
+  const ctx = useContext(ChatContext);
+  if (!ctx)
+    throw new Error("useChatContext must be used inside AiChatProvider");
+  return ctx;
+};
+var useChatStore = (selector) => {
+  const { store } = useChatContext();
+  return useStore(store, selector);
+};
+
+// src/components/chat-thread/lib/chat-thread.ts
+var CHAT_THREAD_SCROLL_TOP_GAP = 16;
+var findLatestUserMessageId = (historyMessages) => {
+  for (let index = historyMessages.length - 1; index >= 0; index -= 1) {
+    if (historyMessages[index]?.role === "user") {
+      return historyMessages[index]?.id;
+    }
+  }
+  return void 0;
+};
+var calculateChatThreadScrollSpacerHeight = ({
+  containerClientHeight,
+  containerScrollHeight,
+  targetOffsetTop
+}) => Math.max(
+  0,
+  targetOffsetTop - CHAT_THREAD_SCROLL_TOP_GAP - (containerScrollHeight - containerClientHeight)
+);
+
+// src/components/chat-thread/components/chat-message-item.tsx
+import { Fragment, memo, useState as useState4 } from "react";
+import styled7 from "@emotion/styled";
+import { keyframes } from "@emotion/react";
+import ReactMarkdown from "react-markdown";
+import remarkGfm from "remark-gfm";
+import remarkMath from "remark-math";
+import rehypeKatex from "rehype-katex";
+
+// src/components/chat-thread/hooks/use-chat-message-reveal.ts
+import { useCallback, useEffect, useMemo as useMemo2, useRef as useRef2, useState as useState2 } from "react";
+
+// src/components/chat-thread/lib/message-reveal.ts
+var STREAM_REVEAL_TICK_MS = 36;
+var STREAM_FRESH_BLOCK_SETTLE_MS = 180;
+var STREAM_INPUT_BATCH_WINDOW_MS = 48;
+var getRevealStep = ({
+  backlogUnits,
+  isStreaming,
+  totalUnits
+}) => {
+  if (!isStreaming) {
+    return Math.max(24, Math.ceil(backlogUnits / 2));
+  }
+  if (backlogUnits >= 240) {
+    return Math.max(24, Math.ceil(backlogUnits / 8));
+  }
+  if (backlogUnits >= 120) {
+    return Math.max(10, Math.ceil(backlogUnits / 12));
+  }
+  if (backlogUnits >= 48) {
+    return Math.max(2, Math.ceil(backlogUnits / 24));
+  }
+  if (totalUnits >= 200 && backlogUnits >= 24) {
+    return 4;
+  }
+  return 1;
+};
+var getNextDisplayedUnitCount = ({
+  currentUnits,
+  targetUnits,
+  isStreaming,
+  minimumStep = 1
+}) => {
+  if (currentUnits >= targetUnits) {
+    return currentUnits;
+  }
+  const revealStep = getRevealStep({
+    backlogUnits: targetUnits - currentUnits,
+    isStreaming,
+    totalUnits: targetUnits
+  });
+  return Math.min(targetUnits, currentUnits + Math.max(minimumStep, revealStep));
+};
+var splitMarkdownBlocks = (content) => content.split(/\n{2,}/).map((block) => block.trim()).filter(Boolean);
+
+// src/components/chat-thread/hooks/use-chat-message-reveal.ts
+var useChatMessageReveal = (message) => {
+  const isAssistantStreaming = message.role === "assistant" && message.status === "streaming";
+  const targetContent = message.content || "";
+  const targetUnits = useMemo2(() => Array.from(targetContent), [targetContent]);
+  const resetSnapshot = useMemo2(
+    () => ({
+      messageId: message.id,
+      initialTargetUnitCount: targetUnits.length,
+      initialBatchedTargetUnitCount: isAssistantStreaming ? 0 : targetUnits.length
+    }),
+    [isAssistantStreaming, message.id, targetUnits.length]
+  );
+  const pendingTargetUnitCountRef = useRef2(targetUnits.length);
+  const batchedTargetUnitCountRef = useRef2(isAssistantStreaming ? 0 : targetUnits.length);
+  const inputBatchTimeoutRef = useRef2(null);
+  const commitAnimationFrameRef = useRef2(null);
+  const freshBlockActivationFrameRef = useRef2(null);
+  const displayedUnitSyncFrameRef = useRef2(null);
+  const resetAnimationFrameRef = useRef2(null);
+  const [batchedTargetUnitCount, setBatchedTargetUnitCount] = useState2(
+    () => isAssistantStreaming ? 0 : targetUnits.length
+  );
+  const lastDisplayedBlockCountRef = useRef2(0);
+  const [displayedUnitCount, setDisplayedUnitCount] = useState2(
+    () => isAssistantStreaming ? 0 : targetUnits.length
+  );
+  const [isFreshBlockActive, setIsFreshBlockActive] = useState2(false);
+  const commitBatchedTargetUnitCount = useCallback(
+    (nextTargetUnitCount) => {
+      batchedTargetUnitCountRef.current = nextTargetUnitCount;
+      setBatchedTargetUnitCount(nextTargetUnitCount);
+      setDisplayedUnitCount(
+        (current) => message.role === "assistant" ? getNextDisplayedUnitCount({
+          currentUnits: current,
+          targetUnits: nextTargetUnitCount,
+          isStreaming: isAssistantStreaming,
+          minimumStep: current > 0 && isAssistantStreaming ? 2 : 1
+        }) : nextTargetUnitCount
+      );
+    },
+    [isAssistantStreaming, message.role]
+  );
+  const scheduleBatchedTargetUnitCountCommit = useCallback(
+    (nextTargetUnitCount) => {
+      if (commitAnimationFrameRef.current !== null) {
+        window.cancelAnimationFrame(commitAnimationFrameRef.current);
+      }
+      commitAnimationFrameRef.current = window.requestAnimationFrame(() => {
+        commitAnimationFrameRef.current = null;
+        commitBatchedTargetUnitCount(nextTargetUnitCount);
+      });
+    },
+    [commitBatchedTargetUnitCount]
+  );
+  useEffect(() => {
+    pendingTargetUnitCountRef.current = resetSnapshot.initialTargetUnitCount;
+    batchedTargetUnitCountRef.current = resetSnapshot.initialBatchedTargetUnitCount;
+    lastDisplayedBlockCountRef.current = 0;
+    if (inputBatchTimeoutRef.current !== null) {
+      window.clearTimeout(inputBatchTimeoutRef.current);
+      inputBatchTimeoutRef.current = null;
+    }
+    if (commitAnimationFrameRef.current !== null) {
+      window.cancelAnimationFrame(commitAnimationFrameRef.current);
+      commitAnimationFrameRef.current = null;
+    }
+    if (freshBlockActivationFrameRef.current !== null) {
+      window.cancelAnimationFrame(freshBlockActivationFrameRef.current);
+      freshBlockActivationFrameRef.current = null;
+    }
+    if (displayedUnitSyncFrameRef.current !== null) {
+      window.cancelAnimationFrame(displayedUnitSyncFrameRef.current);
+      displayedUnitSyncFrameRef.current = null;
+    }
+    if (resetAnimationFrameRef.current !== null) {
+      window.cancelAnimationFrame(resetAnimationFrameRef.current);
+    }
+    resetAnimationFrameRef.current = window.requestAnimationFrame(() => {
+      resetAnimationFrameRef.current = null;
+      setBatchedTargetUnitCount(resetSnapshot.initialBatchedTargetUnitCount);
+      setDisplayedUnitCount(resetSnapshot.initialBatchedTargetUnitCount);
+      setIsFreshBlockActive(false);
+    });
+    return () => {
+      if (resetAnimationFrameRef.current !== null) {
+        window.cancelAnimationFrame(resetAnimationFrameRef.current);
+        resetAnimationFrameRef.current = null;
+      }
+    };
+  }, [resetSnapshot]);
+  useEffect(() => {
+    pendingTargetUnitCountRef.current = targetUnits.length;
+    if (message.role !== "assistant" || !isAssistantStreaming) {
+      if (inputBatchTimeoutRef.current !== null) {
+        window.clearTimeout(inputBatchTimeoutRef.current);
+        inputBatchTimeoutRef.current = null;
+      }
+      scheduleBatchedTargetUnitCountCommit(targetUnits.length);
+      return;
+    }
+    if (targetUnits.length <= batchedTargetUnitCountRef.current) {
+      return;
+    }
+    if (batchedTargetUnitCountRef.current === 0) {
+      scheduleBatchedTargetUnitCountCommit(targetUnits.length);
+      return;
+    }
+    if (inputBatchTimeoutRef.current !== null) {
+      return;
+    }
+    inputBatchTimeoutRef.current = window.setTimeout(() => {
+      inputBatchTimeoutRef.current = null;
+      commitBatchedTargetUnitCount(pendingTargetUnitCountRef.current);
+    }, STREAM_INPUT_BATCH_WINDOW_MS);
+    return () => {
+      if (inputBatchTimeoutRef.current !== null) {
+        window.clearTimeout(inputBatchTimeoutRef.current);
+        inputBatchTimeoutRef.current = null;
+      }
+    };
+  }, [
+    commitBatchedTargetUnitCount,
+    isAssistantStreaming,
+    message.role,
+    scheduleBatchedTargetUnitCountCommit,
+    targetUnits.length
+  ]);
+  const displayedContent = useMemo2(
+    () => targetUnits.slice(0, displayedUnitCount).join(""),
+    [displayedUnitCount, targetUnits]
+  );
+  const contentBlocks = useMemo2(() => splitMarkdownBlocks(displayedContent), [displayedContent]);
+  useEffect(() => {
+    const hasNewDisplayedBlock = message.role === "assistant" && contentBlocks.length > 1 && contentBlocks.length > lastDisplayedBlockCountRef.current;
+    lastDisplayedBlockCountRef.current = contentBlocks.length;
+    if (!hasNewDisplayedBlock) {
+      return;
+    }
+    freshBlockActivationFrameRef.current = window.requestAnimationFrame(() => {
+      freshBlockActivationFrameRef.current = null;
+      setIsFreshBlockActive(true);
+    });
+    const timer = window.setTimeout(() => {
+      setIsFreshBlockActive(false);
+    }, STREAM_FRESH_BLOCK_SETTLE_MS);
+    return () => {
+      if (freshBlockActivationFrameRef.current !== null) {
+        window.cancelAnimationFrame(freshBlockActivationFrameRef.current);
+        freshBlockActivationFrameRef.current = null;
+      }
+      window.clearTimeout(timer);
+    };
+  }, [contentBlocks.length, message.role]);
+  useEffect(() => {
+    const shouldAnimateReveal = message.role === "assistant" && displayedUnitCount < batchedTargetUnitCount && (isAssistantStreaming || displayedUnitCount > 0);
+    if (!shouldAnimateReveal) {
+      if (displayedUnitCount !== batchedTargetUnitCount) {
+        displayedUnitSyncFrameRef.current = window.requestAnimationFrame(() => {
+          displayedUnitSyncFrameRef.current = null;
+          setDisplayedUnitCount(batchedTargetUnitCount);
+        });
+      }
+      return () => {
+        if (displayedUnitSyncFrameRef.current !== null) {
+          window.cancelAnimationFrame(displayedUnitSyncFrameRef.current);
+          displayedUnitSyncFrameRef.current = null;
+        }
+      };
+    }
+    const timer = window.setInterval(() => {
+      setDisplayedUnitCount((current) => {
+        if (current >= batchedTargetUnitCount) {
+          window.clearInterval(timer);
+          return current;
+        }
+        return Math.min(
+          batchedTargetUnitCount,
+          getNextDisplayedUnitCount({
+            currentUnits: current,
+            targetUnits: batchedTargetUnitCount,
+            isStreaming: isAssistantStreaming
+          })
+        );
+      });
+    }, STREAM_REVEAL_TICK_MS);
+    return () => {
+      window.clearInterval(timer);
+    };
+  }, [batchedTargetUnitCount, displayedUnitCount, isAssistantStreaming, message.role]);
+  const settledContent = isFreshBlockActive ? contentBlocks.slice(0, -1).join("\n\n") : displayedContent;
+  const freshContent = isFreshBlockActive ? contentBlocks.at(-1) ?? "" : "";
+  return {
+    isAssistantStreaming,
+    displayedContent,
+    settledContent,
+    freshContent
+  };
+};
+
+// src/components/chat-thread/components/pde-ai-execution-confirmation-card.tsx
+import styled from "@emotion/styled";
+import { jsx as jsx2, jsxs } from "@emotion/react/jsx-runtime";
+var PDEAIExecutionConfirmationCard = ({
+  proposal,
+  interactive = false,
+  onApply,
+  onConfirm,
+  onRevise
+}) => {
+  return /* @__PURE__ */ jsxs(Card, { "data-testid": "pde-ai-execution-confirmation-card", children: [
+    /* @__PURE__ */ jsxs(Header, { children: [
+      /* @__PURE__ */ jsx2(Eyebrow, { children: "Execution Proposal" }),
+      /* @__PURE__ */ jsx2(Title, { children: proposal.equationName }),
+      proposal.solverName ? /* @__PURE__ */ jsx2(Subtitle, { children: proposal.solverName }) : null
+    ] }),
+    /* @__PURE__ */ jsx2(SummaryList, { children: proposal.parameterSummary.map((item) => /* @__PURE__ */ jsxs(SummaryItem, { children: [
+      /* @__PURE__ */ jsx2(SummaryLabel, { children: item.label }),
+      /* @__PURE__ */ jsx2(SummaryValue, { children: item.value })
+    ] }, `${item.fieldPath ?? item.label}-${item.value}`)) }),
+    proposal.warnings?.length ? /* @__PURE__ */ jsx2(Warnings, { children: proposal.warnings.map((warning) => /* @__PURE__ */ jsx2(Warning, { children: warning }, warning)) }) : null,
+    interactive ? /* @__PURE__ */ jsxs(Actions, { children: [
+      onApply && /* @__PURE__ */ jsx2(ActionButton, { type: "button", "data-testid": "pde-ai-confirmation-apply", onClick: onApply, children: "Apply to Parameters" }),
+      onConfirm && /* @__PURE__ */ jsx2(
+        ActionButton,
+        {
+          type: "button",
+          "data-testid": "pde-ai-confirmation-confirm",
+          onClick: onConfirm,
+          children: "Confirm Execution"
+        }
+      ),
+      onRevise && /* @__PURE__ */ jsx2(
+        SecondaryActionButton,
+        {
+          type: "button",
+          "data-testid": "pde-ai-confirmation-revise",
+          onClick: onRevise,
+          children: "Revise Plan"
+        }
+      )
+    ] }) : null
+  ] });
+};
+var Card = styled.section`
+  display: grid;
+  gap: 14px;
+  padding: 16px;
+  border-radius: 20px;
+  border: 1px solid rgba(126, 160, 255, 0.2);
+  background:
+    linear-gradient(180deg, rgba(73, 98, 188, 0.16) 0%, rgba(31, 35, 47, 0.42) 100%),
+    rgba(255, 255, 255, 0.03);
+`;
+var Header = styled.div`
+  display: grid;
+  gap: 4px;
+`;
+var Eyebrow = styled.span`
+  color: rgba(255, 255, 255, 0.58);
+  font-size: 11px;
+  font-weight: 700;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+`;
+var Title = styled.strong`
+  color: rgba(255, 255, 255, 0.95);
+  font-size: 16px;
+  line-height: 1.4;
+`;
+var Subtitle = styled.span`
+  color: rgba(255, 255, 255, 0.68);
+  font-size: 13px;
+`;
+var SummaryList = styled.div`
+  display: grid;
+  gap: 8px;
+`;
+var SummaryItem = styled.div`
+  display: flex;
+  justify-content: space-between;
+  gap: 12px;
+  padding: 10px 12px;
+  border-radius: 14px;
+  background: rgba(255, 255, 255, 0.05);
+`;
+var SummaryLabel = styled.span`
+  color: rgba(255, 255, 255, 0.72);
+  font-size: 13px;
+`;
+var SummaryValue = styled.span`
+  color: rgba(255, 255, 255, 0.94);
+  font-size: 13px;
+  font-weight: 600;
+`;
+var Warnings = styled.div`
+  display: grid;
+  gap: 8px;
+`;
+var Warning = styled.div`
+  padding: 10px 12px;
+  border-radius: 14px;
+  border: 1px solid rgba(255, 193, 92, 0.24);
+  background: rgba(255, 181, 71, 0.12);
+  color: rgba(255, 241, 211, 0.92);
+  font-size: 13px;
+`;
+var Actions = styled.div`
+  display: flex;
+  flex-wrap: wrap;
+  gap: 10px;
+`;
+var ActionButton = styled.button`
+  border: none;
+  border-radius: 999px;
+  background: linear-gradient(180deg, #7ea0ff 0%, #4a6fff 100%);
+  color: #081127;
+  font-size: 12px;
+  font-weight: 700;
+  padding: 10px 14px;
+  cursor: pointer;
+
+  &:disabled {
+    cursor: default;
+    opacity: 0.48;
+  }
+`;
+var SecondaryActionButton = styled(ActionButton)`
+  background: rgba(255, 255, 255, 0.08);
+  color: rgba(255, 255, 255, 0.9);
+  border: 1px solid rgba(255, 255, 255, 0.14);
+`;
+
+// src/components/chat-thread/components/pde-ai-notice-card.tsx
+import styled2 from "@emotion/styled";
+import { jsx as jsx3 } from "@emotion/react/jsx-runtime";
+var PDEAINoticeCard = ({ text, tone }) => /* @__PURE__ */ jsx3(Card2, { "data-testid": "pde-ai-notice-card", "data-tone": tone, children: text });
+var Card2 = styled2.div`
+  padding: 12px 14px;
+  border-radius: 16px;
+  border: 1px solid rgba(255, 255, 255, 0.1);
+  background: rgba(255, 255, 255, 0.04);
+  color: rgba(255, 255, 255, 0.9);
+  font-size: 13px;
+  line-height: 1.5;
+
+  &[data-tone='info'] {
+    border-color: rgba(105, 170, 255, 0.26);
+    background: rgba(68, 118, 255, 0.12);
+  }
+
+  &[data-tone='warning'] {
+    border-color: rgba(255, 193, 92, 0.28);
+    background: rgba(255, 181, 71, 0.12);
+  }
+
+  &[data-tone='success'] {
+    border-color: rgba(84, 214, 160, 0.28);
+    background: rgba(43, 182, 120, 0.12);
+  }
+`;
+
+// src/components/chat-thread/components/pde-ai-parameter-summary-card.tsx
+import styled3 from "@emotion/styled";
+import { jsx as jsx4, jsxs as jsxs2 } from "@emotion/react/jsx-runtime";
+var PDEAIParameterSummaryCard = ({ items }) => /* @__PURE__ */ jsxs2(Card3, { "data-testid": "pde-ai-parameter-summary-card", children: [
+  /* @__PURE__ */ jsx4(Title2, { children: "Parameter Summary" }),
+  /* @__PURE__ */ jsx4(List, { children: items.map((item) => /* @__PURE__ */ jsxs2(ListItem, { children: [
+    /* @__PURE__ */ jsx4(Label, { children: item.label }),
+    /* @__PURE__ */ jsx4(Value, { children: item.value })
+  ] }, `${item.fieldPath ?? item.label}-${item.value}`)) })
+] });
+var Card3 = styled3.section`
+  padding: 14px;
+  border-radius: 18px;
+  border: 1px solid rgba(255, 255, 255, 0.08);
+  background: rgba(255, 255, 255, 0.03);
+`;
+var Title2 = styled3.div`
+  margin-bottom: 10px;
+  color: rgba(255, 255, 255, 0.62);
+  font-size: 11px;
+  font-weight: 700;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+`;
+var List = styled3.div`
+  display: grid;
+  gap: 10px;
+`;
+var ListItem = styled3.div`
+  display: flex;
+  justify-content: space-between;
+  gap: 12px;
+  padding: 10px 12px;
+  border-radius: 14px;
+  background: rgba(255, 255, 255, 0.04);
+`;
+var Label = styled3.span`
+  color: rgba(255, 255, 255, 0.72);
+  font-size: 13px;
+`;
+var Value = styled3.span`
+  color: rgba(255, 255, 255, 0.94);
+  font-size: 13px;
+  font-weight: 600;
+  text-align: right;
+`;
+
+// src/components/chat-thread/components/pde-ai-questionnaire-card.tsx
+import { useState as useState3 } from "react";
+import styled4 from "@emotion/styled";
+import { jsx as jsx5, jsxs as jsxs3 } from "@emotion/react/jsx-runtime";
+var OTHER_OPTION_VALUE = "__other__";
+var createInitialAnswers = (questionnaire) => ({
+  ...questionnaire.answers ?? {}
+});
+var getMultiSelectAnswerValues = (answer) => Array.isArray(answer) ? answer : [];
+var getSingleSelectDraftState = (question, answer) => {
+  if (typeof answer !== "string") {
+    return {
+      selectedValue: void 0,
+      otherValue: ""
+    };
+  }
+  const matchesOption = question.options.some((option) => option.value === answer);
+  return {
+    selectedValue: matchesOption ? answer : question.allowOther ? OTHER_OPTION_VALUE : void 0,
+    otherValue: matchesOption ? "" : answer
+  };
+};
+var updateAnswerValue = (current, questionId, value) => ({
+  ...current,
+  [questionId]: value
+});
+var toggleMultiSelectAnswer = (current, questionId, optionValue) => {
+  const currentValues = getMultiSelectAnswerValues(current[questionId]);
+  const nextValues = currentValues.includes(optionValue) ? currentValues.filter((value) => value !== optionValue) : [...currentValues, optionValue];
+  return updateAnswerValue(current, questionId, nextValues);
+};
+var getTextInputValue = (answer) => typeof answer === "string" ? String(answer) : "";
+var getNumberInputValue = (answer) => typeof answer === "number" || typeof answer === "string" ? String(answer) : "";
+var getOptionChoiceLabel = (index) => {
+  if (index < 26) {
+    return String.fromCharCode(65 + index);
+  }
+  return String(index + 1);
+};
+var isMissingRequiredAnswer = (question, answers) => {
+  const answer = answers[question.id];
+  switch (question.kind) {
+    case "boolean":
+      return typeof answer !== "boolean";
+    case "multi_select":
+      return !Array.isArray(answer) || answer.length === 0;
+    case "number":
+      return typeof answer !== "number" || Number.isNaN(answer);
+    case "text":
+    case "single_select":
+      return typeof answer !== "string" || answer.trim() === "";
+    default:
+      return true;
+  }
+};
+var formatQuestionAnswer = (question, answer) => {
+  switch (question.kind) {
+    case "multi_select": {
+      if (!Array.isArray(answer)) {
+        return "";
+      }
+      return answer.map((value) => question.options.find((option) => option.value === value)?.label ?? value).join(", ");
+    }
+    case "single_select": {
+      if (typeof answer !== "string") {
+        return "";
+      }
+      const matchedOption = question.options.find((option) => option.value === answer);
+      return matchedOption?.label ?? answer;
+    }
+    case "text":
+      return String(answer);
+    case "number":
+      return `${answer}${question.unit ? ` ${question.unit}` : ""}`;
+    case "boolean":
+      return answer ? question.trueLabel ?? "Yes" : question.falseLabel ?? "No";
+    default:
+      return String(answer);
+  }
+};
+var normalizeQuestionAnswer = (question, answer) => {
+  if (answer === void 0) {
+    return void 0;
+  }
+  switch (question.kind) {
+    case "multi_select":
+      return Array.isArray(answer) && answer.length > 0 ? answer : void 0;
+    case "single_select":
+    case "text":
+      return typeof answer === "string" && answer.trim() !== "" ? answer : void 0;
+    case "number":
+      return typeof answer === "number" && !Number.isNaN(answer) ? answer : void 0;
+    case "boolean":
+      return typeof answer === "boolean" ? answer : void 0;
+    default:
+      return answer;
+  }
+};
+var PDEAIQuestionnaireCardInner = ({
+  questionnaire,
+  interactive = false,
+  onSubmit
+}) => {
+  const [answers, setAnswers] = useState3(
+    () => createInitialAnswers(questionnaire)
+  );
+  const [errorMessage, setErrorMessage] = useState3(null);
+  const handleSubmit = () => {
+    const missingQuestions = questionnaire.questions.filter(
+      (question) => question.required && isMissingRequiredAnswer(question, answers)
+    );
+    if (missingQuestions.length > 0) {
+      setErrorMessage(
+        `Please complete: ${missingQuestions.map((question) => question.label).join(", ")}`
+      );
+      return;
+    }
+    setErrorMessage(null);
+    const normalizedAnswers = Object.fromEntries(
+      questionnaire.questions.flatMap((question) => {
+        const value = normalizeQuestionAnswer(question, answers[question.id]);
+        return value === void 0 ? [] : [[question.id, value]];
+      })
+    );
+    const contentLines = [
+      questionnaire.title ?? "Questionnaire responses",
+      ...questionnaire.questions.flatMap((question) => {
+        const value = normalizedAnswers[question.id];
+        if (value === void 0) {
+          return [];
+        }
+        return [`- ${question.label}: ${formatQuestionAnswer(question, value)}`];
+      })
+    ];
+    onSubmit?.({
+      questionnaireId: questionnaire.questionnaireId,
+      answers: normalizedAnswers,
+      content: contentLines.join("\n")
+    });
+  };
+  const renderQuestion = (question) => {
+    const renderOptionChoice = ({
+      questionId,
+      optionLabel,
+      index,
+      isSelected,
+      onClick,
+      inlineInput,
+      tone = "default"
+    }) => /* @__PURE__ */ jsxs3(
+      OptionChoiceItem,
+      {
+        role: "button",
+        tabIndex: interactive ? 0 : -1,
+        "aria-pressed": isSelected,
+        "data-selected": isSelected,
+        "data-tone": tone,
+        "data-testid": `pde-ai-question-option-${questionId}-${index}`,
+        onClick: (event) => {
+          if (!interactive) {
+            return;
+          }
+          if (event.target instanceof HTMLElement && event.target.closest("input")) {
+            return;
+          }
+          onClick();
+        },
+        onKeyDown: (event) => {
+          if (!interactive) {
+            return;
+          }
+          if (event.key !== "Enter" && event.key !== " ") {
+            return;
+          }
+          event.preventDefault();
+          onClick();
+        },
+        children: [
+          /* @__PURE__ */ jsx5(OptionChoiceMarker, { "data-selected": isSelected, children: getOptionChoiceLabel(index) }),
+          /* @__PURE__ */ jsxs3(OptionChoiceContent, { children: [
+            inlineInput ? null : /* @__PURE__ */ jsx5(OptionChoiceLabel, { children: optionLabel }),
+            inlineInput
+          ] })
+        ]
+      },
+      `${questionId}-${optionLabel}`
+    );
+    switch (question.kind) {
+      case "multi_select":
+        return /* @__PURE__ */ jsx5(QuestionBody, { children: /* @__PURE__ */ jsx5(OptionList, { children: question.options.map((option, index) => {
+          const selectedValues = getMultiSelectAnswerValues(answers[question.id]);
+          const isSelected = selectedValues.includes(option.value);
+          return renderOptionChoice({
+            questionId: question.id,
+            optionLabel: option.label,
+            index,
+            isSelected,
+            onClick: () => setAnswers(
+              (current) => toggleMultiSelectAnswer(current, question.id, option.value)
+            )
+          });
+        }) }) });
+      case "single_select": {
+        const singleSelectDraft = getSingleSelectDraftState(question, answers[question.id]);
+        return /* @__PURE__ */ jsx5(QuestionBody, { children: /* @__PURE__ */ jsxs3(OptionList, { children: [
+          question.options.map((option, index) => {
+            const isSelected = singleSelectDraft.selectedValue === option.value;
+            return renderOptionChoice({
+              questionId: question.id,
+              optionLabel: option.label,
+              index,
+              isSelected,
+              onClick: () => setAnswers((current) => updateAnswerValue(current, question.id, option.value))
+            });
+          }),
+          question.allowOther ? renderOptionChoice({
+            questionId: question.id,
+            optionLabel: "Other",
+            index: question.options.length,
+            isSelected: singleSelectDraft.selectedValue === OTHER_OPTION_VALUE,
+            tone: "other",
+            onClick: () => setAnswers(
+              (current) => updateAnswerValue(current, question.id, singleSelectDraft.otherValue)
+            ),
+            inlineInput: singleSelectDraft.selectedValue === OTHER_OPTION_VALUE ? /* @__PURE__ */ jsx5(
+              InlineOtherInput,
+              {
+                "data-testid": `pde-ai-question-input-${question.id}`,
+                type: "text",
+                value: singleSelectDraft.otherValue,
+                placeholder: "Other",
+                readOnly: !interactive,
+                onClick: (event) => {
+                  event.stopPropagation();
+                },
+                onKeyDown: (event) => {
+                  event.stopPropagation();
+                },
+                onChange: (event) => {
+                  setAnswers(
+                    (current) => updateAnswerValue(current, question.id, event.target.value)
+                  );
+                }
+              }
+            ) : null
+          }) : null
+        ] }) });
+      }
+      case "text":
+        return /* @__PURE__ */ jsx5(QuestionBody, { children: /* @__PURE__ */ jsx5(
+          TextInput,
+          {
+            "data-testid": `pde-ai-question-input-${question.id}`,
+            type: "text",
+            value: getTextInputValue(answers[question.id]),
+            placeholder: question.placeholder,
+            readOnly: !interactive,
+            onChange: (event) => {
+              setAnswers((current) => updateAnswerValue(current, question.id, event.target.value));
+            }
+          }
+        ) });
+      case "number":
+        return /* @__PURE__ */ jsx5(QuestionBody, { children: /* @__PURE__ */ jsxs3(NumberInputRow, { children: [
+          /* @__PURE__ */ jsx5(
+            TextInput,
+            {
+              "data-testid": `pde-ai-question-input-${question.id}`,
+              type: "number",
+              value: getNumberInputValue(answers[question.id]),
+              placeholder: question.placeholder,
+              readOnly: !interactive,
+              onChange: (event) => {
+                setAnswers(
+                  (current) => updateAnswerValue(
+                    current,
+                    question.id,
+                    event.target.value === "" ? void 0 : Number(event.target.value)
+                  )
+                );
+              }
+            }
+          ),
+          question.unit ? /* @__PURE__ */ jsx5(Unit, { children: question.unit }) : null
+        ] }) });
+      case "boolean":
+        return /* @__PURE__ */ jsx5(QuestionBody, { children: /* @__PURE__ */ jsxs3(OptionList, { children: [
+          renderOptionChoice({
+            questionId: question.id,
+            optionLabel: question.trueLabel ?? "Yes",
+            index: 0,
+            isSelected: answers[question.id] === true,
+            onClick: () => setAnswers((current) => updateAnswerValue(current, question.id, true))
+          }),
+          renderOptionChoice({
+            questionId: question.id,
+            optionLabel: question.falseLabel ?? "No",
+            index: 1,
+            isSelected: answers[question.id] === false,
+            onClick: () => setAnswers((current) => updateAnswerValue(current, question.id, false))
+          })
+        ] }) });
+      default:
+        return null;
+    }
+  };
+  return /* @__PURE__ */ jsxs3(Card4, { "data-testid": "pde-ai-questionnaire-card", children: [
+    questionnaire.title ? /* @__PURE__ */ jsx5(Title3, { children: questionnaire.title }) : null,
+    questionnaire.description ? /* @__PURE__ */ jsx5(Description, { children: questionnaire.description }) : null,
+    /* @__PURE__ */ jsx5(QuestionList, { children: questionnaire.questions.map((question) => /* @__PURE__ */ jsxs3(QuestionCard, { children: [
+      /* @__PURE__ */ jsxs3(QuestionLabel, { children: [
+        question.label,
+        question.required ? /* @__PURE__ */ jsx5(Required, { children: "*" }) : null
+      ] }),
+      renderQuestion(question)
+    ] }, question.id)) }),
+    errorMessage ? /* @__PURE__ */ jsx5(ErrorMessage, { "data-testid": "pde-ai-questionnaire-error", children: errorMessage }) : null,
+    interactive ? /* @__PURE__ */ jsx5(
+      SubmitButton,
+      {
+        type: "button",
+        "data-testid": "pde-ai-questionnaire-submit",
+        onClick: handleSubmit,
+        children: questionnaire.submitLabel ?? "Submit"
+      }
+    ) : null
+  ] });
+};
+var getQuestionnaireStateKey = (questionnaire) => JSON.stringify([
+  questionnaire.questionnaireId,
+  questionnaire.answers ?? {},
+  questionnaire.questions
+]);
+var PDEAIQuestionnaireCard = (props) => /* @__PURE__ */ jsx5(PDEAIQuestionnaireCardInner, { ...props }, getQuestionnaireStateKey(props.questionnaire));
+var Card4 = styled4.section`
+  display: grid;
+  gap: 14px;
+  padding: 16px;
+  border-radius: 20px;
+  border: 1px solid rgba(255, 255, 255, 0.08);
+  background: rgba(255, 255, 255, 0.03);
+`;
+var Title3 = styled4.strong`
+  color: rgba(255, 255, 255, 0.94);
+  font-size: 16px;
+  line-height: 1.4;
+`;
+var Description = styled4.p`
+  margin: 0;
+  color: rgba(255, 255, 255, 0.72);
+  font-size: 13px;
+`;
+var QuestionList = styled4.div`
+  display: grid;
+  gap: 12px;
+`;
+var QuestionCard = styled4.div`
+  display: grid;
+  gap: 10px;
+  padding: 12px;
+  border-radius: 16px;
+  background: rgba(255, 255, 255, 0.04);
+`;
+var QuestionLabel = styled4.div`
+  color: rgba(255, 255, 255, 0.9);
+  font-size: 13px;
+  font-weight: 600;
+`;
+var Required = styled4.span`
+  margin-left: 4px;
+  color: rgba(255, 122, 122, 0.9);
+`;
+var QuestionBody = styled4.div`
+  display: grid;
+  gap: 10px;
+`;
+var OptionList = styled4.div`
+  display: grid;
+  gap: 10px;
+`;
+var OptionChoiceItem = styled4.div`
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  width: 100%;
+  text-align: left;
+  border: 1px solid rgba(255, 255, 255, 0.1);
+  border-radius: 14px;
+  background: rgba(255, 255, 255, 0.03);
+  padding: 12px 14px;
+  color: rgba(255, 255, 255, 0.9);
+  cursor: pointer;
+  transition:
+    border-color 140ms ease,
+    background 140ms ease,
+    transform 140ms ease;
+  outline: none;
+
+  &[data-selected='true'] {
+    border-color: rgba(126, 160, 255, 0.42);
+    background: linear-gradient(180deg, rgba(82, 114, 255, 0.18) 0%, rgba(82, 114, 255, 0.1) 100%);
+    transform: translateY(-1px);
+  }
+
+  &[data-tone='other'] {
+    border-style: dashed;
+  }
+
+  &:focus-visible {
+    border-color: rgba(126, 160, 255, 0.52);
+    box-shadow: 0 0 0 1px rgba(126, 160, 255, 0.18);
+  }
+
+  &[tabindex='-1'] {
+    cursor: default;
+    opacity: 0.72;
+    transform: none;
+  }
+`;
+var OptionChoiceMarker = styled4.span`
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  flex: 0 0 28px;
+  width: 28px;
+  height: 28px;
+  border-radius: 8px;
+  border: 1px solid rgba(255, 255, 255, 0.14);
+  background: rgba(255, 255, 255, 0.04);
+  color: rgba(255, 255, 255, 0.65);
+  font-size: 12px;
+  font-weight: 700;
+
+  &[data-selected='true'] {
+    border-color: rgba(126, 160, 255, 0.38);
+    background: rgba(126, 160, 255, 0.2);
+    color: rgba(255, 255, 255, 0.96);
+  }
+`;
+var OptionChoiceContent = styled4.span`
+  display: grid;
+  gap: 2px;
+  min-width: 0;
+  flex: 1;
+`;
+var OptionChoiceLabel = styled4.span`
+  color: inherit;
+  font-size: 13px;
+  font-weight: 600;
+  line-height: 1.4;
+`;
+var TextInput = styled4.input`
+  width: 100%;
+  border: 1px solid rgba(255, 255, 255, 0.1);
+  border-radius: 12px;
+  background: rgba(13, 15, 21, 0.55);
+  color: rgba(255, 255, 255, 0.92);
+  font-size: 13px;
+  padding: 10px 12px;
+
+  &::placeholder {
+    color: rgba(255, 255, 255, 0.34);
+  }
+`;
+var InlineOtherInput = styled4(TextInput)`
+  margin-top: 0;
+`;
+var NumberInputRow = styled4.div`
+  display: flex;
+  align-items: center;
+  gap: 10px;
+`;
+var Unit = styled4.span`
+  color: rgba(255, 255, 255, 0.58);
+  font-size: 12px;
+  white-space: nowrap;
+`;
+var ErrorMessage = styled4.div`
+  color: rgba(255, 145, 145, 0.96);
+  font-size: 12px;
+`;
+var SubmitButton = styled4.button`
+  justify-self: flex-start;
+  border: none;
+  border-radius: 999px;
+  background: linear-gradient(180deg, #7ea0ff 0%, #4a6fff 100%);
+  color: #081127;
+  font-size: 12px;
+  font-weight: 700;
+  padding: 10px 14px;
+  cursor: pointer;
+`;
+
+// src/components/chat-thread/components/pde-ai-result-summary-card.tsx
+import styled5 from "@emotion/styled";
+import { jsx as jsx6, jsxs as jsxs4 } from "@emotion/react/jsx-runtime";
+var PDEAIResultSummaryCard = ({ summary }) => /* @__PURE__ */ jsxs4(Card5, { "data-testid": "pde-ai-result-summary-card", "data-status": summary.status, children: [
+  /* @__PURE__ */ jsx6(Eyebrow2, { children: summary.status }),
+  /* @__PURE__ */ jsx6(Headline, { children: summary.headline }),
+  /* @__PURE__ */ jsx6(Details, { children: summary.details.map((detail) => /* @__PURE__ */ jsx6(Detail, { children: detail }, detail)) })
+] });
+var Card5 = styled5.section`
+  display: grid;
+  gap: 10px;
+  padding: 14px;
+  border-radius: 18px;
+  border: 1px solid rgba(255, 255, 255, 0.08);
+  background: rgba(255, 255, 255, 0.03);
+
+  &[data-status='completed'] {
+    border-color: rgba(84, 214, 160, 0.26);
+  }
+
+  &[data-status='failed'] {
+    border-color: rgba(255, 122, 122, 0.24);
+  }
+`;
+var Eyebrow2 = styled5.span`
+  color: rgba(255, 255, 255, 0.58);
+  font-size: 11px;
+  font-weight: 700;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+`;
+var Headline = styled5.strong`
+  color: rgba(255, 255, 255, 0.94);
+  font-size: 15px;
+`;
+var Details = styled5.ul`
+  margin: 0;
+  padding-left: 18px;
+  color: rgba(255, 255, 255, 0.8);
+  font-size: 13px;
+`;
+var Detail = styled5.li`
+  & + & {
+    margin-top: 6px;
+  }
+`;
+
+// src/components/chat-thread/components/image-viewer.tsx
+import styled6 from "@emotion/styled";
+import { useEffect as useEffect2, useRef as useRef3 } from "react";
+import { jsx as jsx7 } from "@emotion/react/jsx-runtime";
+var Overlay = styled6.div`
+  position: fixed;
+  inset: 0;
+  background: rgba(0, 0, 0, 0.85);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  z-index: 9999;
+  cursor: zoom-out;
+`;
+var Img = styled6.img`
+  max-width: 90vw;
+  max-height: 90vh;
+  object-fit: contain;
+  border-radius: 4px;
+`;
+var ImageViewer = ({ src, alt, onClose }) => {
+  const overlayRef = useRef3(null);
+  useEffect2(() => {
+    const handleKey = (e) => {
+      if (e.key === "Escape")
+        onClose();
+    };
+    document.addEventListener("keydown", handleKey);
+    return () => document.removeEventListener("keydown", handleKey);
+  }, [onClose]);
+  useEffect2(() => {
+    overlayRef.current?.focus();
+  }, []);
+  const stopPropagation = (e) => e.stopPropagation();
+  return /* @__PURE__ */ jsx7(
+    Overlay,
+    {
+      ref: overlayRef,
+      role: "dialog",
+      "aria-modal": "true",
+      "aria-label": "Image viewer",
+      tabIndex: -1,
+      onClick: onClose,
+      children: /* @__PURE__ */ jsx7(Img, { src, alt: alt ?? "", onClick: stopPropagation })
+    }
+  );
+};
+
+// src/components/chat-thread/components/chat-message-item.tsx
+import { Fragment as Fragment2, jsx as jsx8, jsxs as jsxs5 } from "@emotion/react/jsx-runtime";
+var MARKDOWN_REMARK_PLUGINS = [remarkGfm, remarkMath];
+var MARKDOWN_REHYPE_PLUGINS = [rehypeKatex];
+var MARKDOWN_COMPONENTS = {
+  table: ({ node: _node, ...props }) => /* @__PURE__ */ jsx8(TableWrapper, { children: /* @__PURE__ */ jsx8("table", { ...props }) })
+};
+var renderMarkdownContent = (content) => /* @__PURE__ */ jsx8(
+  ReactMarkdown,
+  {
+    remarkPlugins: MARKDOWN_REMARK_PLUGINS,
+    rehypePlugins: MARKDOWN_REHYPE_PLUGINS,
+    components: MARKDOWN_COMPONENTS,
+    children: content
+  }
+);
+var createExecutionConfirmationContent = (proposal) => [
+  "Execution confirmed",
+  `- Equation: ${proposal.equationName}`,
+  ...proposal.solverName ? [`- Solver: ${proposal.solverName}`] : [],
+  `- Proposal ID: ${proposal.proposalId}`
+].join("\n");
+var areChatAttachmentsEqual = (previousAttachments, nextAttachments) => {
+  if (previousAttachments === nextAttachments) {
+    return true;
+  }
+  if (!previousAttachments || !nextAttachments) {
+    return previousAttachments === nextAttachments;
+  }
+  if (previousAttachments.length !== nextAttachments.length) {
+    return false;
+  }
+  return previousAttachments.every((attachment, index) => {
+    const nextAttachment = nextAttachments[index];
+    return attachment.id === nextAttachment?.id && attachment.name === nextAttachment.name && attachment.mimeType === nextAttachment.mimeType && attachment.size === nextAttachment.size && attachment.previewUrl === nextAttachment.previewUrl;
+  });
+};
+var areParameterSummaryItemsEqual = (previousItems, nextItems) => previousItems.length === nextItems.length && previousItems.every((item, index) => {
+  const nextItem = nextItems[index];
+  return item.label === nextItem?.label && item.value === nextItem.value && item.fieldPath === nextItem.fieldPath;
+});
+var areExecutionProposalsEqual = (previousProposal, nextProposal) => previousProposal.proposalId === nextProposal.proposalId && previousProposal.equationKey === nextProposal.equationKey && previousProposal.equationName === nextProposal.equationName && previousProposal.solverName === nextProposal.solverName && previousProposal.requiresConfirmation === nextProposal.requiresConfirmation && areParameterSummaryItemsEqual(previousProposal.parameterSummary, nextProposal.parameterSummary) && (previousProposal.warnings ?? []).length === (nextProposal.warnings ?? []).length && (previousProposal.warnings ?? []).every(
+  (warning, index) => warning === nextProposal.warnings?.[index]
+);
+var areResultSummariesEqual = (previousSummary, nextSummary) => previousSummary.taskId === nextSummary.taskId && previousSummary.status === nextSummary.status && previousSummary.headline === nextSummary.headline && previousSummary.details.length === nextSummary.details.length && previousSummary.details.every((detail, index) => detail === nextSummary.details[index]);
+var areStringArraysEqual = (previousValues, nextValues) => previousValues.length === nextValues.length && previousValues.every((value, index) => value === nextValues[index]);
+var areQuestionAnswersEqual = (previousAnswer, nextAnswer) => {
+  if (Array.isArray(previousAnswer) || Array.isArray(nextAnswer)) {
+    return Array.isArray(previousAnswer) && Array.isArray(nextAnswer) && areStringArraysEqual(previousAnswer, nextAnswer);
+  }
+  return previousAnswer === nextAnswer;
+};
+var areQuestionAnswerMapsEqual = (previousAnswers, nextAnswers) => {
+  if (previousAnswers === nextAnswers) {
+    return true;
+  }
+  if (!previousAnswers || !nextAnswers) {
+    return previousAnswers === nextAnswers;
+  }
+  const previousKeys = Object.keys(previousAnswers);
+  const nextKeys = Object.keys(nextAnswers);
+  return previousKeys.length === nextKeys.length && previousKeys.every((key) => areQuestionAnswersEqual(previousAnswers[key], nextAnswers[key]));
+};
+var areQuestionOptionsEqual = (previousOptions, nextOptions) => previousOptions.length === nextOptions.length && previousOptions.every(
+  (option, index) => option.label === nextOptions[index]?.label && option.value === nextOptions[index]?.value
+);
+var arePlanQuestionsEqual = (previousQuestion, nextQuestion) => {
+  if (previousQuestion.id !== nextQuestion.id || previousQuestion.label !== nextQuestion.label || previousQuestion.required !== nextQuestion.required || previousQuestion.kind !== nextQuestion.kind) {
+    return false;
+  }
+  switch (previousQuestion.kind) {
+    case "single_select":
+      return nextQuestion.kind === "single_select" && previousQuestion.allowOther === nextQuestion.allowOther && areQuestionOptionsEqual(previousQuestion.options, nextQuestion.options);
+    case "multi_select":
+      return nextQuestion.kind === "multi_select" && areQuestionOptionsEqual(previousQuestion.options, nextQuestion.options);
+    case "text":
+      return nextQuestion.kind === "text" && previousQuestion.placeholder === nextQuestion.placeholder;
+    case "number":
+      return nextQuestion.kind === "number" && previousQuestion.placeholder === nextQuestion.placeholder && previousQuestion.unit === nextQuestion.unit;
+    case "boolean":
+      return nextQuestion.kind === "boolean" && previousQuestion.trueLabel === nextQuestion.trueLabel && previousQuestion.falseLabel === nextQuestion.falseLabel;
+    default:
+      return false;
+  }
+};
+var areQuestionnairesEqual = (previousQuestionnaire, nextQuestionnaire) => previousQuestionnaire.questionnaireId === nextQuestionnaire.questionnaireId && previousQuestionnaire.title === nextQuestionnaire.title && previousQuestionnaire.description === nextQuestionnaire.description && previousQuestionnaire.submitLabel === nextQuestionnaire.submitLabel && previousQuestionnaire.questions.length === nextQuestionnaire.questions.length && previousQuestionnaire.questions.every(
+  (question, index) => arePlanQuestionsEqual(question, nextQuestionnaire.questions[index])
+) && areQuestionAnswerMapsEqual(previousQuestionnaire.answers, nextQuestionnaire.answers);
+var areMessageBlocksEqual = (previousBlocks, nextBlocks) => {
+  if (previousBlocks === nextBlocks) {
+    return true;
+  }
+  if (!previousBlocks || !nextBlocks) {
+    return previousBlocks === nextBlocks;
+  }
+  if (previousBlocks.length !== nextBlocks.length) {
+    return false;
+  }
+  return previousBlocks.every((block, index) => {
+    const nextBlock = nextBlocks[index];
+    if (!nextBlock || block.type !== nextBlock.type) {
+      return false;
+    }
+    switch (block.type) {
+      case "markdown": {
+        const comparableBlock = nextBlock;
+        return block.text === comparableBlock.text;
+      }
+      case "notice": {
+        const comparableBlock = nextBlock;
+        return block.tone === comparableBlock.tone && block.text === comparableBlock.text;
+      }
+      case "parameter_summary": {
+        const comparableBlock = nextBlock;
+        return areParameterSummaryItemsEqual(block.items, comparableBlock.items);
+      }
+      case "confirmation_card": {
+        const comparableBlock = nextBlock;
+        return areExecutionProposalsEqual(block.proposal, comparableBlock.proposal);
+      }
+      case "result_summary": {
+        const comparableBlock = nextBlock;
+        return areResultSummariesEqual(block.summary, comparableBlock.summary);
+      }
+      case "questionnaire": {
+        const comparableBlock = nextBlock;
+        return areQuestionnairesEqual(block.questionnaire, comparableBlock.questionnaire);
+      }
+      case "custom": {
+        const comparableBlock = nextBlock;
+        return block.kind === comparableBlock.kind && block.data === comparableBlock.data;
+      }
+      default:
+        return false;
+    }
+  });
+};
+var isSameMessage = (previousMessage, nextMessage, previousMode, nextMode, previousConfirmationSubmit, nextConfirmationSubmit, previousQuestionnaireSubmit, nextQuestionnaireSubmit, previousRenderMessageBlock, nextRenderMessageBlock) => previousMessage.id === nextMessage.id && previousMessage.sessionId === nextMessage.sessionId && previousMessage.role === nextMessage.role && previousMessage.content === nextMessage.content && areMessageBlocksEqual(previousMessage.blocks, nextMessage.blocks) && previousMessage.localOnly === nextMessage.localOnly && areChatAttachmentsEqual(previousMessage.attachments, nextMessage.attachments) && previousMessage.status === nextMessage.status && previousMessage.createdAt === nextMessage.createdAt && previousMode === nextMode && previousConfirmationSubmit === nextConfirmationSubmit && previousQuestionnaireSubmit === nextQuestionnaireSubmit && previousRenderMessageBlock === nextRenderMessageBlock;
+var ChatMessageItemView = ({
+  message,
+  mode = "agent",
+  onConfirmationSubmit,
+  onQuestionnaireSubmit,
+  renderMessageBlock
+}) => {
+  const { labels } = useChatContext();
+  const [activeImage, setActiveImage] = useState4(void 0);
+  const { displayedContent, freshContent, isAssistantStreaming, settledContent } = useChatMessageReveal(message);
+  const isStoppedAssistant = message.role === "assistant" && message.status === "stopped";
+  const attachments = message.attachments ?? [];
+  const blocks = message.blocks ?? [];
+  const hasStructuredBlocks = blocks.length > 0;
+  const hasTextContent = Boolean(settledContent || freshContent || displayedContent);
+  const isPlanMode = mode === "plan";
+  const canSubmitConfirmation = isPlanMode && typeof onConfirmationSubmit === "function";
+  const canSubmitQuestionnaire = isPlanMode && typeof onQuestionnaireSubmit === "function";
+  const shouldShowStreamingCaret = isAssistantStreaming && (!hasStructuredBlocks || hasTextContent);
+  const renderChatMessageBlock = (block, index) => {
+    switch (block.type) {
+      case "markdown":
+        return /* @__PURE__ */ jsx8(
+          ContentBlock,
+          {
+            "data-testid": `chat-message-block-${index}`,
+            "data-block-tone": "settled",
+            children: renderMarkdownContent(block.text)
+          },
+          `markdown-${index}`
+        );
+      case "notice":
+        return /* @__PURE__ */ jsx8(Fragment, { children: /* @__PURE__ */ jsx8(PDEAINoticeCard, { text: block.text, tone: block.tone }) }, `notice-${index}`);
+      case "parameter_summary":
+        return /* @__PURE__ */ jsx8(Fragment, { children: /* @__PURE__ */ jsx8(PDEAIParameterSummaryCard, { items: block.items }) }, `parameter-summary-${index}`);
+      case "confirmation_card":
+        return /* @__PURE__ */ jsx8(Fragment, { children: /* @__PURE__ */ jsx8(
+          PDEAIExecutionConfirmationCard,
+          {
+            proposal: block.proposal,
+            interactive: isPlanMode,
+            onConfirm: canSubmitConfirmation ? () => onConfirmationSubmit({
+              proposalId: block.proposal.proposalId,
+              content: createExecutionConfirmationContent(block.proposal),
+              sourceMessageId: message.id
+            }) : void 0
+          }
+        ) }, `confirmation-card-${index}`);
+      case "result_summary":
+        return /* @__PURE__ */ jsx8(Fragment, { children: /* @__PURE__ */ jsx8(PDEAIResultSummaryCard, { summary: block.summary }) }, `result-summary-${index}`);
+      case "questionnaire":
+        return /* @__PURE__ */ jsx8(Fragment, { children: /* @__PURE__ */ jsx8(
+          PDEAIQuestionnaireCard,
+          {
+            questionnaire: block.questionnaire,
+            interactive: canSubmitQuestionnaire,
+            onSubmit: canSubmitQuestionnaire ? (submission) => onQuestionnaireSubmit({
+              ...submission,
+              sourceMessageId: message.id
+            }) : void 0
+          }
+        ) }, `questionnaire-${index}`);
+      case "custom":
+        return /* @__PURE__ */ jsx8(Fragment, { children: renderMessageBlock?.({
+          block,
+          index,
+          message,
+          mode,
+          onConfirmationSubmit,
+          onQuestionnaireSubmit
+        }) ?? null }, `custom-${block.kind}-${index}`);
+      default:
+        return null;
+    }
+  };
+  const renderTextContent = () => /* @__PURE__ */ jsxs5(Fragment2, { children: [
+    settledContent ? /* @__PURE__ */ jsx8(ContentBlock, { "data-testid": "chat-message-settled-block", "data-block-tone": "settled", children: renderMarkdownContent(settledContent) }) : null,
+    freshContent ? /* @__PURE__ */ jsx8(ContentBlock, { "data-testid": "chat-message-fresh-block", "data-block-tone": "fresh", children: renderMarkdownContent(freshContent) }) : null,
+    !settledContent && !freshContent && hasTextContent ? /* @__PURE__ */ jsx8(ContentBlock, { "data-testid": "chat-message-settled-block", "data-block-tone": "settled", children: renderMarkdownContent(displayedContent) }) : null
+  ] });
+  return /* @__PURE__ */ jsxs5(Fragment2, { children: [
+    /* @__PURE__ */ jsxs5(Bubble, { "data-role": message.role, "data-status": message.status ?? "done", children: [
+      /* @__PURE__ */ jsxs5(Header2, { children: [
+        isAssistantStreaming ? /* @__PURE__ */ jsxs5(
+          StreamingIndicator,
+          {
+            "data-testid": "chat-streaming-indicator",
+            "aria-label": labels.assistantStreamingAriaLabel,
+            children: [
+              /* @__PURE__ */ jsx8(IndicatorSpark, {}),
+              /* @__PURE__ */ jsx8(IndicatorSpark, { "data-secondary": true })
+            ]
+          }
+        ) : null,
+        /* @__PURE__ */ jsx8(Role, { children: message.role === "user" ? labels.userRoleLabel : labels.assistantRoleLabel }),
+        isStoppedAssistant ? /* @__PURE__ */ jsx8(StatusTag, { "data-testid": "chat-message-stopped-tag", children: labels.stoppedResponse }) : null
+      ] }),
+      /* @__PURE__ */ jsxs5(Content, { "data-testid": "chat-message-content", children: [
+        hasStructuredBlocks || hasTextContent ? /* @__PURE__ */ jsxs5(ContentStack, { "data-testid": "chat-message-body-stack", children: [
+          hasStructuredBlocks ? blocks.map((block, index) => /* @__PURE__ */ jsx8(
+            ContentSegment,
+            {
+              "data-testid": "chat-message-content-segment",
+              children: renderChatMessageBlock(block, index)
+            },
+            `${block.type}-${index}`
+          )) : null,
+          hasTextContent ? /* @__PURE__ */ jsx8(ContentSegment, { "data-testid": "chat-message-content-segment", children: renderTextContent() }) : null
+        ] }) : null,
+        attachments.length ? /* @__PURE__ */ jsx8(AttachmentGrid, { "data-testid": "chat-message-attachment-grid", children: attachments.map((attachment) => /* @__PURE__ */ jsx8(
+          AttachmentButton,
+          {
+            type: "button",
+            "aria-label": attachment.name,
+            onClick: () => setActiveImage({
+              name: attachment.name,
+              previewUrl: attachment.previewUrl
+            }),
+            children: /* @__PURE__ */ jsx8(AttachmentImage, { src: attachment.previewUrl, alt: attachment.name })
+          },
+          attachment.id
+        )) }) : null,
+        shouldShowStreamingCaret ? /* @__PURE__ */ jsx8(StreamingCaret, { "data-testid": "chat-streaming-caret", "aria-hidden": "true" }) : null
+      ] })
+    ] }),
+    activeImage ? /* @__PURE__ */ jsx8(
+      ImageViewer,
+      {
+        src: activeImage.previewUrl,
+        alt: activeImage.name,
+        onClose: () => setActiveImage(void 0)
+      }
+    ) : null
+  ] });
+};
+var ChatMessageItem = memo(
+  ChatMessageItemView,
+  (previousProps, nextProps) => isSameMessage(
+    previousProps.message,
+    nextProps.message,
+    previousProps.mode,
+    nextProps.mode,
+    previousProps.onConfirmationSubmit,
+    nextProps.onConfirmationSubmit,
+    previousProps.onQuestionnaireSubmit,
+    nextProps.onQuestionnaireSubmit,
+    previousProps.renderMessageBlock,
+    nextProps.renderMessageBlock
+  )
+);
+var Bubble = styled7.article`
+  width: 100%;
+  max-width: 100%;
+  padding: 14px 16px;
+  border-radius: 22px;
+  background: rgba(255, 255, 255, 0.04);
+  border: 1px solid rgba(255, 255, 255, 0.07);
+  box-shadow:
+    inset 0 1px 0 rgba(255, 255, 255, 0.03),
+    0 12px 30px rgba(0, 0, 0, 0.18);
+
+  &[data-role='user'] {
+    width: auto;
+    max-width: min(760px, 100%);
+    margin-left: auto;
+    background: linear-gradient(180deg, rgba(59, 59, 63, 0.9) 0%, rgba(42, 43, 46, 0.92) 100%);
+  }
+`;
+var Header2 = styled7.div`
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  margin-bottom: 10px;
+`;
+var Role = styled7.div`
+  font-size: 12px;
+  color: rgba(255, 255, 255, 0.42);
+  text-transform: capitalize;
+  letter-spacing: 0.08em;
+`;
+var StatusTag = styled7.span`
+  display: inline-flex;
+  align-items: center;
+  padding: 3px 10px;
+  border-radius: 999px;
+  background: rgba(255, 255, 255, 0.14);
+  border: 1px solid rgba(255, 255, 255, 0.16);
+  color: rgba(255, 255, 255, 0.84);
+  font-size: 11px;
+  font-weight: 600;
+  letter-spacing: 0.02em;
+  box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.08);
+`;
+var Content = styled7.div`
+  color: rgba(255, 255, 255, 0.92);
+  line-height: 1.6;
+
+  p {
+    margin: 0;
+  }
+
+  p + p {
+    margin-top: 12px;
+  }
+
+  table {
+    width: 100%;
+    border-collapse: collapse;
+    margin: 0;
+    overflow: hidden;
+    border-radius: 14px;
+    border: 1px solid rgba(255, 255, 255, 0.08);
+    background: rgba(255, 255, 255, 0.03);
+  }
+
+  th,
+  td {
+    padding: 10px 12px;
+    text-align: left;
+    vertical-align: top;
+    border-bottom: 1px solid rgba(255, 255, 255, 0.08);
+  }
+
+  th {
+    color: rgba(255, 255, 255, 0.82);
+    font-weight: 600;
+    background: rgba(255, 255, 255, 0.04);
+  }
+
+  tbody tr:last-of-type td {
+    border-bottom: none;
+  }
+`;
+var ContentStack = styled7.div`
+  display: flex;
+  flex-direction: column;
+  gap: 16px;
+`;
+var ContentSegment = styled7.div`
+  min-width: 0;
+`;
+var ContentBlock = styled7.div`
+  transition:
+    opacity 180ms ease-out,
+    filter 180ms ease-out;
+
+  & + & {
+    margin-top: 16px;
+  }
+
+  &[data-block-tone='fresh'] {
+    opacity: 0.85;
+    filter: brightness(0.82) saturate(0.88);
+  }
+`;
+var AttachmentGrid = styled7.div`
+  display: flex;
+  flex-wrap: wrap;
+  gap: 10px;
+  margin-top: 12px;
+`;
+var AttachmentButton = styled7.button`
+  width: 116px;
+  height: 86px;
+  overflow: hidden;
+  padding: 0;
+  border: 1px solid rgba(255, 255, 255, 0.12);
+  border-radius: 14px;
+  background: rgba(255, 255, 255, 0.05);
+  cursor: pointer;
+`;
+var AttachmentImage = styled7.img`
+  width: 100%;
+  height: 100%;
+  display: block;
+  object-fit: cover;
+`;
+var TableWrapper = styled7.div`
+  overflow-x: auto;
+`;
+var caretBlink = keyframes`
+  0%, 49% {
+    opacity: 1;
+  }
+
+  50%, 100% {
+    opacity: 0.2;
+  }
+`;
+var shimmer = keyframes`
+  0%, 100% {
+    transform: scale(0.9) rotate(0deg);
+    opacity: 0.55;
+  }
+
+  50% {
+    transform: scale(1.05) rotate(8deg);
+    opacity: 1;
+  }
+`;
+var StreamingIndicator = styled7.div`
+  position: relative;
+  width: 26px;
+  height: 26px;
+  flex-shrink: 0;
+  display: grid;
+  place-items: center;
+  border-radius: 8px;
+  background:
+    radial-gradient(circle at 50% 50%, rgba(78, 102, 255, 0.18), transparent 70%),
+    rgba(255, 255, 255, 0.01);
+  border: 1px dashed rgba(255, 255, 255, 0.14);
+`;
+var IndicatorSpark = styled7.span`
+  position: absolute;
+  width: 10px;
+  height: 10px;
+  background: linear-gradient(180deg, #7ea0ff 0%, #4a6fff 100%);
+  clip-path: polygon(50% 0%, 68% 32%, 100% 50%, 68% 68%, 50% 100%, 32% 68%, 0% 50%, 32% 32%);
+  box-shadow: 0 0 12px rgba(78, 102, 255, 0.55);
+  animation: ${shimmer} 1.2s ease-in-out infinite;
+
+  &[data-secondary] {
+    width: 6px;
+    height: 6px;
+    top: 4px;
+    left: 5px;
+    animation-delay: 0.2s;
+  }
+`;
+var StreamingCaret = styled7.span`
+  display: inline-block;
+  width: 8px;
+  height: 1.1em;
+  margin-left: 2px;
+  vertical-align: text-bottom;
+  border-radius: 999px;
+  background: linear-gradient(180deg, rgba(126, 160, 255, 0.95) 0%, rgba(74, 111, 255, 0.75) 100%);
+  box-shadow: 0 0 10px rgba(78, 102, 255, 0.35);
+  animation: ${caretBlink} 0.9s steps(1) infinite;
+`;
+
+// src/components/chat-thread/components/chat-thread-history-list.tsx
+import { memo as memo2 } from "react";
+import styled8 from "@emotion/styled";
+import { jsx as jsx9 } from "@emotion/react/jsx-runtime";
+var ChatThreadHistoryList = memo2(
+  ({
+    mode,
+    historyMessages,
+    latestUserMessageId,
+    latestUserMessageRef,
+    onConfirmationSubmit,
+    onQuestionnaireSubmit,
+    renderMessageBlock
+  }) => /* @__PURE__ */ jsx9(HistoryGroup, { "data-testid": "chat-thread-history", children: historyMessages.map((message) => /* @__PURE__ */ jsx9(
+    MessageSlot,
+    {
+      ref: message.id === latestUserMessageId ? latestUserMessageRef : null,
+      "data-testid": message.id === latestUserMessageId ? "chat-latest-user-anchor" : void 0,
+      style: message.id === latestUserMessageId ? {
+        scrollMarginTop: `${CHAT_THREAD_SCROLL_TOP_GAP}px`
+      } : void 0,
+      children: /* @__PURE__ */ jsx9(
+        ChatMessageItem,
+        {
+          mode,
+          message,
+          onConfirmationSubmit,
+          onQuestionnaireSubmit,
+          renderMessageBlock
+        }
+      )
+    },
+    message.id
+  )) })
+);
+ChatThreadHistoryList.displayName = "ChatThreadHistoryList";
+var HistoryGroup = styled8.div`
+  display: contents;
+`;
+var MessageSlot = styled8.div`
+  display: flex;
+  align-items: flex-start;
+`;
+
+// src/components/chat-thread/components/chat-thread-empty-state.tsx
+import styled9 from "@emotion/styled";
+import { jsx as jsx10, jsxs as jsxs6 } from "@emotion/react/jsx-runtime";
+var ChatThreadEmptyState = () => {
+  const { labels } = useChatContext();
+  return /* @__PURE__ */ jsxs6(EmptyShell, { "data-testid": "chat-empty-hero", children: [
+    /* @__PURE__ */ jsxs6(HeroMark, { children: [
+      /* @__PURE__ */ jsx10(HeroOrbit, {}),
+      /* @__PURE__ */ jsx10(HeroCore, { children: "AI" })
+    ] }),
+    /* @__PURE__ */ jsx10(HeroTitle, { children: labels.emptyStateTitle }),
+    /* @__PURE__ */ jsx10(HeroSubtitle, { children: labels.emptyStateSubtitle })
+  ] });
+};
+var EmptyShell = styled9.div`
+  flex: 1;
+  min-height: 0;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  flex-direction: column;
+  gap: 16px;
+  padding: 48px 24px 24px;
+`;
+var HeroMark = styled9.div`
+  position: relative;
+  width: 108px;
+  height: 108px;
+  border-radius: 24px;
+  display: grid;
+  place-items: center;
+`;
+var HeroOrbit = styled9.div`
+  position: absolute;
+  inset: 20px;
+  border-radius: 50%;
+  border: 1px solid rgba(255, 255, 255, 0.22);
+  box-shadow:
+    0 0 24px rgba(78, 102, 255, 0.3),
+    inset 0 0 16px rgba(255, 255, 255, 0.08);
+
+  &::before,
+  &::after {
+    content: '';
+    position: absolute;
+    border-radius: 50%;
+    inset: -7px;
+    border: 1px solid rgba(78, 102, 255, 0.12);
+  }
+
+  &::after {
+    inset: 8px -10px;
+    transform: rotate(-22deg);
+  }
+`;
+var HeroCore = styled9.div`
+  position: relative;
+  z-index: 1;
+  font-size: 28px;
+  line-height: 1;
+  font-weight: 600;
+  letter-spacing: 0.08em;
+  color: rgba(242, 244, 255, 0.96);
+  text-shadow: 0 0 16px rgba(98, 116, 255, 0.65);
+`;
+var HeroTitle = styled9.p`
+  margin: 0;
+  color: rgba(255, 255, 255, 0.88);
+  font-size: 16px;
+  line-height: 24px;
+`;
+var HeroSubtitle = styled9.p`
+  margin: 0;
+  color: rgba(255, 255, 255, 0.72);
+  font-size: 14px;
+  line-height: 20px;
+`;
+
+// src/components/chat-thread/index.tsx
+import { jsx as jsx11, jsxs as jsxs7 } from "@emotion/react/jsx-runtime";
+var ChatThreadView = ({
+  activeSessionMode = DEFAULT_CHAT_AGENT_MODE,
+  historyMessages,
+  streamingMessage,
+  error,
+  retryButtonLabel,
+  onRetry,
+  onConfirmationSubmit,
+  onQuestionnaireSubmit,
+  renderMessageBlock
+}) => {
+  const containerRef = useRef4(null);
+  const latestUserMessageId = useMemo3(
+    () => findLatestUserMessageId(historyMessages),
+    [historyMessages]
+  );
+  const latestUserMessageRef = useRef4(null);
+  const pendingScrollUserMessageIdRef = useRef4(void 0);
+  const reservedSpaceFrameRef = useRef4(null);
+  const [latestUserMessageReservedSpace, setLatestUserMessageReservedSpace] = useState5({ messageId: void 0, value: 0 });
+  const reservedPaddingBottom = 24 + (latestUserMessageReservedSpace.messageId === latestUserMessageId ? latestUserMessageReservedSpace.value : 0);
+  const measureLatestUserMessageReservedSpace = useCallback2((messageId) => {
+    const container = containerRef.current;
+    const target = latestUserMessageRef.current;
+    if (!container || !target)
+      return;
+    const reservedHeight = calculateChatThreadScrollSpacerHeight({
+      containerClientHeight: container.clientHeight,
+      containerScrollHeight: container.scrollHeight,
+      targetOffsetTop: target.offsetTop
+    });
+    setLatestUserMessageReservedSpace((current) => {
+      const next = reservedHeight > 0 ? reservedHeight : 0;
+      if (current.messageId === messageId && current.value === next)
+        return current;
+      return { messageId, value: next };
+    });
+  }, []);
+  useLayoutEffect(() => {
+    if (reservedSpaceFrameRef.current !== null) {
+      window.cancelAnimationFrame(reservedSpaceFrameRef.current);
+      reservedSpaceFrameRef.current = null;
+    }
+    if (!latestUserMessageId) {
+      pendingScrollUserMessageIdRef.current = void 0;
+      reservedSpaceFrameRef.current = window.requestAnimationFrame(() => {
+        reservedSpaceFrameRef.current = null;
+        setLatestUserMessageReservedSpace(
+          (current) => current.messageId === void 0 && current.value === 0 ? current : { messageId: void 0, value: 0 }
+        );
+      });
+      return () => {
+        if (reservedSpaceFrameRef.current !== null) {
+          window.cancelAnimationFrame(reservedSpaceFrameRef.current);
+          reservedSpaceFrameRef.current = null;
+        }
+      };
+    }
+    pendingScrollUserMessageIdRef.current = latestUserMessageId;
+    reservedSpaceFrameRef.current = window.requestAnimationFrame(() => {
+      reservedSpaceFrameRef.current = null;
+      measureLatestUserMessageReservedSpace(latestUserMessageId);
+    });
+    return () => {
+      if (reservedSpaceFrameRef.current !== null) {
+        window.cancelAnimationFrame(reservedSpaceFrameRef.current);
+        reservedSpaceFrameRef.current = null;
+      }
+    };
+  }, [latestUserMessageId, measureLatestUserMessageReservedSpace]);
+  useLayoutEffect(() => {
+    if (!latestUserMessageId || pendingScrollUserMessageIdRef.current !== latestUserMessageId)
+      return;
+    if (latestUserMessageReservedSpace.messageId !== latestUserMessageId)
+      return;
+    latestUserMessageRef.current?.scrollIntoView({ block: "start", behavior: "smooth" });
+    pendingScrollUserMessageIdRef.current = void 0;
+  }, [latestUserMessageId, latestUserMessageReservedSpace]);
+  return /* @__PURE__ */ jsxs7(
+    Container,
+    {
+      ref: containerRef,
+      "data-testid": "chat-thread",
+      style: { paddingBottom: `${reservedPaddingBottom}px` },
+      children: [
+        /* @__PURE__ */ jsx11(
+          ChatThreadHistoryList,
+          {
+            mode: activeSessionMode,
+            historyMessages,
+            latestUserMessageId,
+            latestUserMessageRef,
+            onConfirmationSubmit,
+            onQuestionnaireSubmit,
+            renderMessageBlock
+          }
+        ),
+        streamingMessage ? /* @__PURE__ */ jsx11(StreamingGroup, { "data-testid": "chat-thread-streaming", children: /* @__PURE__ */ jsx11(MessageSlot2, { children: /* @__PURE__ */ jsx11(
+          ChatMessageItem,
+          {
+            mode: activeSessionMode,
+            message: streamingMessage,
+            onConfirmationSubmit,
+            onQuestionnaireSubmit,
+            renderMessageBlock
+          }
+        ) }) }) : null,
+        error ? /* @__PURE__ */ jsxs7(ErrorState, { "data-testid": "chat-thread-error-state", children: [
+          /* @__PURE__ */ jsx11(ErrorText, { children: error }),
+          onRetry ? /* @__PURE__ */ jsx11(ErrorActions, { children: /* @__PURE__ */ jsx11(RetryButton, { type: "button", "data-testid": "chat-thread-retry", onClick: onRetry, children: retryButtonLabel }) }) : null
+        ] }) : null
+      ]
+    }
+  );
+};
+var EMPTY_MESSAGES = [];
+var ChatThread = () => {
+  const activeSessionId = useChatStore((s) => s.activeSessionId);
+  const hasSessions = useChatStore((s) => s.sessions.length > 0);
+  const activeSessionMode = useChatStore(
+    (s) => s.sessions.find((x) => x.sessionId === s.activeSessionId)?.mode ?? DEFAULT_CHAT_AGENT_MODE
+  );
+  const messages = useChatStore(
+    (s) => s.messagesBySession[s.activeSessionId ?? ""] ?? EMPTY_MESSAGES
+  );
+  const streamingMessage = useChatStore((s) => s.streamingMessageBySession[s.activeSessionId ?? ""]);
+  const error = useChatStore((s) => s.errorBySession[s.activeSessionId ?? ""]);
+  const updateQA = useChatStore((s) => s.updateQuestionnaireAnswers);
+  const clearSessionError = useChatStore((s) => s.clearSessionError);
+  const { sendRef, retryRef, renderMessageBlock, labels } = useChatContext();
+  const handleRetry = useCallback2(() => {
+    if (!activeSessionId)
+      return;
+    clearSessionError(activeSessionId);
+    void retryRef.current();
+  }, [activeSessionId, clearSessionError, retryRef]);
+  const handleQuestionnaireSubmit = useCallback2(
+    (submission) => {
+      if (activeSessionId && submission.sourceMessageId) {
+        updateQA(
+          activeSessionId,
+          submission.sourceMessageId,
+          submission.questionnaireId,
+          submission.answers
+        );
+      }
+      void sendRef.current(submission.content);
+    },
+    [activeSessionId, updateQA, sendRef]
+  );
+  const handleConfirmationSubmit = useCallback2(
+    (submission) => {
+      void sendRef.current(submission.content);
+    },
+    [sendRef]
+  );
+  if (!hasSessions || messages.length === 0 && !streamingMessage) {
+    return /* @__PURE__ */ jsx11(ChatThreadEmptyState, {});
+  }
+  return /* @__PURE__ */ jsx11(
+    ChatThreadView,
+    {
+      activeSessionMode,
+      historyMessages: messages,
+      streamingMessage,
+      error,
+      retryButtonLabel: labels.retryButton,
+      onRetry: handleRetry,
+      onConfirmationSubmit: handleConfirmationSubmit,
+      onQuestionnaireSubmit: handleQuestionnaireSubmit,
+      renderMessageBlock
+    }
+  );
+};
+var Container = styled10.div`
+  display: flex;
+  flex: 1;
+  flex-direction: column;
+  gap: 18px;
+  min-height: 0;
+  overflow: auto;
+  padding: 24px;
+  overscroll-behavior: contain;
+
+  &::-webkit-scrollbar {
+    width: 8px;
+  }
+
+  &::-webkit-scrollbar-thumb {
+    background: rgba(255, 255, 255, 0.18);
+    border-radius: 999px;
+  }
+
+  &::-webkit-scrollbar-track {
+    background: transparent;
+  }
+`;
+var MessageSlot2 = styled10.div`
+  display: flex;
+`;
+var StreamingGroup = styled10.div`
+  display: contents;
+`;
+var ErrorText = styled10.div`
+  color: #ff7b72;
+  font-size: 14px;
+`;
+var ErrorState = styled10.div`
+  display: flex;
+  flex-direction: column;
+  align-items: flex-start;
+  gap: 10px;
+`;
+var ErrorActions = styled10.div`
+  display: flex;
+  align-items: center;
+`;
+var RetryButton = styled10.button`
+  border: 1px solid rgba(255, 255, 255, 0.14);
+  border-radius: 999px;
+  background: rgba(255, 255, 255, 0.04);
+  color: rgba(255, 255, 255, 0.82);
+  font-size: 12px;
+  line-height: 1;
+  padding: 5px 10px;
+  cursor: pointer;
+
+  &:hover {
+    background: rgba(255, 255, 255, 0.08);
+  }
+`;
+
+// src/components/chat-composer/index.tsx
+import { useEffect as useEffect5, useRef as useRef7 } from "react";
+import styled15 from "@emotion/styled";
+
+// src/components/chat-composer/lib/chat-composer.ts
+var DRAFT_CHAT_SESSION_ID_PREFIX = "draft-session-";
+var createDraftChatSessionId = () => `${DRAFT_CHAT_SESSION_ID_PREFIX}${Date.now()}`;
+var isDraftChatSessionId = (sessionId) => Boolean(sessionId?.startsWith(DRAFT_CHAT_SESSION_ID_PREFIX));
+var createDraftChatSession = ({
+  model,
+  mode = DEFAULT_CHAT_AGENT_MODE,
+  nowIso: nowIso2,
+  createSessionId
+}) => {
+  const iso = nowIso2();
+  return {
+    sessionId: createSessionId(),
+    title: "New Chat",
+    createdAt: iso,
+    updatedAt: iso,
+    model,
+    mode
+  };
+};
+var createUserMessage = ({
+  sessionId,
+  content,
+  attachments,
+  localOnly,
+  createdAt,
+  createMessageId
+}) => ({
+  id: createMessageId(),
+  sessionId,
+  role: "user",
+  content,
+  attachments,
+  localOnly,
+  createdAt
+});
+var createAssistantStreamingMessage = ({
+  sessionId,
+  createdAt,
+  createMessageId
+}) => ({
+  id: createMessageId(),
+  sessionId,
+  role: "assistant",
+  content: "",
+  status: "streaming",
+  createdAt
+});
+var canSendChatMessage = ({
+  value,
+  attachmentCount = 0,
+  isModelsLoading,
+  isModelsError,
+  hasModels
+}) => {
+  const hasText = Boolean(value.trim());
+  const hasAttachments = attachmentCount > 0;
+  if (!hasText && !hasAttachments)
+    return false;
+  if (!hasText && hasAttachments)
+    return true;
+  return !isModelsLoading && !isModelsError && hasModels;
+};
+var shouldSubmitChatComposer = ({
+  key,
+  shiftKey,
+  canSend
+}) => key === "Enter" && !shiftKey && canSend;
+var shouldStopChatComposer = ({
+  key,
+  shiftKey,
+  isStreaming
+}) => key === "Enter" && !shiftKey && isStreaming;
+var resolveSelectedChatModel = ({
+  currentModel,
+  availableModels,
+  isModelsLoading
+}) => {
+  if (!availableModels.length) {
+    return isModelsLoading ? currentModel : "";
+  }
+  if (currentModel && availableModels.some((model) => model.id === currentModel)) {
+    return currentModel;
+  }
+  return availableModels[0].id;
+};
+var resolveSendSession = ({
+  activeSessionId,
+  selectedModel,
+  selectedMode,
+  nowIso: nowIso2,
+  createSessionId
+}) => {
+  if (activeSessionId) {
+    return {
+      localSessionId: activeSessionId,
+      sessionId: isDraftChatSessionId(activeSessionId) ? void 0 : activeSessionId
+    };
+  }
+  const session = createDraftChatSession({
+    model: selectedModel,
+    mode: selectedMode ?? DEFAULT_CHAT_AGENT_MODE,
+    nowIso: nowIso2,
+    createSessionId
+  });
+  return { session, localSessionId: session.sessionId, sessionId: void 0 };
+};
+
+// src/components/chat-composer/hooks/use-chat-composer.ts
+import { useCallback as useCallback3, useEffect as useEffect4, useRef as useRef6, useState as useState7 } from "react";
+
+// src/components/chat-composer/hooks/use-composer-attachments.ts
+import { useEffect as useEffect3, useRef as useRef5, useState as useState6 } from "react";
+var SUPPORTED_IMAGE_MIME_TYPES = /* @__PURE__ */ new Set(["image/png", "image/jpeg", "image/webp"]);
+var MAX_COMPOSER_ATTACHMENTS = 10;
+var createObjectUrl = (file) => typeof URL !== "undefined" && typeof URL.createObjectURL === "function" ? URL.createObjectURL(file) : "";
+var revokeObjectUrl = (url) => {
+  if (url && typeof URL !== "undefined" && typeof URL.revokeObjectURL === "function") {
+    URL.revokeObjectURL(url);
+  }
+};
+var createAttachmentId = () => `attachment-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+var releaseComposerAttachments = (attachments) => {
+  attachments.forEach((attachment) => revokeObjectUrl(attachment.previewUrl));
+};
+var useComposerAttachments = () => {
+  const [attachments, setAttachments] = useState6([]);
+  const attachmentsRef = useRef5([]);
+  useEffect3(() => {
+    attachmentsRef.current = attachments;
+  }, [attachments]);
+  useEffect3(
+    () => () => {
+      releaseComposerAttachments(attachmentsRef.current);
+    },
+    []
+  );
+  const appendFiles = (files) => {
+    const validFiles = Array.from(files).filter((file) => SUPPORTED_IMAGE_MIME_TYPES.has(file.type));
+    if (!validFiles.length)
+      return { addedCount: 0, limitExceeded: false };
+    const currentAttachments = attachmentsRef.current;
+    const remainingSlots = MAX_COMPOSER_ATTACHMENTS - currentAttachments.length;
+    if (remainingSlots <= 0)
+      return { addedCount: 0, limitExceeded: true };
+    const filesToAppend = validFiles.slice(0, remainingSlots);
+    const newAttachments = filesToAppend.map((file) => ({
+      id: createAttachmentId(),
+      file,
+      name: file.name,
+      mimeType: file.type,
+      size: file.size,
+      previewUrl: createObjectUrl(file)
+    }));
+    setAttachments((current) => [...current, ...newAttachments]);
+    return {
+      addedCount: filesToAppend.length,
+      limitExceeded: validFiles.length > filesToAppend.length
+    };
+  };
+  const removeAttachment = (attachmentId) => {
+    setAttachments((current) => {
+      const target = current.find((a) => a.id === attachmentId);
+      if (target)
+        releaseComposerAttachments([target]);
+      return current.filter((a) => a.id !== attachmentId);
+    });
+  };
+  const clearAttachments = () => {
+    setAttachments((current) => {
+      releaseComposerAttachments(current);
+      return [];
+    });
+  };
+  const takeMessageAttachments = () => {
+    const currentAttachments = attachmentsRef.current;
+    if (!currentAttachments.length) {
+      return [];
+    }
+    const nextMessageAttachments = currentAttachments.map(({ file: _file, ...attachment }) => ({
+      ...attachment
+    }));
+    attachmentsRef.current = [];
+    setAttachments([]);
+    return nextMessageAttachments;
+  };
+  return {
+    attachments,
+    appendFiles,
+    removeAttachment,
+    clearAttachments,
+    takeMessageAttachments
+  };
+};
+
+// src/components/chat-composer/hooks/use-chat-composer.ts
+var nowIso = () => (/* @__PURE__ */ new Date()).toISOString();
+var ATTACHMENT_NOTICE_DURATION_MS = 3e3;
+var STOP_WAIT_TIMEOUT_MS = 3e3;
+var resolveAccumulatedContent = (currentContent, update) => {
+  if (update.content !== void 0) {
+    return update.content;
+  }
+  if (update.contentDelta) {
+    return currentContent + update.contentDelta;
+  }
+  return currentContent;
+};
+var normalizeChatErrorMessage = (message, labels) => {
+  const trimmedMessage = message?.trim();
+  if (!trimmedMessage) {
+    return labels.genericError;
+  }
+  if (trimmedMessage === "Failed to fetch") {
+    return labels.networkError;
+  }
+  return trimmedMessage;
+};
+var useChatComposer = () => {
+  const { transport, enableImageAttachments, labels } = useChatContext();
+  const activeSessionId = useChatStore((s) => s.activeSessionId);
+  const activeSession = useChatStore(
+    (s) => s.sessions.find((x) => x.sessionId === s.activeSessionId) ?? null
+  );
+  const preferredMode = useChatStore((s) => s.preferredMode);
+  const streamingSessionId = useChatStore(
+    (s) => Object.entries(s.isStreamingBySession).find(([, v]) => v)?.[0] ?? null
+  );
+  const isStreaming = Boolean(streamingSessionId);
+  const isStopping = useChatStore(
+    (s) => streamingSessionId ? s.isStoppingBySession[streamingSessionId] ?? false : false
+  );
+  const createSession = useChatStore((s) => s.createSession);
+  const replaceSessionId = useChatStore((s) => s.replaceSessionId);
+  const appendMessage = useChatStore((s) => s.appendMessage);
+  const startStreamingMessage = useChatStore((s) => s.startStreamingMessage);
+  const patchStreamingMessage = useChatStore((s) => s.patchStreamingMessage);
+  const completeStreamingMessage = useChatStore((s) => s.completeStreamingMessage);
+  const requestStopStreaming = useChatStore((s) => s.requestStopStreaming);
+  const finalizeStoppedStreamingMessage = useChatStore((s) => s.finalizeStoppedStreamingMessage);
+  const setSessionError = useChatStore((s) => s.setSessionError);
+  const clearSessionError = useChatStore((s) => s.clearSessionError);
+  const setPreferredMode = useChatStore((s) => s.setPreferredMode);
+  const setSessionMode = useChatStore((s) => s.setSessionMode);
+  const [availableModels, setAvailableModels] = useState7([]);
+  const [isModelsLoading, setIsModelsLoading] = useState7(true);
+  const [isModelsError, setIsModelsError] = useState7(false);
+  const fetchModels = useCallback3(async () => {
+    setIsModelsLoading(true);
+    setIsModelsError(false);
+    try {
+      const modelsResponse = await transport.getModels();
+      setAvailableModels(modelsResponse.data);
+    } catch {
+      setIsModelsError(true);
+    } finally {
+      setIsModelsLoading(false);
+    }
+  }, [transport]);
+  useEffect4(() => {
+    void fetchModels();
+  }, [fetchModels]);
+  const hasModels = availableModels.length > 0;
+  const [value, setValue] = useState7("");
+  const [selectedModel, setSelectedModel] = useState7("");
+  const [selectedMode, setSelectedModeLocal] = useState7(DEFAULT_CHAT_AGENT_MODE);
+  const [attachmentNotice, setAttachmentNotice] = useState7(null);
+  const { attachments, appendFiles, removeAttachment, takeMessageAttachments } = useComposerAttachments();
+  const abortControllerRef = useRef6(null);
+  const stopRequestRef = useRef6(null);
+  const lastRequestRef = useRef6(null);
+  useEffect4(() => {
+    setSelectedModel(
+      (current) => resolveSelectedChatModel({ currentModel: current, availableModels, isModelsLoading })
+    );
+  }, [availableModels, isModelsLoading]);
+  useEffect4(() => {
+    if (activeSession) {
+      setSelectedModeLocal(activeSession.mode ?? DEFAULT_CHAT_AGENT_MODE);
+      return;
+    }
+    setSelectedModeLocal(preferredMode ?? DEFAULT_CHAT_AGENT_MODE);
+  }, [activeSession, preferredMode]);
+  useEffect4(() => {
+    if (!attachmentNotice)
+      return;
+    const timeoutId = window.setTimeout(
+      () => setAttachmentNotice(null),
+      ATTACHMENT_NOTICE_DURATION_MS
+    );
+    return () => window.clearTimeout(timeoutId);
+  }, [attachmentNotice]);
+  const clearStopTimeout = (sessionId) => {
+    if (!stopRequestRef.current)
+      return;
+    if (sessionId && stopRequestRef.current.sessionId !== sessionId)
+      return;
+    if (stopRequestRef.current.timeoutId !== null) {
+      window.clearTimeout(stopRequestRef.current.timeoutId);
+      stopRequestRef.current.timeoutId = null;
+    }
+  };
+  const clearStopRequest = useCallback3((sessionId) => {
+    if (!stopRequestRef.current)
+      return;
+    if (sessionId && stopRequestRef.current.sessionId !== sessionId)
+      return;
+    clearStopTimeout(sessionId);
+    stopRequestRef.current = null;
+  }, []);
+  const finalizeStop = useCallback3(
+    (sessionId) => {
+      if (stopRequestRef.current?.sessionId === sessionId) {
+        if (stopRequestRef.current.finalized)
+          return;
+        stopRequestRef.current.finalized = true;
+      }
+      clearStopTimeout(sessionId);
+      abortControllerRef.current?.abort();
+      abortControllerRef.current = null;
+      finalizeStoppedStreamingMessage(sessionId);
+      clearStopRequest(sessionId);
+    },
+    [clearStopRequest, finalizeStoppedStreamingMessage]
+  );
+  const runStream = useCallback3(
+    async ({
+      localSessionId,
+      sessionId,
+      content,
+      model,
+      mode
+    }) => {
+      clearStopRequest();
+      let currentSessionId = localSessionId;
+      clearSessionError(currentSessionId);
+      const assistantMessage = createAssistantStreamingMessage({
+        sessionId: currentSessionId,
+        createdAt: nowIso(),
+        createMessageId: () => `assistant-${Date.now()}`
+      });
+      startStreamingMessage(currentSessionId, assistantMessage);
+      abortControllerRef.current?.abort();
+      abortControllerRef.current = new AbortController();
+      lastRequestRef.current = { localSessionId, sessionId, content, model, mode };
+      let accumulated = "";
+      try {
+        await transport.startStream({
+          sessionId,
+          model,
+          mode,
+          content,
+          signal: abortControllerRef.current.signal,
+          onSessionId: (nextSessionId) => {
+            if (!nextSessionId || nextSessionId === currentSessionId)
+              return;
+            replaceSessionId(currentSessionId, nextSessionId);
+            currentSessionId = nextSessionId;
+            lastRequestRef.current = {
+              localSessionId: nextSessionId,
+              sessionId: nextSessionId,
+              content,
+              model,
+              mode
+            };
+          },
+          onUpdate: (update) => {
+            accumulated = resolveAccumulatedContent(accumulated, update);
+            patchStreamingMessage(currentSessionId, {
+              ...update.blocks ? { blocks: update.blocks } : {},
+              ...update.content !== void 0 || update.contentDelta ? { content: accumulated } : {}
+            });
+          },
+          onDone: () => {
+            if (stopRequestRef.current?.sessionId === currentSessionId) {
+              finalizeStop(currentSessionId);
+              return;
+            }
+            completeStreamingMessage(currentSessionId);
+            abortControllerRef.current = null;
+            clearStopRequest(currentSessionId);
+          },
+          onError: (streamError) => {
+            if (stopRequestRef.current?.sessionId === currentSessionId) {
+              finalizeStop(currentSessionId);
+              return;
+            }
+            finalizeStoppedStreamingMessage(currentSessionId);
+            setSessionError(
+              currentSessionId,
+              normalizeChatErrorMessage(streamError.message, labels)
+            );
+            abortControllerRef.current = null;
+            clearStopRequest(currentSessionId);
+          }
+        });
+      } catch {
+        abortControllerRef.current = null;
+      }
+    },
+    [
+      transport,
+      clearSessionError,
+      clearStopRequest,
+      finalizeStop,
+      labels,
+      startStreamingMessage,
+      replaceSessionId,
+      patchStreamingMessage,
+      completeStreamingMessage,
+      finalizeStoppedStreamingMessage,
+      setSessionError
+    ]
+  );
+  const send = useCallback3(
+    async (contentOverride) => {
+      const content = (contentOverride ?? value).trim();
+      const hasText = Boolean(content);
+      const hasAttachments = attachments.length > 0;
+      if (!canSendChatMessage({
+        value: content,
+        attachmentCount: attachments.length,
+        isModelsLoading,
+        isModelsError,
+        hasModels
+      })) {
+        return;
+      }
+      if (hasText && !(selectedModel || activeSession?.model || availableModels[0]?.id)) {
+        return;
+      }
+      const resolvedModel = selectedModel || activeSession?.model || availableModels[0]?.id || "local-image";
+      const { localSessionId, sessionId, session } = resolveSendSession({
+        activeSessionId,
+        selectedModel: resolvedModel,
+        selectedMode,
+        nowIso,
+        createSessionId: createDraftChatSessionId
+      });
+      if (session)
+        createSession(session);
+      const messageAttachments = takeMessageAttachments();
+      const userMessage = createUserMessage({
+        sessionId: localSessionId,
+        content,
+        attachments: messageAttachments,
+        localOnly: hasAttachments,
+        createdAt: nowIso(),
+        createMessageId: () => `user-${Date.now()}`
+      });
+      appendMessage(localSessionId, userMessage);
+      setAttachmentNotice(null);
+      setValue("");
+      if (!hasText)
+        return;
+      await runStream({
+        localSessionId,
+        sessionId,
+        content,
+        model: resolvedModel,
+        mode: selectedMode
+      });
+    },
+    [
+      value,
+      attachments,
+      isModelsLoading,
+      isModelsError,
+      hasModels,
+      selectedModel,
+      activeSession,
+      availableModels,
+      activeSessionId,
+      selectedMode,
+      createSession,
+      takeMessageAttachments,
+      appendMessage,
+      runStream
+    ]
+  );
+  return {
+    state: {
+      value,
+      attachments,
+      attachmentNotice,
+      isStreaming,
+      isStopping,
+      selectedModel,
+      selectedMode,
+      availableModels,
+      isModelsLoading,
+      isModelsError,
+      hasModels
+    },
+    actions: {
+      setValue,
+      send,
+      pickImages: (files) => {
+        if (!enableImageAttachments)
+          return;
+        const result = appendFiles(files);
+        setAttachmentNotice(result.limitExceeded ? "limit_reached" : null);
+      },
+      pasteImages: (files) => {
+        if (!enableImageAttachments)
+          return;
+        const result = appendFiles(files);
+        setAttachmentNotice(result.limitExceeded ? "limit_reached" : null);
+      },
+      removeAttachment: (attachmentId) => {
+        removeAttachment(attachmentId);
+        setAttachmentNotice(null);
+      },
+      setSelectedModel,
+      setSelectedMode: (mode) => {
+        setSelectedModeLocal(mode);
+        setPreferredMode(mode);
+        if (activeSessionId)
+          setSessionMode(activeSessionId, mode);
+        if (lastRequestRef.current && activeSessionId && (lastRequestRef.current.localSessionId === activeSessionId || lastRequestRef.current.sessionId === activeSessionId)) {
+          lastRequestRef.current = { ...lastRequestRef.current, mode };
+        }
+      },
+      reloadModels: () => void fetchModels(),
+      stop: async () => {
+        if (!streamingSessionId)
+          return;
+        if (isStopping)
+          return;
+        if (isDraftChatSessionId(streamingSessionId)) {
+          finalizeStop(streamingSessionId);
+          return;
+        }
+        requestStopStreaming(streamingSessionId);
+        stopRequestRef.current = {
+          sessionId: streamingSessionId,
+          timeoutId: window.setTimeout(() => {
+            finalizeStop(streamingSessionId);
+          }, STOP_WAIT_TIMEOUT_MS),
+          finalized: false
+        };
+        try {
+          const result = await transport.terminateStream(streamingSessionId);
+          if (!result.terminated) {
+            console.error("Failed to terminate chat session: server returned not terminated");
+          }
+          finalizeStop(streamingSessionId);
+        } catch (err) {
+          console.error("Failed to terminate chat session", err);
+          finalizeStop(streamingSessionId);
+        }
+      },
+      retry: () => {
+        if (!lastRequestRef.current)
+          return;
+        void runStream(lastRequestRef.current);
+      }
+    }
+  };
+};
+
+// src/components/chat-composer/components/chat-composer-attachment-list.tsx
+import { useState as useState8 } from "react";
+import styled11 from "@emotion/styled";
+import { Fragment as Fragment3, jsx as jsx12, jsxs as jsxs8 } from "@emotion/react/jsx-runtime";
+var ChatComposerAttachmentList = ({
+  attachments,
+  onRemoveAttachment
+}) => {
+  const [activeImage, setActiveImage] = useState8(null);
+  if (!attachments.length) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxs8(Fragment3, { children: [
+    /* @__PURE__ */ jsx12(AttachmentList, { "data-testid": "chat-composer-attachment-list", children: attachments.map((attachment) => /* @__PURE__ */ jsxs8(AttachmentCard, { children: [
+      /* @__PURE__ */ jsx12(
+        AttachmentPreviewButton,
+        {
+          type: "button",
+          "aria-label": `${attachment.name} preview`,
+          onClick: () => setActiveImage(attachment),
+          children: /* @__PURE__ */ jsx12(AttachmentThumb, { src: attachment.previewUrl, alt: attachment.name })
+        }
+      ),
+      /* @__PURE__ */ jsx12(
+        AttachmentRemoveButton,
+        {
+          type: "button",
+          "aria-label": `Remove ${attachment.name}`,
+          onClick: (event) => {
+            event.stopPropagation();
+            onRemoveAttachment(attachment.id);
+          },
+          children: /* @__PURE__ */ jsx12(CloseGlyph, { "aria-hidden": "true" })
+        }
+      )
+    ] }, attachment.id)) }),
+    activeImage ? /* @__PURE__ */ jsx12(
+      ImageViewer,
+      {
+        src: activeImage.previewUrl,
+        alt: activeImage.name,
+        onClose: () => setActiveImage(null)
+      }
+    ) : null
+  ] });
+};
+var AttachmentList = styled11.div`
+  display: flex;
+  flex-wrap: wrap;
+  gap: 10px;
+  padding: 12px 12px 0;
+  max-height: 238px;
+  overflow-y: auto;
+  overscroll-behavior: contain;
+
+  &::-webkit-scrollbar {
+    width: 8px;
+  }
+
+  &::-webkit-scrollbar-thumb {
+    background: rgba(255, 255, 255, 0.2);
+    border-radius: 999px;
+  }
+
+  &::-webkit-scrollbar-track {
+    background: transparent;
+  }
+`;
+var AttachmentCard = styled11.div`
+  position: relative;
+  width: 108px;
+  height: 72px;
+  overflow: hidden;
+  border-radius: 14px;
+  border: 1px solid rgba(255, 255, 255, 0.12);
+  background: rgba(255, 255, 255, 0.04);
+`;
+var AttachmentPreviewButton = styled11.button`
+  width: 100%;
+  height: 100%;
+  padding: 0;
+  border: 0;
+  background: transparent;
+  cursor: zoom-in;
+`;
+var AttachmentThumb = styled11.img`
+  width: 100%;
+  height: 100%;
+  object-fit: cover;
+  display: block;
+`;
+var AttachmentRemoveButton = styled11.button`
+  position: absolute;
+  top: 6px;
+  right: 6px;
+  width: 22px;
+  height: 22px;
+  display: grid;
+  place-items: center;
+  padding: 0;
+  border: 1px solid rgba(255, 255, 255, 0.16);
+  border-radius: 999px;
+  background: rgba(20, 20, 24, 0.92);
+  color: rgba(255, 255, 255, 0.94);
+  cursor: pointer;
+  line-height: 0;
+  box-shadow:
+    inset 0 1px 0 rgba(255, 255, 255, 0.08),
+    0 4px 10px rgba(0, 0, 0, 0.24);
+  transition:
+    background-color 140ms ease,
+    border-color 140ms ease,
+    transform 140ms ease,
+    box-shadow 140ms ease;
+
+  &:hover {
+    background: rgba(37, 37, 44, 0.98);
+    border-color: rgba(255, 255, 255, 0.28);
+    transform: scale(1.06);
+    box-shadow:
+      inset 0 1px 0 rgba(255, 255, 255, 0.12),
+      0 8px 18px rgba(0, 0, 0, 0.32);
+  }
+
+  &:active {
+    transform: scale(0.96);
+    background: rgba(30, 30, 35, 0.98);
+  }
+`;
+var CloseGlyph = styled11.span`
+  position: relative;
+  width: 11px;
+  height: 11px;
+  display: block;
+
+  &::before,
+  &::after {
+    content: '';
+    position: absolute;
+    top: 50%;
+    left: 50%;
+    width: 11px;
+    height: 1.75px;
+    border-radius: 999px;
+    background: currentColor;
+    transform-origin: center;
+  }
+
+  &::before {
+    transform: translate(-50%, -50%) rotate(45deg);
+  }
+
+  &::after {
+    transform: translate(-50%, -50%) rotate(-45deg);
+  }
+`;
+
+// src/components/chat-composer/components/chat-model-control.tsx
+import styled12 from "@emotion/styled";
+import { Select } from "@xinghunm/compass-ui";
+import { jsx as jsx13, jsxs as jsxs9 } from "@emotion/react/jsx-runtime";
+var ChatModelControl = ({
+  selectedModel,
+  availableModels,
+  isModelsLoading,
+  isModelsError,
+  hasModels,
+  onSelectedModelChange,
+  onReloadModels
+}) => {
+  if (isModelsError) {
+    return /* @__PURE__ */ jsxs9(
+      ModelReloadButton,
+      {
+        type: "button",
+        "data-testid": "chat-model-reload",
+        "aria-label": "Reload",
+        onClick: onReloadModels,
+        children: [
+          /* @__PURE__ */ jsx13("span", { children: "Failed to load models" }),
+          /* @__PURE__ */ jsxs9(
+            ReloadIcon,
+            {
+              "data-testid": "chat-model-reload-icon",
+              "aria-hidden": "true",
+              width: "16",
+              height: "16",
+              viewBox: "0 0 1024 1024",
+              fill: "currentColor",
+              xmlns: "http://www.w3.org/2000/svg",
+              children: [
+                /* @__PURE__ */ jsx13("path", { d: "M895.469672 511.745197c0-146.498562-82.099856-273.805016-202.788589-338.470805l22.072715-46.630017c-4.50664-12.609179-18.382673-19.176758-30.991852-14.670118l-92.436272 33.040511c-12.609179 4.50664-19.176758 18.382673-14.670118 30.991852l33.040511 92.436272c4.50664 12.609179 18.382673 19.176758 30.991852 14.670118l24.581861-51.92972c99.069343 54.335513 166.240185 159.596881 166.240185 280.561907 0 165.56685-125.817544 301.747415-287.057855 318.14692l0 0.022513c-17.730826 0-32.105209 14.374382-32.105209 32.105209 0 17.730826 14.374382 32.105209 32.105209 32.105209 2.098801 0 4.149507-0.207731 6.135744-0.592494C744.270041 874.039593 895.469672 710.564381 895.469672 511.745197z" }),
+                /* @__PURE__ */ jsx13("path", { d: "M480.616222 129.23948c-0.041956 0-0.082888 0.00307-0.124843 0.00307l0-0.00307c-0.01535 0.001023-0.031722 0.00307-0.047072 0.004093-1.892093 0.010233-3.744277 0.189312-5.545296 0.5137-194.674794 18.529005-346.957083 182.459588-346.957083 381.987924 0 147.431817 83.146699 275.42798 205.097168 339.700819l-24.814152 52.419883c4.50664 12.609179 18.382673 19.176758 30.991852 14.670118l92.436272-33.040511c12.609179-4.50664 19.176758-18.382673 14.670118-30.991852l-33.040511-92.436272c-4.50664-12.609179-18.382673-19.176758-30.991852-14.670118l-21.853727 46.167482c-100.326986-53.964052-168.535461-159.920246-168.535461-281.81955 0-166.089759 126.616746-302.591643 288.588721-318.284043l0-0.014326c0.041956 0 0.082888 0.00307 0.124843 0.00307 17.730826 0 32.105209-14.374382 32.105209-32.105209C512.721431 143.613862 498.347049 129.23948 480.616222 129.23948z" })
+              ]
+            }
+          )
+        ]
+      }
+    );
+  }
+  if (isModelsLoading) {
+    return /* @__PURE__ */ jsx13(ModelBadge, { children: "Loading models..." });
+  }
+  if (hasModels && selectedModel) {
+    if (availableModels.length > 1) {
+      return /* @__PURE__ */ jsx13(
+        ModelSelect,
+        {
+          "data-testid": "chat-model-select",
+          "aria-label": "Select model",
+          value: selectedModel,
+          onChange: (value) => onSelectedModelChange(String(value)),
+          options: availableModels.map((model) => ({
+            label: model.id,
+            value: model.id
+          }))
+        }
+      );
+    }
+    return /* @__PURE__ */ jsx13(ModelBadge, { children: selectedModel });
+  }
+  return /* @__PURE__ */ jsx13(ModelBadge, { children: "No model available" });
+};
+var ModelBadge = styled12.span`
+  border-radius: 999px;
+  border: 1px solid var(--border-hover);
+  padding: 5px 12px;
+  font-weight: 400;
+  font-size: 12px;
+  color: var(--text-secondary);
+  line-height: 12px;
+`;
+var ModelReloadButton = styled12.button`
+  display: inline-flex;
+  align-items: center;
+  gap: 8px;
+  border-radius: 999px;
+  min-height: 28px;
+  border: 1px solid rgba(255, 255, 255, 0.14);
+  background: rgba(255, 255, 255, 0.04);
+  padding: 6px 12px;
+  color: rgba(255, 255, 255, 0.72);
+  font-size: 12px;
+  line-height: 1;
+  cursor: pointer;
+
+  transition:
+    background 160ms ease,
+    border-color 160ms ease,
+    color 160ms ease;
+
+  &:hover {
+    background: rgba(255, 255, 255, 0.08);
+    border-color: rgba(255, 255, 255, 0.22);
+    color: rgba(255, 255, 255, 0.88);
+  }
+`;
+var ReloadIcon = styled12.svg`
+  flex-shrink: 0;
+`;
+var ModelSelect = styled12(Select)`
+  && {
+    width: auto;
+    min-width: 0;
+    max-width: 100%;
+
+    .compass-select-selector {
+      line-height: 1;
+      border-radius: 999px;
+      min-height: 24px;
+      height: 24px;
+      background: rgba(255, 255, 255, 0.04);
+      border-color: rgba(255, 255, 255, 0.12);
+      color: rgba(255, 255, 255, 0.82);
+      padding: 4px 12px;
+    }
+  }
+`;
+
+// src/components/chat-composer/components/chat-mode-control.tsx
+import styled13 from "@emotion/styled";
+import { Select as Select2 } from "@xinghunm/compass-ui";
+import { jsx as jsx14 } from "@emotion/react/jsx-runtime";
+var ChatModeControl = ({
+  value,
+  disabled = false,
+  labels,
+  onChange
+}) => {
+  return /* @__PURE__ */ jsx14(
+    ModeSelect,
+    {
+      "data-testid": "chat-mode-select",
+      "aria-label": "Select mode",
+      value,
+      disabled,
+      onChange: (v) => onChange(String(v)),
+      options: CHAT_AGENT_MODES.map((mode) => ({
+        label: labels[mode],
+        value: mode
+      }))
+    }
+  );
+};
+var ModeSelect = styled13(Select2)`
+  && {
+    flex: 0 1 auto;
+    width: auto;
+    min-width: 0;
+    max-width: 100%;
+
+    .compass-select-selector {
+      line-height: 1;
+      border-radius: 999px;
+      min-height: 24px;
+      height: 24px;
+      background: rgba(255, 255, 255, 0.04);
+      border-color: rgba(255, 255, 255, 0.12);
+      color: rgba(255, 255, 255, 0.82);
+      padding: 4px 12px;
+    }
+  }
+`;
+
+// src/components/chat-composer/components/chat-send-actions.tsx
+import styled14 from "@emotion/styled";
+import { Button } from "@xinghunm/compass-ui";
+import { Fragment as Fragment4, jsx as jsx15 } from "@emotion/react/jsx-runtime";
+var ArrowUpIcon = () => /* @__PURE__ */ jsx15(
+  "svg",
+  {
+    "aria-hidden": "true",
+    width: "12",
+    height: "12",
+    viewBox: "0 0 12 12",
+    fill: "none",
+    xmlns: "http://www.w3.org/2000/svg",
+    children: /* @__PURE__ */ jsx15(
+      "path",
+      {
+        d: "M6 10V2M6 2L2 6M6 2L10 6",
+        stroke: "currentColor",
+        strokeWidth: "1.75",
+        strokeLinecap: "round",
+        strokeLinejoin: "round"
+      }
+    )
+  }
+);
+var ChatSendActions = ({
+  canSend,
+  isStreaming,
+  isStopping,
+  onStop,
+  onSend
+}) => /* @__PURE__ */ jsx15(Fragment4, { children: isStreaming ? /* @__PURE__ */ jsx15(
+  StopButton,
+  {
+    type: "button",
+    "aria-label": "Stop",
+    "aria-busy": isStopping,
+    "data-testid": "chat-composer-stop",
+    disabled: isStopping,
+    shape: "circle",
+    onClick: () => void onStop(),
+    children: /* @__PURE__ */ jsx15(StopGlyph, { "aria-hidden": "true" })
+  }
+) : /* @__PURE__ */ jsx15(
+  PrimaryButton,
+  {
+    $canSend: canSend,
+    type: "button",
+    icon: /* @__PURE__ */ jsx15(ArrowUpIcon, {}),
+    "aria-label": "Send",
+    "data-testid": "chat-composer-send",
+    disabled: !canSend,
+    shape: "circle",
+    onClick: () => void onSend()
+  }
+) });
+var PrimaryButton = styled14(Button)`
+  && {
+    min-width: 24px;
+    width: 24px;
+    height: 24px;
+    background: ${({ $canSend }) => $canSend ? "#fcfbf8" : "rgba(255, 255, 255, 0.3)"};
+    color: ${({ $canSend }) => $canSend ? "#5b5448" : "rgba(255, 255, 255, 0.72)"};
+    border-radius: 12px;
+    border: 1px solid ${({ $canSend }) => $canSend ? "rgba(198, 188, 170, 0.38)" : "transparent"};
+    box-shadow: ${({ $canSend }) => $canSend ? "inset 0 1px 0 rgba(255, 255, 255, 0.92), 0 8px 18px rgba(0, 0, 0, 0.18)" : "none"};
+    svg {
+      color: currentColor;
+      stroke: currentColor;
+    }
+
+    &:hover:not(:disabled) {
+      background: ${({ $canSend }) => $canSend ? "#f7f4ec" : "rgba(255, 255, 255, 0.3)"};
+      color: ${({ $canSend }) => $canSend ? "#4f493f" : "rgba(255, 255, 255, 0.72)"};
+      border-color: ${({ $canSend }) => $canSend ? "rgba(198, 188, 170, 0.46)" : "transparent"};
+    }
+
+    &:disabled {
+      cursor: not-allowed;
+    }
+  }
+`;
+var StopButton = styled14(Button)`
+  && {
+    min-width: 24px;
+    width: 24px;
+    height: 24px;
+    padding: 0;
+    background: radial-gradient(
+      circle at 30% 30%,
+      rgba(255, 255, 255, 0.98) 0%,
+      rgba(244, 244, 244, 0.96) 45%,
+      rgba(230, 230, 230, 0.95) 100%
+    );
+    border-radius: 999px;
+    border: 1px solid rgba(255, 255, 255, 0.72);
+    box-shadow:
+      inset 0 1px 0 rgba(255, 255, 255, 0.95),
+      0 8px 18px rgba(0, 0, 0, 0.18);
+
+    &:hover:not(:disabled) {
+      background: radial-gradient(
+        circle at 30% 30%,
+        rgba(255, 255, 255, 1) 0%,
+        rgba(249, 249, 249, 0.98) 45%,
+        rgba(236, 236, 236, 0.98) 100%
+      );
+    }
+  }
+`;
+var StopGlyph = styled14.span`
+  width: 8px;
+  height: 8px;
+  border-radius: 2px;
+  background: #1b1b1b;
+  box-shadow: 0 1px 2px rgba(0, 0, 0, 0.18);
+`;
+
+// src/components/chat-composer/index.tsx
+import { jsx as jsx16, jsxs as jsxs10 } from "@emotion/react/jsx-runtime";
+var PlusIcon = () => /* @__PURE__ */ jsx16(
+  "svg",
+  {
+    "aria-hidden": "true",
+    width: "16",
+    height: "16",
+    viewBox: "0 0 16 16",
+    fill: "none",
+    xmlns: "http://www.w3.org/2000/svg",
+    children: /* @__PURE__ */ jsx16("path", { d: "M8 3v10M3 8h10", stroke: "currentColor", strokeWidth: "1.75", strokeLinecap: "round" })
+  }
+);
+var ChatComposerView = ({
+  value,
+  placeholder,
+  attachments,
+  attachmentNotice,
+  attachmentLimitNotice,
+  selectedModel,
+  selectedMode,
+  availableModels,
+  isModelsLoading,
+  isModelsError,
+  hasModels,
+  isStreaming,
+  isStopping,
+  enableImageAttachments,
+  modeLabels,
+  onValueChange,
+  onPickImages,
+  onPasteImages,
+  onRemoveAttachment,
+  onSelectedModelChange,
+  onSelectedModeChange,
+  onReloadModels,
+  onStop,
+  onSend
+}) => {
+  const imageInputRef = useRef7(null);
+  const canSend = canSendChatMessage({
+    value,
+    attachmentCount: attachments.length,
+    isModelsLoading,
+    isModelsError,
+    hasModels
+  });
+  const handleKeyDown = (event) => {
+    if (shouldStopChatComposer({ key: event.key, shiftKey: event.shiftKey, isStreaming })) {
+      event.preventDefault();
+      void onStop();
+      return;
+    }
+    if (!shouldSubmitChatComposer({ key: event.key, shiftKey: event.shiftKey, canSend }))
+      return;
+    event.preventDefault();
+    void onSend();
+  };
+  const handlePickImages = (event) => {
+    if (event.target.files?.length)
+      onPickImages(event.target.files);
+    event.target.value = "";
+  };
+  const handlePaste = (event) => {
+    const imageFiles = Array.from(event.clipboardData.items).filter((item) => item.kind === "file" && item.type.startsWith("image/")).map((item) => item.getAsFile()).filter((file) => Boolean(file));
+    if (!imageFiles.length)
+      return;
+    event.preventDefault();
+    onPasteImages(imageFiles);
+  };
+  return /* @__PURE__ */ jsx16(Container2, { children: /* @__PURE__ */ jsxs10(Surface, { "data-testid": "chat-composer-surface", children: [
+    enableImageAttachments ? /* @__PURE__ */ jsx16(
+      "input",
+      {
+        ref: imageInputRef,
+        type: "file",
+        accept: "image/png,image/jpeg,image/webp",
+        multiple: true,
+        hidden: true,
+        "data-testid": "chat-composer-image-input",
+        onChange: handlePickImages
+      }
+    ) : null,
+    /* @__PURE__ */ jsx16(
+      ChatComposerAttachmentList,
+      {
+        attachments,
+        onRemoveAttachment
+      }
+    ),
+    attachmentNotice === "limit_reached" ? /* @__PURE__ */ jsx16(AttachmentNotice, { "data-testid": "chat-composer-attachment-notice", children: attachmentLimitNotice }) : null,
+    /* @__PURE__ */ jsx16(
+      Input,
+      {
+        "data-testid": "chat-composer-input",
+        value,
+        onChange: (event) => onValueChange(event.target.value),
+        onKeyDown: handleKeyDown,
+        onPaste: enableImageAttachments ? handlePaste : void 0,
+        placeholder
+      }
+    ),
+    /* @__PURE__ */ jsx16(Footer, { children: /* @__PURE__ */ jsxs10(Actions2, { "data-testid": "chat-composer-actions", children: [
+      enableImageAttachments ? /* @__PURE__ */ jsx16(
+        AttachButton,
+        {
+          type: "button",
+          "data-testid": "chat-composer-attach-image",
+          "aria-label": "Attach image",
+          onClick: () => imageInputRef.current?.click(),
+          children: /* @__PURE__ */ jsx16(PlusIcon, {})
+        }
+      ) : null,
+      /* @__PURE__ */ jsx16(
+        ChatModeControl,
+        {
+          value: selectedMode,
+          disabled: isStreaming,
+          labels: modeLabels,
+          onChange: onSelectedModeChange
+        }
+      ),
+      /* @__PURE__ */ jsx16(
+        ChatModelControl,
+        {
+          selectedModel,
+          availableModels,
+          isModelsLoading,
+          isModelsError,
+          hasModels,
+          onSelectedModelChange,
+          onReloadModels
+        }
+      ),
+      /* @__PURE__ */ jsx16(
+        ChatSendActions,
+        {
+          canSend,
+          isStreaming,
+          isStopping,
+          onStop,
+          onSend
+        }
+      )
+    ] }) })
+  ] }) });
+};
+var ChatComposer = () => {
+  const { labels, sendRef, retryRef, enableImageAttachments } = useChatContext();
+  const { state, actions } = useChatComposer();
+  const { send, retry } = actions;
+  useEffect5(() => {
+    sendRef.current = send;
+    retryRef.current = async () => {
+      retry();
+    };
+  }, [retry, retryRef, send, sendRef]);
+  const modeLabels = {
+    ask: labels.modeLabelAsk,
+    plan: labels.modeLabelPlan,
+    agent: labels.modeLabelAgent
+  };
+  return /* @__PURE__ */ jsx16(
+    ChatComposerView,
+    {
+      value: state.value,
+      attachments: state.attachments,
+      attachmentNotice: state.attachmentNotice,
+      attachmentLimitNotice: labels.attachmentLimitNotice,
+      placeholder: labels.placeholder,
+      selectedModel: state.selectedModel,
+      selectedMode: state.selectedMode,
+      availableModels: state.availableModels,
+      isModelsLoading: state.isModelsLoading,
+      isModelsError: state.isModelsError,
+      hasModels: state.hasModels,
+      isStreaming: state.isStreaming,
+      isStopping: state.isStopping,
+      enableImageAttachments,
+      modeLabels,
+      onValueChange: actions.setValue,
+      onPickImages: actions.pickImages,
+      onPasteImages: actions.pasteImages,
+      onRemoveAttachment: actions.removeAttachment,
+      onSelectedModelChange: actions.setSelectedModel,
+      onSelectedModeChange: actions.setSelectedMode,
+      onReloadModels: actions.reloadModels,
+      onStop: actions.stop,
+      onSend: send
+    }
+  );
+};
+var Container2 = styled15.div`
+  padding: 0 16px 16px;
+`;
+var Surface = styled15.div`
+  background: var(--border-color);
+  border-radius: 20px;
+  border: 1px solid var(--border-hover);
+  box-shadow:
+    inset 0 1px 0 rgba(255, 255, 255, 0.04),
+    0 12px 36px rgba(0, 0, 0, 0.3);
+  backdrop-filter: blur(10px);
+`;
+var AttachmentNotice = styled15.div`
+  margin: 10px 12px 0;
+  padding: 8px 10px;
+  border-radius: 10px;
+  background: rgba(255, 196, 87, 0.12);
+  border: 1px solid rgba(255, 196, 87, 0.28);
+  color: rgba(255, 220, 148, 0.95);
+  font-size: 12px;
+  line-height: 1.4;
+`;
+var Input = styled15.textarea`
+  width: 100%;
+  min-height: 96px;
+  resize: none;
+  appearance: none;
+  border: 0;
+  outline: 0;
+  background: transparent;
+  padding: 8px 12px 12px 12px;
+  font-weight: 400;
+  font-size: 14px;
+  color: var(--text-primary);
+  line-height: 20px;
+
+  &::placeholder {
+    color: var(--text-secondary);
+  }
+
+  &::-webkit-resizer {
+    display: none;
+  }
+`;
+var Footer = styled15.div`
+  display: flex;
+  align-items: flex-end;
+  justify-content: stretch;
+  gap: 16px;
+  padding: 0 14px 14px;
+`;
+var Actions2 = styled15.div`
+  display: flex;
+  align-items: center;
+  flex-wrap: wrap;
+  width: 100%;
+  min-width: 0;
+  justify-content: flex-end;
+  gap: 8px;
+`;
+var AttachButton = styled15.button`
+  width: 28px;
+  height: 28px;
+  display: grid;
+  place-items: center;
+  border: none;
+  border-radius: 999px;
+  background: transparent;
+  color: rgba(255, 255, 255, 0.82);
+  cursor: pointer;
+
+  &:hover {
+    background: rgba(255, 255, 255, 0.08);
+  }
+`;
+
+// src/components/chat-conversation-list/index.tsx
+import styled17 from "@emotion/styled";
+
+// src/components/chat-conversation-list/components/chat-session-item.tsx
+import { memo as memo3 } from "react";
+import styled16 from "@emotion/styled";
+import { jsx as jsx17, jsxs as jsxs11 } from "@emotion/react/jsx-runtime";
+var ChatSessionItem = memo3(
+  ({ session, isActive, modeLabel, onClick }) => {
+    return /* @__PURE__ */ jsx17(
+      SessionButton,
+      {
+        type: "button",
+        "data-active": isActive,
+        onClick: () => onClick(session.sessionId),
+        children: /* @__PURE__ */ jsxs11(SessionMeta, { children: [
+          /* @__PURE__ */ jsx17(SessionTitle, { children: session.title }),
+          /* @__PURE__ */ jsx17(ModeBadge, { children: modeLabel })
+        ] })
+      }
+    );
+  }
+);
+ChatSessionItem.displayName = "ChatSessionItem";
+var SessionMeta = styled16.div`
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+`;
+var SessionTitle = styled16.span`
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+`;
+var SessionButton = styled16.button`
+  border: 1px solid transparent;
+  border-radius: 12px;
+  padding: 12px;
+  text-align: left;
+  color: var(--text-primary);
+  background: rgba(255, 255, 255, 0.03);
+  cursor: pointer;
+
+  &[data-active='true'] {
+    border-color: rgba(255, 255, 255, 0.2);
+    background: rgba(255, 255, 255, 0.08);
+  }
+`;
+var ModeBadge = styled16.span`
+  flex-shrink: 0;
+  border-radius: 999px;
+  border: 1px solid rgba(255, 255, 255, 0.1);
+  padding: 4px 10px;
+  font-size: 11px;
+  line-height: 1;
+  color: var(--text-secondary);
+  background: rgba(255, 255, 255, 0.04);
+`;
+
+// src/components/chat-conversation-list/index.tsx
+import { jsx as jsx18, jsxs as jsxs12 } from "@emotion/react/jsx-runtime";
+var ChatConversationList = () => {
+  const { labels } = useChatContext();
+  const sessions = useChatStore((s) => s.sessions);
+  const activeSessionId = useChatStore((s) => s.activeSessionId);
+  const preferredMode = useChatStore((s) => s.preferredMode);
+  const createSession = useChatStore((s) => s.createSession);
+  const setActiveSession = useChatStore((s) => s.setActiveSession);
+  const modeLabels = {
+    ask: labels.modeLabelAsk,
+    plan: labels.modeLabelPlan,
+    agent: labels.modeLabelAgent
+  };
+  const handleCreateSession = () => {
+    const session = createDraftChatSession({
+      // Model is intentionally deferred: ChatComposer resolves selectedModel at send time.
+      model: "",
+      mode: preferredMode,
+      nowIso: () => (/* @__PURE__ */ new Date()).toISOString(),
+      createSessionId: createDraftChatSessionId
+    });
+    createSession(session);
+  };
+  return /* @__PURE__ */ jsxs12(Container3, { children: [
+    /* @__PURE__ */ jsxs12(Toolbar, { children: [
+      /* @__PURE__ */ jsx18(Title4, { children: "Sessions" }),
+      /* @__PURE__ */ jsx18(CreateButton, { type: "button", "data-testid": "chat-create-session", onClick: handleCreateSession, children: labels.newChat })
+    ] }),
+    /* @__PURE__ */ jsx18(List2, { "data-testid": "chat-session-list", children: sessions.map((session) => /* @__PURE__ */ jsx18(
+      ChatSessionItem,
+      {
+        session,
+        isActive: activeSessionId === session.sessionId,
+        modeLabel: modeLabels[session.mode ?? DEFAULT_CHAT_AGENT_MODE] ?? "",
+        onClick: setActiveSession
+      },
+      session.sessionId
+    )) })
+  ] });
+};
+var Container3 = styled17.aside`
+  width: 280px;
+  min-width: 280px;
+  border-right: 1px solid var(--border-default, rgba(255, 255, 255, 0.08));
+  display: flex;
+  flex-direction: column;
+  background: rgba(255, 255, 255, 0.02);
+`;
+var Toolbar = styled17.div`
+  padding: 20px 16px 12px;
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+`;
+var Title4 = styled17.h2`
+  margin: 0;
+  font-size: 14px;
+  color: var(--text-secondary);
+`;
+var CreateButton = styled17.button`
+  border: none;
+  border-radius: 12px;
+  padding: 12px 14px;
+  background: var(--text-primary);
+  color: var(--bg-primary);
+  text-align: left;
+  cursor: pointer;
+`;
+var List2 = styled17.div`
+  padding: 0 12px 16px;
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  overflow: auto;
+`;
+
+// src/components/ai-chat/index.tsx
+import { jsx as jsx19, jsxs as jsxs13 } from "@emotion/react/jsx-runtime";
+var AiChat = ({ showConversationList = false, ...providerProps }) => /* @__PURE__ */ jsx19(
+  ConfigProvider,
+  {
+    theme: {
+      token: {
+        spacing: {
+          lg: 16
+        },
+        colors: {
+          primary: "#1f52f0",
+          background: "#1c1c1c",
+          text: "#fcfbf8",
+          textSecondary: "#c5c1ba"
+        },
+        components: {
+          select: {
+            optionColor: "#fcfbf8",
+            optionSelectedBg: "transparent",
+            optionHoverBg: "#41413f",
+            optionSelectedColor: "#fcfbf8",
+            backgroundColor: "#1c1c1c",
+            dropdownBg: "#1c1c1c",
+            placeholderColor: "#c5c1ba",
+            borderRadius: "12px",
+            dropdownPadding: "4px"
+          },
+          modal: { contentBg: "#1c1c1c", padding: "24px" },
+          dropdown: {
+            backgroundColor: "#1c1c1c",
+            borderRadius: "12px",
+            padding: "4px"
+          }
+        }
+      }
+    },
+    children: /* @__PURE__ */ jsx19(AiChatProvider, { ...providerProps, children: /* @__PURE__ */ jsxs13(Root, { "data-testid": "ai-chat", children: [
+      showConversationList ? /* @__PURE__ */ jsx19(ChatConversationList, {}) : null,
+      /* @__PURE__ */ jsxs13(Workspace, { children: [
+        /* @__PURE__ */ jsx19(ChatThread, {}),
+        /* @__PURE__ */ jsx19(ChatComposer, {})
+      ] })
+    ] }) })
+  }
+);
+var Root = styled18.div`
+  display: flex;
+  width: 100%;
+  height: 100%;
+  min-height: 0;
+  overflow: hidden;
+`;
+var Workspace = styled18.section`
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+  min-height: 0;
+  overflow: hidden;
+`;
+export {
+  AiChat,
+  AiChatProvider,
+  CHAT_AGENT_MODES,
+  ChatComposer,
+  ChatConversationList,
+  ChatThread,
+  DEFAULT_AI_CHAT_LABELS,
+  DEFAULT_CHAT_AGENT_MODE,
+  createDefaultChatTransport,
+  useChatContext,
+  useChatStore
+};