@xinghunm/ai-chat 0.1.0

package/dist/index.js

@@ -0,0 +1,4051 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AiChat: () => AiChat,
+  AiChatProvider: () => AiChatProvider,
+  CHAT_AGENT_MODES: () => CHAT_AGENT_MODES,
+  ChatComposer: () => ChatComposer,
+  ChatConversationList: () => ChatConversationList,
+  ChatThread: () => ChatThread,
+  DEFAULT_AI_CHAT_LABELS: () => DEFAULT_AI_CHAT_LABELS,
+  DEFAULT_CHAT_AGENT_MODE: () => DEFAULT_CHAT_AGENT_MODE,
+  createDefaultChatTransport: () => createDefaultChatTransport,
+  useChatContext: () => useChatContext,
+  useChatStore: () => useChatStore
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/components/ai-chat/index.tsx
+var import_styled18 = __toESM(require("@emotion/styled"));
+var import_compass_ui4 = require("@xinghunm/compass-ui");
+
+// src/components/ai-chat-provider/index.tsx
+var import_react2 = require("react");
+var import_axios2 = __toESM(require("axios"));
+
+// src/context/chat-context.ts
+var import_react = require("react");
+var ChatContext = (0, import_react.createContext)(null);
+
+// src/store/chat-store.ts
+var import_vanilla = require("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) => (0, import_vanilla.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
+var import_axios = __toESM(require("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 ?? import_axios.default.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
+var import_jsx_runtime = require("@emotion/react/jsx-runtime");
+var AiChatProvider = (props) => {
+  const { defaultMode, labels, renderMessageBlock, enableImageAttachments = true, children } = props;
+  const [store] = (0, import_react2.useState)(
+    () => createChatStore(defaultMode ? { preferredMode: defaultMode } : void 0)
+  );
+  const sendRef = (0, import_react2.useRef)(async () => {
+  });
+  const retryRef = (0, import_react2.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 = (0, import_react2.useMemo)(() => {
+    if (!defaultApiBaseUrl || !defaultAuthToken) {
+      return void 0;
+    }
+    return import_axios2.default.create({
+      baseURL: defaultApiBaseUrl,
+      headers: { Authorization: defaultAuthToken }
+    });
+  }, [defaultApiBaseUrl, defaultAuthToken]);
+  const transport = (0, import_react2.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 = (0, import_react2.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__ */ (0, import_jsx_runtime.jsx)(ChatContext.Provider, { value: contextValue, children });
+};
+
+// src/components/chat-thread/index.tsx
+var import_react11 = require("react");
+var import_styled10 = __toESM(require("@emotion/styled"));
+
+// src/context/use-chat-context.ts
+var import_react3 = require("react");
+var import_react4 = require("zustand/react");
+var useChatContext = () => {
+  const ctx = (0, import_react3.useContext)(ChatContext);
+  if (!ctx)
+    throw new Error("useChatContext must be used inside AiChatProvider");
+  return ctx;
+};
+var useChatStore = (selector) => {
+  const { store } = useChatContext();
+  return (0, import_react4.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
+var import_react8 = require("react");
+var import_styled7 = __toESM(require("@emotion/styled"));
+var import_react9 = require("@emotion/react");
+var import_react_markdown = __toESM(require("react-markdown"));
+var import_remark_gfm = __toESM(require("remark-gfm"));
+var import_remark_math = __toESM(require("remark-math"));
+var import_rehype_katex = __toESM(require("rehype-katex"));
+
+// src/components/chat-thread/hooks/use-chat-message-reveal.ts
+var import_react5 = require("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 = (0, import_react5.useMemo)(() => Array.from(targetContent), [targetContent]);
+  const resetSnapshot = (0, import_react5.useMemo)(
+    () => ({
+      messageId: message.id,
+      initialTargetUnitCount: targetUnits.length,
+      initialBatchedTargetUnitCount: isAssistantStreaming ? 0 : targetUnits.length
+    }),
+    [isAssistantStreaming, message.id, targetUnits.length]
+  );
+  const pendingTargetUnitCountRef = (0, import_react5.useRef)(targetUnits.length);
+  const batchedTargetUnitCountRef = (0, import_react5.useRef)(isAssistantStreaming ? 0 : targetUnits.length);
+  const inputBatchTimeoutRef = (0, import_react5.useRef)(null);
+  const commitAnimationFrameRef = (0, import_react5.useRef)(null);
+  const freshBlockActivationFrameRef = (0, import_react5.useRef)(null);
+  const displayedUnitSyncFrameRef = (0, import_react5.useRef)(null);
+  const resetAnimationFrameRef = (0, import_react5.useRef)(null);
+  const [batchedTargetUnitCount, setBatchedTargetUnitCount] = (0, import_react5.useState)(
+    () => isAssistantStreaming ? 0 : targetUnits.length
+  );
+  const lastDisplayedBlockCountRef = (0, import_react5.useRef)(0);
+  const [displayedUnitCount, setDisplayedUnitCount] = (0, import_react5.useState)(
+    () => isAssistantStreaming ? 0 : targetUnits.length
+  );
+  const [isFreshBlockActive, setIsFreshBlockActive] = (0, import_react5.useState)(false);
+  const commitBatchedTargetUnitCount = (0, import_react5.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 = (0, import_react5.useCallback)(
+    (nextTargetUnitCount) => {
+      if (commitAnimationFrameRef.current !== null) {
+        window.cancelAnimationFrame(commitAnimationFrameRef.current);
+      }
+      commitAnimationFrameRef.current = window.requestAnimationFrame(() => {
+        commitAnimationFrameRef.current = null;
+        commitBatchedTargetUnitCount(nextTargetUnitCount);
+      });
+    },
+    [commitBatchedTargetUnitCount]
+  );
+  (0, import_react5.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]);
+  (0, import_react5.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 = (0, import_react5.useMemo)(
+    () => targetUnits.slice(0, displayedUnitCount).join(""),
+    [displayedUnitCount, targetUnits]
+  );
+  const contentBlocks = (0, import_react5.useMemo)(() => splitMarkdownBlocks(displayedContent), [displayedContent]);
+  (0, import_react5.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]);
+  (0, import_react5.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
+var import_styled = __toESM(require("@emotion/styled"));
+var import_jsx_runtime2 = require("@emotion/react/jsx-runtime");
+var PDEAIExecutionConfirmationCard = ({
+  proposal,
+  interactive = false,
+  onApply,
+  onConfirm,
+  onRevise
+}) => {
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(Card, { "data-testid": "pde-ai-execution-confirmation-card", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(Header, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Eyebrow, { children: "Execution Proposal" }),
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Title, { children: proposal.equationName }),
+      proposal.solverName ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Subtitle, { children: proposal.solverName }) : null
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(SummaryList, { children: proposal.parameterSummary.map((item) => /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(SummaryItem, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(SummaryLabel, { children: item.label }),
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(SummaryValue, { children: item.value })
+    ] }, `${item.fieldPath ?? item.label}-${item.value}`)) }),
+    proposal.warnings?.length ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Warnings, { children: proposal.warnings.map((warning) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Warning, { children: warning }, warning)) }) : null,
+    interactive ? /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(Actions, { children: [
+      onApply && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(ActionButton, { type: "button", "data-testid": "pde-ai-confirmation-apply", onClick: onApply, children: "Apply to Parameters" }),
+      onConfirm && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+        ActionButton,
+        {
+          type: "button",
+          "data-testid": "pde-ai-confirmation-confirm",
+          onClick: onConfirm,
+          children: "Confirm Execution"
+        }
+      ),
+      onRevise && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+        SecondaryActionButton,
+        {
+          type: "button",
+          "data-testid": "pde-ai-confirmation-revise",
+          onClick: onRevise,
+          children: "Revise Plan"
+        }
+      )
+    ] }) : null
+  ] });
+};
+var Card = import_styled.default.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 = import_styled.default.div`
+  display: grid;
+  gap: 4px;
+`;
+var Eyebrow = import_styled.default.span`
+  color: rgba(255, 255, 255, 0.58);
+  font-size: 11px;
+  font-weight: 700;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+`;
+var Title = import_styled.default.strong`
+  color: rgba(255, 255, 255, 0.95);
+  font-size: 16px;
+  line-height: 1.4;
+`;
+var Subtitle = import_styled.default.span`
+  color: rgba(255, 255, 255, 0.68);
+  font-size: 13px;
+`;
+var SummaryList = import_styled.default.div`
+  display: grid;
+  gap: 8px;
+`;
+var SummaryItem = import_styled.default.div`
+  display: flex;
+  justify-content: space-between;
+  gap: 12px;
+  padding: 10px 12px;
+  border-radius: 14px;
+  background: rgba(255, 255, 255, 0.05);
+`;
+var SummaryLabel = import_styled.default.span`
+  color: rgba(255, 255, 255, 0.72);
+  font-size: 13px;
+`;
+var SummaryValue = import_styled.default.span`
+  color: rgba(255, 255, 255, 0.94);
+  font-size: 13px;
+  font-weight: 600;
+`;
+var Warnings = import_styled.default.div`
+  display: grid;
+  gap: 8px;
+`;
+var Warning = import_styled.default.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 = import_styled.default.div`
+  display: flex;
+  flex-wrap: wrap;
+  gap: 10px;
+`;
+var ActionButton = import_styled.default.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 = (0, import_styled.default)(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
+var import_styled2 = __toESM(require("@emotion/styled"));
+var import_jsx_runtime3 = require("@emotion/react/jsx-runtime");
+var PDEAINoticeCard = ({ text, tone }) => /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(Card2, { "data-testid": "pde-ai-notice-card", "data-tone": tone, children: text });
+var Card2 = import_styled2.default.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
+var import_styled3 = __toESM(require("@emotion/styled"));
+var import_jsx_runtime4 = require("@emotion/react/jsx-runtime");
+var PDEAIParameterSummaryCard = ({ items }) => /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(Card3, { "data-testid": "pde-ai-parameter-summary-card", children: [
+  /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(Title2, { children: "Parameter Summary" }),
+  /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(List, { children: items.map((item) => /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(ListItem, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(Label, { children: item.label }),
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(Value, { children: item.value })
+  ] }, `${item.fieldPath ?? item.label}-${item.value}`)) })
+] });
+var Card3 = import_styled3.default.section`
+  padding: 14px;
+  border-radius: 18px;
+  border: 1px solid rgba(255, 255, 255, 0.08);
+  background: rgba(255, 255, 255, 0.03);
+`;
+var Title2 = import_styled3.default.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 = import_styled3.default.div`
+  display: grid;
+  gap: 10px;
+`;
+var ListItem = import_styled3.default.div`
+  display: flex;
+  justify-content: space-between;
+  gap: 12px;
+  padding: 10px 12px;
+  border-radius: 14px;
+  background: rgba(255, 255, 255, 0.04);
+`;
+var Label = import_styled3.default.span`
+  color: rgba(255, 255, 255, 0.72);
+  font-size: 13px;
+`;
+var Value = import_styled3.default.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
+var import_react6 = require("react");
+var import_styled4 = __toESM(require("@emotion/styled"));
+var import_jsx_runtime5 = require("@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] = (0, import_react6.useState)(
+    () => createInitialAnswers(questionnaire)
+  );
+  const [errorMessage, setErrorMessage] = (0, import_react6.useState)(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__ */ (0, import_jsx_runtime5.jsxs)(
+      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__ */ (0, import_jsx_runtime5.jsx)(OptionChoiceMarker, { "data-selected": isSelected, children: getOptionChoiceLabel(index) }),
+          /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(OptionChoiceContent, { children: [
+            inlineInput ? null : /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(OptionChoiceLabel, { children: optionLabel }),
+            inlineInput
+          ] })
+        ]
+      },
+      `${questionId}-${optionLabel}`
+    );
+    switch (question.kind) {
+      case "multi_select":
+        return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(QuestionBody, { children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(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__ */ (0, import_jsx_runtime5.jsx)(QuestionBody, { children: /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(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__ */ (0, import_jsx_runtime5.jsx)(
+              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__ */ (0, import_jsx_runtime5.jsx)(QuestionBody, { children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+          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__ */ (0, import_jsx_runtime5.jsx)(QuestionBody, { children: /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(NumberInputRow, { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+            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__ */ (0, import_jsx_runtime5.jsx)(Unit, { children: question.unit }) : null
+        ] }) });
+      case "boolean":
+        return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(QuestionBody, { children: /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(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__ */ (0, import_jsx_runtime5.jsxs)(Card4, { "data-testid": "pde-ai-questionnaire-card", children: [
+    questionnaire.title ? /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(Title3, { children: questionnaire.title }) : null,
+    questionnaire.description ? /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(Description, { children: questionnaire.description }) : null,
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(QuestionList, { children: questionnaire.questions.map((question) => /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(QuestionCard, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(QuestionLabel, { children: [
+        question.label,
+        question.required ? /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(Required, { children: "*" }) : null
+      ] }),
+      renderQuestion(question)
+    ] }, question.id)) }),
+    errorMessage ? /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(ErrorMessage, { "data-testid": "pde-ai-questionnaire-error", children: errorMessage }) : null,
+    interactive ? /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+      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__ */ (0, import_jsx_runtime5.jsx)(PDEAIQuestionnaireCardInner, { ...props }, getQuestionnaireStateKey(props.questionnaire));
+var Card4 = import_styled4.default.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 = import_styled4.default.strong`
+  color: rgba(255, 255, 255, 0.94);
+  font-size: 16px;
+  line-height: 1.4;
+`;
+var Description = import_styled4.default.p`
+  margin: 0;
+  color: rgba(255, 255, 255, 0.72);
+  font-size: 13px;
+`;
+var QuestionList = import_styled4.default.div`
+  display: grid;
+  gap: 12px;
+`;
+var QuestionCard = import_styled4.default.div`
+  display: grid;
+  gap: 10px;
+  padding: 12px;
+  border-radius: 16px;
+  background: rgba(255, 255, 255, 0.04);
+`;
+var QuestionLabel = import_styled4.default.div`
+  color: rgba(255, 255, 255, 0.9);
+  font-size: 13px;
+  font-weight: 600;
+`;
+var Required = import_styled4.default.span`
+  margin-left: 4px;
+  color: rgba(255, 122, 122, 0.9);
+`;
+var QuestionBody = import_styled4.default.div`
+  display: grid;
+  gap: 10px;
+`;
+var OptionList = import_styled4.default.div`
+  display: grid;
+  gap: 10px;
+`;
+var OptionChoiceItem = import_styled4.default.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 = import_styled4.default.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 = import_styled4.default.span`
+  display: grid;
+  gap: 2px;
+  min-width: 0;
+  flex: 1;
+`;
+var OptionChoiceLabel = import_styled4.default.span`
+  color: inherit;
+  font-size: 13px;
+  font-weight: 600;
+  line-height: 1.4;
+`;
+var TextInput = import_styled4.default.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 = (0, import_styled4.default)(TextInput)`
+  margin-top: 0;
+`;
+var NumberInputRow = import_styled4.default.div`
+  display: flex;
+  align-items: center;
+  gap: 10px;
+`;
+var Unit = import_styled4.default.span`
+  color: rgba(255, 255, 255, 0.58);
+  font-size: 12px;
+  white-space: nowrap;
+`;
+var ErrorMessage = import_styled4.default.div`
+  color: rgba(255, 145, 145, 0.96);
+  font-size: 12px;
+`;
+var SubmitButton = import_styled4.default.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
+var import_styled5 = __toESM(require("@emotion/styled"));
+var import_jsx_runtime6 = require("@emotion/react/jsx-runtime");
+var PDEAIResultSummaryCard = ({ summary }) => /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)(Card5, { "data-testid": "pde-ai-result-summary-card", "data-status": summary.status, children: [
+  /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(Eyebrow2, { children: summary.status }),
+  /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(Headline, { children: summary.headline }),
+  /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(Details, { children: summary.details.map((detail) => /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(Detail, { children: detail }, detail)) })
+] });
+var Card5 = import_styled5.default.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 = import_styled5.default.span`
+  color: rgba(255, 255, 255, 0.58);
+  font-size: 11px;
+  font-weight: 700;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+`;
+var Headline = import_styled5.default.strong`
+  color: rgba(255, 255, 255, 0.94);
+  font-size: 15px;
+`;
+var Details = import_styled5.default.ul`
+  margin: 0;
+  padding-left: 18px;
+  color: rgba(255, 255, 255, 0.8);
+  font-size: 13px;
+`;
+var Detail = import_styled5.default.li`
+  & + & {
+    margin-top: 6px;
+  }
+`;
+
+// src/components/chat-thread/components/image-viewer.tsx
+var import_styled6 = __toESM(require("@emotion/styled"));
+var import_react7 = require("react");
+var import_jsx_runtime7 = require("@emotion/react/jsx-runtime");
+var Overlay = import_styled6.default.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 = import_styled6.default.img`
+  max-width: 90vw;
+  max-height: 90vh;
+  object-fit: contain;
+  border-radius: 4px;
+`;
+var ImageViewer = ({ src, alt, onClose }) => {
+  const overlayRef = (0, import_react7.useRef)(null);
+  (0, import_react7.useEffect)(() => {
+    const handleKey = (e) => {
+      if (e.key === "Escape")
+        onClose();
+    };
+    document.addEventListener("keydown", handleKey);
+    return () => document.removeEventListener("keydown", handleKey);
+  }, [onClose]);
+  (0, import_react7.useEffect)(() => {
+    overlayRef.current?.focus();
+  }, []);
+  const stopPropagation = (e) => e.stopPropagation();
+  return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+    Overlay,
+    {
+      ref: overlayRef,
+      role: "dialog",
+      "aria-modal": "true",
+      "aria-label": "Image viewer",
+      tabIndex: -1,
+      onClick: onClose,
+      children: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(Img, { src, alt: alt ?? "", onClick: stopPropagation })
+    }
+  );
+};
+
+// src/components/chat-thread/components/chat-message-item.tsx
+var import_jsx_runtime8 = require("@emotion/react/jsx-runtime");
+var MARKDOWN_REMARK_PLUGINS = [import_remark_gfm.default, import_remark_math.default];
+var MARKDOWN_REHYPE_PLUGINS = [import_rehype_katex.default];
+var MARKDOWN_COMPONENTS = {
+  table: ({ node: _node, ...props }) => /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(TableWrapper, { children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("table", { ...props }) })
+};
+var renderMarkdownContent = (content) => /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+  import_react_markdown.default,
+  {
+    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] = (0, import_react8.useState)(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__ */ (0, import_jsx_runtime8.jsx)(
+          ContentBlock,
+          {
+            "data-testid": `chat-message-block-${index}`,
+            "data-block-tone": "settled",
+            children: renderMarkdownContent(block.text)
+          },
+          `markdown-${index}`
+        );
+      case "notice":
+        return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_react8.Fragment, { children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(PDEAINoticeCard, { text: block.text, tone: block.tone }) }, `notice-${index}`);
+      case "parameter_summary":
+        return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_react8.Fragment, { children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(PDEAIParameterSummaryCard, { items: block.items }) }, `parameter-summary-${index}`);
+      case "confirmation_card":
+        return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_react8.Fragment, { children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+          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__ */ (0, import_jsx_runtime8.jsx)(import_react8.Fragment, { children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(PDEAIResultSummaryCard, { summary: block.summary }) }, `result-summary-${index}`);
+      case "questionnaire":
+        return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_react8.Fragment, { children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+          PDEAIQuestionnaireCard,
+          {
+            questionnaire: block.questionnaire,
+            interactive: canSubmitQuestionnaire,
+            onSubmit: canSubmitQuestionnaire ? (submission) => onQuestionnaireSubmit({
+              ...submission,
+              sourceMessageId: message.id
+            }) : void 0
+          }
+        ) }, `questionnaire-${index}`);
+      case "custom":
+        return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_react8.Fragment, { children: renderMessageBlock?.({
+          block,
+          index,
+          message,
+          mode,
+          onConfirmationSubmit,
+          onQuestionnaireSubmit
+        }) ?? null }, `custom-${block.kind}-${index}`);
+      default:
+        return null;
+    }
+  };
+  const renderTextContent = () => /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(import_jsx_runtime8.Fragment, { children: [
+    settledContent ? /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(ContentBlock, { "data-testid": "chat-message-settled-block", "data-block-tone": "settled", children: renderMarkdownContent(settledContent) }) : null,
+    freshContent ? /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(ContentBlock, { "data-testid": "chat-message-fresh-block", "data-block-tone": "fresh", children: renderMarkdownContent(freshContent) }) : null,
+    !settledContent && !freshContent && hasTextContent ? /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(ContentBlock, { "data-testid": "chat-message-settled-block", "data-block-tone": "settled", children: renderMarkdownContent(displayedContent) }) : null
+  ] });
+  return /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(import_jsx_runtime8.Fragment, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(Bubble, { "data-role": message.role, "data-status": message.status ?? "done", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(Header2, { children: [
+        isAssistantStreaming ? /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(
+          StreamingIndicator,
+          {
+            "data-testid": "chat-streaming-indicator",
+            "aria-label": labels.assistantStreamingAriaLabel,
+            children: [
+              /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(IndicatorSpark, {}),
+              /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(IndicatorSpark, { "data-secondary": true })
+            ]
+          }
+        ) : null,
+        /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(Role, { children: message.role === "user" ? labels.userRoleLabel : labels.assistantRoleLabel }),
+        isStoppedAssistant ? /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(StatusTag, { "data-testid": "chat-message-stopped-tag", children: labels.stoppedResponse }) : null
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(Content, { "data-testid": "chat-message-content", children: [
+        hasStructuredBlocks || hasTextContent ? /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(ContentStack, { "data-testid": "chat-message-body-stack", children: [
+          hasStructuredBlocks ? blocks.map((block, index) => /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+            ContentSegment,
+            {
+              "data-testid": "chat-message-content-segment",
+              children: renderChatMessageBlock(block, index)
+            },
+            `${block.type}-${index}`
+          )) : null,
+          hasTextContent ? /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(ContentSegment, { "data-testid": "chat-message-content-segment", children: renderTextContent() }) : null
+        ] }) : null,
+        attachments.length ? /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(AttachmentGrid, { "data-testid": "chat-message-attachment-grid", children: attachments.map((attachment) => /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+          AttachmentButton,
+          {
+            type: "button",
+            "aria-label": attachment.name,
+            onClick: () => setActiveImage({
+              name: attachment.name,
+              previewUrl: attachment.previewUrl
+            }),
+            children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(AttachmentImage, { src: attachment.previewUrl, alt: attachment.name })
+          },
+          attachment.id
+        )) }) : null,
+        shouldShowStreamingCaret ? /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(StreamingCaret, { "data-testid": "chat-streaming-caret", "aria-hidden": "true" }) : null
+      ] })
+    ] }),
+    activeImage ? /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+      ImageViewer,
+      {
+        src: activeImage.previewUrl,
+        alt: activeImage.name,
+        onClose: () => setActiveImage(void 0)
+      }
+    ) : null
+  ] });
+};
+var ChatMessageItem = (0, import_react8.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 = import_styled7.default.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 = import_styled7.default.div`
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  margin-bottom: 10px;
+`;
+var Role = import_styled7.default.div`
+  font-size: 12px;
+  color: rgba(255, 255, 255, 0.42);
+  text-transform: capitalize;
+  letter-spacing: 0.08em;
+`;
+var StatusTag = import_styled7.default.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 = import_styled7.default.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 = import_styled7.default.div`
+  display: flex;
+  flex-direction: column;
+  gap: 16px;
+`;
+var ContentSegment = import_styled7.default.div`
+  min-width: 0;
+`;
+var ContentBlock = import_styled7.default.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 = import_styled7.default.div`
+  display: flex;
+  flex-wrap: wrap;
+  gap: 10px;
+  margin-top: 12px;
+`;
+var AttachmentButton = import_styled7.default.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 = import_styled7.default.img`
+  width: 100%;
+  height: 100%;
+  display: block;
+  object-fit: cover;
+`;
+var TableWrapper = import_styled7.default.div`
+  overflow-x: auto;
+`;
+var caretBlink = import_react9.keyframes`
+  0%, 49% {
+    opacity: 1;
+  }
+
+  50%, 100% {
+    opacity: 0.2;
+  }
+`;
+var shimmer = import_react9.keyframes`
+  0%, 100% {
+    transform: scale(0.9) rotate(0deg);
+    opacity: 0.55;
+  }
+
+  50% {
+    transform: scale(1.05) rotate(8deg);
+    opacity: 1;
+  }
+`;
+var StreamingIndicator = import_styled7.default.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 = import_styled7.default.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 = import_styled7.default.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
+var import_react10 = require("react");
+var import_styled8 = __toESM(require("@emotion/styled"));
+var import_jsx_runtime9 = require("@emotion/react/jsx-runtime");
+var ChatThreadHistoryList = (0, import_react10.memo)(
+  ({
+    mode,
+    historyMessages,
+    latestUserMessageId,
+    latestUserMessageRef,
+    onConfirmationSubmit,
+    onQuestionnaireSubmit,
+    renderMessageBlock
+  }) => /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(HistoryGroup, { "data-testid": "chat-thread-history", children: historyMessages.map((message) => /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
+    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__ */ (0, import_jsx_runtime9.jsx)(
+        ChatMessageItem,
+        {
+          mode,
+          message,
+          onConfirmationSubmit,
+          onQuestionnaireSubmit,
+          renderMessageBlock
+        }
+      )
+    },
+    message.id
+  )) })
+);
+ChatThreadHistoryList.displayName = "ChatThreadHistoryList";
+var HistoryGroup = import_styled8.default.div`
+  display: contents;
+`;
+var MessageSlot = import_styled8.default.div`
+  display: flex;
+  align-items: flex-start;
+`;
+
+// src/components/chat-thread/components/chat-thread-empty-state.tsx
+var import_styled9 = __toESM(require("@emotion/styled"));
+var import_jsx_runtime10 = require("@emotion/react/jsx-runtime");
+var ChatThreadEmptyState = () => {
+  const { labels } = useChatContext();
+  return /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)(EmptyShell, { "data-testid": "chat-empty-hero", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)(HeroMark, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(HeroOrbit, {}),
+      /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(HeroCore, { children: "AI" })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(HeroTitle, { children: labels.emptyStateTitle }),
+    /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(HeroSubtitle, { children: labels.emptyStateSubtitle })
+  ] });
+};
+var EmptyShell = import_styled9.default.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 = import_styled9.default.div`
+  position: relative;
+  width: 108px;
+  height: 108px;
+  border-radius: 24px;
+  display: grid;
+  place-items: center;
+`;
+var HeroOrbit = import_styled9.default.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 = import_styled9.default.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 = import_styled9.default.p`
+  margin: 0;
+  color: rgba(255, 255, 255, 0.88);
+  font-size: 16px;
+  line-height: 24px;
+`;
+var HeroSubtitle = import_styled9.default.p`
+  margin: 0;
+  color: rgba(255, 255, 255, 0.72);
+  font-size: 14px;
+  line-height: 20px;
+`;
+
+// src/components/chat-thread/index.tsx
+var import_jsx_runtime11 = require("@emotion/react/jsx-runtime");
+var ChatThreadView = ({
+  activeSessionMode = DEFAULT_CHAT_AGENT_MODE,
+  historyMessages,
+  streamingMessage,
+  error,
+  retryButtonLabel,
+  onRetry,
+  onConfirmationSubmit,
+  onQuestionnaireSubmit,
+  renderMessageBlock
+}) => {
+  const containerRef = (0, import_react11.useRef)(null);
+  const latestUserMessageId = (0, import_react11.useMemo)(
+    () => findLatestUserMessageId(historyMessages),
+    [historyMessages]
+  );
+  const latestUserMessageRef = (0, import_react11.useRef)(null);
+  const pendingScrollUserMessageIdRef = (0, import_react11.useRef)(void 0);
+  const reservedSpaceFrameRef = (0, import_react11.useRef)(null);
+  const [latestUserMessageReservedSpace, setLatestUserMessageReservedSpace] = (0, import_react11.useState)({ messageId: void 0, value: 0 });
+  const reservedPaddingBottom = 24 + (latestUserMessageReservedSpace.messageId === latestUserMessageId ? latestUserMessageReservedSpace.value : 0);
+  const measureLatestUserMessageReservedSpace = (0, import_react11.useCallback)((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 };
+    });
+  }, []);
+  (0, import_react11.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]);
+  (0, import_react11.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__ */ (0, import_jsx_runtime11.jsxs)(
+    Container,
+    {
+      ref: containerRef,
+      "data-testid": "chat-thread",
+      style: { paddingBottom: `${reservedPaddingBottom}px` },
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+          ChatThreadHistoryList,
+          {
+            mode: activeSessionMode,
+            historyMessages,
+            latestUserMessageId,
+            latestUserMessageRef,
+            onConfirmationSubmit,
+            onQuestionnaireSubmit,
+            renderMessageBlock
+          }
+        ),
+        streamingMessage ? /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(StreamingGroup, { "data-testid": "chat-thread-streaming", children: /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(MessageSlot2, { children: /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+          ChatMessageItem,
+          {
+            mode: activeSessionMode,
+            message: streamingMessage,
+            onConfirmationSubmit,
+            onQuestionnaireSubmit,
+            renderMessageBlock
+          }
+        ) }) }) : null,
+        error ? /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(ErrorState, { "data-testid": "chat-thread-error-state", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(ErrorText, { children: error }),
+          onRetry ? /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(ErrorActions, { children: /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(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 = (0, import_react11.useCallback)(() => {
+    if (!activeSessionId)
+      return;
+    clearSessionError(activeSessionId);
+    void retryRef.current();
+  }, [activeSessionId, clearSessionError, retryRef]);
+  const handleQuestionnaireSubmit = (0, import_react11.useCallback)(
+    (submission) => {
+      if (activeSessionId && submission.sourceMessageId) {
+        updateQA(
+          activeSessionId,
+          submission.sourceMessageId,
+          submission.questionnaireId,
+          submission.answers
+        );
+      }
+      void sendRef.current(submission.content);
+    },
+    [activeSessionId, updateQA, sendRef]
+  );
+  const handleConfirmationSubmit = (0, import_react11.useCallback)(
+    (submission) => {
+      void sendRef.current(submission.content);
+    },
+    [sendRef]
+  );
+  if (!hasSessions || messages.length === 0 && !streamingMessage) {
+    return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(ChatThreadEmptyState, {});
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+    ChatThreadView,
+    {
+      activeSessionMode,
+      historyMessages: messages,
+      streamingMessage,
+      error,
+      retryButtonLabel: labels.retryButton,
+      onRetry: handleRetry,
+      onConfirmationSubmit: handleConfirmationSubmit,
+      onQuestionnaireSubmit: handleQuestionnaireSubmit,
+      renderMessageBlock
+    }
+  );
+};
+var Container = import_styled10.default.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 = import_styled10.default.div`
+  display: flex;
+`;
+var StreamingGroup = import_styled10.default.div`
+  display: contents;
+`;
+var ErrorText = import_styled10.default.div`
+  color: #ff7b72;
+  font-size: 14px;
+`;
+var ErrorState = import_styled10.default.div`
+  display: flex;
+  flex-direction: column;
+  align-items: flex-start;
+  gap: 10px;
+`;
+var ErrorActions = import_styled10.default.div`
+  display: flex;
+  align-items: center;
+`;
+var RetryButton = import_styled10.default.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
+var import_react15 = require("react");
+var import_styled15 = __toESM(require("@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
+var import_react13 = require("react");
+
+// src/components/chat-composer/hooks/use-composer-attachments.ts
+var import_react12 = require("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] = (0, import_react12.useState)([]);
+  const attachmentsRef = (0, import_react12.useRef)([]);
+  (0, import_react12.useEffect)(() => {
+    attachmentsRef.current = attachments;
+  }, [attachments]);
+  (0, import_react12.useEffect)(
+    () => () => {
+      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] = (0, import_react13.useState)([]);
+  const [isModelsLoading, setIsModelsLoading] = (0, import_react13.useState)(true);
+  const [isModelsError, setIsModelsError] = (0, import_react13.useState)(false);
+  const fetchModels = (0, import_react13.useCallback)(async () => {
+    setIsModelsLoading(true);
+    setIsModelsError(false);
+    try {
+      const modelsResponse = await transport.getModels();
+      setAvailableModels(modelsResponse.data);
+    } catch {
+      setIsModelsError(true);
+    } finally {
+      setIsModelsLoading(false);
+    }
+  }, [transport]);
+  (0, import_react13.useEffect)(() => {
+    void fetchModels();
+  }, [fetchModels]);
+  const hasModels = availableModels.length > 0;
+  const [value, setValue] = (0, import_react13.useState)("");
+  const [selectedModel, setSelectedModel] = (0, import_react13.useState)("");
+  const [selectedMode, setSelectedModeLocal] = (0, import_react13.useState)(DEFAULT_CHAT_AGENT_MODE);
+  const [attachmentNotice, setAttachmentNotice] = (0, import_react13.useState)(null);
+  const { attachments, appendFiles, removeAttachment, takeMessageAttachments } = useComposerAttachments();
+  const abortControllerRef = (0, import_react13.useRef)(null);
+  const stopRequestRef = (0, import_react13.useRef)(null);
+  const lastRequestRef = (0, import_react13.useRef)(null);
+  (0, import_react13.useEffect)(() => {
+    setSelectedModel(
+      (current) => resolveSelectedChatModel({ currentModel: current, availableModels, isModelsLoading })
+    );
+  }, [availableModels, isModelsLoading]);
+  (0, import_react13.useEffect)(() => {
+    if (activeSession) {
+      setSelectedModeLocal(activeSession.mode ?? DEFAULT_CHAT_AGENT_MODE);
+      return;
+    }
+    setSelectedModeLocal(preferredMode ?? DEFAULT_CHAT_AGENT_MODE);
+  }, [activeSession, preferredMode]);
+  (0, import_react13.useEffect)(() => {
+    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 = (0, import_react13.useCallback)((sessionId) => {
+    if (!stopRequestRef.current)
+      return;
+    if (sessionId && stopRequestRef.current.sessionId !== sessionId)
+      return;
+    clearStopTimeout(sessionId);
+    stopRequestRef.current = null;
+  }, []);
+  const finalizeStop = (0, import_react13.useCallback)(
+    (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 = (0, import_react13.useCallback)(
+    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 = (0, import_react13.useCallback)(
+    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
+var import_react14 = require("react");
+var import_styled11 = __toESM(require("@emotion/styled"));
+var import_jsx_runtime12 = require("@emotion/react/jsx-runtime");
+var ChatComposerAttachmentList = ({
+  attachments,
+  onRemoveAttachment
+}) => {
+  const [activeImage, setActiveImage] = (0, import_react14.useState)(null);
+  if (!attachments.length) {
+    return null;
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(import_jsx_runtime12.Fragment, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(AttachmentList, { "data-testid": "chat-composer-attachment-list", children: attachments.map((attachment) => /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(AttachmentCard, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
+        AttachmentPreviewButton,
+        {
+          type: "button",
+          "aria-label": `${attachment.name} preview`,
+          onClick: () => setActiveImage(attachment),
+          children: /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(AttachmentThumb, { src: attachment.previewUrl, alt: attachment.name })
+        }
+      ),
+      /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
+        AttachmentRemoveButton,
+        {
+          type: "button",
+          "aria-label": `Remove ${attachment.name}`,
+          onClick: (event) => {
+            event.stopPropagation();
+            onRemoveAttachment(attachment.id);
+          },
+          children: /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(CloseGlyph, { "aria-hidden": "true" })
+        }
+      )
+    ] }, attachment.id)) }),
+    activeImage ? /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
+      ImageViewer,
+      {
+        src: activeImage.previewUrl,
+        alt: activeImage.name,
+        onClose: () => setActiveImage(null)
+      }
+    ) : null
+  ] });
+};
+var AttachmentList = import_styled11.default.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 = import_styled11.default.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 = import_styled11.default.button`
+  width: 100%;
+  height: 100%;
+  padding: 0;
+  border: 0;
+  background: transparent;
+  cursor: zoom-in;
+`;
+var AttachmentThumb = import_styled11.default.img`
+  width: 100%;
+  height: 100%;
+  object-fit: cover;
+  display: block;
+`;
+var AttachmentRemoveButton = import_styled11.default.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 = import_styled11.default.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
+var import_styled12 = __toESM(require("@emotion/styled"));
+var import_compass_ui = require("@xinghunm/compass-ui");
+var import_jsx_runtime13 = require("@emotion/react/jsx-runtime");
+var ChatModelControl = ({
+  selectedModel,
+  availableModels,
+  isModelsLoading,
+  isModelsError,
+  hasModels,
+  onSelectedModelChange,
+  onReloadModels
+}) => {
+  if (isModelsError) {
+    return /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(
+      ModelReloadButton,
+      {
+        type: "button",
+        "data-testid": "chat-model-reload",
+        "aria-label": "Reload",
+        onClick: onReloadModels,
+        children: [
+          /* @__PURE__ */ (0, import_jsx_runtime13.jsx)("span", { children: "Failed to load models" }),
+          /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(
+            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__ */ (0, import_jsx_runtime13.jsx)("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__ */ (0, import_jsx_runtime13.jsx)("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__ */ (0, import_jsx_runtime13.jsx)(ModelBadge, { children: "Loading models..." });
+  }
+  if (hasModels && selectedModel) {
+    if (availableModels.length > 1) {
+      return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
+        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__ */ (0, import_jsx_runtime13.jsx)(ModelBadge, { children: selectedModel });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(ModelBadge, { children: "No model available" });
+};
+var ModelBadge = import_styled12.default.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 = import_styled12.default.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 = import_styled12.default.svg`
+  flex-shrink: 0;
+`;
+var ModelSelect = (0, import_styled12.default)(import_compass_ui.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
+var import_styled13 = __toESM(require("@emotion/styled"));
+var import_compass_ui2 = require("@xinghunm/compass-ui");
+var import_jsx_runtime14 = require("@emotion/react/jsx-runtime");
+var ChatModeControl = ({
+  value,
+  disabled = false,
+  labels,
+  onChange
+}) => {
+  return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
+    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 = (0, import_styled13.default)(import_compass_ui2.Select)`
+  && {
+    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
+var import_styled14 = __toESM(require("@emotion/styled"));
+var import_compass_ui3 = require("@xinghunm/compass-ui");
+var import_jsx_runtime15 = require("@emotion/react/jsx-runtime");
+var ArrowUpIcon = () => /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+  "svg",
+  {
+    "aria-hidden": "true",
+    width: "12",
+    height: "12",
+    viewBox: "0 0 12 12",
+    fill: "none",
+    xmlns: "http://www.w3.org/2000/svg",
+    children: /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+      "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__ */ (0, import_jsx_runtime15.jsx)(import_jsx_runtime15.Fragment, { children: isStreaming ? /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+  StopButton,
+  {
+    type: "button",
+    "aria-label": "Stop",
+    "aria-busy": isStopping,
+    "data-testid": "chat-composer-stop",
+    disabled: isStopping,
+    shape: "circle",
+    onClick: () => void onStop(),
+    children: /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(StopGlyph, { "aria-hidden": "true" })
+  }
+) : /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+  PrimaryButton,
+  {
+    $canSend: canSend,
+    type: "button",
+    icon: /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(ArrowUpIcon, {}),
+    "aria-label": "Send",
+    "data-testid": "chat-composer-send",
+    disabled: !canSend,
+    shape: "circle",
+    onClick: () => void onSend()
+  }
+) });
+var PrimaryButton = (0, import_styled14.default)(import_compass_ui3.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 = (0, import_styled14.default)(import_compass_ui3.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 = import_styled14.default.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
+var import_jsx_runtime16 = require("@emotion/react/jsx-runtime");
+var PlusIcon = () => /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(
+  "svg",
+  {
+    "aria-hidden": "true",
+    width: "16",
+    height: "16",
+    viewBox: "0 0 16 16",
+    fill: "none",
+    xmlns: "http://www.w3.org/2000/svg",
+    children: /* @__PURE__ */ (0, import_jsx_runtime16.jsx)("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 = (0, import_react15.useRef)(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__ */ (0, import_jsx_runtime16.jsx)(Container2, { children: /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)(Surface, { "data-testid": "chat-composer-surface", children: [
+    enableImageAttachments ? /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(
+      "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__ */ (0, import_jsx_runtime16.jsx)(
+      ChatComposerAttachmentList,
+      {
+        attachments,
+        onRemoveAttachment
+      }
+    ),
+    attachmentNotice === "limit_reached" ? /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(AttachmentNotice, { "data-testid": "chat-composer-attachment-notice", children: attachmentLimitNotice }) : null,
+    /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(
+      Input,
+      {
+        "data-testid": "chat-composer-input",
+        value,
+        onChange: (event) => onValueChange(event.target.value),
+        onKeyDown: handleKeyDown,
+        onPaste: enableImageAttachments ? handlePaste : void 0,
+        placeholder
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(Footer, { children: /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)(Actions2, { "data-testid": "chat-composer-actions", children: [
+      enableImageAttachments ? /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(
+        AttachButton,
+        {
+          type: "button",
+          "data-testid": "chat-composer-attach-image",
+          "aria-label": "Attach image",
+          onClick: () => imageInputRef.current?.click(),
+          children: /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(PlusIcon, {})
+        }
+      ) : null,
+      /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(
+        ChatModeControl,
+        {
+          value: selectedMode,
+          disabled: isStreaming,
+          labels: modeLabels,
+          onChange: onSelectedModeChange
+        }
+      ),
+      /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(
+        ChatModelControl,
+        {
+          selectedModel,
+          availableModels,
+          isModelsLoading,
+          isModelsError,
+          hasModels,
+          onSelectedModelChange,
+          onReloadModels
+        }
+      ),
+      /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(
+        ChatSendActions,
+        {
+          canSend,
+          isStreaming,
+          isStopping,
+          onStop,
+          onSend
+        }
+      )
+    ] }) })
+  ] }) });
+};
+var ChatComposer = () => {
+  const { labels, sendRef, retryRef, enableImageAttachments } = useChatContext();
+  const { state, actions } = useChatComposer();
+  const { send, retry } = actions;
+  (0, import_react15.useEffect)(() => {
+    sendRef.current = send;
+    retryRef.current = async () => {
+      retry();
+    };
+  }, [retry, retryRef, send, sendRef]);
+  const modeLabels = {
+    ask: labels.modeLabelAsk,
+    plan: labels.modeLabelPlan,
+    agent: labels.modeLabelAgent
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(
+    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 = import_styled15.default.div`
+  padding: 0 16px 16px;
+`;
+var Surface = import_styled15.default.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 = import_styled15.default.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 = import_styled15.default.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 = import_styled15.default.div`
+  display: flex;
+  align-items: flex-end;
+  justify-content: stretch;
+  gap: 16px;
+  padding: 0 14px 14px;
+`;
+var Actions2 = import_styled15.default.div`
+  display: flex;
+  align-items: center;
+  flex-wrap: wrap;
+  width: 100%;
+  min-width: 0;
+  justify-content: flex-end;
+  gap: 8px;
+`;
+var AttachButton = import_styled15.default.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
+var import_styled17 = __toESM(require("@emotion/styled"));
+
+// src/components/chat-conversation-list/components/chat-session-item.tsx
+var import_react16 = require("react");
+var import_styled16 = __toESM(require("@emotion/styled"));
+var import_jsx_runtime17 = require("@emotion/react/jsx-runtime");
+var ChatSessionItem = (0, import_react16.memo)(
+  ({ session, isActive, modeLabel, onClick }) => {
+    return /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
+      SessionButton,
+      {
+        type: "button",
+        "data-active": isActive,
+        onClick: () => onClick(session.sessionId),
+        children: /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)(SessionMeta, { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(SessionTitle, { children: session.title }),
+          /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(ModeBadge, { children: modeLabel })
+        ] })
+      }
+    );
+  }
+);
+ChatSessionItem.displayName = "ChatSessionItem";
+var SessionMeta = import_styled16.default.div`
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+`;
+var SessionTitle = import_styled16.default.span`
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+`;
+var SessionButton = import_styled16.default.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 = import_styled16.default.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
+var import_jsx_runtime18 = require("@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__ */ (0, import_jsx_runtime18.jsxs)(Container3, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime18.jsxs)(Toolbar, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(Title4, { children: "Sessions" }),
+      /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(CreateButton, { type: "button", "data-testid": "chat-create-session", onClick: handleCreateSession, children: labels.newChat })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(List2, { "data-testid": "chat-session-list", children: sessions.map((session) => /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(
+      ChatSessionItem,
+      {
+        session,
+        isActive: activeSessionId === session.sessionId,
+        modeLabel: modeLabels[session.mode ?? DEFAULT_CHAT_AGENT_MODE] ?? "",
+        onClick: setActiveSession
+      },
+      session.sessionId
+    )) })
+  ] });
+};
+var Container3 = import_styled17.default.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 = import_styled17.default.div`
+  padding: 20px 16px 12px;
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+`;
+var Title4 = import_styled17.default.h2`
+  margin: 0;
+  font-size: 14px;
+  color: var(--text-secondary);
+`;
+var CreateButton = import_styled17.default.button`
+  border: none;
+  border-radius: 12px;
+  padding: 12px 14px;
+  background: var(--text-primary);
+  color: var(--bg-primary);
+  text-align: left;
+  cursor: pointer;
+`;
+var List2 = import_styled17.default.div`
+  padding: 0 12px 16px;
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  overflow: auto;
+`;
+
+// src/components/ai-chat/index.tsx
+var import_jsx_runtime19 = require("@emotion/react/jsx-runtime");
+var AiChat = ({ showConversationList = false, ...providerProps }) => /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(
+  import_compass_ui4.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__ */ (0, import_jsx_runtime19.jsx)(AiChatProvider, { ...providerProps, children: /* @__PURE__ */ (0, import_jsx_runtime19.jsxs)(Root, { "data-testid": "ai-chat", children: [
+      showConversationList ? /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(ChatConversationList, {}) : null,
+      /* @__PURE__ */ (0, import_jsx_runtime19.jsxs)(Workspace, { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(ChatThread, {}),
+        /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(ChatComposer, {})
+      ] })
+    ] }) })
+  }
+);
+var Root = import_styled18.default.div`
+  display: flex;
+  width: 100%;
+  height: 100%;
+  min-height: 0;
+  overflow: hidden;
+`;
+var Workspace = import_styled18.default.section`
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+  min-height: 0;
+  overflow: hidden;
+`;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AiChat,
+  AiChatProvider,
+  CHAT_AGENT_MODES,
+  ChatComposer,
+  ChatConversationList,
+  ChatThread,
+  DEFAULT_AI_CHAT_LABELS,
+  DEFAULT_CHAT_AGENT_MODE,
+  createDefaultChatTransport,
+  useChatContext,
+  useChatStore
+});