@m6d/cortex-react 1.0.0 → 1.0.1

package/dist/index.js

@@ -1,3 +1,3662 @@
+// src/components/CortexChatWidget.tsx
+import { useCallback, useEffect as useEffect6, useMemo as useMemo3, useRef as useRef8, useState as useState9, useSyncExternalStore } from "react";
+
+// ../../internal/client/src/api-client.ts
+function resolveTransportHeaders(transport) {
+  return Promise.resolve(transport.getHeaders());
+}
+function resolveTransportUrl(transport, path) {
+  const baseUrl = transport.baseUrl;
+  const base = typeof baseUrl === "string" ? baseUrl : baseUrl();
+  return base.replace(/\/$/, "") + path;
+}
+function filenameFrom(disposition) {
+  const encoded = disposition?.match(/filename\*\s*=\s*[^']*'[^']*'([^;\r\n]+)/i)?.[1]?.trim().replace(/^"|"$/g, "");
+  if (encoded) {
+    try {
+      return decodeURIComponent(encoded);
+    } catch {}
+  }
+  return disposition?.match(/filename\s*=\s*"?([^";\r\n]+)"?/i)?.[1];
+}
+function createCortexApiClient(getTransport) {
+  function resolveHeaders() {
+    return resolveTransportHeaders(getTransport());
+  }
+  function resolveUrl(path) {
+    return resolveTransportUrl(getTransport(), path);
+  }
+  async function send(path, init) {
+    const headers = new Headers(await resolveHeaders());
+    new Headers(init?.headers).forEach(function(value, name) {
+      headers.set(name, value);
+    });
+    if (init?.body instanceof FormData) {
+      headers.delete("Content-Type");
+    } else if (!headers.has("Content-Type")) {
+      headers.set("Content-Type", "application/json");
+    }
+    const response = await fetch(resolveUrl(path), {
+      ...init,
+      headers
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    const text = await response.text();
+    return text ? JSON.parse(text) : undefined;
+  }
+  return {
+    listThreads() {
+      return send("/threads");
+    },
+    createThread(prompt) {
+      return send("/threads", {
+        method: "POST",
+        body: JSON.stringify({ prompt })
+      });
+    },
+    deleteThread(threadId) {
+      return send(`/threads/${threadId}`, { method: "DELETE" });
+    },
+    listMessages(threadId) {
+      return send(`/threads/${threadId}/messages`);
+    },
+    listLlmRequests(messageId) {
+      return send(`/messages/${messageId}/llm-requests`);
+    },
+    abortStream(threadId) {
+      return send(`/chat/${threadId}/abort`, { method: "POST" });
+    },
+    async uploadAttachment(threadId, file) {
+      const body = new FormData;
+      body.append("file", file);
+      return await send(`/threads/${threadId}/files`, {
+        method: "POST",
+        body
+      });
+    },
+    deleteAttachment(id) {
+      return send(`/files/${id}`, { method: "DELETE" });
+    },
+    async downloadAttachment(id) {
+      const response = await fetch(resolveUrl(`/files/${id}`), {
+        headers: await resolveHeaders()
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      return {
+        blob: await response.blob(),
+        name: filenameFrom(response.headers.get("Content-Disposition")) ?? id
+      };
+    },
+    resolveHeaders,
+    resolveUrl
+  };
+}
+// ../../internal/client/src/utils/pending-tool-calls.ts
+var SETTLED_STATES = new Set(["complete", "error"]);
+function isSettledToolState(state) {
+  return SETTLED_STATES.has(state);
+}
+function unansweredToolCalls(messages) {
+  const parts = newestAssistantMessage(messages)?.parts ?? [];
+  return parts.filter((part) => part.type === "tool-call" && !isSettledToolState(part.state));
+}
+function newestAssistantMessage(messages) {
+  for (let index = messages.length - 1;index >= 0; index -= 1) {
+    const message = messages[index];
+    if (message?.role === "assistant")
+      return message;
+  }
+  return;
+}
+
+// ../../internal/client/src/tool-call-view.ts
+var STATE_MODIFIERS = {
+  complete: "success",
+  error: "error",
+  "approval-requested": "approval",
+  "approval-responded": "approval",
+  "awaiting-input": "pending",
+  "input-streaming": "pending",
+  "input-complete": "pending"
+};
+var BADGE_LABEL_KEYS = {
+  "awaiting-input": "translate_calling",
+  "input-streaming": "translate_calling",
+  "input-complete": "translate_input_ready",
+  "approval-requested": "translate_needs_approval",
+  "approval-responded": "translate_responded",
+  complete: "translate_completed",
+  error: "translate_error"
+};
+function toolCallBadge(part) {
+  const { state, approval } = part;
+  return {
+    modifier: STATE_MODIFIERS[state],
+    labelKey: state === "approval-responded" && approval?.approved ? "translate_approved" : BADGE_LABEL_KEYS[state],
+    pulse: state === "awaiting-input" || state === "input-streaming" ? "default" : state === "approval-requested" ? "violet" : undefined
+  };
+}
+function toolCallOutputText(part) {
+  const output = part.output;
+  if (output === undefined || output === null)
+    return "";
+  if (typeof output === "string")
+    return output;
+  return JSON.stringify(output, null, 2);
+}
+var CODE_FIELDS = {
+  code: "javascript",
+  query: "cypher"
+};
+function splitToolCallInput(input) {
+  const record = input && typeof input === "object" ? input : null;
+  const codeSnippets = record ? Object.entries(CODE_FIELDS).flatMap(([key, lang]) => {
+    const value = record[key];
+    return typeof value === "string" ? [{ key, lang, value: value.replace(/\\n/g, `
+`) }] : [];
+  }) : [];
+  let remainingInput = input;
+  if (record) {
+    const rest = Object.fromEntries(Object.entries(record).filter(([key]) => !Object.hasOwn(CODE_FIELDS, key)));
+    remainingInput = Object.keys(rest).length > 0 ? rest : null;
+  }
+  return {
+    codeSnippets,
+    remainingInput,
+    remainingInputText: remainingInput ? JSON.stringify(remainingInput, null, 2) : ""
+  };
+}
+var STATUS_COUNT = 10;
+var ANIM_STATES = {
+  "awaiting-input": "starting",
+  "input-streaming": "starting",
+  "input-complete": "processing",
+  "approval-requested": "processing",
+  "approval-responded": "processing",
+  complete: "complete",
+  error: "error"
+};
+function stableIndex(id) {
+  let hash = 0;
+  for (let i = 0;i < id.length; i++) {
+    hash = hash * 31 + id.charCodeAt(i) | 0;
+  }
+  return Math.abs(hash) % STATUS_COUNT;
+}
+function toolCallAnimation(part) {
+  const state = ANIM_STATES[part.state] ?? "processing";
+  const family = part.name === "readAttachment" ? "attachment" : "tool";
+  const variant = family === "tool" ? `_${stableIndex(part.id)}` : "";
+  return {
+    state,
+    active: state === "starting" || state === "processing",
+    titleKey: state === "error" ? "translate_tool_error" : `translate_${family}_${state === "complete" ? "done" : "status"}${variant}`
+  };
+}
+function activityLabelKeys(activity) {
+  return Array.from({ length: STATUS_COUNT }, (_, index) => `translate_${activity}_${index}`);
+}
+var SELF_DESCRIBING_TOOLS = ["queryGraph", "executeCode"];
+function isHiddenInAnimatedMode(part, isLast, isStreaming) {
+  if (part.type === "thinking")
+    return !(isStreaming && isLast);
+  if (part.type !== "tool-call")
+    return false;
+  return SELF_DESCRIBING_TOOLS.includes(part.name) && isSettledToolState(part.state);
+}
+// ../../internal/client/src/chat-connection.ts
+import { EventType } from "@tanstack/ai";
+import { fetchServerSentEvents } from "@tanstack/ai-client";
+function toUiMessage(message) {
+  return { id: message.id, role: message.role, parts: message.parts };
+}
+function newestUnsent(messages) {
+  for (let index = messages.length - 1;index >= 0; index -= 1) {
+    const message = messages[index];
+    const answersToolCall = "parts" in message && message.parts.some((part) => part.type === "tool-result");
+    if (message.role === "user" || answersToolCall)
+      return messages.slice(index, index + 1);
+  }
+  return messages.slice(-1);
+}
+function metadataByMessageId(rows) {
+  return new Map(rows.flatMap((row) => row.metadata ? [[row.id, row.metadata]] : []));
+}
+function createCortexConnection(options) {
+  const { api, thread } = options;
+  const requestOptions = async () => ({ headers: await api.resolveHeaders() });
+  const turn = fetchServerSentEvents(() => api.resolveUrl("/chat"), requestOptions);
+  const connect = function(messages, data, abortSignal, runContext) {
+    return turn.connect(newestUnsent(messages), data, abortSignal, runContext);
+  };
+  const join = fetchServerSentEvents(() => api.resolveUrl(`/chat/${thread.id}/stream`), requestOptions);
+  let replayBase = [];
+  return {
+    connect,
+    async* joinRun(runId, abortSignal) {
+      yield {
+        type: EventType.MESSAGES_SNAPSHOT,
+        timestamp: Date.now(),
+        messages: replayBase
+      };
+      yield* join.joinRun(runId, abortSignal);
+    },
+    hydrate: async () => {
+      const hydration = await hydrateThread(options);
+      replayBase = hydration.messages;
+      return hydration;
+    }
+  };
+}
+async function hydrateThread(options) {
+  const { api, thread, mode } = options;
+  const activeRun = thread.isRunning ? { runId: thread.id } : null;
+  if (mode === "skip")
+    return { messages: [], activeRun, interrupts: null };
+  if (mode === "load")
+    options.setLoadingMessages?.(true);
+  try {
+    const rows = await api.listMessages(thread.id);
+    const messages = rows.map(toUiMessage);
+    options.onHydrated?.(rows, messages);
+    return { messages, activeRun, interrupts: null };
+  } finally {
+    options.setLoadingMessages?.(false);
+  }
+}
+async function settleTurn(options) {
+  try {
+    const rows = await options.api.listMessages(options.threadId);
+    if (options.isStale?.())
+      return;
+    options.absorbMetadata(metadataByMessageId(rows));
+    if (options.isStreaming())
+      return;
+    options.setMessages(rows.map(toUiMessage));
+  } catch {}
+}
+// ../../internal/contracts/wire.ts
+var ATTACHMENT_MIME_TYPES = [
+  "image/png",
+  "image/jpeg",
+  "image/webp",
+  "application/pdf"
+];
+var ATTACHMENT_MAX_BYTES = 10 * 1024 * 1024;
+var MAX_ATTACHMENTS_PER_MESSAGE = 5;
+function checkAttachmentPolicy(contentType, sizeBytes) {
+  if (!ATTACHMENT_MIME_TYPES.some((type) => type === contentType))
+    return "type";
+  if (sizeBytes > ATTACHMENT_MAX_BYTES)
+    return "size";
+  return "ok";
+}
+
+// ../../internal/client/src/attachment-queue.ts
+function createAttachmentQueue(options) {
+  const { api } = options;
+  const listeners = new Set;
+  const cancelled = new Set;
+  let items = [];
+  let consumed = [];
+  function getState() {
+    return items;
+  }
+  function subscribe(listener) {
+    listeners.add(listener);
+    return () => {
+      listeners.delete(listener);
+    };
+  }
+  function setItems(next) {
+    items = next;
+    for (const listener of listeners)
+      listener();
+  }
+  function patch(localId, changes) {
+    setItems(items.map((item) => item.localId === localId ? { ...item, ...changes } : item));
+  }
+  function fail(localId) {
+    if (cancelled.delete(localId))
+      return;
+    patch(localId, { status: "error" });
+  }
+  function accept(files) {
+    const accepted = [];
+    for (const file of files) {
+      const rejected = checkAttachmentPolicy(file.type, file.size) !== "ok" || items.filter((item) => item.status !== "error").length >= MAX_ATTACHMENTS_PER_MESSAGE;
+      const localId = crypto.randomUUID();
+      setItems([
+        ...items,
+        { localId, filename: file.name, status: rejected ? "error" : "uploading" }
+      ]);
+      if (!rejected)
+        accepted.push({ localId, file });
+    }
+    if (!accepted.length)
+      return;
+    options.ensureThread().then((threadId) => {
+      for (const { localId, file } of accepted) {
+        if (cancelled.delete(localId))
+          continue;
+        patch(localId, { threadId });
+        api.uploadAttachment(threadId, file).then((attachment) => {
+          if (cancelled.delete(localId)) {
+            api.deleteAttachment(attachment.id).catch(() => {});
+            return;
+          }
+          patch(localId, {
+            status: "ready",
+            attachmentId: attachment.id,
+            summary: attachment
+          });
+        }, () => fail(localId));
+      }
+    }, () => {
+      for (const { localId } of accepted) {
+        fail(localId);
+      }
+    });
+  }
+  function remove(localId) {
+    const item = items.find((current) => current.localId === localId);
+    if (!item)
+      return;
+    if (item.status === "uploading") {
+      cancelled.add(localId);
+      setItems(items.filter((current) => current.localId !== localId));
+      return;
+    }
+    if (item.attachmentId) {
+      patch(localId, { status: "deleting" });
+      api.deleteAttachment(item.attachmentId).then(() => setItems(items.filter((current) => current.localId !== localId)), () => patch(localId, { status: "error" }));
+      return;
+    }
+    setItems(items.filter((current) => current.localId !== localId));
+  }
+  function clear(threadId) {
+    const retained = [];
+    for (const item of items) {
+      if (item.threadId !== undefined && item.threadId !== threadId) {
+        retained.push(item);
+        continue;
+      }
+      if (item.status === "uploading") {
+        cancelled.add(item.localId);
+      } else if (item.status === "ready" && item.threadId === threadId && item.attachmentId) {
+        api.deleteAttachment(item.attachmentId).catch(() => {});
+      }
+    }
+    setItems(retained);
+  }
+  function consumeReady() {
+    const attachments = items.flatMap((item) => item.status === "ready" && item.summary ? [{ ...item, status: "ready", summary: item.summary }] : []);
+    setItems(items.filter((item) => item.status !== "ready"));
+    consumed = attachments;
+    return attachments;
+  }
+  function restoreConsumed(threadId) {
+    const attachments = consumed;
+    consumed = [];
+    if (attachments.some((attachment) => attachment.threadId !== threadId))
+      return;
+    setItems([
+      ...attachments.map((attachment) => ({ ...attachment, status: "error" })),
+      ...items
+    ]);
+  }
+  function discardConsumed() {
+    consumed = [];
+  }
+  return {
+    getState,
+    subscribe,
+    accept,
+    remove,
+    clear,
+    consumeReady,
+    restoreConsumed,
+    discardConsumed
+  };
+}
+function attachmentQueueFlags(items) {
+  return {
+    uploading: items.some((item) => item.status === "uploading"),
+    busy: items.some((item) => item.status === "uploading" || item.status === "deleting"),
+    hasReady: items.some((item) => item.status === "ready")
+  };
+}
+// ../../internal/client/src/websocket.ts
+function wsBackoffDelay(attempt) {
+  return Math.min(1000 * 2 ** (attempt - 1), 30000);
+}
+var STABLE_CONNECTION_MS = 1e4;
+function createCortexSocket(options) {
+  let ws;
+  let reconnectTimer;
+  let attempt = 0;
+  let closed = false;
+  function connect() {
+    const wsUrlOption = typeof options.wsUrl === "function" ? options.wsUrl() : options.wsUrl;
+    const wsUrl = resolveWsUrl(wsUrlOption, options.transport.baseUrl);
+    resolveTransportHeaders(options.transport).then((headers) => {
+      if (closed)
+        return;
+      ws = new WebSocket(appendTokenToUrl(wsUrl, headers));
+      ws.addEventListener("open", () => {
+        const opened = ws;
+        setTimeout(() => {
+          if (ws === opened && !closed)
+            attempt = 0;
+        }, STABLE_CONNECTION_MS);
+        options.onOpen?.();
+      });
+      ws.addEventListener("message", (event) => {
+        const raw = event.data;
+        if (typeof raw !== "string")
+          return;
+        let parsed;
+        try {
+          parsed = JSON.parse(raw);
+        } catch {
+          return;
+        }
+        options.onEvent(parsed);
+      });
+      ws.addEventListener("close", scheduleReconnect);
+    }).catch(scheduleReconnect);
+  }
+  function scheduleReconnect() {
+    if (closed || reconnectTimer)
+      return;
+    attempt += 1;
+    reconnectTimer = setTimeout(() => {
+      reconnectTimer = undefined;
+      connect();
+    }, wsBackoffDelay(attempt));
+  }
+  connect();
+  return {
+    close() {
+      closed = true;
+      clearTimeout(reconnectTimer);
+      ws?.close();
+    }
+  };
+}
+function resolveWsUrl(wsUrl, baseUrl) {
+  const resolvedUrl = wsUrl ?? deriveWsUrl(baseUrl);
+  if (!wsUrl)
+    return resolvedUrl;
+  const agentId = extractAgentId(baseUrl);
+  if (!agentId)
+    return resolvedUrl;
+  return appendAgentIdToUrl(resolvedUrl, agentId);
+}
+function deriveWsUrl(baseUrl) {
+  const url = typeof baseUrl === "string" ? baseUrl : baseUrl();
+  const parsed = new URL(url, window.location.origin);
+  parsed.protocol = parsed.protocol === "https:" ? "wss:" : "ws:";
+  parsed.pathname = parsed.pathname.replace(/\/$/, "") + "/ws";
+  return parsed.toString();
+}
+function extractAgentId(baseUrl) {
+  const url = typeof baseUrl === "string" ? baseUrl : baseUrl();
+  const parsed = new URL(url, window.location.origin);
+  const segments = parsed.pathname.split("/").filter(Boolean);
+  const agentsIndex = segments.lastIndexOf("agents");
+  if (agentsIndex === -1)
+    return;
+  return segments[agentsIndex + 1];
+}
+function appendAgentIdToUrl(wsUrl, agentId) {
+  const parsed = new URL(wsUrl, window.location.origin);
+  if (parsed.searchParams.has("agentId") || hasAgentIdInPath(parsed))
+    return parsed.toString();
+  parsed.searchParams.set("agentId", agentId);
+  return parsed.toString();
+}
+function hasAgentIdInPath(url) {
+  const segments = url.pathname.split("/").filter(Boolean);
+  const agentsIndex = segments.lastIndexOf("agents");
+  return agentsIndex !== -1 && Boolean(segments[agentsIndex + 1]);
+}
+function appendTokenToUrl(wsUrl, headers) {
+  const authHeader = headers["Authorization"] ?? headers["authorization"];
+  if (!authHeader?.startsWith("Bearer "))
+    return wsUrl;
+  const parsed = new URL(wsUrl, window.location.origin);
+  if (parsed.searchParams.has("token"))
+    return parsed.toString();
+  parsed.searchParams.set("token", authHeader.slice(7));
+  return parsed.toString();
+}
+// ../../internal/client/src/threads.ts
+function sortThreads(threads) {
+  return [...threads].sort((left, right) => {
+    const updatedAtDelta = Date.parse(right.updatedAt) - Date.parse(left.updatedAt);
+    if (updatedAtDelta !== 0)
+      return updatedAtDelta;
+    return Date.parse(right.createdAt) - Date.parse(left.createdAt);
+  });
+}
+function upsertThread(threads, thread) {
+  const nextThreads = [...threads];
+  const existingIndex = nextThreads.findIndex((currentThread) => currentThread.id === thread.id);
+  if (existingIndex === -1) {
+    nextThreads.push(thread);
+  } else {
+    nextThreads[existingIndex] = { ...nextThreads[existingIndex], ...thread };
+  }
+  return sortThreads(nextThreads);
+}
+function removeThread(threads, threadId) {
+  return threads.filter((thread) => thread.id !== threadId);
+}
+function applyWsEvent(threads, event) {
+  switch (event.type) {
+    case "thread:deleted":
+      return removeThread(threads, event.payload.threadId);
+    case "thread:created":
+    case "thread:title-updated":
+    case "thread:run-started":
+    case "thread:run-finished":
+    case "thread:messages-updated":
+      return upsertThread(threads, event.payload.thread);
+    default:
+      return threads;
+  }
+}
+// ../../internal/client/src/markdown.ts
+import { marked } from "marked";
+import DOMPurify from "dompurify";
+function renderMarkdown(value) {
+  if (!value) {
+    return "";
+  }
+  let html = marked.parse(value, { async: false });
+  html = html.replace(/<table>/g, '<div style="overflow-x:auto"><table style="width:auto">').replace(/<\/table>/g, "</table></div>").replace(/<(t[hd])([\s>])/g, '<$1 style="padding:0.5rem 1rem"$2');
+  return DOMPurify.sanitize(html);
+}
+// ../../internal/client/src/highlight.ts
+import hljs from "highlight.js/lib/core";
+import javascript from "highlight.js/lib/languages/javascript";
+import json from "highlight.js/lib/languages/json";
+import sql from "highlight.js/lib/languages/sql";
+var registered = false;
+function ensureLanguages() {
+  if (registered)
+    return;
+  registered = true;
+  hljs.registerLanguage("javascript", javascript);
+  hljs.registerLanguage("json", json);
+  hljs.registerLanguage("cypher", sql);
+}
+function highlightCode(code, lang) {
+  if (!code)
+    return "";
+  ensureLanguages();
+  return hljs.getLanguage(lang) ? hljs.highlight(code, { language: lang }).value : escapeHtml(code);
+}
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+// ../../internal/client/src/i18n/ar.json
+var ar_default = {
+  translate_new: "جديد",
+  translate_threads: "المحادثات",
+  translate_n_conversations: "{{count}} محادثات",
+  translate_one_conversation: "محادثة واحدة",
+  translate_no_threads_yet: "لا توجد محادثات بعد",
+  translate_start_a_new_conversation: "ابدأ محادثة جديدة",
+  translate_untitled: "بدون عنوان",
+  translate_new_chat: "محادثة جديدة",
+  translate_normal: "عادي",
+  translate_debug: "تصحيح",
+  translate_type_a_message: "اكتب رسالة...",
+  translate_thinking: "جارٍ معالجة الطلب...",
+  translate_reasoned: "تم الاستنتاج",
+  translate_knowledge_graph_query: "استعلام الرسم البياني المعرفي",
+  translate_javascript_code_execution: "تنفيذ كود جافاسكريبت",
+  translate_completed: "مكتمل",
+  translate_attach_files: "إرفاق ملفات",
+  translate_drop_files_here: "أفلت ملفاتك هنا...",
+  translate_remove_attachment: "إزالة المرفق",
+  translate_attachment_rejected: "لا يمكن إرفاق هذا الملف",
+  translate_attachment_caption: "من فضلك اطّلع على الملفات المرفقة.",
+  translate_download: "تنزيل",
+  translate_tool_status_0: "جارٍ جلب البيانات…",
+  translate_tool_status_1: "جارٍ تحليل المعلومات…",
+  translate_tool_status_2: "جارٍ معالجة الطلب…",
+  translate_tool_status_3: "جارٍ تجميع النتائج…",
+  translate_tool_status_4: "جارٍ تحضير الرد…",
+  translate_tool_status_5: "جارٍ البحث…",
+  translate_tool_status_6: "جارٍ فحص السجلات…",
+  translate_tool_status_7: "جارٍ مراجعة التفاصيل…",
+  translate_tool_status_8: "جارٍ إجراء الحسابات…",
+  translate_tool_status_9: "جارٍ سحب المعلومات…",
+  translate_tool_done_0: "تم جلب البيانات بنجاح",
+  translate_tool_done_1: "تم التحليل بنجاح",
+  translate_tool_done_2: "تمت معالجة الطلب بنجاح",
+  translate_tool_done_3: "تم تجميع النتائج بنجاح",
+  translate_tool_done_4: "تم تحضير الرد بنجاح",
+  translate_tool_done_5: "تم البحث بنجاح",
+  translate_tool_done_6: "تم فحص السجلات بنجاح",
+  translate_tool_done_7: "تمت المراجعة بنجاح",
+  translate_tool_done_8: "تمت الحسابات بنجاح",
+  translate_tool_done_9: "تم استرجاع المعلومات بنجاح",
+  translate_tool_error: "حدث خطأ",
+  translate_attachment_status: "جارٍ قراءة الملف المرفق…",
+  translate_attachment_done: "تمت قراءة الملف المرفق",
+  translate_graph_0: "جارٍ استكشاف الروابط...",
+  translate_graph_1: "جارٍ رسم الخريطة...",
+  translate_graph_2: "جارٍ اكتشاف العلاقات...",
+  translate_graph_3: "جارٍ تتبع الروابط...",
+  translate_graph_4: "جارٍ التنقل في المعرفة...",
+  translate_graph_5: "جارٍ كشف الرؤى...",
+  translate_graph_6: "جارٍ ربط النقاط...",
+  translate_graph_7: "جارٍ تتبع المسار...",
+  translate_graph_8: "جارٍ تجميع الأجزاء...",
+  translate_graph_9: "جارٍ بناء الصورة...",
+  translate_code_0: "جارٍ حساب الأرقام...",
+  translate_code_1: "جارٍ معالجة البيانات...",
+  translate_code_2: "جارٍ تنفيذ طلبك...",
+  translate_code_3: "جارٍ تحليل الأرقام...",
+  translate_code_4: "جارٍ تجميع كل شيء...",
+  translate_code_5: "جارٍ تحليل النتائج...",
+  translate_code_6: "جارٍ العمل خلف الكواليس...",
+  translate_code_7: "جارٍ ترتيب التفاصيل...",
+  translate_code_8: "جارٍ تحضير إجابتك...",
+  translate_code_9: "أوشك على الانتهاء...",
+  translate_reasoning_0: "جارٍ التفكير...",
+  translate_reasoning_1: "جارٍ دراسة الخيارات...",
+  translate_reasoning_2: "جارٍ تقييم الاحتمالات...",
+  translate_reasoning_3: "جارٍ التأمل في هذا...",
+  translate_reasoning_4: "جارٍ إيجاد الحل...",
+  translate_reasoning_5: "جارٍ ترتيب الأفكار...",
+  translate_reasoning_6: "جارٍ التمعن في الأمر...",
+  translate_reasoning_7: "جارٍ إيجاد أفضل طريقة...",
+  translate_reasoning_8: "جارٍ تنظيم أفكاري...",
+  translate_reasoning_9: "أوشك على الانتهاء...",
+  translate_running: "قيد التنفيذ",
+  translate_aborted: "تم الإلغاء",
+  translate_input: "المدخلات",
+  translate_output: "المخرجات",
+  translate_calling: "جارٍ الاستدعاء",
+  translate_input_ready: "المدخلات جاهزة",
+  translate_needs_approval: "بحاجة إلى موافقة",
+  translate_approved: "تمت الموافقة",
+  translate_responded: "تم الرد",
+  translate_error: "خطأ",
+  translate_approval_requested: "طلب موافقة",
+  translate_approval_response: "رد الموافقة",
+  translate_waiting_for_approval: "في انتظار الموافقة لتنفيذ هذه الأداة.",
+  translate_tool_approved: "تمت الموافقة.",
+  translate_tool_response_received: "تم استلام الرد.",
+  translate_tokens: "رمز",
+  translate_fresh: "جديد",
+  translate_cache_read: "قراءة من الذاكرة",
+  translate_cache_write: "كتابة في الذاكرة",
+  translate_n_percent_cached: "{{percent}}٪ مخزّن مؤقتًا",
+  translate_text: "نص",
+  translate_reasoning: "الاستنتاج",
+  translate_read: "قراءة",
+  translate_write: "كتابة",
+  translate_total: "الإجمالي",
+  translate_request: "الطلب",
+  translate_response: "الرد",
+  translate_step_n: "الخطوة {{number}}",
+  translate_inspect_llm_requests: "فحص طلبات النموذج",
+  translate_loading: "جارٍ التحميل…",
+  translate_no_llm_requests: "لا توجد طلبات نموذج مسجّلة لهذه الرسالة.",
+  translate_unhandled_type: "نوع غير مدعوم:"
+};
+// ../../internal/client/src/i18n/en.json
+var en_default = {
+  translate_new: "New",
+  translate_threads: "Threads",
+  translate_n_conversations: "{{count}} conversations",
+  translate_one_conversation: "1 conversation",
+  translate_no_threads_yet: "No threads yet",
+  translate_start_a_new_conversation: "Start a new conversation",
+  translate_untitled: "Untitled",
+  translate_new_chat: "New Chat",
+  translate_normal: "Normal",
+  translate_debug: "Debug",
+  translate_type_a_message: "Type a message...",
+  translate_thinking: "Thinking things through...",
+  translate_reasoned: "Reasoned",
+  translate_knowledge_graph_query: "Knowledge Graph Query",
+  translate_javascript_code_execution: "JavaScript Code Execution",
+  translate_completed: "Completed",
+  translate_attach_files: "Attach files",
+  translate_drop_files_here: "Drop your files here...",
+  translate_remove_attachment: "Remove attachment",
+  translate_attachment_rejected: "This file cannot be attached",
+  translate_attachment_caption: "Please take a look at the attached files.",
+  translate_download: "Download",
+  translate_tool_status_0: "Fetching data...",
+  translate_tool_status_1: "Analyzing information...",
+  translate_tool_status_2: "Processing request...",
+  translate_tool_status_3: "Gathering results...",
+  translate_tool_status_4: "Preparing response...",
+  translate_tool_status_5: "Looking things up...",
+  translate_tool_status_6: "Checking records...",
+  translate_tool_status_7: "Reviewing details...",
+  translate_tool_status_8: "Running calculations...",
+  translate_tool_status_9: "Pulling information...",
+  translate_tool_done_0: "Data fetched successfully",
+  translate_tool_done_1: "Analysis completed successfully",
+  translate_tool_done_2: "Request processed successfully",
+  translate_tool_done_3: "Results gathered successfully",
+  translate_tool_done_4: "Response prepared successfully",
+  translate_tool_done_5: "Lookup completed successfully",
+  translate_tool_done_6: "Records checked successfully",
+  translate_tool_done_7: "Review completed successfully",
+  translate_tool_done_8: "Calculations completed successfully",
+  translate_tool_done_9: "Information retrieved successfully",
+  translate_tool_error: "Something went wrong",
+  translate_attachment_status: "Reading the attached file...",
+  translate_attachment_done: "Finished reading the file",
+  translate_graph_0: "Exploring connections...",
+  translate_graph_1: "Mapping out the links...",
+  translate_graph_2: "Discovering relationships...",
+  translate_graph_3: "Tracing the connections...",
+  translate_graph_4: "Navigating the knowledge...",
+  translate_graph_5: "Uncovering insights...",
+  translate_graph_6: "Connecting the dots...",
+  translate_graph_7: "Following the trail...",
+  translate_graph_8: "Piecing things together...",
+  translate_graph_9: "Building the picture...",
+  translate_code_0: "Running the numbers...",
+  translate_code_1: "Working through the data...",
+  translate_code_2: "Processing your request...",
+  translate_code_3: "Crunching the figures...",
+  translate_code_4: "Putting it all together...",
+  translate_code_5: "Analyzing the results...",
+  translate_code_6: "Working behind the scenes...",
+  translate_code_7: "Sorting through the details...",
+  translate_code_8: "Preparing your answer...",
+  translate_code_9: "Almost ready...",
+  translate_reasoning_0: "Thinking it through...",
+  translate_reasoning_1: "Considering the options...",
+  translate_reasoning_2: "Weighing the possibilities...",
+  translate_reasoning_3: "Reflecting on this...",
+  translate_reasoning_4: "Working it out...",
+  translate_reasoning_5: "Putting thoughts together...",
+  translate_reasoning_6: "Mulling it over...",
+  translate_reasoning_7: "Finding the best approach...",
+  translate_reasoning_8: "Organizing my thoughts...",
+  translate_reasoning_9: "Almost there...",
+  translate_running: "Running",
+  translate_aborted: "Aborted",
+  translate_input: "Input",
+  translate_output: "Output",
+  translate_calling: "Calling",
+  translate_input_ready: "Input ready",
+  translate_needs_approval: "Needs approval",
+  translate_approved: "Approved",
+  translate_responded: "Responded",
+  translate_error: "Error",
+  translate_approval_requested: "Approval requested",
+  translate_approval_response: "Approval response",
+  translate_waiting_for_approval: "Waiting for approval to execute this tool.",
+  translate_tool_approved: "Approved.",
+  translate_tool_response_received: "Response received.",
+  translate_tokens: "tokens",
+  translate_fresh: "Fresh",
+  translate_cache_read: "Cache read",
+  translate_cache_write: "Cache write",
+  translate_n_percent_cached: "{{percent}}% cached",
+  translate_text: "Text",
+  translate_reasoning: "Reasoning",
+  translate_read: "Read",
+  translate_write: "Write",
+  translate_total: "Total",
+  translate_request: "Request",
+  translate_response: "Response",
+  translate_step_n: "Step {{number}}",
+  translate_inspect_llm_requests: "Inspect LLM requests",
+  translate_loading: "loading…",
+  translate_no_llm_requests: "No LLM requests recorded for this message.",
+  translate_unhandled_type: "Unhandled type:"
+};
+
+// ../../internal/client/src/i18n.ts
+var translations = { en: en_default, ar: ar_default };
+function translate(locale, key, params) {
+  const table = translations[locale] ?? translations["en"];
+  const value = table?.[key] ?? translations["en"]?.[key] ?? key;
+  if (!params)
+    return value;
+  return value.replace(/\{\{\s*(\w+)\s*\}\}/g, (match, name) => (name in params) ? String(params[name]) : match);
+}
+// ../../internal/client/src/utils/deep-parse-json.ts
+function deepParseJson(value) {
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    const looksLikeJson = trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]");
+    if (!looksLikeJson)
+      return value;
+    try {
+      return deepParseJson(JSON.parse(trimmed));
+    } catch {
+      return value;
+    }
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => deepParseJson(item));
+  }
+  if (value !== null && typeof value === "object") {
+    const result = {};
+    for (const [key, val] of Object.entries(value)) {
+      result[key] = deepParseJson(val);
+    }
+    return result;
+  }
+  return value;
+}
+// ../../internal/client/src/utils/describe-json-value.ts
+function describeJsonValue(value, path) {
+  if (Array.isArray(value)) {
+    const items = value;
+    return {
+      kind: "container",
+      open: "[",
+      close: "]",
+      summary: count(items.length, "item", "items"),
+      entries: items.map((item, index) => ({
+        key: null,
+        value: item,
+        path: `${path}[${index}]`
+      }))
+    };
+  }
+  if (value !== null && typeof value === "object") {
+    const entries = Object.entries(value);
+    return {
+      kind: "container",
+      open: "{",
+      close: "}",
+      summary: count(entries.length, "property", "properties"),
+      entries: entries.map(([key, entryValue]) => ({
+        key,
+        value: entryValue,
+        path: `${path}.${key}`
+      }))
+    };
+  }
+  return {
+    kind: "primitive",
+    text: formatPrimitive(value),
+    className: primitiveClass(value)
+  };
+}
+function count(total, singular, plural) {
+  return `${total} ${total === 1 ? singular : plural}`;
+}
+function formatPrimitive(value) {
+  if (value === null || value === undefined)
+    return "null";
+  if (typeof value === "string")
+    return JSON.stringify(value);
+  if (typeof value === "number" || typeof value === "boolean")
+    return String(value);
+  return JSON.stringify(value) ?? "null";
+}
+function primitiveClass(value) {
+  if (value === null || value === undefined)
+    return "jt-null";
+  if (typeof value === "string")
+    return "jt-string";
+  if (typeof value === "number")
+    return "jt-number";
+  if (typeof value === "boolean")
+    return "jt-boolean";
+  return "";
+}
+// ../../internal/client/src/utils/json-text.ts
+function parseJsonText(value) {
+  if (!value)
+    return null;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+function prettyJsonText(value) {
+  if (!value)
+    return "";
+  try {
+    return JSON.stringify(JSON.parse(value), null, 2);
+  } catch {
+    return value;
+  }
+}
+// ../../internal/client/src/utils/relative-time.ts
+var UNITS = [
+  ["year", 31536000000],
+  ["month", 2592000000],
+  ["week", 604800000],
+  ["day", 86400000],
+  ["hour", 3600000],
+  ["minute", 60000],
+  ["second", 1000]
+];
+function relativeTimeLabel(iso, locale, now = Date.now()) {
+  const at = Date.parse(iso);
+  if (Number.isNaN(at))
+    return "";
+  const elapsed = at - now;
+  const [unit, ms] = UNITS.find(([, size]) => Math.abs(elapsed) >= size) ?? UNITS[UNITS.length - 1];
+  return new Intl.RelativeTimeFormat(locale, { numeric: "auto" }).format(Math.round(elapsed / ms), unit);
+}
+// ../../internal/client/src/utils/save-blob.ts
+function saveBlob(blob, name) {
+  const url = URL.createObjectURL(blob);
+  const link = document.createElement("a");
+  link.href = url;
+  link.download = name;
+  link.click();
+  URL.revokeObjectURL(url);
+}
+// ../../internal/client/src/utils/stream-text-smoother.ts
+class StreamTextSmoother {
+  onUpdate;
+  fullText = "";
+  displayedLength = 0;
+  animationFrameId = null;
+  isDone = false;
+  static DRAIN_FRACTION = 0.03;
+  static MIN_CHARS_PER_FRAME = 1;
+  static DONE_DRAIN_FRACTION = 0.1;
+  constructor(onUpdate) {
+    this.onUpdate = onUpdate;
+  }
+  seed(displayedText) {
+    this.fullText = displayedText;
+    this.displayedLength = displayedText.length;
+    this.onUpdate(displayedText);
+  }
+  update(newFullText, done) {
+    this.fullText = newFullText;
+    this.isDone = done;
+    this.displayedLength = Math.min(this.displayedLength, this.fullText.length);
+    if (done && this.displayedLength >= this.fullText.length) {
+      this.onUpdate(this.fullText);
+      this.stopAnimation();
+      return;
+    }
+    if (!this.animationFrameId) {
+      this.scheduleFrame();
+    }
+  }
+  destroy() {
+    this.stopAnimation();
+  }
+  scheduleFrame() {
+    this.animationFrameId = requestAnimationFrame(() => this.tick());
+  }
+  tick() {
+    const bufferSize = this.fullText.length - this.displayedLength;
+    if (bufferSize <= 0) {
+      this.animationFrameId = null;
+      return;
+    }
+    const fraction = this.isDone ? StreamTextSmoother.DONE_DRAIN_FRACTION : StreamTextSmoother.DRAIN_FRACTION;
+    const charsToRelease = Math.max(StreamTextSmoother.MIN_CHARS_PER_FRAME, Math.ceil(bufferSize * fraction));
+    this.displayedLength = Math.min(this.fullText.length, this.displayedLength + charsToRelease);
+    this.onUpdate(this.fullText.substring(0, this.displayedLength));
+    if (this.displayedLength < this.fullText.length) {
+      this.scheduleFrame();
+    } else {
+      this.animationFrameId = null;
+    }
+  }
+  stopAnimation() {
+    if (this.animationFrameId) {
+      cancelAnimationFrame(this.animationFrameId);
+      this.animationFrameId = null;
+    }
+  }
+}
+// ../../internal/client/src/utils/token-usage.ts
+function cachePercent(usage) {
+  if (usage.input.total <= 0)
+    return null;
+  return Math.round(usage.input.cacheRead / usage.input.total * 100);
+}
+// src/chat-session.tsx
+import { useEffect, useLayoutEffect, useMemo, useRef } from "react";
+import { useChat } from "@tanstack/ai-react";
+function ChatSession(props) {
+  const { thread, api, patchUi } = props;
+  const alive = useRef(true);
+  const ownsRun = useRef(false);
+  const serverAnswered = useRef(false);
+  const wasAborted = useRef(false);
+  const wasWorking = useRef(false);
+  const dispatchedToolCalls = useRef(new Set);
+  const refreshing = useRef(Promise.resolve());
+  const connection = useMemo(() => createCortexConnection({
+    api,
+    thread: { id: thread.id, isRunning: thread.isRunning },
+    mode: props.mode,
+    onHydrated: (rows, messages) => {
+      if (!alive.current)
+        return;
+      patchUi({
+        messageMetadata: metadataByMessageId(rows),
+        hasPendingToolCalls: unansweredToolCalls(messages).length > 0
+      });
+    },
+    setLoadingMessages: (loading) => {
+      if (alive.current)
+        patchUi({ isLoadingMessages: loading });
+    }
+  }), []);
+  const chat = useChat({
+    threadId: thread.id,
+    persistence: true,
+    connection,
+    onChunk: () => {
+      if (!alive.current)
+        return;
+      serverAnswered.current = true;
+    },
+    onError: () => {
+      if (!alive.current)
+        return;
+      patchUi({ hasPendingToolCalls: false });
+      if (serverAnswered.current)
+        props.onTurnFinished();
+      else
+        props.onSendFailed();
+    }
+  });
+  const chatRef = useRef(chat);
+  chatRef.current = chat;
+  const isLoadingRef = useRef(chat.isLoading);
+  isLoadingRef.current = chat.isLoading;
+  function syncPendingToolCalls() {
+    const pending = unansweredToolCalls(chatRef.current.messages);
+    patchUi({ hasPendingToolCalls: pending.length > 0 });
+    return pending;
+  }
+  async function resolveToolCall(call, onToolCall) {
+    const result = onToolCall({ toolCallId: call.id, toolName: call.name, input: call.input }, { threadId: thread.id });
+    if (result === null || result === undefined)
+      return;
+    const output = await Promise.resolve(result);
+    if (output === null || output === undefined)
+      return;
+    if (!alive.current)
+      return;
+    await chatRef.current.addToolResult({ toolCallId: call.id, tool: call.name, output });
+    syncPendingToolCalls();
+  }
+  function dispatchPendingToolCalls() {
+    const pending = syncPendingToolCalls();
+    const onToolCall = props.configRef.current.hooks?.onToolCall;
+    if (!onToolCall)
+      return pending.length > 0;
+    for (const call of pending) {
+      if (call.state !== "input-complete")
+        continue;
+      if (dispatchedToolCalls.current.has(call.id))
+        continue;
+      dispatchedToolCalls.current.add(call.id);
+      resolveToolCall(call, onToolCall);
+    }
+    return pending.length > 0;
+  }
+  async function readBackMessages(threadId) {
+    if (!alive.current || threadId !== thread.id)
+      return;
+    await settleTurn({
+      api,
+      threadId,
+      isStale: () => !alive.current,
+      isStreaming: () => isLoadingRef.current,
+      absorbMetadata: (metadata) => patchUi({ messageMetadata: metadata }),
+      setMessages: (messages) => {
+        chatRef.current.setMessages(messages);
+        patchUi({ hasPendingToolCalls: unansweredToolCalls(messages).length > 0 });
+      }
+    });
+  }
+  function refreshMessages(threadId) {
+    refreshing.current = refreshing.current.then(() => readBackMessages(threadId));
+    return refreshing.current;
+  }
+  async function settleSession() {
+    if (wasAborted.current) {
+      wasAborted.current = false;
+      return;
+    }
+    if (ownsRun.current && dispatchPendingToolCalls())
+      return;
+    await refreshMessages(thread.id);
+  }
+  async function performSend(prompt, attachments) {
+    props.setRunning(thread.id, true);
+    ownsRun.current = true;
+    serverAnswered.current = false;
+    const message = {
+      id: crypto.randomUUID(),
+      role: "user",
+      parts: [{ type: "text", content: prompt }]
+    };
+    if (attachments.length) {
+      patchUi((previous) => ({
+        messageMetadata: new Map(previous.messageMetadata).set(message.id, { attachments })
+      }));
+    }
+    await chatRef.current.append(message);
+  }
+  async function abort() {
+    if (!isLoadingRef.current)
+      return;
+    const { aborted } = await api.abortStream(thread.id).catch(() => ({ aborted: false }));
+    if (!alive.current)
+      return;
+    if (aborted) {
+      wasAborted.current = true;
+      props.setRunning(thread.id, false);
+    }
+    chatRef.current.stop();
+    patchUi({ hasPendingToolCalls: false });
+  }
+  function addToolResult(toolCallId, toolName, output) {
+    chatRef.current.addToolResult({ toolCallId, tool: toolName, output }).then(() => syncPendingToolCalls());
+  }
+  function reattach(freshThread) {
+    if (isLoadingRef.current)
+      return;
+    if (freshThread.isRunning) {
+      props.remount(freshThread);
+      return;
+    }
+    refreshMessages(freshThread.id);
+  }
+  useEffect(() => {
+    alive.current = true;
+    return () => {
+      alive.current = false;
+    };
+  }, []);
+  const handleRef = useRef(undefined);
+  handleRef.current = {
+    threadId: thread.id,
+    send: performSend,
+    abort,
+    addToolResult,
+    reattach,
+    refreshMessages: (threadId) => {
+      refreshMessages(threadId);
+    }
+  };
+  useLayoutEffect(() => {
+    props.sessionRef.current = handleRef.current;
+  });
+  useLayoutEffect(() => {
+    return () => {
+      if (props.sessionRef.current === handleRef.current) {
+        props.sessionRef.current = undefined;
+      }
+    };
+  }, []);
+  useEffect(() => {
+    if (!props.pendingSendRef.current.length)
+      return;
+    const timer = setTimeout(() => {
+      const pending = props.pendingSendRef.current;
+      props.pendingSendRef.current = [];
+      (async () => {
+        for (const { prompt, attachments } of pending) {
+          await performSend(prompt, attachments);
+        }
+      })();
+    });
+    return () => clearTimeout(timer);
+  }, []);
+  useEffect(() => {
+    patchUi({ messages: chat.messages });
+  }, [chat.messages]);
+  useEffect(() => {
+    patchUi({ isAgentWorking: chat.isLoading });
+    if (chat.isLoading) {
+      wasWorking.current = true;
+      return;
+    }
+    if (!wasWorking.current)
+      return;
+    wasWorking.current = false;
+    props.onTurnFinished();
+    settleSession();
+  }, [chat.isLoading]);
+  return null;
+}
+
+// src/context.ts
+import { createContext, useContext } from "react";
+var CortexContext = createContext(undefined);
+function useCortex() {
+  const value = useContext(CortexContext);
+  if (!value)
+    throw new Error("useCortex must be used inside <CortexChatWidget>");
+  return value;
+}
+
+// src/cx.ts
+function cx(...parts) {
+  return parts.filter(Boolean).join(" ");
+}
+
+// src/components/ChatComposer.tsx
+import { forwardRef, useEffect as useEffect2, useImperativeHandle, useRef as useRef2, useState } from "react";
+
+// src/components/AttachmentQueue.tsx
+import { jsxDEV } from "react/jsx-dev-runtime";
+function AttachmentQueue() {
+  const { queue, t } = useCortex();
+  if (!queue.items.length)
+    return null;
+  return /* @__PURE__ */ jsxDEV("div", {
+    className: "cortex-attachment-queue",
+    children: queue.items.map((item) => /* @__PURE__ */ jsxDEV("div", {
+      className: cx("cortex-attachment-chip", item.status === "error" && "cortex-attachment-chip--error"),
+      title: item.status === "error" ? t("translate_attachment_rejected") : "",
+      children: [
+        item.status === "uploading" || item.status === "deleting" ? /* @__PURE__ */ jsxDEV("svg", {
+          className: "cortex-attachment-chip__spinner",
+          viewBox: "0 0 16 16",
+          fill: "none",
+          children: [
+            /* @__PURE__ */ jsxDEV("circle", {
+              cx: "8",
+              cy: "8",
+              r: "6",
+              stroke: "currentColor",
+              strokeWidth: "2",
+              className: "cortex-attachment-chip__spinner-track"
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsxDEV("path", {
+              d: "M14 8a6 6 0 0 0-6-6",
+              stroke: "currentColor",
+              strokeWidth: "2",
+              strokeLinecap: "round"
+            }, undefined, false, undefined, this)
+          ]
+        }, undefined, true, undefined, this) : /* @__PURE__ */ jsxDEV("svg", {
+          viewBox: "0 0 16 16",
+          className: "cortex-attachment-chip__icon",
+          fill: "none",
+          children: [
+            /* @__PURE__ */ jsxDEV("path", {
+              d: "M4 1.5h5.172a2 2 0 0 1 1.414.586l2.328 2.328a2 2 0 0 1 .586 1.414V12.5a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2v-9a2 2 0 0 1 2-2Z",
+              stroke: "currentColor",
+              strokeWidth: "1.25"
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsxDEV("path", {
+              d: "M9.5 1.5v2a2 2 0 0 0 2 2h2",
+              stroke: "currentColor",
+              strokeWidth: "1.25",
+              strokeLinecap: "round"
+            }, undefined, false, undefined, this)
+          ]
+        }, undefined, true, undefined, this),
+        /* @__PURE__ */ jsxDEV("span", {
+          className: "cortex-attachment-chip__name",
+          children: item.filename
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsxDEV("button", {
+          type: "button",
+          onClick: () => queue.remove(item.localId),
+          className: "cortex-attachment-chip__remove",
+          disabled: item.status === "deleting",
+          "aria-label": t("translate_remove_attachment"),
+          children: /* @__PURE__ */ jsxDEV("svg", {
+            viewBox: "0 0 16 16",
+            fill: "none",
+            children: /* @__PURE__ */ jsxDEV("path", {
+              d: "M4.5 4.5l7 7m0-7l-7 7",
+              stroke: "currentColor",
+              strokeWidth: "1.5",
+              strokeLinecap: "round"
+            }, undefined, false, undefined, this)
+          }, undefined, false, undefined, this)
+        }, undefined, false, undefined, this)
+      ]
+    }, item.localId, true, undefined, this))
+  }, undefined, false, undefined, this);
+}
+
+// src/components/ChatComposer.tsx
+import { jsxDEV as jsxDEV2 } from "react/jsx-dev-runtime";
+var ACCEPTED_TYPES = ATTACHMENT_MIME_TYPES.join(",");
+var ChatComposer = forwardRef(function ChatComposer2(_props, ref) {
+  const { t, queue, isAgentWorking, send, abort } = useCortex();
+  const [text, setText] = useState("");
+  const [dragging, setDragging] = useState(false);
+  const messageInput = useRef2(null);
+  const fileInput = useRef2(null);
+  useImperativeHandle(ref, () => ({
+    focusInput: () => messageInput.current?.focus()
+  }));
+  const wasWorking = useRef2(isAgentWorking);
+  useEffect2(() => {
+    if (wasWorking.current && !isAgentWorking)
+      messageInput.current?.focus();
+    wasWorking.current = isAgentWorking;
+  }, [isAgentWorking]);
+  const canSend = !queue.busy && (Boolean(text.trim()) || queue.hasReady);
+  function onSend() {
+    if (isAgentWorking || !canSend) {
+      return;
+    }
+    const captionKey = "translate_attachment_caption";
+    const translated = t(captionKey);
+    const caption = translated !== captionKey ? translated : "Please take a look at the attached files.";
+    const prompt = text.trim() || caption;
+    const attachments = queue.consumeReady();
+    setText("");
+    send(prompt, attachments.map((attachment) => attachment.summary));
+  }
+  function onKeydown(event) {
+    if (event.key === "Enter" && !event.shiftKey) {
+      event.preventDefault();
+      onSend();
+    }
+  }
+  function onDragOver(event) {
+    event.preventDefault();
+    setDragging(true);
+  }
+  function onDragLeave(event) {
+    const area = event.currentTarget;
+    if (!area.contains(event.relatedTarget)) {
+      setDragging(false);
+    }
+  }
+  function onDrop(event) {
+    event.preventDefault();
+    setDragging(false);
+    queue.accept([...event.dataTransfer.files]);
+  }
+  function onPaste(event) {
+    const files = event.clipboardData.files;
+    if (!files.length)
+      return;
+    event.preventDefault();
+    queue.accept([...files]);
+  }
+  return /* @__PURE__ */ jsxDEV2("div", {
+    className: "cortex-widget__input-area",
+    onDragOver,
+    onDragLeave,
+    onDrop,
+    children: [
+      /* @__PURE__ */ jsxDEV2(AttachmentQueue, {}, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV2("div", {
+        className: cx("cortex-widget__input-box", isAgentWorking && "cortex-widget__input-box--disabled", !isAgentWorking && "cortex-widget__input-box--enabled", dragging && "cortex-widget__input-box--dragging"),
+        children: [
+          /* @__PURE__ */ jsxDEV2("textarea", {
+            ref: messageInput,
+            onKeyDown: onKeydown,
+            onPaste,
+            value: text,
+            onChange: (event) => setText(event.target.value),
+            placeholder: dragging ? t("translate_drop_files_here") : isAgentWorking ? "" : t("translate_type_a_message"),
+            disabled: isAgentWorking,
+            rows: 1,
+            className: cx("cortex-widget__textarea", isAgentWorking && "cortex-widget__textarea--disabled")
+          }, undefined, false, undefined, this),
+          isAgentWorking ? /* @__PURE__ */ jsxDEV2("button", {
+            onClick: () => void abort(),
+            className: "cortex-stop-btn",
+            children: [
+              /* @__PURE__ */ jsxDEV2("span", {
+                className: "cortex-stop-btn__ring"
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV2("svg", {
+                width: "12",
+                height: "12",
+                viewBox: "0 0 12 12",
+                fill: "none",
+                className: "cortex-stop-btn__icon",
+                children: /* @__PURE__ */ jsxDEV2("rect", {
+                  x: "1",
+                  y: "1",
+                  width: "10",
+                  height: "10",
+                  rx: "2.5",
+                  fill: "currentColor"
+                }, undefined, false, undefined, this)
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this) : /* @__PURE__ */ jsxDEV2("div", {
+            className: "cortex-widget__input-actions",
+            children: [
+              /* @__PURE__ */ jsxDEV2("button", {
+                type: "button",
+                onClick: () => fileInput.current?.click(),
+                className: "cortex-widget__attach-btn",
+                "aria-label": t("translate_attach_files"),
+                children: /* @__PURE__ */ jsxDEV2("svg", {
+                  width: "16",
+                  height: "16",
+                  viewBox: "0 0 16 16",
+                  fill: "none",
+                  children: /* @__PURE__ */ jsxDEV2("path", {
+                    d: "M10.5 5.5 6.2 9.8a1.4 1.4 0 0 0 2 2l4.6-4.6a2.8 2.8 0 0 0-4-4L4.2 7.8a4.2 4.2 0 0 0 6 6l4-4",
+                    stroke: "currentColor",
+                    strokeWidth: "1.3",
+                    strokeLinecap: "round",
+                    strokeLinejoin: "round"
+                  }, undefined, false, undefined, this)
+                }, undefined, false, undefined, this)
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV2("input", {
+                ref: fileInput,
+                type: "file",
+                multiple: true,
+                accept: ACCEPTED_TYPES,
+                onChange: (event) => {
+                  queue.accept([...event.target.files ?? []]);
+                  event.target.value = "";
+                },
+                className: "cortex-widget__file-input"
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV2("button", {
+                onClick: onSend,
+                className: cx("cortex-widget__send-btn", !canSend && "cortex-widget__send-btn--empty", canSend && "cortex-widget__send-btn--ready"),
+                disabled: !canSend,
+                children: /* @__PURE__ */ jsxDEV2("svg", {
+                  width: "14",
+                  height: "14",
+                  viewBox: "0 0 16 16",
+                  fill: "none",
+                  className: "cortex-widget__send-icon",
+                  children: /* @__PURE__ */ jsxDEV2("path", {
+                    d: "M3 8h10M9 4l4 4-4 4",
+                    stroke: "currentColor",
+                    strokeWidth: "1.5",
+                    strokeLinecap: "round",
+                    strokeLinejoin: "round"
+                  }, undefined, false, undefined, this)
+                }, undefined, false, undefined, this)
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this)
+        ]
+      }, undefined, true, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+});
+
+// src/components/MessageList.tsx
+import { useEffect as useEffect5, useRef as useRef7, useState as useState8 } from "react";
+
+// src/components/MessageAbortedFlag.tsx
+import { jsxDEV as jsxDEV3 } from "react/jsx-dev-runtime";
+function MessageAbortedFlag() {
+  const { t } = useCortex();
+  return /* @__PURE__ */ jsxDEV3("div", {
+    className: "cortex-aborted-flag",
+    children: [
+      /* @__PURE__ */ jsxDEV3("span", {
+        className: "cortex-aborted-flag__line"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV3("span", {
+        className: "cortex-aborted-flag__label",
+        children: [
+          /* @__PURE__ */ jsxDEV3("svg", {
+            className: "cortex-aborted-flag__icon",
+            width: "12",
+            height: "12",
+            viewBox: "0 0 12 12",
+            fill: "none",
+            children: /* @__PURE__ */ jsxDEV3("path", {
+              d: "M6 1.5v5M6 8.75v.5",
+              stroke: "currentColor",
+              strokeWidth: "1.4",
+              strokeLinecap: "round"
+            }, undefined, false, undefined, this)
+          }, undefined, false, undefined, this),
+          t("translate_aborted")
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsxDEV3("span", {
+        className: "cortex-aborted-flag__line"
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+
+// src/components/MessageAttachments.tsx
+import { jsxDEV as jsxDEV4 } from "react/jsx-dev-runtime";
+function MessageAttachments(props) {
+  const { api, t } = useCortex();
+  async function download(id) {
+    const { blob, name } = await api.downloadAttachment(id);
+    saveBlob(blob, name);
+  }
+  return /* @__PURE__ */ jsxDEV4("div", {
+    className: "cortex-message-attachments",
+    children: props.attachments.map((attachment) => /* @__PURE__ */ jsxDEV4("button", {
+      type: "button",
+      onClick: () => void download(attachment.id),
+      className: "cortex-message-attachment",
+      "aria-label": `${t("translate_download")}: ${attachment.filename}`,
+      children: [
+        /* @__PURE__ */ jsxDEV4("svg", {
+          viewBox: "0 0 16 16",
+          className: "cortex-message-attachment__icon",
+          fill: "none",
+          children: [
+            /* @__PURE__ */ jsxDEV4("path", {
+              d: "M4 1.5h5.172a2 2 0 0 1 1.414.586l2.328 2.328a2 2 0 0 1 .586 1.414V12.5a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2v-9a2 2 0 0 1 2-2Z",
+              stroke: "currentColor",
+              strokeWidth: "1.25"
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsxDEV4("path", {
+              d: "M9.5 1.5v2a2 2 0 0 0 2 2h2",
+              stroke: "currentColor",
+              strokeWidth: "1.25",
+              strokeLinecap: "round"
+            }, undefined, false, undefined, this)
+          ]
+        }, undefined, true, undefined, this),
+        /* @__PURE__ */ jsxDEV4("span", {
+          className: "cortex-message-attachment__name",
+          children: attachment.filename
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsxDEV4("svg", {
+          viewBox: "0 0 16 16",
+          className: "cortex-message-attachment__dl-icon",
+          fill: "none",
+          children: /* @__PURE__ */ jsxDEV4("path", {
+            d: "M8 3v7m0 0L5.5 7.5M8 10l2.5-2.5M3 13h10",
+            stroke: "currentColor",
+            strokeWidth: "1.5",
+            strokeLinecap: "round",
+            strokeLinejoin: "round"
+          }, undefined, false, undefined, this)
+        }, undefined, false, undefined, this)
+      ]
+    }, attachment.id, true, undefined, this))
+  }, undefined, false, undefined, this);
+}
+
+// src/components/MessageLlmInspector.tsx
+import { useRef as useRef4, useState as useState4 } from "react";
+
+// src/components/CopyButton.tsx
+import { useRef as useRef3, useState as useState2 } from "react";
+import { jsxDEV as jsxDEV5 } from "react/jsx-dev-runtime";
+function CopyButton({ value, className }) {
+  const [copied, setCopied] = useState2(false);
+  const resetTimer = useRef3(null);
+  async function copy(event) {
+    event.stopPropagation();
+    event.preventDefault();
+    try {
+      await navigator.clipboard.writeText(value);
+      setCopied(true);
+      if (resetTimer.current)
+        clearTimeout(resetTimer.current);
+      resetTimer.current = setTimeout(() => setCopied(false), 1500);
+    } catch {}
+  }
+  return /* @__PURE__ */ jsxDEV5("span", {
+    className: cx("cortex-copy-btn", className),
+    children: /* @__PURE__ */ jsxDEV5("button", {
+      className: cx("cortex-copy-btn__button", copied && "cortex-copy-btn__button--copied"),
+      onClick: (event) => void copy(event),
+      "aria-label": copied ? "Copied" : "Copy to clipboard",
+      type: "button",
+      children: copied ? /* @__PURE__ */ jsxDEV5("svg", {
+        className: "cortex-copy-btn__icon cortex-copy-btn__icon--check",
+        width: "13",
+        height: "13",
+        viewBox: "0 0 24 24",
+        fill: "none",
+        children: /* @__PURE__ */ jsxDEV5("path", {
+          d: "M5 13l4 4L19 7",
+          stroke: "currentColor",
+          strokeWidth: "2.5",
+          strokeLinecap: "round",
+          strokeLinejoin: "round"
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this) : /* @__PURE__ */ jsxDEV5("svg", {
+        className: "cortex-copy-btn__icon",
+        width: "13",
+        height: "13",
+        viewBox: "0 0 24 24",
+        fill: "none",
+        children: [
+          /* @__PURE__ */ jsxDEV5("rect", {
+            x: "9",
+            y: "9",
+            width: "12",
+            height: "12",
+            rx: "2",
+            stroke: "currentColor",
+            strokeWidth: "2"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV5("path", {
+            d: "M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1",
+            stroke: "currentColor",
+            strokeWidth: "2",
+            strokeLinecap: "round"
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this)
+    }, undefined, false, undefined, this)
+  }, undefined, false, undefined, this);
+}
+
+// src/components/JsonTree.tsx
+import { useMemo as useMemo2, useState as useState3 } from "react";
+import { jsxDEV as jsxDEV6, Fragment } from "react/jsx-dev-runtime";
+function JsonTree({ data, expandDepth = 1, className }) {
+  const parsedData = useMemo2(() => deepParseJson(data), [data]);
+  const [userToggled, setUserToggled] = useState3({});
+  function isCollapsed(path, depth) {
+    return userToggled[path] ?? depth >= expandDepth;
+  }
+  function toggle(path, depth) {
+    setUserToggled((current) => ({ ...current, [path]: !isCollapsed(path, depth) }));
+  }
+  return /* @__PURE__ */ jsxDEV6("div", {
+    className: cx("cortex-json-tree", className),
+    children: /* @__PURE__ */ jsxDEV6(JsonValue, {
+      value: parsedData,
+      path: "$",
+      depth: 0,
+      isCollapsed,
+      toggle
+    }, undefined, false, undefined, this)
+  }, undefined, false, undefined, this);
+}
+function JsonValue({ value, path, depth, isCollapsed, toggle }) {
+  const node = describeJsonValue(value, path);
+  if (node.kind === "primitive")
+    return /* @__PURE__ */ jsxDEV6("span", {
+      className: node.className,
+      children: node.text
+    }, undefined, false, undefined, this);
+  if (node.entries.length === 0) {
+    return /* @__PURE__ */ jsxDEV6("span", {
+      className: "jt-bracket",
+      children: [
+        node.open,
+        node.close
+      ]
+    }, undefined, true, undefined, this);
+  }
+  const collapsed = isCollapsed(path, depth);
+  function onToggle(event) {
+    toggle(path, depth);
+    event.stopPropagation();
+  }
+  return /* @__PURE__ */ jsxDEV6(Fragment, {
+    children: [
+      /* @__PURE__ */ jsxDEV6("span", {
+        className: "jt-toggle",
+        onClick: onToggle,
+        role: "button",
+        children: [
+          /* @__PURE__ */ jsxDEV6("span", {
+            className: cx("jt-arrow", collapsed && "jt-arrow--collapsed"),
+            children: "▾"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV6("span", {
+            className: "jt-bracket",
+            children: node.open
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      collapsed ? /* @__PURE__ */ jsxDEV6(Fragment, {
+        children: [
+          /* @__PURE__ */ jsxDEV6("span", {
+            className: "jt-collapsed-hint",
+            onClick: onToggle,
+            role: "button",
+            children: node.summary
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV6("span", {
+            className: "jt-bracket",
+            children: node.close
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this) : /* @__PURE__ */ jsxDEV6(Fragment, {
+        children: [
+          /* @__PURE__ */ jsxDEV6("div", {
+            className: "jt-indent",
+            children: node.entries.map((entry, index) => /* @__PURE__ */ jsxDEV6("div", {
+              className: "jt-line",
+              children: [
+                entry.key !== null && /* @__PURE__ */ jsxDEV6(Fragment, {
+                  children: [
+                    /* @__PURE__ */ jsxDEV6("span", {
+                      className: "jt-key",
+                      children: `"${entry.key}"`
+                    }, undefined, false, undefined, this),
+                    /* @__PURE__ */ jsxDEV6("span", {
+                      className: "jt-colon",
+                      children: ": "
+                    }, undefined, false, undefined, this)
+                  ]
+                }, undefined, true, undefined, this),
+                /* @__PURE__ */ jsxDEV6(JsonValue, {
+                  value: entry.value,
+                  path: entry.path,
+                  depth: depth + 1,
+                  isCollapsed,
+                  toggle
+                }, undefined, false, undefined, this),
+                index < node.entries.length - 1 && /* @__PURE__ */ jsxDEV6("span", {
+                  className: "jt-comma",
+                  children: ","
+                }, undefined, false, undefined, this)
+              ]
+            }, entry.path, true, undefined, this))
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV6("span", {
+            className: "jt-bracket",
+            children: node.close
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+
+// src/format.ts
+function num(value) {
+  return value.toLocaleString("en-US");
+}
+
+// src/components/LlmUsageBreakdown.tsx
+import { jsxDEV as jsxDEV7 } from "react/jsx-dev-runtime";
+function LlmUsageBreakdown({ usage }) {
+  const { t } = useCortex();
+  return /* @__PURE__ */ jsxDEV7("div", {
+    className: "cortex-llm-inspector__usage-rows",
+    children: [
+      /* @__PURE__ */ jsxDEV7("div", {
+        className: "cortex-llm-inspector__usage-row",
+        children: [
+          /* @__PURE__ */ jsxDEV7("span", {
+            className: "cortex-llm-inspector__usage-lbl",
+            children: t("translate_input")
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV7("span", {
+            className: "cortex-llm-inspector__usage-val",
+            children: num(usage.input.total)
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV7("span", {
+            className: "cortex-llm-inspector__usage-detail",
+            children: [
+              t("translate_fresh"),
+              " ",
+              num(usage.input.noCache),
+              " · ",
+              t("translate_read"),
+              " ",
+              num(usage.input.cacheRead),
+              " · ",
+              t("translate_write"),
+              " ",
+              num(usage.input.cacheWrite)
+            ]
+          }, undefined, true, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsxDEV7("div", {
+        className: "cortex-llm-inspector__usage-row",
+        children: [
+          /* @__PURE__ */ jsxDEV7("span", {
+            className: "cortex-llm-inspector__usage-lbl",
+            children: t("translate_output")
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV7("span", {
+            className: "cortex-llm-inspector__usage-val",
+            children: num(usage.output.total)
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV7("span", {
+            className: "cortex-llm-inspector__usage-detail",
+            children: [
+              t("translate_text"),
+              " ",
+              num(usage.output.text),
+              " · ",
+              t("translate_reasoning"),
+              " ",
+              num(usage.output.reasoning)
+            ]
+          }, undefined, true, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsxDEV7("div", {
+        className: "cortex-llm-inspector__usage-row cortex-llm-inspector__usage-row--total",
+        children: [
+          /* @__PURE__ */ jsxDEV7("span", {
+            className: "cortex-llm-inspector__usage-lbl",
+            children: t("translate_total")
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV7("span", {
+            className: "cortex-llm-inspector__usage-val",
+            children: num(usage.total)
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+
+// src/components/LlmUsageChips.tsx
+import { jsxDEV as jsxDEV8 } from "react/jsx-dev-runtime";
+function LlmUsageChips({ usage }) {
+  const percent = cachePercent(usage);
+  return /* @__PURE__ */ jsxDEV8("span", {
+    children: /* @__PURE__ */ jsxDEV8("span", {
+      className: "cortex-llm-inspector__step-metrics",
+      children: [
+        /* @__PURE__ */ jsxDEV8("span", {
+          className: "cortex-llm-inspector__metric",
+          children: [
+            /* @__PURE__ */ jsxDEV8("span", {
+              className: "cortex-llm-inspector__dot cortex-llm-inspector__dot--input"
+            }, undefined, false, undefined, this),
+            num(usage.input.total)
+          ]
+        }, undefined, true, undefined, this),
+        /* @__PURE__ */ jsxDEV8("span", {
+          className: "cortex-llm-inspector__metric",
+          children: [
+            /* @__PURE__ */ jsxDEV8("span", {
+              className: "cortex-llm-inspector__dot cortex-llm-inspector__dot--output"
+            }, undefined, false, undefined, this),
+            num(usage.output.total)
+          ]
+        }, undefined, true, undefined, this),
+        percent !== null ? /* @__PURE__ */ jsxDEV8("span", {
+          className: "cortex-llm-inspector__cache-pct",
+          children: [
+            percent,
+            "%"
+          ]
+        }, undefined, true, undefined, this) : null
+      ]
+    }, undefined, true, undefined, this)
+  }, undefined, false, undefined, this);
+}
+
+// src/components/MessageLlmInspector.tsx
+import { jsxDEV as jsxDEV9 } from "react/jsx-dev-runtime";
+function MessageLlmInspector({ messageId }) {
+  const { t, api } = useCortex();
+  const [open, setOpen] = useState4(false);
+  const [loading, setLoading] = useState4(false);
+  const [requests, setRequests] = useState4([]);
+  const [expandedStep, setExpandedStep] = useState4(null);
+  const [activeTab, setActiveTab] = useState4({});
+  const loaded = useRef4(false);
+  async function toggle() {
+    if (!loaded.current) {
+      setLoading(true);
+      try {
+        setRequests(await api.listLlmRequests(messageId));
+      } finally {
+        setLoading(false);
+        loaded.current = true;
+      }
+    }
+    setOpen((v) => !v);
+  }
+  function toggleStep(id) {
+    setExpandedStep((current) => current === id ? null : id);
+  }
+  function getTab(id) {
+    return activeTab[id] ?? "prompt";
+  }
+  function setTab(id, tab) {
+    setActiveTab((current) => ({ ...current, [id]: tab }));
+  }
+  return /* @__PURE__ */ jsxDEV9("div", {
+    className: cx("cortex-llm-inspector", open && "cortex-llm-inspector--open"),
+    children: [
+      /* @__PURE__ */ jsxDEV9("button", {
+        className: "cortex-llm-inspector__trigger",
+        onClick: () => void toggle(),
+        children: [
+          /* @__PURE__ */ jsxDEV9("svg", {
+            className: "cortex-llm-inspector__icon",
+            width: "14",
+            height: "14",
+            viewBox: "0 0 16 16",
+            fill: "none",
+            children: /* @__PURE__ */ jsxDEV9("path", {
+              d: "M6 2a4 4 0 1 0 0 8 4 4 0 0 0 0-8ZM0 6a6 6 0 1 1 10.89 3.477l4.817 4.816a1 1 0 0 1-1.414 1.414l-4.816-4.816A6 6 0 0 1 0 6Z",
+              fill: "currentColor"
+            }, undefined, false, undefined, this)
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV9("span", {
+            children: t("translate_inspect_llm_requests")
+          }, undefined, false, undefined, this),
+          loading ? /* @__PURE__ */ jsxDEV9("span", {
+            className: "cortex-llm-inspector__loading",
+            children: t("translate_loading")
+          }, undefined, false, undefined, this) : requests.length > 0 ? /* @__PURE__ */ jsxDEV9("span", {
+            className: "cortex-llm-inspector__badge",
+            children: requests.length
+          }, undefined, false, undefined, this) : null,
+          /* @__PURE__ */ jsxDEV9("svg", {
+            className: "cortex-llm-inspector__chevron",
+            width: "12",
+            height: "12",
+            viewBox: "0 0 12 12",
+            fill: "none",
+            children: /* @__PURE__ */ jsxDEV9("path", {
+              d: "M3 4.5L6 7.5L9 4.5",
+              stroke: "currentColor",
+              strokeWidth: "1.25",
+              strokeLinecap: "round",
+              strokeLinejoin: "round"
+            }, undefined, false, undefined, this)
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsxDEV9("div", {
+        className: "cortex-llm-inspector__panel-wrapper",
+        children: /* @__PURE__ */ jsxDEV9("div", {
+          className: "cortex-llm-inspector__panel-inner",
+          children: /* @__PURE__ */ jsxDEV9("div", {
+            className: "cortex-llm-inspector__panel",
+            children: [
+              requests.length === 0 && !loading ? /* @__PURE__ */ jsxDEV9("div", {
+                className: "cortex-llm-inspector__empty",
+                children: t("translate_no_llm_requests")
+              }, undefined, false, undefined, this) : null,
+              requests.map((req, idx) => /* @__PURE__ */ jsxDEV9("div", {
+                className: cx("cortex-llm-inspector__step", expandedStep === req.id && "cortex-llm-inspector__step--expanded"),
+                children: [
+                  /* @__PURE__ */ jsxDEV9("button", {
+                    className: "cortex-llm-inspector__step-header",
+                    onClick: () => toggleStep(req.id),
+                    children: [
+                      /* @__PURE__ */ jsxDEV9("span", {
+                        className: "cortex-llm-inspector__step-label",
+                        children: t("translate_step_n", { number: idx + 1 })
+                      }, undefined, false, undefined, this),
+                      req.tokenUsage ? /* @__PURE__ */ jsxDEV9(LlmUsageChips, {
+                        usage: req.tokenUsage
+                      }, undefined, false, undefined, this) : null,
+                      /* @__PURE__ */ jsxDEV9("svg", {
+                        className: "cortex-llm-inspector__step-chevron",
+                        width: "10",
+                        height: "10",
+                        viewBox: "0 0 12 12",
+                        fill: "none",
+                        children: /* @__PURE__ */ jsxDEV9("path", {
+                          d: "M3 4.5L6 7.5L9 4.5",
+                          stroke: "currentColor",
+                          strokeWidth: "1.25",
+                          strokeLinecap: "round",
+                          strokeLinejoin: "round"
+                        }, undefined, false, undefined, this)
+                      }, undefined, false, undefined, this)
+                    ]
+                  }, undefined, true, undefined, this),
+                  /* @__PURE__ */ jsxDEV9("div", {
+                    className: "cortex-llm-inspector__step-body-wrapper",
+                    children: /* @__PURE__ */ jsxDEV9("div", {
+                      className: "cortex-llm-inspector__step-body-inner",
+                      children: /* @__PURE__ */ jsxDEV9("div", {
+                        className: "cortex-llm-inspector__step-body",
+                        children: [
+                          req.tokenUsage ? /* @__PURE__ */ jsxDEV9(LlmUsageBreakdown, {
+                            usage: req.tokenUsage
+                          }, undefined, false, undefined, this) : null,
+                          /* @__PURE__ */ jsxDEV9("div", {
+                            className: "cortex-llm-inspector__tabs",
+                            children: [
+                              /* @__PURE__ */ jsxDEV9("button", {
+                                className: cx("cortex-llm-inspector__tab", getTab(req.id) === "prompt" && "cortex-llm-inspector__tab--active"),
+                                onClick: () => setTab(req.id, "prompt"),
+                                children: t("translate_request")
+                              }, undefined, false, undefined, this),
+                              /* @__PURE__ */ jsxDEV9("button", {
+                                className: cx("cortex-llm-inspector__tab", getTab(req.id) === "response" && "cortex-llm-inspector__tab--active"),
+                                onClick: () => setTab(req.id, "response"),
+                                children: t("translate_response")
+                              }, undefined, false, undefined, this)
+                            ]
+                          }, undefined, true, undefined, this),
+                          /* @__PURE__ */ jsxDEV9("div", {
+                            className: "cortex-llm-inspector__json-pane",
+                            children: [
+                              /* @__PURE__ */ jsxDEV9(CopyButton, {
+                                className: "cortex-llm-inspector__json-copy",
+                                value: getTab(req.id) === "prompt" ? prettyJsonText(req.prompt) : prettyJsonText(req.output)
+                              }, undefined, false, undefined, this),
+                              getTab(req.id) === "prompt" ? /* @__PURE__ */ jsxDEV9(JsonTree, {
+                                data: parseJsonText(req.prompt),
+                                expandDepth: 2
+                              }, undefined, false, undefined, this) : /* @__PURE__ */ jsxDEV9(JsonTree, {
+                                data: parseJsonText(req.output),
+                                expandDepth: 2
+                              }, undefined, false, undefined, this)
+                            ]
+                          }, undefined, true, undefined, this)
+                        ]
+                      }, undefined, true, undefined, this)
+                    }, undefined, false, undefined, this)
+                  }, undefined, false, undefined, this)
+                ]
+              }, req.id, true, undefined, this))
+            ]
+          }, undefined, true, undefined, this)
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+
+// src/components/SubtleActivity.tsx
+import { useEffect as useEffect3, useRef as useRef5, useState as useState5 } from "react";
+import { jsxDEV as jsxDEV10 } from "react/jsx-dev-runtime";
+function SubtleActivity({ labels, className }) {
+  const { t } = useCortex();
+  const [currentIndex, setCurrentIndex] = useState5(0);
+  const [labelState, setLabelState] = useState5("idle");
+  const labelCount = useRef5(labels.length);
+  labelCount.current = labels.length;
+  useEffect3(() => {
+    let timeout;
+    let frame;
+    function scheduleNextTransition() {
+      timeout = setTimeout(() => {
+        setLabelState("exiting");
+        timeout = setTimeout(() => {
+          setCurrentIndex((i) => (i + 1) % labelCount.current);
+          setLabelState("enter-start");
+          frame = requestAnimationFrame(() => {
+            setLabelState("entering");
+            timeout = setTimeout(() => {
+              setLabelState("idle");
+              scheduleNextTransition();
+            }, 300);
+          });
+        }, 300);
+      }, 2000);
+    }
+    scheduleNextTransition();
+    return () => {
+      if (timeout)
+        clearTimeout(timeout);
+      if (frame)
+        cancelAnimationFrame(frame);
+    };
+  }, []);
+  return /* @__PURE__ */ jsxDEV10("div", {
+    className: cx("cortex-subtle-activity", className),
+    children: [
+      /* @__PURE__ */ jsxDEV10("div", {
+        className: "cortex-subtle-activity__dots",
+        children: [
+          /* @__PURE__ */ jsxDEV10("span", {
+            className: "cortex-subtle-activity__dot"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV10("span", {
+            className: "cortex-subtle-activity__dot cortex-subtle-activity__dot--d1"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV10("span", {
+            className: "cortex-subtle-activity__dot cortex-subtle-activity__dot--d2"
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsxDEV10("div", {
+        className: "cortex-subtle-activity__label-mask",
+        children: /* @__PURE__ */ jsxDEV10("span", {
+          className: cx("cortex-subtle-activity__label", `cortex-subtle-activity__label--${labelState}`),
+          children: t(labels[currentIndex])
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+
+// src/components/MessageReasoningAnimated.tsx
+import { jsxDEV as jsxDEV11 } from "react/jsx-dev-runtime";
+var LABELS = activityLabelKeys("reasoning");
+function MessageReasoningAnimated() {
+  return /* @__PURE__ */ jsxDEV11("div", {
+    className: "cortex-reasoning-animated",
+    children: /* @__PURE__ */ jsxDEV11(SubtleActivity, {
+      labels: LABELS
+    }, undefined, false, undefined, this)
+  }, undefined, false, undefined, this);
+}
+
+// src/components/MessageReasoningPart.tsx
+import { jsxDEV as jsxDEV12 } from "react/jsx-dev-runtime";
+function MessageReasoningPart(props) {
+  const { reasoningPart, streaming = false } = props;
+  const { t } = useCortex();
+  return /* @__PURE__ */ jsxDEV12("details", {
+    className: "cortex-reasoning-details",
+    children: [
+      /* @__PURE__ */ jsxDEV12("summary", {
+        className: "cortex-reasoning-details__summary",
+        children: [
+          /* @__PURE__ */ jsxDEV12("div", {
+            className: "cortex-reasoning-details__header",
+            children: [
+              /* @__PURE__ */ jsxDEV12("span", {
+                className: "cortex-reasoning-details__icon",
+                children: /* @__PURE__ */ jsxDEV12("svg", {
+                  width: "14",
+                  height: "14",
+                  viewBox: "0 0 20 20",
+                  fill: "none",
+                  "aria-hidden": "true",
+                  children: [
+                    /* @__PURE__ */ jsxDEV12("path", {
+                      d: "M10 2C6.686 2 4 4.686 4 8c0 1.655.672 3.154 1.757 4.243.362.363.576.858.576 1.371V14.5a1 1 0 0 0 1 1h5.334a1 1 0 0 0 1-1v-.886c0-.513.214-1.008.576-1.371A5.978 5.978 0 0 0 16 8c0-3.314-2.686-6-6-6Z",
+                      stroke: "currentColor",
+                      strokeWidth: "1.4",
+                      strokeLinecap: "round",
+                      strokeLinejoin: "round"
+                    }, undefined, false, undefined, this),
+                    /* @__PURE__ */ jsxDEV12("path", {
+                      d: "M7.5 17.5h5M8.5 8a2 2 0 0 1 2-2",
+                      stroke: "currentColor",
+                      strokeWidth: "1.4",
+                      strokeLinecap: "round",
+                      strokeLinejoin: "round"
+                    }, undefined, false, undefined, this)
+                  ]
+                }, undefined, true, undefined, this)
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV12("div", {
+                className: "cortex-reasoning-details__title-group",
+                children: /* @__PURE__ */ jsxDEV12("div", {
+                  className: "cortex-reasoning-details__title-row",
+                  children: [
+                    /* @__PURE__ */ jsxDEV12("div", {
+                      className: "cortex-reasoning-details__title",
+                      children: t("translate_reasoning")
+                    }, undefined, false, undefined, this),
+                    /* @__PURE__ */ jsxDEV12("span", {
+                      className: cx("cortex-reasoning-details__badge", streaming ? "cortex-reasoning-details__badge--streaming" : "cortex-reasoning-details__badge--done"),
+                      children: streaming ? "Streaming" : "Done"
+                    }, undefined, false, undefined, this)
+                  ]
+                }, undefined, true, undefined, this)
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this),
+          /* @__PURE__ */ jsxDEV12("span", {
+            className: "cortex-reasoning-details__chevron",
+            "aria-hidden": "true",
+            children: /* @__PURE__ */ jsxDEV12("svg", {
+              width: "14",
+              height: "14",
+              viewBox: "0 0 20 20",
+              fill: "none",
+              children: /* @__PURE__ */ jsxDEV12("path", {
+                d: "m5.75 8.25 4.25 4.25 4.25-4.25",
+                stroke: "currentColor",
+                strokeWidth: "1.5",
+                strokeLinecap: "round",
+                strokeLinejoin: "round"
+              }, undefined, false, undefined, this)
+            }, undefined, false, undefined, this)
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsxDEV12("div", {
+        className: "cortex-reasoning-details__body",
+        children: /* @__PURE__ */ jsxDEV12("div", {
+          className: "cortex-reasoning-details__content",
+          children: /* @__PURE__ */ jsxDEV12("pre", {
+            className: "cortex-reasoning-details__pre",
+            children: reasoningPart.content.trim() ? reasoningPart.content : "No reasoning provided."
+          }, undefined, false, undefined, this)
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+
+// src/components/MessageTextPart.tsx
+import { useEffect as useEffect4, useRef as useRef6, useState as useState6 } from "react";
+import { jsxDEV as jsxDEV13 } from "react/jsx-dev-runtime";
+function MessageTextPart(props) {
+  const { role, textPart, streaming = false } = props;
+  const initialText = role === "assistant" && streaming ? "" : textPart.content;
+  const [displayedText, setDisplayedText] = useState6(initialText);
+  const displayedTextRef = useRef6(initialText);
+  const smootherRef = useRef6(null);
+  const isFirstRenderRef = useRef6(true);
+  useEffect4(() => {
+    function setText(text) {
+      displayedTextRef.current = text;
+      setDisplayedText(text);
+    }
+    if (role !== "assistant" || !streaming) {
+      smootherRef.current?.destroy();
+      smootherRef.current = null;
+      setText(textPart.content);
+      isFirstRenderRef.current = false;
+      return;
+    }
+    if (!smootherRef.current) {
+      smootherRef.current = new StreamTextSmoother(setText);
+      smootherRef.current.seed(displayedTextRef.current);
+    }
+    if (isFirstRenderRef.current) {
+      isFirstRenderRef.current = false;
+      smootherRef.current.seed(textPart.content);
+      return;
+    }
+    smootherRef.current.update(textPart.content, false);
+  }, [role, streaming, textPart]);
+  useEffect4(() => () => {
+    smootherRef.current?.destroy();
+    smootherRef.current = null;
+  }, []);
+  return /* @__PURE__ */ jsxDEV13("div", {
+    className: cx("cortex-text-part", role === "assistant" && "cortex-text-part--assistant", role === "user" && "cortex-text-part--user"),
+    children: /* @__PURE__ */ jsxDEV13("div", {
+      className: cx("cortex-text-bubble", role === "assistant" && "cortex-text-bubble--assistant", role === "user" && "cortex-text-bubble--user"),
+      dangerouslySetInnerHTML: { __html: renderMarkdown(displayedText) }
+    }, undefined, false, undefined, this)
+  }, undefined, false, undefined, this);
+}
+
+// src/components/MessageToolCallOutcome.tsx
+import { jsxDEV as jsxDEV14 } from "react/jsx-dev-runtime";
+function MessageToolCallOutcome({ toolCallPart }) {
+  const { t } = useCortex();
+  const { state, approval } = toolCallPart;
+  const output = toolCallPart.output;
+  const outputText = toolCallOutputText(toolCallPart);
+  function section() {
+    if (state === "complete") {
+      return /* @__PURE__ */ jsxDEV14("div", {
+        className: "dbg-tool__section dbg-tool__section--success",
+        children: [
+          /* @__PURE__ */ jsxDEV14("div", {
+            className: "dbg-tool__section-bar",
+            children: [
+              /* @__PURE__ */ jsxDEV14("span", {
+                className: "dbg-tool__section-label dbg-tool__section-label--success",
+                children: t("translate_output")
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV14("span", {
+                className: "dbg-tool__section-lang",
+                children: "json"
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV14(CopyButton, {
+                value: outputText
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this),
+          /* @__PURE__ */ jsxDEV14("div", {
+            dir: "ltr",
+            className: "dbg-tool__tree",
+            children: /* @__PURE__ */ jsxDEV14(JsonTree, {
+              data: output,
+              expandDepth: 2
+            }, undefined, false, undefined, this)
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this);
+    }
+    if (state === "error") {
+      return /* @__PURE__ */ jsxDEV14("div", {
+        className: "dbg-tool__section dbg-tool__section--error",
+        children: [
+          /* @__PURE__ */ jsxDEV14("div", {
+            className: "dbg-tool__section-bar",
+            children: [
+              /* @__PURE__ */ jsxDEV14("span", {
+                className: "dbg-tool__section-label dbg-tool__section-label--error",
+                children: t("translate_error")
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV14(CopyButton, {
+                value: outputText
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this),
+          /* @__PURE__ */ jsxDEV14("pre", {
+            dir: "ltr",
+            className: "dbg-tool__error-pre",
+            children: outputText
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this);
+    }
+    if (state === "approval-requested") {
+      return /* @__PURE__ */ jsxDEV14("div", {
+        className: "dbg-tool__section dbg-tool__section--approval",
+        children: [
+          /* @__PURE__ */ jsxDEV14("div", {
+            className: "dbg-tool__section-bar",
+            children: [
+              /* @__PURE__ */ jsxDEV14("span", {
+                className: "dbg-tool__section-label dbg-tool__section-label--approval",
+                children: t("translate_approval_requested")
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV14("span", {
+                className: "dbg-tool__section-lang",
+                children: approval?.id
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this),
+          /* @__PURE__ */ jsxDEV14("div", {
+            className: "dbg-tool__message dbg-tool__message--approval",
+            children: t("translate_waiting_for_approval")
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this);
+    }
+    if (state === "approval-responded") {
+      return /* @__PURE__ */ jsxDEV14("div", {
+        className: "dbg-tool__section dbg-tool__section--approval",
+        children: [
+          /* @__PURE__ */ jsxDEV14("div", {
+            className: "dbg-tool__section-bar",
+            children: [
+              /* @__PURE__ */ jsxDEV14("span", {
+                className: "dbg-tool__section-label dbg-tool__section-label--approval",
+                children: t("translate_approval_response")
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV14("span", {
+                className: "dbg-tool__section-lang",
+                children: approval?.id
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this),
+          /* @__PURE__ */ jsxDEV14("div", {
+            className: "dbg-tool__message dbg-tool__message--approval",
+            children: t(approval?.approved ? "translate_tool_approved" : "translate_tool_response_received")
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this);
+    }
+    return null;
+  }
+  return /* @__PURE__ */ jsxDEV14("div", {
+    children: section()
+  }, undefined, false, undefined, this);
+}
+
+// src/components/MessageToolCallStatus.tsx
+import { jsxDEV as jsxDEV15 } from "react/jsx-dev-runtime";
+function MessageToolCallStatus({ toolCallPart }) {
+  const { t } = useCortex();
+  const badge = toolCallBadge(toolCallPart);
+  return /* @__PURE__ */ jsxDEV15("span", {
+    children: /* @__PURE__ */ jsxDEV15("span", {
+      className: cx("dbg-tool__state", badge.modifier && `dbg-tool__state--${badge.modifier}`),
+      children: [
+        badge.pulse && /* @__PURE__ */ jsxDEV15("span", {
+          className: cx("dbg-tool__pulse", badge.pulse === "violet" && "dbg-tool__pulse--violet")
+        }, undefined, false, undefined, this),
+        t(badge.labelKey)
+      ]
+    }, undefined, true, undefined, this)
+  }, undefined, false, undefined, this);
+}
+
+// src/components/MessageToolCallPart.tsx
+import { jsxDEV as jsxDEV16 } from "react/jsx-dev-runtime";
+function MessageToolCallPart({ toolCallPart }) {
+  const { t } = useCortex();
+  const { codeSnippets, remainingInput, remainingInputText } = splitToolCallInput(toolCallPart.input);
+  return /* @__PURE__ */ jsxDEV16("details", {
+    className: "dbg-tool",
+    "data-state": toolCallPart.state,
+    children: [
+      /* @__PURE__ */ jsxDEV16("summary", {
+        className: "dbg-tool__summary",
+        children: /* @__PURE__ */ jsxDEV16("div", {
+          className: "dbg-tool__header",
+          children: [
+            /* @__PURE__ */ jsxDEV16("div", {
+              className: "dbg-tool__meta",
+              children: [
+                /* @__PURE__ */ jsxDEV16("div", {
+                  className: "dbg-tool__title-row",
+                  children: /* @__PURE__ */ jsxDEV16("span", {
+                    className: "dbg-tool__name",
+                    title: toolCallPart.name,
+                    children: toolCallPart.name
+                  }, undefined, false, undefined, this)
+                }, undefined, false, undefined, this),
+                /* @__PURE__ */ jsxDEV16("div", {
+                  className: "dbg-tool__id-row",
+                  children: /* @__PURE__ */ jsxDEV16("span", {
+                    className: "dbg-tool__id",
+                    children: toolCallPart.id
+                  }, undefined, false, undefined, this)
+                }, undefined, false, undefined, this)
+              ]
+            }, undefined, true, undefined, this),
+            /* @__PURE__ */ jsxDEV16("div", {
+              className: "dbg-tool__actions",
+              children: [
+                /* @__PURE__ */ jsxDEV16(MessageToolCallStatus, {
+                  toolCallPart
+                }, undefined, false, undefined, this),
+                /* @__PURE__ */ jsxDEV16("svg", {
+                  className: "dbg-tool__chevron",
+                  width: "14",
+                  height: "14",
+                  viewBox: "0 0 20 20",
+                  fill: "none",
+                  children: /* @__PURE__ */ jsxDEV16("path", {
+                    d: "m5.75 8.25 4.25 4.25 4.25-4.25",
+                    stroke: "currentColor",
+                    strokeWidth: "1.5",
+                    strokeLinecap: "round",
+                    strokeLinejoin: "round"
+                  }, undefined, false, undefined, this)
+                }, undefined, false, undefined, this)
+              ]
+            }, undefined, true, undefined, this)
+          ]
+        }, undefined, true, undefined, this)
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV16("div", {
+        className: "dbg-tool__body",
+        children: [
+          codeSnippets.map((snippet) => /* @__PURE__ */ jsxDEV16("div", {
+            className: "dbg-tool__section",
+            children: [
+              /* @__PURE__ */ jsxDEV16("div", {
+                className: "dbg-tool__section-bar",
+                children: [
+                  /* @__PURE__ */ jsxDEV16("span", {
+                    className: "dbg-tool__section-label",
+                    children: snippet.key
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ jsxDEV16("span", {
+                    className: "dbg-tool__section-lang",
+                    children: snippet.lang
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ jsxDEV16(CopyButton, {
+                    value: snippet.value
+                  }, undefined, false, undefined, this)
+                ]
+              }, undefined, true, undefined, this),
+              /* @__PURE__ */ jsxDEV16("pre", {
+                dir: "ltr",
+                className: "dbg-tool__pre",
+                children: /* @__PURE__ */ jsxDEV16("code", {
+                  className: "hljs",
+                  dangerouslySetInnerHTML: { __html: highlightCode(snippet.value, snippet.lang) }
+                }, undefined, false, undefined, this)
+              }, undefined, false, undefined, this)
+            ]
+          }, snippet.key, true, undefined, this)),
+          !!remainingInput && /* @__PURE__ */ jsxDEV16("div", {
+            className: "dbg-tool__section",
+            children: [
+              /* @__PURE__ */ jsxDEV16("div", {
+                className: "dbg-tool__section-bar",
+                children: [
+                  /* @__PURE__ */ jsxDEV16("span", {
+                    className: "dbg-tool__section-label",
+                    children: t("translate_input")
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ jsxDEV16("span", {
+                    className: "dbg-tool__section-lang",
+                    children: "json"
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ jsxDEV16(CopyButton, {
+                    value: remainingInputText
+                  }, undefined, false, undefined, this)
+                ]
+              }, undefined, true, undefined, this),
+              /* @__PURE__ */ jsxDEV16("div", {
+                dir: "ltr",
+                className: "dbg-tool__tree",
+                children: /* @__PURE__ */ jsxDEV16(JsonTree, {
+                  data: remainingInput,
+                  expandDepth: 2
+                }, undefined, false, undefined, this)
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this),
+          /* @__PURE__ */ jsxDEV16(MessageToolCallOutcome, {
+            toolCallPart
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+
+// src/components/MessageToolCallAnimated.tsx
+import { jsxDEV as jsxDEV17 } from "react/jsx-dev-runtime";
+function MessageToolCallAnimated({ message, toolCallPart }) {
+  const { config, t, addToolResult } = useCortex();
+  const Custom = config.toolComponents?.[toolCallPart.name];
+  if (Custom) {
+    return /* @__PURE__ */ jsxDEV17("div", {
+      className: "cortex-tool-call-animated",
+      children: /* @__PURE__ */ jsxDEV17(Custom, {
+        toolCallPart,
+        message,
+        setOutput: (output) => addToolResult(toolCallPart.id, toolCallPart.name, output)
+      }, undefined, false, undefined, this)
+    }, undefined, false, undefined, this);
+  }
+  const { state, active, titleKey } = toolCallAnimation(toolCallPart);
+  return /* @__PURE__ */ jsxDEV17("div", {
+    className: "cortex-tool-call-animated",
+    children: /* @__PURE__ */ jsxDEV17("div", {
+      className: "cortex-tool-pill",
+      children: [
+        /* @__PURE__ */ jsxDEV17("span", {
+          className: "cortex-tool-pill__icon",
+          children: [
+            /* @__PURE__ */ jsxDEV17("span", {
+              className: cx("cortex-tool-pill__spinner", active && "cortex-tool-pill__spinner--visible")
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsxDEV17("svg", {
+              className: cx("cortex-tool-pill__svg", "cortex-tool-pill__svg--check", state === "complete" && "cortex-tool-pill__svg--visible"),
+              viewBox: "0 0 20 20",
+              fill: "none",
+              children: /* @__PURE__ */ jsxDEV17("path", {
+                d: "M5.5 10.5 L8.5 13.5 L14.5 7",
+                stroke: "currentColor",
+                strokeWidth: "2",
+                strokeLinecap: "round",
+                strokeLinejoin: "round"
+              }, undefined, false, undefined, this)
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsxDEV17("svg", {
+              className: cx("cortex-tool-pill__svg", "cortex-tool-pill__svg--error", state === "error" && "cortex-tool-pill__svg--visible"),
+              viewBox: "0 0 20 20",
+              fill: "none",
+              children: /* @__PURE__ */ jsxDEV17("path", {
+                d: "M6.5 6.5 L13.5 13.5 M13.5 6.5 L6.5 13.5",
+                stroke: "currentColor",
+                strokeWidth: "2",
+                strokeLinecap: "round"
+              }, undefined, false, undefined, this)
+            }, undefined, false, undefined, this)
+          ]
+        }, undefined, true, undefined, this),
+        /* @__PURE__ */ jsxDEV17("span", {
+          className: cx("cortex-tool-pill__title", state === "error" && "cortex-tool-pill__title--error"),
+          children: t(titleKey)
+        }, undefined, false, undefined, this)
+      ]
+    }, undefined, true, undefined, this)
+  }, undefined, false, undefined, this);
+}
+
+// src/components/ToolExecuteCodeAnimated.tsx
+import { jsxDEV as jsxDEV18 } from "react/jsx-dev-runtime";
+var LABELS2 = activityLabelKeys("code");
+function ToolExecuteCodeAnimated() {
+  return /* @__PURE__ */ jsxDEV18(SubtleActivity, {
+    labels: LABELS2
+  }, undefined, false, undefined, this);
+}
+
+// src/components/ToolQueryGraphAnimated.tsx
+import { jsxDEV as jsxDEV19 } from "react/jsx-dev-runtime";
+var LABELS3 = activityLabelKeys("graph");
+function ToolQueryGraphAnimated() {
+  return /* @__PURE__ */ jsxDEV19(SubtleActivity, {
+    labels: LABELS3
+  }, undefined, false, undefined, this);
+}
+
+// src/components/ToolAnimation.tsx
+import { jsxDEV as jsxDEV20 } from "react/jsx-dev-runtime";
+function ToolAnimation({ message, toolCallPart }) {
+  if (toolCallPart.name === "queryGraph")
+    return /* @__PURE__ */ jsxDEV20(ToolQueryGraphAnimated, {}, undefined, false, undefined, this);
+  if (toolCallPart.name === "executeCode")
+    return /* @__PURE__ */ jsxDEV20(ToolExecuteCodeAnimated, {}, undefined, false, undefined, this);
+  return /* @__PURE__ */ jsxDEV20(MessageToolCallAnimated, {
+    toolCallPart,
+    message
+  }, undefined, false, undefined, this);
+}
+
+// src/components/MessagePart.tsx
+import { jsxDEV as jsxDEV21 } from "react/jsx-dev-runtime";
+function MessagePart(props) {
+  const { message, part, debugMode = false, animate = false, streaming = false } = props;
+  const { t } = useCortex();
+  function renderPart() {
+    switch (part.type) {
+      case "text":
+        return /* @__PURE__ */ jsxDEV21(MessageTextPart, {
+          textPart: part,
+          role: message.role,
+          streaming
+        }, undefined, false, undefined, this);
+      case "thinking":
+        return debugMode ? /* @__PURE__ */ jsxDEV21(MessageReasoningPart, {
+          reasoningPart: part,
+          streaming
+        }, undefined, false, undefined, this) : /* @__PURE__ */ jsxDEV21(MessageReasoningAnimated, {}, undefined, false, undefined, this);
+      case "tool-call":
+        return debugMode ? /* @__PURE__ */ jsxDEV21(MessageToolCallPart, {
+          toolCallPart: part
+        }, undefined, false, undefined, this) : /* @__PURE__ */ jsxDEV21(ToolAnimation, {
+          toolCallPart: part,
+          message
+        }, undefined, false, undefined, this);
+      default:
+        return /* @__PURE__ */ jsxDEV21("p", {
+          className: "cortex-unhandled-type",
+          children: [
+            t("translate_unhandled_type"),
+            " ",
+            part.type
+          ]
+        }, undefined, true, undefined, this);
+    }
+  }
+  return /* @__PURE__ */ jsxDEV21("div", {
+    className: cx("cortex-message-part", animate && "cortex-message-part--animated"),
+    children: renderPart()
+  }, undefined, false, undefined, this);
+}
+
+// src/components/MessageTokenUsage.tsx
+import { useState as useState7 } from "react";
+import { jsxDEV as jsxDEV22 } from "react/jsx-dev-runtime";
+function MessageTokenUsage({ usage, modelId }) {
+  const { t } = useCortex();
+  const [expanded, setExpanded] = useState7(false);
+  const cacheRatio = cachePercent(usage) ?? 0;
+  return /* @__PURE__ */ jsxDEV22("div", {
+    className: cx("cortex-token-usage", expanded && "cortex-token-usage--expanded"),
+    children: [
+      /* @__PURE__ */ jsxDEV22("button", {
+        className: "cortex-token-usage__summary",
+        onClick: () => setExpanded((v) => !v),
+        children: [
+          /* @__PURE__ */ jsxDEV22("span", {
+            className: "cortex-token-usage__total",
+            children: [
+              /* @__PURE__ */ jsxDEV22("span", {
+                className: "cortex-token-usage__total-number",
+                children: num(usage.total)
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV22("span", {
+                className: "cortex-token-usage__total-label",
+                children: t("translate_tokens")
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this),
+          modelId ? /* @__PURE__ */ jsxDEV22("span", {
+            className: "cortex-token-usage__model",
+            children: modelId
+          }, undefined, false, undefined, this) : null,
+          /* @__PURE__ */ jsxDEV22("span", {
+            className: "cortex-token-usage__pills",
+            children: [
+              /* @__PURE__ */ jsxDEV22("span", {
+                className: "cortex-token-usage__pill",
+                children: [
+                  /* @__PURE__ */ jsxDEV22("span", {
+                    className: "cortex-token-usage__dot cortex-token-usage__dot--input"
+                  }, undefined, false, undefined, this),
+                  num(usage.input.total)
+                ]
+              }, undefined, true, undefined, this),
+              /* @__PURE__ */ jsxDEV22("span", {
+                className: "cortex-token-usage__pill",
+                children: [
+                  /* @__PURE__ */ jsxDEV22("span", {
+                    className: "cortex-token-usage__dot cortex-token-usage__dot--output"
+                  }, undefined, false, undefined, this),
+                  num(usage.output.total)
+                ]
+              }, undefined, true, undefined, this)
+            ]
+          }, undefined, true, undefined, this),
+          cacheRatio > 0 ? /* @__PURE__ */ jsxDEV22("span", {
+            className: "cortex-token-usage__cache-badge",
+            children: [
+              cacheRatio,
+              "%"
+            ]
+          }, undefined, true, undefined, this) : null,
+          /* @__PURE__ */ jsxDEV22("svg", {
+            className: "cortex-token-usage__chevron",
+            width: "12",
+            height: "12",
+            viewBox: "0 0 12 12",
+            fill: "none",
+            children: /* @__PURE__ */ jsxDEV22("path", {
+              d: "M3 4.5L6 7.5L9 4.5",
+              stroke: "currentColor",
+              strokeWidth: "1.25",
+              strokeLinecap: "round",
+              strokeLinejoin: "round"
+            }, undefined, false, undefined, this)
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsxDEV22("div", {
+        className: "cortex-token-usage__details",
+        children: /* @__PURE__ */ jsxDEV22("div", {
+          className: "cortex-token-usage__details-inner",
+          children: /* @__PURE__ */ jsxDEV22("div", {
+            className: "cortex-token-usage__columns",
+            children: [
+              /* @__PURE__ */ jsxDEV22("div", {
+                className: "cortex-token-usage__col",
+                children: [
+                  /* @__PURE__ */ jsxDEV22("div", {
+                    className: "cortex-token-usage__col-header",
+                    children: [
+                      /* @__PURE__ */ jsxDEV22("span", {
+                        className: "cortex-token-usage__dot cortex-token-usage__dot--input"
+                      }, undefined, false, undefined, this),
+                      /* @__PURE__ */ jsxDEV22("span", {
+                        className: "cortex-token-usage__col-label",
+                        children: t("translate_input")
+                      }, undefined, false, undefined, this),
+                      /* @__PURE__ */ jsxDEV22("span", {
+                        className: "cortex-token-usage__col-total",
+                        children: num(usage.input.total)
+                      }, undefined, false, undefined, this)
+                    ]
+                  }, undefined, true, undefined, this),
+                  /* @__PURE__ */ jsxDEV22("div", {
+                    className: "cortex-token-usage__rows",
+                    children: [
+                      usage.input.noCache ? /* @__PURE__ */ jsxDEV22("div", {
+                        className: "cortex-token-usage__row",
+                        children: [
+                          /* @__PURE__ */ jsxDEV22("span", {
+                            className: "cortex-token-usage__row-label",
+                            children: t("translate_fresh")
+                          }, undefined, false, undefined, this),
+                          /* @__PURE__ */ jsxDEV22("span", {
+                            className: "cortex-token-usage__row-value",
+                            children: num(usage.input.noCache)
+                          }, undefined, false, undefined, this)
+                        ]
+                      }, undefined, true, undefined, this) : null,
+                      usage.input.cacheRead ? /* @__PURE__ */ jsxDEV22("div", {
+                        className: "cortex-token-usage__row",
+                        children: [
+                          /* @__PURE__ */ jsxDEV22("span", {
+                            className: "cortex-token-usage__row-label",
+                            children: t("translate_cache_read")
+                          }, undefined, false, undefined, this),
+                          /* @__PURE__ */ jsxDEV22("span", {
+                            className: "cortex-token-usage__row-value",
+                            children: num(usage.input.cacheRead)
+                          }, undefined, false, undefined, this)
+                        ]
+                      }, undefined, true, undefined, this) : null,
+                      usage.input.cacheWrite ? /* @__PURE__ */ jsxDEV22("div", {
+                        className: "cortex-token-usage__row",
+                        children: [
+                          /* @__PURE__ */ jsxDEV22("span", {
+                            className: "cortex-token-usage__row-label",
+                            children: t("translate_cache_write")
+                          }, undefined, false, undefined, this),
+                          /* @__PURE__ */ jsxDEV22("span", {
+                            className: "cortex-token-usage__row-value",
+                            children: num(usage.input.cacheWrite)
+                          }, undefined, false, undefined, this)
+                        ]
+                      }, undefined, true, undefined, this) : null
+                    ]
+                  }, undefined, true, undefined, this),
+                  cacheRatio > 0 ? /* @__PURE__ */ jsxDEV22("div", {
+                    className: "cortex-token-usage__cache-bar-row",
+                    children: [
+                      /* @__PURE__ */ jsxDEV22("div", {
+                        className: "cortex-token-usage__cache-bar",
+                        children: /* @__PURE__ */ jsxDEV22("div", {
+                          className: "cortex-token-usage__cache-fill",
+                          style: { width: `${cacheRatio}%` }
+                        }, undefined, false, undefined, this)
+                      }, undefined, false, undefined, this),
+                      /* @__PURE__ */ jsxDEV22("span", {
+                        className: "cortex-token-usage__cache-label",
+                        children: t("translate_n_percent_cached", { percent: cacheRatio })
+                      }, undefined, false, undefined, this)
+                    ]
+                  }, undefined, true, undefined, this) : null
+                ]
+              }, undefined, true, undefined, this),
+              /* @__PURE__ */ jsxDEV22("div", {
+                className: "cortex-token-usage__col",
+                children: [
+                  /* @__PURE__ */ jsxDEV22("div", {
+                    className: "cortex-token-usage__col-header",
+                    children: [
+                      /* @__PURE__ */ jsxDEV22("span", {
+                        className: "cortex-token-usage__dot cortex-token-usage__dot--output"
+                      }, undefined, false, undefined, this),
+                      /* @__PURE__ */ jsxDEV22("span", {
+                        className: "cortex-token-usage__col-label",
+                        children: t("translate_output")
+                      }, undefined, false, undefined, this),
+                      /* @__PURE__ */ jsxDEV22("span", {
+                        className: "cortex-token-usage__col-total",
+                        children: num(usage.output.total)
+                      }, undefined, false, undefined, this)
+                    ]
+                  }, undefined, true, undefined, this),
+                  /* @__PURE__ */ jsxDEV22("div", {
+                    className: "cortex-token-usage__rows",
+                    children: [
+                      usage.output.text ? /* @__PURE__ */ jsxDEV22("div", {
+                        className: "cortex-token-usage__row",
+                        children: [
+                          /* @__PURE__ */ jsxDEV22("span", {
+                            className: "cortex-token-usage__row-label",
+                            children: t("translate_text")
+                          }, undefined, false, undefined, this),
+                          /* @__PURE__ */ jsxDEV22("span", {
+                            className: "cortex-token-usage__row-value",
+                            children: num(usage.output.text)
+                          }, undefined, false, undefined, this)
+                        ]
+                      }, undefined, true, undefined, this) : null,
+                      usage.output.reasoning ? /* @__PURE__ */ jsxDEV22("div", {
+                        className: "cortex-token-usage__row",
+                        children: [
+                          /* @__PURE__ */ jsxDEV22("span", {
+                            className: "cortex-token-usage__row-label",
+                            children: t("translate_reasoning")
+                          }, undefined, false, undefined, this),
+                          /* @__PURE__ */ jsxDEV22("span", {
+                            className: "cortex-token-usage__row-value",
+                            children: num(usage.output.reasoning)
+                          }, undefined, false, undefined, this)
+                        ]
+                      }, undefined, true, undefined, this) : null
+                    ]
+                  }, undefined, true, undefined, this)
+                ]
+              }, undefined, true, undefined, this)
+            ]
+          }, undefined, true, undefined, this)
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+
+// src/components/Message.tsx
+import { jsxDEV as jsxDEV23 } from "react/jsx-dev-runtime";
+function Message(props) {
+  const { message, debugMode = false, animate = false } = props;
+  const { messages, isAgentWorking, messageMetadata } = useCortex();
+  const isStreaming = isAgentWorking && newestAssistantMessage(messages)?.id === message.id;
+  const isAssistant = message.role === "assistant";
+  const parts = message.parts;
+  const visibleParts = parts.filter((part, index) => {
+    if (part.type === "tool-result")
+      return false;
+    return debugMode || !isHiddenInAnimatedMode(part, index === parts.length - 1, isStreaming);
+  });
+  const streamingPartIndex = isStreaming ? visibleParts.length - 1 : -1;
+  const metadata = messageMetadata.get(message.id);
+  const isAborted = Boolean(metadata?.isAborted);
+  const tokenUsage = metadata?.tokenUsage;
+  const attachments = message.role === "user" ? metadata?.attachments ?? [] : [];
+  const showsDebugZone = debugMode && !isStreaming && (Boolean(tokenUsage) || isAssistant);
+  return /* @__PURE__ */ jsxDEV23("div", {
+    className: "cortex-message",
+    children: visibleParts.length > 0 && /* @__PURE__ */ jsxDEV23("div", {
+      className: "cortex-message-parts",
+      children: [
+        visibleParts.map((part, index) => /* @__PURE__ */ jsxDEV23(MessagePart, {
+          part,
+          message,
+          debugMode,
+          animate,
+          streaming: index === streamingPartIndex
+        }, index, false, undefined, this)),
+        attachments.length > 0 && /* @__PURE__ */ jsxDEV23(MessageAttachments, {
+          attachments
+        }, undefined, false, undefined, this),
+        isAborted && /* @__PURE__ */ jsxDEV23(MessageAbortedFlag, {}, undefined, false, undefined, this),
+        showsDebugZone && /* @__PURE__ */ jsxDEV23("div", {
+          className: "cortex-message-debug-zone",
+          children: [
+            tokenUsage && /* @__PURE__ */ jsxDEV23(MessageTokenUsage, {
+              usage: tokenUsage,
+              modelId: metadata?.modelId
+            }, undefined, false, undefined, this),
+            isAssistant && /* @__PURE__ */ jsxDEV23(MessageLlmInspector, {
+              messageId: message.id
+            }, undefined, false, undefined, this)
+          ]
+        }, undefined, true, undefined, this)
+      ]
+    }, undefined, true, undefined, this)
+  }, undefined, false, undefined, this);
+}
+
+// src/components/MessageList.tsx
+import { jsxDEV as jsxDEV24 } from "react/jsx-dev-runtime";
+function MessageList(props) {
+  const { messages, selectedThread } = useCortex();
+  const containerRef = useRef7(null);
+  const shouldScrollToBottom = useRef7(true);
+  const isNearBottom = useRef7(true);
+  const scrollToBottomQueued = useRef7(false);
+  const [animateNewParts, setAnimateNewParts] = useState8(false);
+  function scrollToBottom() {
+    const el = containerRef.current;
+    if (el)
+      el.scrollTop = el.scrollHeight;
+  }
+  function scheduleScrollToBottom() {
+    if (scrollToBottomQueued.current)
+      return;
+    scrollToBottomQueued.current = true;
+    queueMicrotask(() => {
+      scrollToBottomQueued.current = false;
+      scrollToBottom();
+      shouldScrollToBottom.current = false;
+    });
+  }
+  useEffect5(() => {
+    const el = containerRef.current;
+    scheduleScrollToBottom();
+    setAnimateNewParts(true);
+    if (!el || typeof MutationObserver === "undefined")
+      return;
+    const observer = new MutationObserver(() => {
+      if (!shouldScrollToBottom.current && !isNearBottom.current)
+        return;
+      scheduleScrollToBottom();
+    });
+    observer.observe(el, { childList: true, subtree: true, characterData: true });
+    return () => observer.disconnect();
+  }, []);
+  const threadId = selectedThread?.id;
+  useEffect5(() => {
+    setAnimateNewParts(false);
+    shouldScrollToBottom.current = true;
+    queueMicrotask(() => setAnimateNewParts(true));
+  }, [threadId]);
+  const lastMessage = messages[messages.length - 1];
+  const lastUserMessageId = lastMessage?.role === "user" ? lastMessage.id : undefined;
+  useEffect5(() => {
+    if (lastUserMessageId)
+      shouldScrollToBottom.current = true;
+  }, [lastUserMessageId]);
+  useEffect5(() => {
+    if (!shouldScrollToBottom.current && !isNearBottom.current)
+      return;
+    scheduleScrollToBottom();
+  }, [messages]);
+  function onScroll() {
+    const el = containerRef.current;
+    if (!el)
+      return;
+    isNearBottom.current = el.scrollHeight - el.scrollTop - el.clientHeight < 100;
+  }
+  return /* @__PURE__ */ jsxDEV24("div", {
+    className: props.className,
+    children: /* @__PURE__ */ jsxDEV24("div", {
+      ref: containerRef,
+      className: "cortex-message-list",
+      onScroll,
+      children: messages.map((message) => /* @__PURE__ */ jsxDEV24(Message, {
+        message,
+        debugMode: props.debugMode,
+        animate: animateNewParts
+      }, message.id, false, undefined, this))
+    }, undefined, false, undefined, this)
+  }, undefined, false, undefined, this);
+}
+
+// src/components/ThreadList.tsx
+import { jsxDEV as jsxDEV25, Fragment as Fragment2 } from "react/jsx-dev-runtime";
+var BUBBLE_PATH = "M13.5 7.6c0 2.4-2.5 4.4-5.5 4.4-.6 0-1.2-.08-1.7-.23L3 13l.8-2.3C3 9.8 2.5 8.7 2.5 7.6 2.5 5.2 5 3.2 8 3.2s5.5 2 5.5 4.4Z";
+function ThreadList(props) {
+  const { config, t, threads, selectedThread, deleteThread } = useCortex();
+  const locale = config.locale ?? "en";
+  return /* @__PURE__ */ jsxDEV25("div", {
+    className: props.className,
+    children: [
+      /* @__PURE__ */ jsxDEV25("div", {
+        className: "cortex-widget__threads-header",
+        children: [
+          /* @__PURE__ */ jsxDEV25("div", {
+            children: [
+              /* @__PURE__ */ jsxDEV25("h2", {
+                className: "cortex-widget__threads-title",
+                children: t("translate_threads")
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV25("p", {
+                className: "cortex-widget__threads-count",
+                children: t(threads?.length === 1 ? "translate_one_conversation" : "translate_n_conversations", {
+                  count: threads?.length ?? 0
+                })
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this),
+          /* @__PURE__ */ jsxDEV25("button", {
+            onClick: () => props.onNewChatRequested(),
+            className: "cortex-widget__new-chat-btn",
+            children: [
+              /* @__PURE__ */ jsxDEV25("svg", {
+                width: "12",
+                height: "12",
+                viewBox: "0 0 16 16",
+                fill: "none",
+                children: /* @__PURE__ */ jsxDEV25("path", {
+                  d: "M8 3v10M3 8h10",
+                  stroke: "currentColor",
+                  strokeWidth: "1.5",
+                  strokeLinecap: "round"
+                }, undefined, false, undefined, this)
+              }, undefined, false, undefined, this),
+              t("translate_new")
+            ]
+          }, undefined, true, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsxDEV25("div", {
+        className: "cortex-widget__threads-list",
+        children: threads === undefined ? [1, 2, 3, 4].map((i) => /* @__PURE__ */ jsxDEV25("div", {
+          className: "cortex-widget__thread-skeleton",
+          children: [
+            /* @__PURE__ */ jsxDEV25("div", {
+              className: "cortex-skeleton cortex-widget__thread-skeleton-icon"
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsxDEV25("div", {
+              className: "cortex-widget__thread-skeleton-lines",
+              children: /* @__PURE__ */ jsxDEV25("div", {
+                className: "cortex-skeleton cortex-widget__thread-skeleton-line",
+                style: { width: `${40 + i * 12}%` }
+              }, undefined, false, undefined, this)
+            }, undefined, false, undefined, this)
+          ]
+        }, i, true, undefined, this)) : /* @__PURE__ */ jsxDEV25(Fragment2, {
+          children: [
+            threads.map((thread) => {
+              const isActive = thread.id === selectedThread?.id;
+              const time = relativeTimeLabel(thread.updatedAt, locale);
+              return /* @__PURE__ */ jsxDEV25("button", {
+                onClick: () => props.onThreadSelected(thread),
+                className: cx("cortex-widget__thread-item", isActive && "cortex-widget__thread-item--active"),
+                children: [
+                  /* @__PURE__ */ jsxDEV25("div", {
+                    className: cx("cortex-widget__thread-icon", isActive && "cortex-widget__thread-icon--active"),
+                    children: /* @__PURE__ */ jsxDEV25("svg", {
+                      width: "14",
+                      height: "14",
+                      viewBox: "0 0 16 16",
+                      fill: "none",
+                      children: /* @__PURE__ */ jsxDEV25("path", {
+                        d: BUBBLE_PATH,
+                        stroke: "currentColor",
+                        strokeWidth: "1.3",
+                        strokeLinecap: "round",
+                        strokeLinejoin: "round"
+                      }, undefined, false, undefined, this)
+                    }, undefined, false, undefined, this)
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ jsxDEV25("div", {
+                    className: "cortex-widget__thread-info",
+                    children: [
+                      /* @__PURE__ */ jsxDEV25("div", {
+                        className: "cortex-widget__thread-title-row",
+                        children: [
+                          /* @__PURE__ */ jsxDEV25("p", {
+                            className: cx("cortex-widget__thread-title", isActive && "cortex-widget__thread-title--active"),
+                            children: thread.title ?? t("translate_untitled")
+                          }, undefined, false, undefined, this),
+                          thread.isRunning && /* @__PURE__ */ jsxDEV25("span", {
+                            className: cx("cortex-widget__thread-running", isActive && "cortex-widget__thread-running--active"),
+                            children: [
+                              /* @__PURE__ */ jsxDEV25("span", {
+                                className: "cortex-widget__thread-running-dot"
+                              }, undefined, false, undefined, this),
+                              t("translate_running")
+                            ]
+                          }, undefined, true, undefined, this)
+                        ]
+                      }, undefined, true, undefined, this),
+                      time && /* @__PURE__ */ jsxDEV25("p", {
+                        className: "cortex-widget__thread-time",
+                        children: time
+                      }, undefined, false, undefined, this)
+                    ]
+                  }, undefined, true, undefined, this),
+                  /* @__PURE__ */ jsxDEV25("span", {
+                    role: "button",
+                    tabIndex: 0,
+                    onClick: (event) => {
+                      event.stopPropagation();
+                      deleteThread(thread.id);
+                    },
+                    onKeyDown: (event) => {
+                      if (event.key !== "Enter" && event.key !== " ")
+                        return;
+                      event.preventDefault();
+                      event.stopPropagation();
+                      deleteThread(thread.id);
+                    },
+                    className: cx("cortex-widget__thread-delete", isActive && "cortex-widget__thread-delete--active"),
+                    children: /* @__PURE__ */ jsxDEV25("svg", {
+                      width: "12",
+                      height: "12",
+                      viewBox: "0 0 16 16",
+                      fill: "none",
+                      children: /* @__PURE__ */ jsxDEV25("path", {
+                        d: "M4 4l8 8M12 4l-8 8",
+                        stroke: "currentColor",
+                        strokeWidth: "1.3",
+                        strokeLinecap: "round"
+                      }, undefined, false, undefined, this)
+                    }, undefined, false, undefined, this)
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ jsxDEV25("svg", {
+                    className: cx("cortex-widget__thread-arrow", isActive && "cortex-widget__thread-arrow--active"),
+                    width: "10",
+                    height: "10",
+                    viewBox: "0 0 16 16",
+                    fill: "none",
+                    children: /* @__PURE__ */ jsxDEV25("path", {
+                      d: "M6 4l4 4-4 4",
+                      stroke: "currentColor",
+                      strokeWidth: "1.5",
+                      strokeLinecap: "round",
+                      strokeLinejoin: "round"
+                    }, undefined, false, undefined, this)
+                  }, undefined, false, undefined, this)
+                ]
+              }, thread.id, true, undefined, this);
+            }),
+            !threads.length && /* @__PURE__ */ jsxDEV25("div", {
+              className: "cortex-widget__threads-empty",
+              children: [
+                /* @__PURE__ */ jsxDEV25("div", {
+                  className: "cortex-widget__threads-empty-icon",
+                  children: /* @__PURE__ */ jsxDEV25("svg", {
+                    width: "18",
+                    height: "18",
+                    viewBox: "0 0 16 16",
+                    fill: "none",
+                    className: "cortex-widget__threads-empty-svg",
+                    children: /* @__PURE__ */ jsxDEV25("path", {
+                      d: BUBBLE_PATH,
+                      stroke: "currentColor",
+                      strokeWidth: "1.3",
+                      strokeLinecap: "round",
+                      strokeLinejoin: "round"
+                    }, undefined, false, undefined, this)
+                  }, undefined, false, undefined, this)
+                }, undefined, false, undefined, this),
+                /* @__PURE__ */ jsxDEV25("p", {
+                  className: "cortex-widget__threads-empty-title",
+                  children: t("translate_no_threads_yet")
+                }, undefined, false, undefined, this),
+                /* @__PURE__ */ jsxDEV25("p", {
+                  className: "cortex-widget__threads-empty-subtitle",
+                  children: t("translate_start_a_new_conversation")
+                }, undefined, false, undefined, this),
+                /* @__PURE__ */ jsxDEV25("button", {
+                  onClick: () => props.onNewChatRequested(),
+                  className: "cortex-widget__new-chat-btn cortex-widget__new-chat-btn--empty-state",
+                  children: t("translate_new_chat")
+                }, undefined, false, undefined, this)
+              ]
+            }, undefined, true, undefined, this)
+          ]
+        }, undefined, true, undefined, this)
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+
+// src/components/CortexChatWidget.tsx
+import { jsxDEV as jsxDEV26 } from "react/jsx-dev-runtime";
+var initialSessionUi = {
+  messages: [],
+  isAgentWorking: false,
+  isLoadingMessages: false,
+  hasPendingToolCalls: false,
+  messageMetadata: new Map
+};
+function CortexChatWidget({
+  config,
+  className
+}) {
+  const configRef = useRef8(config);
+  configRef.current = config;
+  const [threads, setThreads] = useState9();
+  const [session, setSession] = useState9();
+  const [sessionUi, setSessionUi] = useState9(initialSessionUi);
+  const [debugMode, setDebugMode] = useState9(false);
+  const [screen, setScreen] = useState9("threads");
+  const [sidebarOpen, setSidebarOpen] = useState9(false);
+  const sessionRef = useRef8(undefined);
+  const pendingSendRef = useRef8([]);
+  const pendingThreadCreation = useRef8(undefined);
+  const composerRef = useRef8(null);
+  const api = useMemo3(() => createCortexApiClient(() => configRef.current.transport), []);
+  const selectedThread = useMemo3(() => {
+    const snapshot = session?.thread;
+    if (!snapshot)
+      return;
+    return threads?.find((thread) => thread.id === snapshot.id) ?? snapshot;
+  }, [threads, session]);
+  const selectedThreadRef = useRef8(selectedThread);
+  selectedThreadRef.current = selectedThread;
+  const sessionUiRef = useRef8(sessionUi);
+  sessionUiRef.current = sessionUi;
+  const patchUi = useCallback((patch) => {
+    setSessionUi((previous) => ({
+      ...previous,
+      ...typeof patch === "function" ? patch(previous) : patch
+    }));
+  }, []);
+  const setRunning = useCallback((threadId, isRunning) => {
+    setThreads((current) => {
+      const thread = current?.find((candidate) => candidate.id === threadId);
+      return thread ? upsertThread(current ?? [], { ...thread, isRunning }) : current;
+    });
+  }, []);
+  const selectThread = useCallback((thread, options) => {
+    if (selectedThreadRef.current?.id === thread.id && sessionRef.current)
+      return;
+    const previous = selectedThreadRef.current;
+    selectedThreadRef.current = thread;
+    setSessionUi(initialSessionUi);
+    setSession({ thread, mode: options?.skipLoadingMessages ? "skip" : "load", epoch: 0 });
+    if (previous && previous.id !== thread.id) {
+      configRef.current.hooks?.onThreadDeselected?.(previous);
+    }
+    configRef.current.hooks?.onThreadSelected?.(thread);
+  }, []);
+  const deselectThread = useCallback(() => {
+    const previous = selectedThreadRef.current;
+    if (!previous && !sessionRef.current)
+      return;
+    selectedThreadRef.current = undefined;
+    setSession(undefined);
+    setSessionUi(initialSessionUi);
+    if (previous) {
+      configRef.current.hooks?.onThreadDeselected?.(previous);
+    }
+  }, []);
+  const remountSession = useCallback((thread) => {
+    patchUi({ hasPendingToolCalls: false, messageMetadata: new Map });
+    setSession((current) => ({ thread, mode: "reload", epoch: (current?.epoch ?? 0) + 1 }));
+  }, [patchUi]);
+  const ensureThread = useCallback((prompt) => {
+    const selected = selectedThreadRef.current;
+    if (selected)
+      return Promise.resolve(selected.id);
+    pendingThreadCreation.current ??= api.createThread(prompt).then((thread) => {
+      pendingThreadCreation.current = undefined;
+      setThreads((current) => upsertThread(current ?? [], thread));
+      selectThread(thread, { skipLoadingMessages: true });
+      return thread.id;
+    }, (error) => {
+      pendingThreadCreation.current = undefined;
+      throw error;
+    });
+    return pendingThreadCreation.current;
+  }, [api, selectThread]);
+  const queueStore = useMemo3(() => createAttachmentQueue({ api, ensureThread: () => ensureThread() }), [api, ensureThread]);
+  const queueItems = useSyncExternalStore(queueStore.subscribe, queueStore.getState, queueStore.getState);
+  const send = useCallback(async (prompt, attachments = []) => {
+    if (sessionUiRef.current.isAgentWorking || sessionUiRef.current.hasPendingToolCalls)
+      return;
+    const handle = sessionRef.current;
+    if (handle) {
+      await handle.send(prompt, attachments);
+      return;
+    }
+    pendingSendRef.current.push({ prompt, attachments });
+    try {
+      await ensureThread(prompt);
+    } catch (error) {
+      pendingSendRef.current = [];
+      throw error;
+    }
+  }, [ensureThread]);
+  const abort = useCallback(async () => {
+    await sessionRef.current?.abort();
+  }, []);
+  const addToolResult = useCallback((toolCallId, toolName, output) => {
+    sessionRef.current?.addToolResult(toolCallId, toolName, output);
+  }, []);
+  const deleteThread = useCallback(async (threadId) => {
+    if (selectedThreadRef.current?.id === threadId)
+      deselectThread();
+    await api.deleteThread(threadId);
+    setThreads((current) => current ? removeThread(current, threadId) : current);
+  }, [api, deselectThread]);
+  const onTurnFinished = useCallback(() => {
+    queueStore.discardConsumed();
+    setTimeout(() => composerRef.current?.focusInput());
+  }, [queueStore]);
+  const onSendFailed = useCallback(() => {
+    queueStore.restoreConsumed(selectedThreadRef.current?.id);
+  }, [queueStore]);
+  const reloadThreads = useCallback(async () => {
+    const listed = sortThreads(await api.listThreads());
+    setThreads(listed);
+    return listed;
+  }, [api]);
+  const handleWsEvent = useCallback((event) => {
+    setThreads((current) => {
+      const next = applyWsEvent(current ?? [], event);
+      return current || next.length ? next : current;
+    });
+    const selectedId = selectedThreadRef.current?.id;
+    switch (event.type) {
+      case "thread:deleted":
+        if (selectedId === event.payload.threadId)
+          deselectThread();
+        break;
+      case "thread:run-started":
+        if (selectedId === event.payload.thread.id) {
+          sessionRef.current?.reattach(event.payload.thread);
+        }
+        break;
+      case "thread:messages-updated":
+        sessionRef.current?.refreshMessages(event.payload.threadId);
+        break;
+    }
+  }, [deselectThread]);
+  useEffect6(() => {
+    reloadThreads();
+    let openedOnce = false;
+    const socket = createCortexSocket({
+      wsUrl: () => configRef.current.wsUrl,
+      transport: {
+        baseUrl: () => {
+          const baseUrl = configRef.current.transport.baseUrl;
+          return typeof baseUrl === "string" ? baseUrl : baseUrl();
+        },
+        getHeaders: () => configRef.current.transport.getHeaders()
+      },
+      onEvent: handleWsEvent,
+      onOpen: () => {
+        if (!openedOnce) {
+          openedOnce = true;
+          return;
+        }
+        reloadThreads().then((listed) => {
+          const selected = selectedThreadRef.current;
+          if (!selected)
+            return;
+          sessionRef.current?.reattach(listed.find((thread) => thread.id === selected.id) ?? selected);
+        });
+      }
+    });
+    return () => {
+      socket.close();
+    };
+  }, [handleWsEvent, reloadThreads]);
+  const previousThreadId = useRef8(undefined);
+  const selectedThreadId = selectedThread?.id;
+  useEffect6(() => {
+    if (selectedThreadId === previousThreadId.current)
+      return;
+    queueStore.clear(previousThreadId.current);
+    previousThreadId.current = selectedThreadId;
+  }, [selectedThreadId, queueStore]);
+  const locale = config.locale ?? "en";
+  const t = useCallback((key, params) => translate(locale, key, params), [locale]);
+  const viewMode = config.viewMode ?? "helper";
+  const contextValue = {
+    config,
+    t,
+    api,
+    debugMode,
+    threads,
+    selectedThread,
+    deleteThread,
+    ...sessionUi,
+    send,
+    abort,
+    addToolResult,
+    queue: {
+      items: queueItems,
+      ...attachmentQueueFlags(queueItems),
+      accept: queueStore.accept,
+      remove: queueStore.remove,
+      consumeReady: queueStore.consumeReady
+    }
+  };
+  function openThread(thread) {
+    selectThread(thread);
+    setScreen("chat");
+    setSidebarOpen(false);
+  }
+  function newChat() {
+    deselectThread();
+    setScreen("chat");
+    setSidebarOpen(false);
+  }
+  function goBack() {
+    deselectThread();
+    setScreen("threads");
+  }
+  return /* @__PURE__ */ jsxDEV26(CortexContext.Provider, {
+    value: contextValue,
+    children: /* @__PURE__ */ jsxDEV26("div", {
+      className: cx("cortex-widget", className),
+      "data-cortex-theme": config.theme,
+      children: [
+        /* @__PURE__ */ jsxDEV26("div", {
+          className: cx("cortex-widget__container", viewMode === "full" && "cortex-widget__container--full", sidebarOpen && "cortex-widget__container--sidebar-open"),
+          onDragOver: (event) => event.preventDefault(),
+          onDrop: (event) => event.preventDefault(),
+          children: [
+            /* @__PURE__ */ jsxDEV26(ThreadList, {
+              className: cx("cortex-widget__screen", screen === "threads" && "cortex-widget__screen--active", screen !== "threads" && "cortex-widget__screen--left"),
+              onThreadSelected: openThread,
+              onNewChatRequested: newChat
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsxDEV26("div", {
+              className: cx("cortex-widget__screen", screen === "chat" && "cortex-widget__screen--active", screen !== "chat" && "cortex-widget__screen--right"),
+              children: [
+                /* @__PURE__ */ jsxDEV26("div", {
+                  className: "cortex-widget__chat-header",
+                  children: [
+                    /* @__PURE__ */ jsxDEV26("button", {
+                      onClick: () => setSidebarOpen((open) => !open),
+                      className: "cortex-widget__sidebar-toggle-btn",
+                      children: /* @__PURE__ */ jsxDEV26("svg", {
+                        width: "16",
+                        height: "16",
+                        viewBox: "0 0 16 16",
+                        fill: "none",
+                        children: /* @__PURE__ */ jsxDEV26("path", {
+                          d: "M2.5 4h11M2.5 8h11M2.5 12h11",
+                          stroke: "currentColor",
+                          strokeWidth: "1.4",
+                          strokeLinecap: "round"
+                        }, undefined, false, undefined, this)
+                      }, undefined, false, undefined, this)
+                    }, undefined, false, undefined, this),
+                    /* @__PURE__ */ jsxDEV26("button", {
+                      onClick: goBack,
+                      className: "cortex-widget__back-btn",
+                      children: /* @__PURE__ */ jsxDEV26("svg", {
+                        width: "14",
+                        height: "14",
+                        viewBox: "0 0 16 16",
+                        fill: "none",
+                        className: "cortex-widget__back-icon",
+                        children: /* @__PURE__ */ jsxDEV26("path", {
+                          d: "M10 3L5 8l5 5",
+                          stroke: "currentColor",
+                          strokeWidth: "1.5",
+                          strokeLinecap: "round",
+                          strokeLinejoin: "round"
+                        }, undefined, false, undefined, this)
+                      }, undefined, false, undefined, this)
+                    }, undefined, false, undefined, this),
+                    /* @__PURE__ */ jsxDEV26("div", {
+                      className: "cortex-widget__chat-title-wrap",
+                      children: /* @__PURE__ */ jsxDEV26("p", {
+                        className: "cortex-widget__chat-title",
+                        children: selectedThread?.title ?? t("translate_new_chat")
+                      }, undefined, false, undefined, this)
+                    }, undefined, false, undefined, this),
+                    config.showDebugButton && /* @__PURE__ */ jsxDEV26("button", {
+                      onClick: () => setDebugMode((mode) => !mode),
+                      className: cx("cortex-widget__debug-btn", debugMode ? "cortex-widget__debug-btn--on" : "cortex-widget__debug-btn--off"),
+                      children: debugMode ? t("translate_debug") : t("translate_normal")
+                    }, undefined, false, undefined, this)
+                  ]
+                }, undefined, true, undefined, this),
+                sessionUi.isLoadingMessages && !sessionUi.isAgentWorking ? /* @__PURE__ */ jsxDEV26("div", {
+                  className: "cortex-widget__messages-skeleton",
+                  children: [
+                    /* @__PURE__ */ jsxDEV26("div", {
+                      className: "cortex-widget__msg-skel cortex-widget__msg-skel--user",
+                      children: /* @__PURE__ */ jsxDEV26("div", {
+                        className: "cortex-widget__msg-skel-bubble cortex-widget__msg-skel-bubble--user",
+                        children: [
+                          /* @__PURE__ */ jsxDEV26("div", {
+                            className: "cortex-skeleton cortex-widget__msg-skel-line",
+                            style: { width: "13rem" }
+                          }, undefined, false, undefined, this),
+                          /* @__PURE__ */ jsxDEV26("div", {
+                            className: "cortex-skeleton cortex-widget__msg-skel-line",
+                            style: { width: "9rem" }
+                          }, undefined, false, undefined, this)
+                        ]
+                      }, undefined, true, undefined, this)
+                    }, undefined, false, undefined, this),
+                    /* @__PURE__ */ jsxDEV26("div", {
+                      className: "cortex-widget__msg-skel cortex-widget__msg-skel--assistant",
+                      children: /* @__PURE__ */ jsxDEV26("div", {
+                        className: "cortex-widget__msg-skel-bubble cortex-widget__msg-skel-bubble--assistant",
+                        children: [
+                          /* @__PURE__ */ jsxDEV26("div", {
+                            className: "cortex-skeleton cortex-widget__msg-skel-line",
+                            style: { width: "16rem" }
+                          }, undefined, false, undefined, this),
+                          /* @__PURE__ */ jsxDEV26("div", {
+                            className: "cortex-skeleton cortex-widget__msg-skel-line",
+                            style: { width: "18rem" }
+                          }, undefined, false, undefined, this),
+                          /* @__PURE__ */ jsxDEV26("div", {
+                            className: "cortex-skeleton cortex-widget__msg-skel-line",
+                            style: { width: "12rem" }
+                          }, undefined, false, undefined, this)
+                        ]
+                      }, undefined, true, undefined, this)
+                    }, undefined, false, undefined, this),
+                    /* @__PURE__ */ jsxDEV26("div", {
+                      className: "cortex-widget__msg-skel cortex-widget__msg-skel--user",
+                      children: /* @__PURE__ */ jsxDEV26("div", {
+                        className: "cortex-widget__msg-skel-bubble cortex-widget__msg-skel-bubble--user",
+                        children: /* @__PURE__ */ jsxDEV26("div", {
+                          className: "cortex-skeleton cortex-widget__msg-skel-line",
+                          style: { width: "11rem" }
+                        }, undefined, false, undefined, this)
+                      }, undefined, false, undefined, this)
+                    }, undefined, false, undefined, this),
+                    /* @__PURE__ */ jsxDEV26("div", {
+                      className: "cortex-widget__msg-skel cortex-widget__msg-skel--assistant",
+                      children: /* @__PURE__ */ jsxDEV26("div", {
+                        className: "cortex-widget__msg-skel-bubble cortex-widget__msg-skel-bubble--assistant",
+                        children: [
+                          /* @__PURE__ */ jsxDEV26("div", {
+                            className: "cortex-skeleton cortex-widget__msg-skel-line",
+                            style: { width: "14rem" }
+                          }, undefined, false, undefined, this),
+                          /* @__PURE__ */ jsxDEV26("div", {
+                            className: "cortex-skeleton cortex-widget__msg-skel-line",
+                            style: { width: "15rem" }
+                          }, undefined, false, undefined, this)
+                        ]
+                      }, undefined, true, undefined, this)
+                    }, undefined, false, undefined, this)
+                  ]
+                }, undefined, true, undefined, this) : /* @__PURE__ */ jsxDEV26(MessageList, {
+                  className: "cortex-widget__messages",
+                  debugMode
+                }, undefined, false, undefined, this),
+                sessionUi.isAgentWorking && !sessionUi.hasPendingToolCalls && /* @__PURE__ */ jsxDEV26("div", {
+                  className: "cortex-widget__working",
+                  children: [
+                    /* @__PURE__ */ jsxDEV26("div", {
+                      className: "cortex-widget__working-dots",
+                      children: [
+                        /* @__PURE__ */ jsxDEV26("span", {
+                          className: "cortex-working-dot"
+                        }, undefined, false, undefined, this),
+                        /* @__PURE__ */ jsxDEV26("span", {
+                          className: "cortex-working-dot"
+                        }, undefined, false, undefined, this),
+                        /* @__PURE__ */ jsxDEV26("span", {
+                          className: "cortex-working-dot"
+                        }, undefined, false, undefined, this)
+                      ]
+                    }, undefined, true, undefined, this),
+                    /* @__PURE__ */ jsxDEV26("span", {
+                      className: "cortex-widget__working-text",
+                      children: t("translate_thinking")
+                    }, undefined, false, undefined, this)
+                  ]
+                }, undefined, true, undefined, this),
+                !sessionUi.hasPendingToolCalls && /* @__PURE__ */ jsxDEV26(ChatComposer, {
+                  ref: composerRef
+                }, undefined, false, undefined, this)
+              ]
+            }, undefined, true, undefined, this),
+            /* @__PURE__ */ jsxDEV26("div", {
+              className: "cortex-widget__sidebar-backdrop",
+              onClick: () => setSidebarOpen(false)
+            }, undefined, false, undefined, this)
+          ]
+        }, undefined, true, undefined, this),
+        session && /* @__PURE__ */ jsxDEV26(ChatSession, {
+          thread: session.thread,
+          mode: session.mode,
+          api,
+          configRef,
+          sessionRef,
+          pendingSendRef,
+          patchUi,
+          setRunning,
+          remount: remountSession,
+          onTurnFinished,
+          onSendFailed
+        }, `${session.thread.id}:${session.epoch}`, false, undefined, this)
+      ]
+    }, undefined, true, undefined, this)
+  }, undefined, false, undefined, this);
+}
 export {
   CortexChatWidget
 };