@sarchauhan/chat 0.0.0-stage → 0.0.1

package/dist/index.mjs

@@ -0,0 +1,2247 @@
+"use client";
+import {
+  ArtifactWidget,
+  ArtifactsWidget,
+  BaseWidget,
+  LoadingState,
+  MessageContent,
+  PatchWidget,
+  QuestionWidget,
+  ReadFileWidget,
+  ResponsiveDetail,
+  SearchWidget,
+  SubagentWidget,
+  TextSkeleton,
+  TextSwap,
+  ThemeProvider,
+  ThinkingBlock,
+  WidgetProvider,
+  WidgetRenderer,
+  calibrateCheckPath,
+  clearErrorShake,
+  closeDropdown,
+  cn,
+  computeDiff,
+  computeTextDiff,
+  computeToolState,
+  computeToolWidget,
+  createArtifactData,
+  createSubagentData,
+  createWidgetRegistry,
+  defineWidget,
+  dropdownOrigins,
+  formatArtifactSize,
+  formatElapsed,
+  formatElapsedWords,
+  getUserDisplayText,
+  iconSwapStates,
+  motion,
+  motionData,
+  motionRoot,
+  normalizeSearchResults,
+  openDropdown,
+  parseArtifact,
+  parseSubagent,
+  prebuiltWidgets,
+  prefersReducedMotion,
+  readDurationMs,
+  safeArtifactUrl,
+  safeResultUrl,
+  successCheckStates,
+  swapText,
+  triggerErrorShake,
+  useDropdownPresence,
+  useTheme,
+  useWidgets
+} from "./chunk-5SNRYULC.mjs";
+
+// src/components/Chat.tsx
+import { PenSquare } from "lucide-react";
+import { useCallback as useCallback6, useLayoutEffect, useMemo as useMemo7, useRef as useRef10 } from "react";
+
+// src/theme/theme.toggle.tsx
+import { Moon, Sun } from "lucide-react";
+import { jsx } from "react/jsx-runtime";
+function ThemeToggle({ className }) {
+  const { resolvedTheme, toggleTheme } = useTheme();
+  const isDark = resolvedTheme === "dark";
+  return /* @__PURE__ */ jsx(
+    "button",
+    {
+      type: "button",
+      className: ["chat-theme-toggle", className].filter(Boolean).join(" "),
+      onClick: toggleTheme,
+      "aria-label": isDark ? "Switch to light theme" : "Switch to dark theme",
+      title: isDark ? "Light mode" : "Dark mode",
+      children: isDark ? /* @__PURE__ */ jsx(Sun, { size: 16, strokeWidth: 1.75 }) : /* @__PURE__ */ jsx(Moon, { size: 16, strokeWidth: 1.75 })
+    }
+  );
+}
+
+// src/components/Chat/chat.tsx
+import { MessageCircle } from "lucide-react";
+import { useEffect as useEffect6, useRef as useRef9, useState as useState7 } from "react";
+
+// src/components/Chat/chat.attachments.tsx
+import { FileText, Paperclip, X } from "lucide-react";
+import { useRef as useRef6 } from "react";
+
+// src/components/Chat/context/index.ts
+import { useMemo as useMemo5 } from "react";
+
+// src/components/Chat/context/composer.context.tsx
+import {
+  createContext as createContext4,
+  useCallback as useCallback4,
+  useContext as useContext4,
+  useMemo as useMemo4,
+  useRef as useRef5,
+  useState as useState5
+} from "react";
+
+// src/components/Chat/chat.tooltip.tsx
+import { memo, useEffect, useRef, useState } from "react";
+import { createPortal } from "react-dom";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var isEditableSelection = (selection) => {
+  var _a, _b;
+  const anchorElement = (_a = selection.anchorNode) == null ? void 0 : _a.parentElement;
+  const focusElement = (_b = selection.focusNode) == null ? void 0 : _b.parentElement;
+  return Boolean(
+    (anchorElement == null ? void 0 : anchorElement.closest("textarea,input,[contenteditable='true']")) || (focusElement == null ? void 0 : focusElement.closest("textarea,input,[contenteditable='true']"))
+  );
+};
+var getSelectionRect = (range) => {
+  const rect = range.getBoundingClientRect();
+  const fallbackRect = range.getClientRects()[0];
+  return rect.width || rect.height ? rect : fallbackRect;
+};
+var positionFromRange = (range, container) => {
+  const selectionRect = getSelectionRect(range);
+  if (!selectionRect) {
+    return null;
+  }
+  const containerRect = container.getBoundingClientRect();
+  return {
+    top: Math.max(8, selectionRect.top - containerRect.top + container.scrollTop),
+    left: selectionRect.left - containerRect.left + container.scrollLeft + selectionRect.width / 2
+  };
+};
+var readSelection = () => {
+  const selection = window.getSelection();
+  const text = selection == null ? void 0 : selection.toString().replace(/\s+/g, " ").trim();
+  if (!selection || !text || selection.rangeCount === 0 || selection.isCollapsed) {
+    return null;
+  }
+  if (isEditableSelection(selection)) {
+    return null;
+  }
+  return {
+    text,
+    range: selection.getRangeAt(0).cloneRange()
+  };
+};
+var getPortalContainer = (range) => {
+  const node = range.commonAncestorContainer;
+  const element = node instanceof Element ? node : node.parentElement;
+  const found = element == null ? void 0 : element.closest(".chat-messages");
+  return found instanceof HTMLElement ? found : null;
+};
+var ChatTooltip = memo(function ChatTooltip2({
+  onAddReference
+}) {
+  const [selectionAction, setSelectionAction] = useState(null);
+  const rangeRef = useRef(null);
+  const textRef = useRef("");
+  useEffect(() => {
+    const clearSelectionAction = () => {
+      rangeRef.current = null;
+      textRef.current = "";
+      setSelectionAction(null);
+    };
+    const syncPosition = () => {
+      const range = rangeRef.current;
+      if (!range) {
+        return;
+      }
+      const container = getPortalContainer(range);
+      if (!container) {
+        clearSelectionAction();
+        return;
+      }
+      const position = positionFromRange(range, container);
+      if (!position) {
+        clearSelectionAction();
+        return;
+      }
+      setSelectionAction({
+        text: textRef.current,
+        top: position.top,
+        left: position.left,
+        container
+      });
+    };
+    const captureSelection = () => {
+      const next = readSelection();
+      if (!next) {
+        clearSelectionAction();
+        return;
+      }
+      rangeRef.current = next.range;
+      textRef.current = next.text;
+      syncPosition();
+    };
+    document.addEventListener("mouseup", captureSelection);
+    document.addEventListener("keyup", captureSelection);
+    document.addEventListener("selectionchange", captureSelection);
+    window.addEventListener("scroll", syncPosition, true);
+    window.addEventListener("resize", syncPosition);
+    return () => {
+      document.removeEventListener("mouseup", captureSelection);
+      document.removeEventListener("keyup", captureSelection);
+      document.removeEventListener("selectionchange", captureSelection);
+      window.removeEventListener("scroll", syncPosition, true);
+      window.removeEventListener("resize", syncPosition);
+    };
+  }, [onAddReference]);
+  if (!selectionAction) {
+    return null;
+  }
+  return createPortal(
+    /* @__PURE__ */ jsx2(
+      "button",
+      {
+        type: "button",
+        className: "chat-reference-action",
+        style: { top: selectionAction.top, left: selectionAction.left },
+        "aria-label": "Add selected text as reference",
+        onPointerDown: (event) => event.preventDefault(),
+        onClick: () => {
+          var _a;
+          onAddReference(selectionAction.text);
+          (_a = window.getSelection()) == null ? void 0 : _a.removeAllRanges();
+          rangeRef.current = null;
+          textRef.current = "";
+          setSelectionAction(null);
+        },
+        children: "Add reference"
+      }
+    ),
+    selectionAction.container
+  );
+});
+
+// src/components/Chat/context/message.helpers.ts
+var normalizeReferenceText = (text) => text.replace(/\s+/g, " ").trim().slice(0, 4e3);
+var createMessageId = (prefix) => {
+  var _a, _b, _c;
+  return (_c = (_b = (_a = globalThis.crypto) == null ? void 0 : _a.randomUUID) == null ? void 0 : _b.call(_a)) != null ? _c : `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+};
+var createUserMessage = (text, files = []) => ({
+  id: createMessageId("msg"),
+  role: "user",
+  parts: [
+    ...files.map((file) => ({
+      type: "file",
+      mediaType: file.mediaType,
+      url: file.url,
+      filename: file.filename
+    })),
+    ...text ? [{ type: "text", text }] : []
+  ]
+});
+var updateMessageText = (message, text) => ({
+  ...message,
+  parts: [{ type: "text", text }]
+});
+var upsertAssistantMessage = (current, nextMessage) => {
+  const existingIndex = current.findIndex((message) => message.id === nextMessage.id);
+  if (existingIndex === -1) {
+    return [...current, nextMessage];
+  }
+  return current.map((message, index) => index === existingIndex ? nextMessage : message);
+};
+
+// src/components/Chat/context/messages.context.tsx
+import {
+  createContext as createContext3,
+  useCallback as useCallback3,
+  useContext as useContext3,
+  useEffect as useEffect4,
+  useMemo as useMemo3,
+  useRef as useRef4,
+  useState as useState4
+} from "react";
+import { flushSync } from "react-dom";
+
+// src/components/Chat/context/model.context.tsx
+import {
+  createContext,
+  useCallback,
+  useContext,
+  useEffect as useEffect2,
+  useMemo,
+  useRef as useRef2,
+  useState as useState2
+} from "react";
+
+// src/components/Chat/context/types.ts
+var ProviderId = /* @__PURE__ */ ((ProviderId2) => {
+  ProviderId2["SYMPHONY"] = "symphony";
+  ProviderId2["MOCK"] = "mock";
+  ProviderId2["OPENAI"] = "openai";
+  ProviderId2["GOOGLE"] = "google";
+  ProviderId2["GEMINI"] = "gemini";
+  ProviderId2["CLAUDE"] = "anthropic";
+  ProviderId2["GROK"] = "grok";
+  ProviderId2["OLLAMA"] = "ollama";
+  ProviderId2["LOCAL"] = "local";
+  return ProviderId2;
+})(ProviderId || {});
+var PROVIDER_IDS = new Set(Object.values(ProviderId));
+var isProviderId = (value) => typeof value === "string" && PROVIDER_IDS.has(value);
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isRegistryModel = (value) => {
+  if (!isRecord(value) || typeof value.id !== "string" || typeof value.label !== "string") {
+    return false;
+  }
+  if (value.description !== void 0 && typeof value.description !== "string") {
+    return false;
+  }
+  if (value.thinkingLevels !== void 0 && (!Array.isArray(value.thinkingLevels) || !value.thinkingLevels.every((level) => typeof level === "string"))) {
+    return false;
+  }
+  return true;
+};
+var isRegistryProvider = (value) => isRecord(value) && typeof value.id === "string" && typeof value.label === "string" && typeof value.defaultModel === "string" && Array.isArray(value.models) && value.models.every(isRegistryModel) && (value.name === void 0 || typeof value.name === "string") && (value.logo === void 0 || typeof value.logo === "string");
+var parseRegistryConfig = (value) => {
+  if (!isRecord(value) || typeof value.defaultProviderId !== "string" || !Array.isArray(value.providers)) {
+    return void 0;
+  }
+  const providers = value.providers.filter(isRegistryProvider);
+  if (providers.length === 0) {
+    return void 0;
+  }
+  return {
+    defaultProviderId: value.defaultProviderId,
+    providers
+  };
+};
+var defaultRegistry = {
+  defaultProviderId: "mock" /* MOCK */,
+  providers: [
+    {
+      id: "symphony" /* SYMPHONY */,
+      label: "Symphony (custom harness)",
+      defaultModel: "",
+      models: []
+    },
+    {
+      id: "mock" /* MOCK */,
+      label: "Mock",
+      defaultModel: "canned",
+      models: [{ id: "canned", label: "Canned replies" }]
+    },
+    {
+      id: "openai" /* OPENAI */,
+      label: "OpenAI",
+      defaultModel: "gpt-4.1",
+      models: [{ id: "gpt-4.1", label: "GPT-4.1" }]
+    },
+    {
+      id: "anthropic" /* CLAUDE */,
+      label: "Anthropic",
+      defaultModel: "claude-3-7-sonnet-20250219",
+      models: [{ id: "claude-3-7-sonnet-20250219", label: "Claude 3.7 Sonnet" }]
+    },
+    {
+      id: "google" /* GOOGLE */,
+      label: "Google",
+      defaultModel: "gemini-2.5-flash",
+      models: [{ id: "gemini-2.5-flash", label: "Gemini 2.5 Flash" }]
+    },
+    {
+      id: "ollama" /* OLLAMA */,
+      label: "Ollama",
+      defaultModel: "smallthinker:latest",
+      models: [{ id: "smallthinker:latest", label: "smallthinker:latest" }]
+    }
+  ]
+};
+
+// src/components/Chat/context/model.context.tsx
+import { jsx as jsx3 } from "react/jsx-runtime";
+var ModelContext = createContext(null);
+function ModelProvider({
+  children,
+  defaultProvider = "mock" /* MOCK */,
+  registryUrl = "/api/ai/registry"
+}) {
+  const [registry, setRegistry] = useState2(defaultRegistry);
+  const [provider, setProviderState] = useState2(defaultProvider);
+  const [model, setModelState] = useState2(
+    () => {
+      var _a, _b;
+      return (_b = (_a = defaultRegistry.providers.find((entry) => entry.id === defaultProvider)) == null ? void 0 : _a.defaultModel) != null ? _b : "";
+    }
+  );
+  const [thinkingLevels, setThinkingLevelsState] = useState2(() => {
+    const initial = {};
+    for (const p of defaultRegistry.providers) {
+      for (const m of p.models) {
+        const levels = m.thinkingLevels;
+        if (levels == null ? void 0 : levels.length) initial[`${p.id}::${m.id}`] = levels.includes("medium") ? "medium" : levels[0];
+      }
+    }
+    return initial;
+  });
+  const providerRef = useRef2(provider);
+  const modelRef = useRef2(model);
+  const thinkingLevelsRef = useRef2(thinkingLevels);
+  providerRef.current = provider;
+  modelRef.current = model;
+  thinkingLevelsRef.current = thinkingLevels;
+  useEffect2(() => {
+    let cancelled = false;
+    const loadRegistry = async () => {
+      var _a;
+      try {
+        const response = await fetch(registryUrl, { cache: "no-store" });
+        if (!response.ok) {
+          throw new Error("Failed to load registry");
+        }
+        const data = parseRegistryConfig(await response.json());
+        if (cancelled || !data) {
+          return;
+        }
+        setRegistry(data);
+        const nextThinking = {};
+        for (const p of data.providers) {
+          for (const m of p.models) {
+            const levels = m.thinkingLevels;
+            if (levels == null ? void 0 : levels.length) nextThinking[`${p.id}::${m.id}`] = levels.includes("medium") ? "medium" : levels[0];
+          }
+        }
+        setThinkingLevelsState((prev) => ({ ...nextThinking, ...prev }));
+        const preferred = (_a = data.providers.find((entry) => entry.id === data.defaultProviderId)) != null ? _a : data.providers[0];
+        if (preferred) {
+          setProviderState(preferred.id);
+          setModelState(preferred.defaultModel);
+        }
+      } catch {
+        if (!cancelled) {
+          setRegistry(defaultRegistry);
+        }
+      }
+    };
+    void loadRegistry();
+    return () => {
+      cancelled = true;
+    };
+  }, [registryUrl]);
+  useEffect2(() => {
+    var _a, _b;
+    const nextProvider = (_b = (_a = registry.providers.find((entry) => entry.id === provider)) != null ? _a : registry.providers.find((entry) => entry.id === registry.defaultProviderId)) != null ? _b : registry.providers[0];
+    if (!nextProvider) {
+      return;
+    }
+    const hasModel = nextProvider.models.some((entry) => entry.id === model);
+    if (!hasModel) {
+      setProviderState(nextProvider.id);
+      setModelState(nextProvider.defaultModel);
+    }
+  }, [model, provider, registry]);
+  const setProvider = useCallback((nextProvider, nextModel) => {
+    setProviderState(nextProvider);
+    if (nextModel) {
+      setModelState(nextModel);
+    }
+  }, []);
+  const getThinkingLevel = useCallback(
+    (providerId, modelId) => thinkingLevels[`${providerId}::${modelId}`],
+    [thinkingLevels]
+  );
+  const setThinkingLevel = useCallback((providerId, modelId, level) => {
+    setThinkingLevelsState((prev) => ({ ...prev, [`${providerId}::${modelId}`]: level }));
+  }, []);
+  const setModel = useCallback((nextModel) => {
+    setModelState(nextModel);
+  }, []);
+  const value = useMemo(
+    () => ({
+      registry,
+      provider,
+      model,
+      thinkingLevels,
+      getThinkingLevel,
+      setThinkingLevel,
+      setProvider,
+      setModel,
+      providerRef,
+      modelRef,
+      thinkingLevelsRef
+    }),
+    [model, provider, registry, setModel, setProvider, thinkingLevels, getThinkingLevel, setThinkingLevel]
+  );
+  return /* @__PURE__ */ jsx3(ModelContext.Provider, { value, children });
+}
+function useModel() {
+  const context = useContext(ModelContext);
+  if (!context) {
+    throw new Error("useModel must be used inside ModelProvider");
+  }
+  return context;
+}
+
+// src/components/Chat/context/thread.context.tsx
+import {
+  createContext as createContext2,
+  useCallback as useCallback2,
+  useContext as useContext2,
+  useEffect as useEffect3,
+  useMemo as useMemo2,
+  useRef as useRef3,
+  useState as useState3
+} from "react";
+import { jsx as jsx4 } from "react/jsx-runtime";
+var ThreadContext = createContext2(null);
+function ThreadProvider({
+  adapter,
+  children,
+  defaultThreadId
+}) {
+  const [threads, setThreads] = useState3([]);
+  const [activeThreadId, setActiveThreadId] = useState3(defaultThreadId != null ? defaultThreadId : null);
+  const [isLoadingThread, setIsLoadingThread] = useState3(true);
+  const activeThreadIdRef = useRef3(activeThreadId);
+  activeThreadIdRef.current = activeThreadId;
+  const adapterRef = useRef3(adapter);
+  adapterRef.current = adapter;
+  useEffect3(() => {
+    let cancelled = false;
+    const bootstrap = async () => {
+      setIsLoadingThread(true);
+      if (defaultThreadId) {
+        setThreads(
+          (current) => current.some((thread2) => thread2.id === defaultThreadId) ? current : [{ id: defaultThreadId, title: "New chat" }, ...current]
+        );
+        setActiveThreadId(defaultThreadId);
+        setIsLoadingThread(false);
+        return;
+      }
+      const currentAdapter = adapterRef.current;
+      if (!currentAdapter.listThreads || !currentAdapter.createThread) {
+        const localThread = { id: createMessageId("thread"), title: "New chat" };
+        setThreads([localThread]);
+        setActiveThreadId(localThread.id);
+        setIsLoadingThread(false);
+        return;
+      }
+      const nextThreads = await currentAdapter.listThreads();
+      if (cancelled) {
+        return;
+      }
+      if (nextThreads.length > 0) {
+        setThreads(nextThreads);
+        setActiveThreadId(nextThreads[0].id);
+        setIsLoadingThread(false);
+        return;
+      }
+      const thread = await currentAdapter.createThread();
+      if (cancelled) {
+        return;
+      }
+      setThreads([thread]);
+      setActiveThreadId(thread.id);
+      setIsLoadingThread(false);
+    };
+    bootstrap().catch(() => {
+      if (!cancelled) {
+        setIsLoadingThread(false);
+      }
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [defaultThreadId]);
+  const selectThread = useCallback2(async (threadId) => {
+    setActiveThreadId((current) => current === threadId ? current : threadId);
+  }, []);
+  const createThread = useCallback2(async () => {
+    const currentAdapter = adapterRef.current;
+    const thread = currentAdapter.createThread ? await currentAdapter.createThread() : { id: createMessageId("thread"), title: "New chat" };
+    setThreads((current) => [thread, ...current]);
+    setActiveThreadId(thread.id);
+  }, []);
+  const deleteThread = useCallback2(
+    async (threadId) => {
+      var _a, _b;
+      await ((_b = (_a = adapterRef.current).deleteThread) == null ? void 0 : _b.call(_a, threadId));
+      setThreads((current) => {
+        const remaining = current.filter((thread) => thread.id !== threadId);
+        setActiveThreadId((active) => {
+          var _a2, _b2;
+          if (active !== threadId) {
+            return active;
+          }
+          const nextActive = (_b2 = (_a2 = remaining[0]) == null ? void 0 : _a2.id) != null ? _b2 : null;
+          if (!nextActive) {
+            void createThread();
+          }
+          return nextActive;
+        });
+        return remaining;
+      });
+    },
+    [createThread]
+  );
+  const value = useMemo2(
+    () => ({
+      threads,
+      activeThreadId,
+      isLoadingThread,
+      activeThreadIdRef,
+      setThreads,
+      setIsLoadingThread,
+      selectThread,
+      createThread,
+      deleteThread
+    }),
+    [
+      activeThreadId,
+      createThread,
+      deleteThread,
+      isLoadingThread,
+      selectThread,
+      threads
+    ]
+  );
+  return /* @__PURE__ */ jsx4(ThreadContext.Provider, { value, children });
+}
+function useThread() {
+  const context = useContext2(ThreadContext);
+  if (!context) {
+    throw new Error("useThread must be used inside ThreadProvider");
+  }
+  return context;
+}
+
+// src/components/Chat/context/messages.context.tsx
+import { jsx as jsx5 } from "react/jsx-runtime";
+var MINIMUM_RESPONSE_LOADING_MS = 350;
+var wait = (milliseconds) => new Promise((resolve) => window.setTimeout(resolve, milliseconds));
+var hasVisibleAssistantContent = (message) => message.parts.some((part) => {
+  if (part.type === "text") {
+    return "text" in part && typeof part.text === "string" && part.text.trim().length > 0;
+  }
+  if (part.type === "data") {
+    return "name" in part && part.name !== "usage" && part.name !== "context" && part.name !== "context-warning";
+  }
+  return ["reasoning", "tool", "widget", "source-url", "source-document", "file", "unknown"].includes(part.type);
+});
+var MessagesContext = createContext3(null);
+function MessagesProvider({ adapter, children }) {
+  const { activeThreadId, activeThreadIdRef, setThreads, setIsLoadingThread } = useThread();
+  const { providerRef, modelRef, thinkingLevelsRef } = useModel();
+  const [messages, setMessages] = useState4([]);
+  const [status, setStatus] = useState4("ready");
+  const [isWaitingForResponse, setIsWaitingForResponse] = useState4(false);
+  const messagesRef = useRef4(messages);
+  const statusRef = useRef4(status);
+  const adapterRef = useRef4(adapter);
+  const abortRef = useRef4(null);
+  messagesRef.current = messages;
+  statusRef.current = status;
+  adapterRef.current = adapter;
+  useEffect4(() => {
+    let cancelled = false;
+    const loadMessages = async () => {
+      if (!activeThreadId) {
+        setMessages([]);
+        setIsLoadingThread(false);
+        return;
+      }
+      const currentAdapter = adapterRef.current;
+      if (!currentAdapter.loadMessages) {
+        setIsLoadingThread(false);
+        return;
+      }
+      setIsLoadingThread(true);
+      try {
+        const nextMessages = await currentAdapter.loadMessages(activeThreadId);
+        if (cancelled) {
+          return;
+        }
+        setMessages(nextMessages);
+        setIsLoadingThread(false);
+      } catch {
+        if (!cancelled) {
+          setMessages([]);
+          setIsLoadingThread(false);
+          setStatus("error");
+        }
+      }
+    };
+    void loadMessages();
+    return () => {
+      cancelled = true;
+    };
+  }, [activeThreadId, setIsLoadingThread]);
+  const streamMessage = useCallback3(
+    async ({
+      message,
+      nextMessages,
+      provider,
+      model,
+      thinkingLevel
+    }) => {
+      var _a;
+      const threadId = activeThreadIdRef.current;
+      if (!threadId) {
+        setIsWaitingForResponse(false);
+        return;
+      }
+      (_a = abortRef.current) == null ? void 0 : _a.abort();
+      const abortController = new AbortController();
+      abortRef.current = abortController;
+      setStatus("submitted");
+      const responseStartedAt = Date.now();
+      let receivedVisibleResponse = false;
+      try {
+        for await (const assistantMessage of adapterRef.current.sendMessage({
+          threadId,
+          message,
+          messages: nextMessages,
+          provider,
+          model,
+          thinkingLevel,
+          signal: abortController.signal
+        })) {
+          if (!receivedVisibleResponse && hasVisibleAssistantContent(assistantMessage)) {
+            receivedVisibleResponse = true;
+            const remaining = MINIMUM_RESPONSE_LOADING_MS - (Date.now() - responseStartedAt);
+            if (remaining > 0) {
+              await wait(remaining);
+            }
+            if (abortController.signal.aborted) {
+              setIsWaitingForResponse(false);
+              setStatus("ready");
+              return;
+            }
+          }
+          if (receivedVisibleResponse) {
+            setIsWaitingForResponse(false);
+            setStatus("streaming");
+          }
+          setMessages((current) => upsertAssistantMessage(current, assistantMessage));
+        }
+        setStatus("ready");
+      } catch (error) {
+        setIsWaitingForResponse(false);
+        if (abortController.signal.aborted) {
+          setStatus("ready");
+          return;
+        }
+        setStatus("error");
+        throw error;
+      } finally {
+        setIsWaitingForResponse(false);
+        if (abortRef.current === abortController) {
+          abortRef.current = null;
+        }
+      }
+    },
+    [activeThreadIdRef]
+  );
+  const sendMessage = useCallback3(
+    async (message, options) => {
+      var _a, _b, _c, _d, _e;
+      const text = message.text.trim();
+      const files = (_a = message.files) != null ? _a : [];
+      const threadId = activeThreadIdRef.current;
+      if (!text && files.length === 0 || !threadId) {
+        return;
+      }
+      const userMessage = createUserMessage(text, files);
+      const nextMessages = [...messagesRef.current, userMessage];
+      flushSync(() => {
+        setMessages(nextMessages);
+        setIsWaitingForResponse(true);
+      });
+      const resolvedProvider = (_c = (_b = options == null ? void 0 : options.body) == null ? void 0 : _b.provider) != null ? _c : providerRef.current;
+      const resolvedModel = (_e = (_d = options == null ? void 0 : options.body) == null ? void 0 : _d.model) != null ? _e : modelRef.current;
+      const thinkingLevel = thinkingLevelsRef.current[`${resolvedProvider}::${resolvedModel}`];
+      await streamMessage({
+        message: userMessage,
+        nextMessages,
+        provider: resolvedProvider,
+        model: resolvedModel,
+        thinkingLevel
+      });
+    },
+    [activeThreadIdRef, modelRef, providerRef, streamMessage]
+  );
+  const editAndResendMessage = useCallback3(
+    async (messageId, text) => {
+      var _a;
+      const trimmedText = text.trim();
+      const threadId = activeThreadIdRef.current;
+      const isSending2 = statusRef.current === "submitted" || statusRef.current === "streaming";
+      if (!trimmedText || !threadId || isSending2) {
+        return;
+      }
+      const previousMessages = messagesRef.current;
+      const messageIndex = previousMessages.findIndex((message2) => message2.id === messageId);
+      const message = previousMessages[messageIndex];
+      if (!message || message.role !== "user") {
+        return;
+      }
+      let editedMessages = previousMessages.slice(0, messageIndex + 1).map(
+        (currentMessage) => currentMessage.id === messageId ? updateMessageText(currentMessage, trimmedText) : currentMessage
+      );
+      setThreads((current) => {
+        const firstUserMessage = editedMessages.find(
+          (currentMessage) => currentMessage.role === "user"
+        );
+        const firstUserTitle = firstUserMessage ? getUserDisplayText(firstUserMessage).trim().slice(0, 60) : "";
+        return current.map(
+          (thread) => thread.id === threadId && firstUserTitle ? { ...thread, title: firstUserTitle } : thread
+        );
+      });
+      try {
+        if (adapterRef.current.editMessage) {
+          editedMessages = await adapterRef.current.editMessage({
+            threadId,
+            messageId,
+            text: trimmedText
+          });
+        }
+        const editedMessage = (_a = editedMessages.find((currentMessage) => currentMessage.id === messageId)) != null ? _a : updateMessageText(message, trimmedText);
+        setMessages(editedMessages);
+        setIsWaitingForResponse(true);
+        const thinkingLevel = thinkingLevelsRef.current[`${providerRef.current}::${modelRef.current}`];
+        await streamMessage({
+          message: editedMessage,
+          nextMessages: editedMessages,
+          provider: providerRef.current,
+          model: modelRef.current,
+          thinkingLevel
+        });
+      } catch (error) {
+        setIsWaitingForResponse(false);
+        setMessages(previousMessages);
+        throw error;
+      }
+    },
+    [activeThreadIdRef, modelRef, providerRef, setThreads, streamMessage]
+  );
+  const stopResponse = useCallback3(() => {
+    var _a;
+    const isSending2 = statusRef.current === "submitted" || statusRef.current === "streaming";
+    if (!isSending2) {
+      return;
+    }
+    (_a = abortRef.current) == null ? void 0 : _a.abort();
+    setIsWaitingForResponse(false);
+    setStatus("ready");
+  }, []);
+  const isSending = status === "submitted" || status === "streaming";
+  const value = useMemo3(
+    () => ({
+      messages,
+      status,
+      isSending,
+      isWaitingForResponse,
+      sendMessage,
+      editAndResendMessage,
+      stopResponse
+    }),
+    [editAndResendMessage, isSending, isWaitingForResponse, messages, sendMessage, status, stopResponse]
+  );
+  return /* @__PURE__ */ jsx5(MessagesContext.Provider, { value, children });
+}
+function useMessages() {
+  const context = useContext3(MessagesContext);
+  if (!context) {
+    throw new Error("useMessages must be used inside MessagesProvider");
+  }
+  return context;
+}
+
+// src/components/Chat/context/composer.context.tsx
+import { jsx as jsx6, jsxs } from "react/jsx-runtime";
+var readFileAsDataUrl = (file) => new Promise((resolve, reject) => {
+  const reader = new FileReader();
+  reader.onload = () => {
+    if (typeof reader.result === "string") {
+      resolve(reader.result);
+      return;
+    }
+    reject(new Error("Could not read file"));
+  };
+  reader.onerror = () => {
+    var _a;
+    reject((_a = reader.error) != null ? _a : new Error("Could not read file"));
+  };
+  reader.readAsDataURL(file);
+});
+var ComposerContext = createContext4(null);
+function ComposerProvider({ children }) {
+  const { activeThreadId, activeThreadIdRef, isLoadingThread, setThreads } = useThread();
+  const { providerRef, modelRef } = useModel();
+  const { sendMessage, isSending } = useMessages();
+  const [input, setInputState] = useState5("");
+  const [references, setReferences] = useState5([]);
+  const [attachments, setAttachments] = useState5([]);
+  const inputRef = useRef5(input);
+  const referencesRef = useRef5(references);
+  const attachmentsRef = useRef5(attachments);
+  inputRef.current = input;
+  referencesRef.current = references;
+  attachmentsRef.current = attachments;
+  const setInput = useCallback4((value2) => {
+    setInputState(value2);
+  }, []);
+  const addReference = useCallback4((text) => {
+    const normalized = normalizeReferenceText(text);
+    if (!normalized) {
+      return;
+    }
+    setReferences((current) => {
+      if (current.some((reference) => reference.text === normalized)) {
+        return current;
+      }
+      return [
+        ...current,
+        {
+          id: createMessageId("ref"),
+          text: normalized
+        }
+      ];
+    });
+  }, []);
+  const removeReference = useCallback4((id) => {
+    setReferences((current) => current.filter((reference) => reference.id !== id));
+  }, []);
+  const clearReferences = useCallback4(() => {
+    setReferences([]);
+  }, []);
+  const addFiles = useCallback4(async (list) => {
+    const incoming = Array.from(list);
+    const next = [];
+    for (const file of incoming) {
+      try {
+        const url = await readFileAsDataUrl(file);
+        next.push({
+          id: createMessageId("file"),
+          filename: file.name || "file",
+          mediaType: file.type || "application/octet-stream",
+          url
+        });
+      } catch {
+      }
+    }
+    if (next.length === 0) {
+      return;
+    }
+    setAttachments((current) => [...current, ...next]);
+  }, []);
+  const removeAttachment = useCallback4((id) => {
+    setAttachments((current) => current.filter((attachment) => attachment.id !== id));
+  }, []);
+  const disabled = isSending || isLoadingThread || !activeThreadId;
+  const canSend = !disabled && (!!input.trim() || attachments.length > 0);
+  const disabledRef = useRef5(disabled);
+  disabledRef.current = disabled;
+  const submitInput = useCallback4(async () => {
+    var _a;
+    const text = inputRef.current.trim();
+    const threadId = activeThreadIdRef.current;
+    const attachmentsSnapshot = attachmentsRef.current;
+    if (!text && attachmentsSnapshot.length === 0 || !threadId || disabledRef.current) {
+      return;
+    }
+    const nextTitle = (text || ((_a = attachmentsSnapshot[0]) == null ? void 0 : _a.filename) || "").slice(0, 60);
+    const referencesSnapshot = referencesRef.current;
+    const referenceText = referencesSnapshot.map(
+      (reference, index) => `<reference ${index + 1}>
+${reference.text}
+</reference ${index + 1}>`
+    ).join("\n\n");
+    const messageText = referenceText ? `Use the following selected references as context:
+
+${referenceText}
+
+User message:
+${text}` : text;
+    setInputState("");
+    setReferences([]);
+    setAttachments([]);
+    setThreads((current) => {
+      const next = current.map(
+        (thread) => thread.id === threadId && thread.title === "New chat" ? { ...thread, title: nextTitle || thread.title } : thread
+      );
+      const selected = next.find((thread) => thread.id === threadId);
+      const remaining = next.filter((thread) => thread.id !== threadId);
+      return selected ? [selected, ...remaining] : next;
+    });
+    try {
+      await sendMessage(
+        {
+          text: messageText,
+          files: attachmentsSnapshot.map((file) => ({
+            mediaType: file.mediaType,
+            url: file.url,
+            filename: file.filename
+          }))
+        },
+        {
+          body: {
+            provider: providerRef.current,
+            model: modelRef.current
+          }
+        }
+      );
+    } catch (error) {
+      setInputState(text);
+      setReferences(referencesSnapshot);
+      setAttachments(attachmentsSnapshot);
+      throw error;
+    }
+  }, [activeThreadIdRef, modelRef, providerRef, sendMessage, setThreads]);
+  const value = useMemo4(
+    () => ({
+      input,
+      setInput,
+      references,
+      addReference,
+      removeReference,
+      clearReferences,
+      attachments,
+      addFiles,
+      removeAttachment,
+      disabled,
+      canSend,
+      submitInput
+    }),
+    [
+      addReference,
+      canSend,
+      clearReferences,
+      disabled,
+      input,
+      addFiles,
+      attachments,
+      references,
+      removeAttachment,
+      removeReference,
+      setInput,
+      submitInput
+    ]
+  );
+  return /* @__PURE__ */ jsxs(ComposerContext.Provider, { value, children: [
+    children,
+    /* @__PURE__ */ jsx6(ChatTooltip, { onAddReference: addReference })
+  ] });
+}
+function useComposer() {
+  const context = useContext4(ComposerContext);
+  if (!context) {
+    throw new Error("useComposer must be used inside ComposerProvider");
+  }
+  return context;
+}
+
+// src/components/Chat/context/chat.provider.tsx
+import { jsx as jsx7 } from "react/jsx-runtime";
+function ChatContextProvider({
+  adapter,
+  children,
+  defaultProvider = "mock" /* MOCK */,
+  defaultThreadId,
+  registryUrl = "/api/ai/registry"
+}) {
+  return /* @__PURE__ */ jsx7(ModelProvider, { defaultProvider, registryUrl, children: /* @__PURE__ */ jsx7(ThreadProvider, { adapter, defaultThreadId, children: /* @__PURE__ */ jsx7(MessagesProvider, { adapter, children: /* @__PURE__ */ jsx7(ComposerProvider, { children }) }) }) });
+}
+
+// src/components/Chat/context/index.ts
+function useChat() {
+  const composer = useComposer();
+  const messages = useMessages();
+  const model = useModel();
+  const thread = useThread();
+  return useMemo5(() => {
+    const dispatch = (action) => {
+      switch (action.type) {
+        case "setInput":
+          composer.setInput(action.data.input);
+          break;
+        case "setProvider":
+          model.setProvider(action.data.provider, action.data.model);
+          break;
+        case "setModel":
+          model.setModel(action.data.model);
+          break;
+        case "addReference":
+          composer.addReference(action.data.text);
+          break;
+        case "removeReference":
+          composer.removeReference(action.data.id);
+          break;
+        case "clearReferences":
+          composer.clearReferences();
+          break;
+        default:
+          break;
+      }
+    };
+    return {
+      state: {
+        input: composer.input,
+        provider: model.provider,
+        model: model.model,
+        references: composer.references,
+        disabled: composer.disabled,
+        sendDisabled: !composer.canSend
+      },
+      dispatch,
+      messages: messages.messages,
+      status: messages.status,
+      activeThreadId: thread.activeThreadId,
+      threads: thread.threads,
+      isLoadingThread: thread.isLoadingThread,
+      registry: model.registry,
+      sendMessage: messages.sendMessage,
+      submitInput: composer.submitInput,
+      editAndResendMessage: messages.editAndResendMessage,
+      stopResponse: messages.stopResponse,
+      selectThread: thread.selectThread,
+      createThread: thread.createThread,
+      deleteThread: thread.deleteThread
+    };
+  }, [composer, messages, model, thread]);
+}
+
+// src/components/Chat/chat.attachments.tsx
+import { Fragment, jsx as jsx8, jsxs as jsxs2 } from "react/jsx-runtime";
+var isImageMediaType = (mediaType) => mediaType.startsWith("image/");
+var ChatAttachments = () => {
+  const { attachments, removeAttachment } = useComposer();
+  if (attachments.length === 0) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx8("div", { className: "chat-attachments", children: attachments.map((attachment) => {
+    const image = isImageMediaType(attachment.mediaType);
+    return /* @__PURE__ */ jsxs2(
+      "div",
+      {
+        className: image ? "chat-attachment chat-attachment-image" : "chat-attachment chat-attachment-file",
+        children: [
+          image ? /* @__PURE__ */ jsx8("img", { src: attachment.url, alt: attachment.filename }) : /* @__PURE__ */ jsxs2(Fragment, { children: [
+            /* @__PURE__ */ jsx8(FileText, { size: 14, "aria-hidden": "true" }),
+            /* @__PURE__ */ jsx8("span", { className: "chat-attachment-name", children: attachment.filename })
+          ] }),
+          /* @__PURE__ */ jsx8(
+            "button",
+            {
+              type: "button",
+              className: "chat-attachment-remove",
+              "aria-label": `Remove ${attachment.filename}`,
+              onClick: () => removeAttachment(attachment.id),
+              children: /* @__PURE__ */ jsx8(X, { size: 12 })
+            }
+          )
+        ]
+      },
+      attachment.id
+    );
+  }) });
+};
+var ChatAttachButton = () => {
+  const { disabled, addFiles } = useComposer();
+  const inputRef = useRef6(null);
+  return /* @__PURE__ */ jsxs2(Fragment, { children: [
+    /* @__PURE__ */ jsx8(
+      "button",
+      {
+        type: "button",
+        className: "chat-attach",
+        "aria-label": "Add attachment",
+        disabled,
+        onClick: () => {
+          var _a;
+          return (_a = inputRef.current) == null ? void 0 : _a.click();
+        },
+        children: /* @__PURE__ */ jsx8(Paperclip, { size: 16 })
+      }
+    ),
+    /* @__PURE__ */ jsx8(
+      "input",
+      {
+        ref: inputRef,
+        className: "chat-attach-input",
+        type: "file",
+        multiple: true,
+        tabIndex: -1,
+        "aria-hidden": "true",
+        onChange: (event) => {
+          const files = event.currentTarget.files;
+          if (files && files.length > 0) {
+            void addFiles(files);
+          }
+          event.currentTarget.value = "";
+        }
+      }
+    )
+  ] });
+};
+
+// src/components/Chat/chat.input.tsx
+import { useEffect as useEffect5, useRef as useRef7 } from "react";
+import { jsx as jsx9 } from "react/jsx-runtime";
+var ChatInput = ({
+  placeholder = "Message...",
+  expanded = true
+}) => {
+  const { input, setInput, disabled, submitInput, attachments } = useComposer();
+  const ref = useRef7(null);
+  const hasDraft = input.trim().length > 0 || attachments.length > 0;
+  useEffect5(() => {
+    const el = ref.current;
+    if (!el) return;
+    if (!expanded) {
+      el.style.height = "";
+      el.style.overflowY = "hidden";
+      return;
+    }
+    el.style.height = "auto";
+    const shell = el.closest(".chat-composer-shell");
+    const isSmall = (shell == null ? void 0 : shell.dataset.variant) === "small";
+    const max = isSmall ? 128 : 320;
+    el.style.height = `${Math.min(el.scrollHeight, max)}px`;
+    el.style.overflowY = el.scrollHeight > max ? "auto" : "hidden";
+  }, [expanded, input]);
+  return /* @__PURE__ */ jsx9("div", { className: "chat-composer-input", children: /* @__PURE__ */ jsx9(
+    "textarea",
+    {
+      ref,
+      value: input,
+      onChange: (event) => {
+        const wrap = event.currentTarget.closest(`.${motion.inputWrap}`);
+        if (wrap) {
+          clearErrorShake(wrap);
+        }
+        setInput(event.target.value);
+      },
+      placeholder,
+      disabled,
+      rows: 1,
+      onKeyDown: (event) => {
+        if (event.key !== "Enter" || event.shiftKey) return;
+        if (event.nativeEvent.isComposing) return;
+        event.preventDefault();
+        if (disabled) {
+          return;
+        }
+        if (!hasDraft) {
+          const wrap = event.currentTarget.closest(`.${motion.inputWrap}`);
+          if (wrap) {
+            triggerErrorShake(wrap);
+          }
+          return;
+        }
+        void submitInput();
+      }
+    }
+  ) });
+};
+
+// src/components/Chat/chat.references.tsx
+import { X as X2 } from "lucide-react";
+import { jsx as jsx10, jsxs as jsxs3 } from "react/jsx-runtime";
+var ChatReferences = () => {
+  const { references, removeReference } = useComposer();
+  if (references.length === 0) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx10("div", { className: "chat-references", children: references.map((reference, index) => /* @__PURE__ */ jsxs3("div", { className: "chat-reference", title: reference.text, children: [
+    /* @__PURE__ */ jsx10("span", { className: "chat-reference-text", children: reference.text }),
+    /* @__PURE__ */ jsx10(
+      "button",
+      {
+        type: "button",
+        className: "chat-icon-button",
+        "aria-label": `Remove reference ${index + 1}`,
+        onClick: () => removeReference(reference.id),
+        children: /* @__PURE__ */ jsx10(X2, { size: 12 })
+      }
+    )
+  ] }, reference.id)) });
+};
+
+// src/components/Chat/chat.send.tsx
+import { Send, Square } from "lucide-react";
+import { jsx as jsx11 } from "react/jsx-runtime";
+var ChatSend = () => {
+  const { canSend, submitInput } = useComposer();
+  const { status, stopResponse, isSending } = useMessages();
+  return /* @__PURE__ */ jsx11(
+    "button",
+    {
+      className: "chat-send",
+      type: "button",
+      "data-state": isSending ? "stop" : "send",
+      onClick: isSending ? stopResponse : submitInput,
+      disabled: isSending ? false : !canSend,
+      "aria-label": isSending ? "Stop response" : "Send message",
+      children: isSending ? /* @__PURE__ */ jsx11(Square, { size: 14, fill: "currentColor" }) : /* @__PURE__ */ jsx11(Send, { size: 16 })
+    }
+  );
+};
+
+// src/components/Chat/chat.select.tsx
+import { Fragment as Fragment2, useCallback as useCallback5, useMemo as useMemo6, useRef as useRef8, useState as useState6 } from "react";
+
+// src/ui/select.tsx
+import { CheckIcon, ChevronDownIcon, ChevronUpIcon } from "lucide-react";
+import { Select as SelectPrimitive } from "radix-ui";
+import { jsx as jsx12, jsxs as jsxs4 } from "react/jsx-runtime";
+function Select({
+  ...props
+}) {
+  return /* @__PURE__ */ jsx12(SelectPrimitive.Root, { "data-slot": "select", ...props });
+}
+function SelectGroup({
+  ...props
+}) {
+  return /* @__PURE__ */ jsx12(SelectPrimitive.Group, { "data-slot": "select-group", ...props });
+}
+function SelectTrigger({
+  className,
+  size = "default",
+  children,
+  ...props
+}) {
+  return /* @__PURE__ */ jsxs4(
+    SelectPrimitive.Trigger,
+    {
+      "data-slot": "select-trigger",
+      "data-size": size,
+      className: cn(
+        "border-input data-[placeholder]:text-muted-foreground [&_svg:not([class*='text-'])]:text-muted-foreground focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive dark:bg-input/30 dark:hover:bg-input/50 flex w-fit items-center justify-between gap-2 rounded-md border bg-transparent px-3 py-2 text-sm whitespace-nowrap shadow-xs transition-[color,box-shadow] outline-none focus-visible:ring-[3px] disabled:cursor-not-allowed disabled:opacity-50 data-[size=default]:h-9 data-[size=sm]:h-8 *:data-[slot=select-value]:line-clamp-1 *:data-[slot=select-value]:flex *:data-[slot=select-value]:items-center *:data-[slot=select-value]:gap-2 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+        className
+      ),
+      ...props,
+      children: [
+        children,
+        /* @__PURE__ */ jsx12(SelectPrimitive.Icon, { asChild: true, children: /* @__PURE__ */ jsx12(ChevronDownIcon, { className: "size-4 opacity-50" }) })
+      ]
+    }
+  );
+}
+function SelectContent({
+  className,
+  children,
+  portalContainer,
+  position = "item-aligned",
+  align = "center",
+  ...props
+}) {
+  return /* @__PURE__ */ jsx12(SelectPrimitive.Portal, { container: portalContainer, children: /* @__PURE__ */ jsxs4(
+    SelectPrimitive.Content,
+    {
+      "data-slot": "select-content",
+      className: cn(
+        "bg-popover text-popover-foreground relative z-50 max-h-(--radix-select-content-available-height) min-w-[8rem] overflow-x-hidden overflow-y-auto rounded-md border shadow-md",
+        position === "popper" && "data-[side=bottom]:translate-y-1 data-[side=left]:-translate-x-1 data-[side=right]:translate-x-1 data-[side=top]:-translate-y-1",
+        className
+      ),
+      position,
+      align,
+      ...props,
+      children: [
+        /* @__PURE__ */ jsx12(SelectScrollUpButton, {}),
+        /* @__PURE__ */ jsx12(
+          SelectPrimitive.Viewport,
+          {
+            "data-slot": "select-viewport",
+            className: cn(
+              "p-1",
+              position === "popper" && "h-[var(--radix-select-trigger-height)] w-full min-w-[var(--radix-select-trigger-width)] scroll-my-1"
+            ),
+            children
+          }
+        ),
+        /* @__PURE__ */ jsx12(SelectScrollDownButton, {})
+      ]
+    }
+  ) });
+}
+function SelectLabel({
+  className,
+  ...props
+}) {
+  return /* @__PURE__ */ jsx12(
+    SelectPrimitive.Label,
+    {
+      "data-slot": "select-label",
+      className: cn("text-muted-foreground px-2 py-1.5 text-xs", className),
+      ...props
+    }
+  );
+}
+function SelectItem({
+  className,
+  children,
+  ...props
+}) {
+  return /* @__PURE__ */ jsxs4(
+    SelectPrimitive.Item,
+    {
+      "data-slot": "select-item",
+      className: cn(
+        "focus:bg-accent focus:text-accent-foreground [&_svg:not([class*='text-'])]:text-muted-foreground relative flex w-full cursor-default items-center gap-2 rounded-sm py-1.5 pr-8 pl-2 text-sm outline-hidden select-none data-[disabled]:pointer-events-none data-[disabled]:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4 *:[span]:last:flex *:[span]:last:items-center *:[span]:last:gap-2",
+        className
+      ),
+      ...props,
+      children: [
+        /* @__PURE__ */ jsx12(
+          "span",
+          {
+            "data-slot": "select-item-indicator",
+            className: "absolute right-2 flex size-3.5 items-center justify-center",
+            children: /* @__PURE__ */ jsx12(SelectPrimitive.ItemIndicator, { children: /* @__PURE__ */ jsx12(CheckIcon, { className: "size-4" }) })
+          }
+        ),
+        /* @__PURE__ */ jsx12(SelectPrimitive.ItemText, { children })
+      ]
+    }
+  );
+}
+function SelectScrollUpButton({
+  className,
+  ...props
+}) {
+  return /* @__PURE__ */ jsx12(
+    SelectPrimitive.ScrollUpButton,
+    {
+      "data-slot": "select-scroll-up-button",
+      className: cn(
+        "flex cursor-default items-center justify-center py-1",
+        className
+      ),
+      ...props,
+      children: /* @__PURE__ */ jsx12(ChevronUpIcon, { className: "size-4" })
+    }
+  );
+}
+function SelectScrollDownButton({
+  className,
+  ...props
+}) {
+  return /* @__PURE__ */ jsx12(
+    SelectPrimitive.ScrollDownButton,
+    {
+      "data-slot": "select-scroll-down-button",
+      className: cn(
+        "flex cursor-default items-center justify-center py-1",
+        className
+      ),
+      ...props,
+      children: /* @__PURE__ */ jsx12(ChevronDownIcon, { className: "size-4" })
+    }
+  );
+}
+
+// src/components/Chat/chat.select.tsx
+import { Check, Ellipsis } from "lucide-react";
+import { Fragment as Fragment3, jsx as jsx13, jsxs as jsxs5 } from "react/jsx-runtime";
+var SELECT_ORIGIN = "top-left";
+var THINKING_ORIGIN = "top-right";
+var ProviderBadge = ({ logo, name }) => {
+  if (logo) {
+    return /* @__PURE__ */ jsx13(
+      "img",
+      {
+        className: "chat-model-provider-logo",
+        src: logo,
+        alt: "",
+        "aria-hidden": "true"
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx13("span", { className: "chat-model-provider-logo chat-model-provider-fallback", "aria-hidden": "true", children: name.slice(0, 1) });
+};
+var ChatSelect = () => {
+  var _a, _b, _c;
+  const { provider, model, registry, setProvider, getThinkingLevel, setThinkingLevel } = useModel();
+  const { isSending } = useMessages();
+  const [portalContainer, setPortalContainer] = useState6(null);
+  const [query, setQuery] = useState6("");
+  const [thinkingOpen, setThinkingOpen] = useState6(null);
+  const [menuOpen, setMenuOpen] = useState6(false);
+  const rootRef = useRef8(null);
+  const menu = useDropdownPresence(menuOpen, rootRef);
+  const selectedValue = `${provider}::${model}`;
+  const selectedProvider = registry.providers.find((entry) => entry.id === provider);
+  const selectedModel = selectedProvider == null ? void 0 : selectedProvider.models.find((entry) => entry.id === model);
+  const providerName = (_b = (_a = selectedProvider == null ? void 0 : selectedProvider.name) != null ? _a : selectedProvider == null ? void 0 : selectedProvider.label) != null ? _b : provider;
+  const modelLabel = (_c = selectedModel == null ? void 0 : selectedModel.label) != null ? _c : model || "Loading models\u2026";
+  const filteredProviders = useMemo6(() => {
+    const q = query.trim().toLowerCase();
+    if (!q) return registry.providers;
+    return registry.providers.map((entry) => ({
+      ...entry,
+      models: entry.models.filter(
+        (item) => item.label.toLowerCase().includes(q) || item.id.toLowerCase().includes(q) || item.description && item.description.toLowerCase().includes(q) || entry.label.toLowerCase().includes(q)
+      )
+    })).filter((entry) => entry.models.length > 0);
+  }, [registry.providers, query]);
+  const setRootElement = useCallback5((node) => {
+    const found = node == null ? void 0 : node.closest(".chat-root");
+    rootRef.current = found instanceof HTMLElement ? found : null;
+    setPortalContainer(found instanceof HTMLElement ? found : null);
+  }, []);
+  return /* @__PURE__ */ jsx13("div", { ref: setRootElement, children: /* @__PURE__ */ jsxs5(
+    Select,
+    {
+      open: menuOpen || menu.mounted,
+      onOpenChange: setMenuOpen,
+      value: selectedValue,
+      onValueChange: (value) => {
+        const separator = value.indexOf("::");
+        if (separator <= 0) {
+          return;
+        }
+        const nextProvider = value.slice(0, separator);
+        const nextModel = value.slice(separator + 2);
+        const match = registry.providers.find((entry) => entry.id === nextProvider);
+        if (!match || !nextModel) {
+          return;
+        }
+        setProvider(match.id, nextModel);
+      },
+      disabled: isSending,
+      children: [
+        /* @__PURE__ */ jsx13(SelectTrigger, { className: "chat-model-trigger", children: /* @__PURE__ */ jsxs5("span", { className: "chat-model-selected", children: [
+          selectedModel ? /* @__PURE__ */ jsx13(ProviderBadge, { logo: selectedProvider == null ? void 0 : selectedProvider.logo, name: providerName }) : null,
+          /* @__PURE__ */ jsx13("span", { children: modelLabel })
+        ] }) }),
+        /* @__PURE__ */ jsxs5(
+          SelectContent,
+          {
+            align: "start",
+            position: "popper",
+            sideOffset: 6,
+            collisionPadding: 12,
+            className: cn("chat-model-content", motion.dropdown, menu.className),
+            "data-origin": SELECT_ORIGIN,
+            portalContainer,
+            onCloseAutoFocus: (event) => {
+              event.preventDefault();
+              setQuery("");
+              setThinkingOpen(null);
+            },
+            onPointerDownOutside: () => setThinkingOpen(null),
+            children: [
+              /* @__PURE__ */ jsx13("div", { className: "chat-model-search", children: /* @__PURE__ */ jsx13(
+                "input",
+                {
+                  autoFocus: true,
+                  placeholder: "Search models",
+                  value: query,
+                  onChange: (event) => setQuery(event.target.value),
+                  onKeyDown: (event) => event.stopPropagation(),
+                  className: "chat-model-search-input"
+                }
+              ) }),
+              /* @__PURE__ */ jsx13("div", { className: "chat-model-list", children: filteredProviders.length === 0 ? /* @__PURE__ */ jsx13("div", { className: "chat-model-empty", children: "No models found" }) : filteredProviders.map((entry) => {
+                var _a2;
+                const providerName2 = (_a2 = entry.name) != null ? _a2 : entry.label;
+                const hideLabel = filteredProviders.length === 1;
+                return /* @__PURE__ */ jsx13(Fragment2, { children: /* @__PURE__ */ jsxs5(SelectGroup, { className: "chat-model-group", children: [
+                  hideLabel ? null : /* @__PURE__ */ jsxs5(SelectLabel, { className: "chat-model-label", children: [
+                    /* @__PURE__ */ jsx13(ProviderBadge, { logo: entry.logo, name: providerName2 }),
+                    /* @__PURE__ */ jsx13("span", { children: providerName2 })
+                  ] }),
+                  entry.models.map((item) => {
+                    var _a3;
+                    const key = `${entry.id}::${item.id}`;
+                    const levels = item.thinkingLevels;
+                    const defaultThinking = levels && levels.length > 0 ? levels.includes("medium") ? "medium" : levels[0] : void 0;
+                    const thinking = defaultThinking && levels ? { levels } : void 0;
+                    const activeThinking = defaultThinking ? (_a3 = getThinkingLevel(entry.id, item.id)) != null ? _a3 : defaultThinking : void 0;
+                    const isOpen = thinkingOpen === key;
+                    return /* @__PURE__ */ jsx13(
+                      ModelRow,
+                      {
+                        itemKey: key,
+                        item,
+                        thinking,
+                        activeThinking,
+                        isOpen,
+                        onToggleThinking: () => setThinkingOpen(isOpen ? null : key),
+                        onPickThinking: (level) => {
+                          setThinkingLevel(entry.id, item.id, level);
+                          setThinkingOpen(null);
+                        }
+                      },
+                      key
+                    );
+                  })
+                ] }) }, entry.id);
+              }) })
+            ]
+          }
+        )
+      ]
+    }
+  ) });
+};
+var ModelRow = ({
+  itemKey,
+  item,
+  thinking,
+  activeThinking,
+  isOpen,
+  onToggleThinking,
+  onPickThinking
+}) => {
+  const menu = useDropdownPresence(isOpen);
+  return /* @__PURE__ */ jsxs5("div", { className: "chat-model-row", children: [
+    /* @__PURE__ */ jsxs5(SelectItem, { value: itemKey, className: "chat-model-item", children: [
+      /* @__PURE__ */ jsx13("span", { className: "chat-model-item-label", children: item.label }),
+      item.description ? /* @__PURE__ */ jsx13("span", { className: "chat-model-item-hint", children: item.description }) : thinking && activeThinking ? /* @__PURE__ */ jsx13("span", { className: "chat-model-item-hint", children: activeThinking }) : null
+    ] }),
+    thinking ? /* @__PURE__ */ jsxs5(Fragment3, { children: [
+      /* @__PURE__ */ jsx13(
+        "button",
+        {
+          type: "button",
+          "aria-label": "Thinking settings",
+          className: "chat-model-thinking-trigger",
+          "data-open": isOpen ? "true" : "false",
+          onPointerDown: (event) => {
+            event.preventDefault();
+            event.stopPropagation();
+          },
+          onClick: (event) => {
+            event.preventDefault();
+            event.stopPropagation();
+            onToggleThinking();
+          },
+          children: /* @__PURE__ */ jsx13(Ellipsis, { className: "chat-model-thinking-icon" })
+        }
+      ),
+      menu.mounted ? /* @__PURE__ */ jsx13(
+        "div",
+        {
+          className: cn("chat-model-thinking-menu", motion.dropdown, menu.className),
+          "data-origin": THINKING_ORIGIN,
+          onPointerDown: (event) => event.stopPropagation(),
+          onClick: (event) => event.stopPropagation(),
+          children: thinking.levels.map((level) => {
+            const isActive = level === activeThinking;
+            return /* @__PURE__ */ jsxs5(
+              "button",
+              {
+                type: "button",
+                className: "chat-model-thinking-option",
+                "data-active": isActive ? "true" : "false",
+                onClick: (event) => {
+                  event.preventDefault();
+                  event.stopPropagation();
+                  onPickThinking(level);
+                },
+                children: [
+                  /* @__PURE__ */ jsx13("span", { children: level }),
+                  isActive ? /* @__PURE__ */ jsx13(Check, { className: "chat-model-thinking-check" }) : null
+                ]
+              },
+              level
+            );
+          })
+        }
+      ) : null
+    ] }) : null
+  ] });
+};
+
+// src/components/Chat/chat.tsx
+import { jsx as jsx14, jsxs as jsxs6 } from "react/jsx-runtime";
+var focusStaysInComposer = (shell, node) => {
+  if (node && shell.contains(node)) {
+    return true;
+  }
+  return node instanceof Element && node.closest("[data-slot='select-content']") !== null;
+};
+var ChatComposer = ({
+  showModelSelector = true,
+  collapsedVariant = "pill",
+  defaultExpanded = false
+}) => {
+  const { status } = useMessages();
+  const { input, attachments, references } = useComposer();
+  const shellRef = useRef9(null);
+  const [focused, setFocused] = useState7(defaultExpanded);
+  const expanded = focused || input.trim().length > 0 || attachments.length > 0 || references.length > 0;
+  useEffect6(() => {
+    if (status !== "error" || !shellRef.current) {
+      return;
+    }
+    triggerErrorShake(shellRef.current);
+  }, [status]);
+  useEffect6(() => {
+    if (!focused) {
+      return;
+    }
+    const onFocusIn = () => {
+      const shell = shellRef.current;
+      if (!shell) {
+        return;
+      }
+      if (focusStaysInComposer(shell, document.activeElement)) {
+        return;
+      }
+      setFocused(false);
+    };
+    document.addEventListener("focusin", onFocusIn, true);
+    return () => document.removeEventListener("focusin", onFocusIn, true);
+  }, [focused]);
+  return /* @__PURE__ */ jsxs6(
+    "div",
+    {
+      ref: shellRef,
+      className: cn("chat-composer-shell", motion.inputWrap, motion.input),
+      "data-expanded": expanded ? "true" : "false",
+      "data-collapsed": collapsedVariant,
+      onFocus: () => setFocused(true),
+      onBlur: (event) => {
+        const shell = event.currentTarget;
+        const next = event.relatedTarget;
+        if (next instanceof Node && focusStaysInComposer(shell, next)) {
+          return;
+        }
+        window.setTimeout(() => {
+          if (focusStaysInComposer(shell, document.activeElement)) {
+            return;
+          }
+          setFocused(false);
+        }, 0);
+      },
+      children: [
+        expanded || collapsedVariant !== "circle" ? null : /* @__PURE__ */ jsx14(MessageCircle, { className: "chat-composer-collapsed-icon", size: 18, "aria-hidden": "true" }),
+        /* @__PURE__ */ jsx14(ChatAttachments, {}),
+        /* @__PURE__ */ jsx14(ChatReferences, {}),
+        /* @__PURE__ */ jsx14(ChatInput, { expanded }),
+        /* @__PURE__ */ jsxs6("div", { className: "chat-composer-row", children: [
+          /* @__PURE__ */ jsxs6("div", { className: "chat-composer-tools", children: [
+            /* @__PURE__ */ jsx14(ChatAttachButton, {}),
+            showModelSelector && expanded && collapsedVariant === "circle" ? /* @__PURE__ */ jsx14(ChatSelect, {}) : null
+          ] }),
+          /* @__PURE__ */ jsx14(ChatSend, {})
+        ] })
+      ]
+    }
+  );
+};
+
+// src/components/Message/message.item.tsx
+import { Pencil } from "lucide-react";
+import { useState as useState10 } from "react";
+import { normalizeAgentParts } from "@sarchauhan/protocol";
+
+// src/components/Message/message.feedback.tsx
+import { ThumbsDown, ThumbsUp } from "lucide-react";
+import { useState as useState9 } from "react";
+
+// src/components/Message/message.copy.tsx
+import { Check as Check2, Copy } from "lucide-react";
+import { useState as useState8 } from "react";
+import { jsx as jsx15 } from "react/jsx-runtime";
+var MessageCopy = ({ text, disabled = false }) => {
+  const [isCopied, setIsCopied] = useState8(false);
+  const copyMessage = async () => {
+    await navigator.clipboard.writeText(text);
+    setIsCopied(true);
+    window.setTimeout(() => setIsCopied(false), 1500);
+  };
+  return /* @__PURE__ */ jsx15(
+    "button",
+    {
+      type: "button",
+      className: "chat-feedback-button",
+      title: isCopied ? "Copied" : "Copy response",
+      "aria-label": isCopied ? "Copied" : "Copy response",
+      onClick: () => void copyMessage(),
+      disabled,
+      children: isCopied ? /* @__PURE__ */ jsx15(Check2, { size: 16 }) : /* @__PURE__ */ jsx15(Copy, { size: 16 })
+    }
+  );
+};
+
+// src/components/Message/message.regenerate.tsx
+import { RotateCcw } from "lucide-react";
+import { jsx as jsx16 } from "react/jsx-runtime";
+var MessageRegenerate = ({ onRegenerate, disabled = false }) => /* @__PURE__ */ jsx16(
+  "button",
+  {
+    type: "button",
+    className: "chat-feedback-button",
+    title: "Regenerate response",
+    "aria-label": "Regenerate response",
+    disabled,
+    onClick: onRegenerate,
+    children: /* @__PURE__ */ jsx16(RotateCcw, { size: 17 })
+  }
+);
+
+// src/components/Message/message.feedback.tsx
+import { jsx as jsx17, jsxs as jsxs7 } from "react/jsx-runtime";
+var MessageFeedback = ({
+  responseText,
+  onRegenerate,
+  canRegenerate,
+  disabled = false
+}) => {
+  const [feedback, setFeedback] = useState9(null);
+  if (!responseText.trim()) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxs7("div", { className: "chat-message-feedback", "aria-label": "Message actions", children: [
+    /* @__PURE__ */ jsx17(MessageCopy, { text: responseText, disabled }),
+    /* @__PURE__ */ jsx17(
+      MessageRegenerate,
+      {
+        onRegenerate,
+        disabled: !canRegenerate || disabled
+      }
+    ),
+    /* @__PURE__ */ jsx17(
+      "button",
+      {
+        type: "button",
+        className: `chat-feedback-button${feedback === "up" ? " is-selected" : ""}`,
+        title: "Good response",
+        "aria-label": "Good response",
+        "aria-pressed": feedback === "up",
+        onClick: () => setFeedback(feedback === "up" ? null : "up"),
+        disabled,
+        children: /* @__PURE__ */ jsx17(ThumbsUp, { size: 18 })
+      }
+    ),
+    /* @__PURE__ */ jsx17(
+      "button",
+      {
+        type: "button",
+        className: `chat-feedback-button${feedback === "down" ? " is-selected" : ""}`,
+        title: "Poor response",
+        "aria-label": "Poor response",
+        "aria-pressed": feedback === "down",
+        onClick: () => setFeedback(feedback === "down" ? null : "down"),
+        disabled,
+        children: /* @__PURE__ */ jsx17(ThumbsDown, { size: 18 })
+      }
+    )
+  ] });
+};
+
+// src/components/Message/message.usage.tsx
+import {
+  parseContext,
+  parseUsage
+} from "@sarchauhan/protocol";
+import { Fragment as Fragment4, jsxs as jsxs8 } from "react/jsx-runtime";
+var formatTokens = (value) => new Intl.NumberFormat("en-US").format(value);
+var isTokenCount = (value) => typeof value === "number" && Number.isFinite(value);
+var getContextMetrics = (context) => {
+  const currentTokens = context == null ? void 0 : context.current_tokens;
+  const contextWindow = context == null ? void 0 : context.context_window;
+  return isTokenCount(currentTokens) && isTokenCount(contextWindow) ? { currentTokens, contextWindow } : null;
+};
+var MessageUsage = ({ parts }) => {
+  var _a, _b;
+  const usage = parseUsage((_a = parts.find((part) => part.name === "usage")) == null ? void 0 : _a.data);
+  const context = parseContext((_b = parts.find((part) => part.name === "context")) == null ? void 0 : _b.data);
+  const contextMetrics = getContextMetrics(context);
+  const tokenMetrics = usage ? [
+    ["in", usage.input_tokens],
+    ["out", usage.output_tokens],
+    ["reasoning", usage.reasoning_tokens],
+    ["total", usage.total_tokens]
+  ].filter((metric) => isTokenCount(metric[1])) : [];
+  if (!contextMetrics && tokenMetrics.length === 0) return null;
+  return /* @__PURE__ */ jsxs8("p", { className: "chat-message-usage", "aria-label": "Context and token usage", children: [
+    contextMetrics ? /* @__PURE__ */ jsxs8(Fragment4, { children: [
+      "Context ",
+      formatTokens(contextMetrics.currentTokens),
+      " / ",
+      formatTokens(contextMetrics.contextWindow),
+      " (",
+      Math.round(contextMetrics.currentTokens / contextMetrics.contextWindow * 100),
+      "%)"
+    ] }) : null,
+    tokenMetrics.length > 0 ? /* @__PURE__ */ jsxs8(Fragment4, { children: [
+      contextMetrics ? " \xB7 " : null,
+      "Tokens ",
+      tokenMetrics.map(([label, value]) => `${label} ${formatTokens(value)}`).join(" \xB7 ")
+    ] }) : null
+  ] });
+};
+
+// src/components/Message/message.item.tsx
+import { jsx as jsx18, jsxs as jsxs9 } from "react/jsx-runtime";
+var getMessageTargetId = (messageId) => `chat-message-${messageId}`;
+var MessageItem = ({ message }) => {
+  var _a;
+  const { editAndResendMessage, isSending, messages } = useMessages();
+  const [isEditing, setIsEditing] = useState10(false);
+  const [draft, setDraft] = useState10(() => getUserDisplayText(message));
+  const [isSubmittingEdit, setIsSubmittingEdit] = useState10(false);
+  const isUser = message.role === "user";
+  const isActiveAssistantMessage = isSending && ((_a = messages[messages.length - 1]) == null ? void 0 : _a.id) === message.id;
+  const assistantText = message.parts.filter((part) => part.type === "text").map((part) => "text" in part ? String(part.text) : "").join("\n").trim();
+  const dataParts = normalizeAgentParts(message.parts).filter(
+    (part) => part.type === "data"
+  );
+  const previousUserMessage = [...messages].reverse().find((item) => item.role === "user");
+  const cancelEdit = () => {
+    setDraft(getUserDisplayText(message));
+    setIsEditing(false);
+  };
+  const submitEdit = async () => {
+    if (!draft.trim() || isSending || isSubmittingEdit) {
+      return;
+    }
+    setIsSubmittingEdit(true);
+    try {
+      await editAndResendMessage(message.id, draft);
+      setIsEditing(false);
+    } finally {
+      setIsSubmittingEdit(false);
+    }
+  };
+  if (isUser) {
+    return /* @__PURE__ */ jsx18("div", { id: getMessageTargetId(message.id), className: "chat-message chat-message-user", children: /* @__PURE__ */ jsxs9("div", { className: `chat-message-user-inner${isEditing ? " is-editing" : ""}`, children: [
+      /* @__PURE__ */ jsx18("div", { className: "chat-message-bubble", children: isEditing ? /* @__PURE__ */ jsx18(
+        "textarea",
+        {
+          className: "chat-edit-area",
+          value: draft,
+          disabled: isSubmittingEdit,
+          autoFocus: true,
+          onChange: (event) => setDraft(event.target.value),
+          onKeyDown: (event) => {
+            if (event.key !== "Enter" || event.shiftKey) return;
+            if (event.nativeEvent.isComposing) return;
+            event.preventDefault();
+            void submitEdit();
+          }
+        }
+      ) : /* @__PURE__ */ jsx18(MessageContent, { parts: message.parts, isUser: true }) }),
+      isEditing ? /* @__PURE__ */ jsxs9("div", { className: "chat-message-actions", children: [
+        /* @__PURE__ */ jsx18(
+          "button",
+          {
+            type: "button",
+            className: "chat-text-button",
+            onClick: cancelEdit,
+            disabled: isSubmittingEdit,
+            children: "Cancel"
+          }
+        ),
+        /* @__PURE__ */ jsx18(
+          "button",
+          {
+            type: "button",
+            className: "chat-text-button chat-text-button-done",
+            onClick: submitEdit,
+            disabled: !draft.trim() || isSubmittingEdit || isSending,
+            children: "Done"
+          }
+        )
+      ] }) : /* @__PURE__ */ jsx18(
+        "button",
+        {
+          type: "button",
+          className: "chat-icon-button",
+          onClick: () => {
+            setDraft(getUserDisplayText(message));
+            setIsEditing(true);
+          },
+          disabled: isSending,
+          "aria-label": "Edit and resend message",
+          children: /* @__PURE__ */ jsx18(Pencil, { size: 14 })
+        }
+      )
+    ] }) });
+  }
+  return /* @__PURE__ */ jsx18("div", { className: "chat-message chat-message-assistant", children: /* @__PURE__ */ jsxs9("div", { className: "chat-message-assistant-inner", children: [
+    /* @__PURE__ */ jsx18(MessageContent, { parts: message.parts, isUser: false }),
+    /* @__PURE__ */ jsx18(MessageUsage, { parts: dataParts }),
+    isActiveAssistantMessage ? null : /* @__PURE__ */ jsx18(
+      MessageFeedback,
+      {
+        responseText: assistantText,
+        canRegenerate: !!previousUserMessage,
+        disabled: isSending,
+        onRegenerate: () => {
+          if (previousUserMessage) {
+            void editAndResendMessage(
+              previousUserMessage.id,
+              getUserDisplayText(previousUserMessage)
+            );
+          }
+        }
+      }
+    )
+  ] }) });
+};
+
+// src/components/Message/message.tsx
+import { jsx as jsx19, jsxs as jsxs10 } from "react/jsx-runtime";
+var WaitingForResponse = () => /* @__PURE__ */ jsx19("div", { className: "chat-response-status", role: "status", "aria-live": "polite", children: /* @__PURE__ */ jsx19(TextSkeleton, {}) });
+var Message = () => {
+  const { messages, isWaitingForResponse } = useMessages();
+  const { isLoadingThread } = useThread();
+  if (isLoadingThread) {
+    return /* @__PURE__ */ jsx19("div", { className: "chat-messages-inner", children: /* @__PURE__ */ jsx19("div", { className: "chat-loading chat-loading-initial", role: "status", "aria-live": "polite", children: "Loading conversation\u2026" }) });
+  }
+  if (messages.length === 0) {
+    return /* @__PURE__ */ jsx19("div", { className: "chat-messages-inner", children: /* @__PURE__ */ jsx19("div", { className: "chat-empty", children: /* @__PURE__ */ jsxs10("div", { children: [
+      /* @__PURE__ */ jsx19("p", { className: "chat-empty-title", children: "How can I help?" }),
+      /* @__PURE__ */ jsx19("p", { className: "chat-empty-copy", children: "Ask a question, explore ideas, or use tools and widgets when the agent needs them." })
+    ] }) }) });
+  }
+  return /* @__PURE__ */ jsxs10("div", { className: "chat-messages-inner", children: [
+    messages.map((message) => /* @__PURE__ */ jsx19(MessageItem, { message }, message.id)),
+    isWaitingForResponse ? /* @__PURE__ */ jsx19(WaitingForResponse, {}) : null
+  ] });
+};
+
+// src/components/Chat.tsx
+import { jsx as jsx20, jsxs as jsxs11 } from "react/jsx-runtime";
+function ChatShell({
+  className,
+  style,
+  widgets,
+  showThemeToggle = true,
+  showModelSelector = true,
+  collapsedVariant = "pill",
+  defaultExpanded = false
+}) {
+  const { sendMessage, isSending, messages, status } = useMessages();
+  const { createThread } = useThread();
+  const { resolvedTheme } = useTheme();
+  const registry = useMemo7(() => createWidgetRegistry(widgets), [widgets]);
+  const messagesRef = useRef10(null);
+  useLayoutEffect(() => {
+    const container = messagesRef.current;
+    if (!container) {
+      return;
+    }
+    container.scrollTop = container.scrollHeight;
+  }, [messages, status]);
+  useLayoutEffect(() => {
+    const container = messagesRef.current;
+    if (!container || status !== "submitted" && status !== "streaming") {
+      return;
+    }
+    const scrollToEnd = () => {
+      container.scrollTop = container.scrollHeight;
+    };
+    const observer = new ResizeObserver(scrollToEnd);
+    observer.observe(container);
+    const inner = container.firstElementChild;
+    if (inner) {
+      observer.observe(inner);
+    }
+    scrollToEnd();
+    return () => observer.disconnect();
+  }, [status]);
+  const respondToWidget = useCallback6(
+    async (response) => {
+      var _a, _b;
+      const text = (_b = (_a = response.label) != null ? _a : response.actionId) != null ? _b : typeof response.value === "string" ? response.value : JSON.stringify(response.value);
+      if (!text.trim()) {
+        return;
+      }
+      await sendMessage({ text });
+    },
+    [sendMessage]
+  );
+  return /* @__PURE__ */ jsx20(
+    WidgetProvider,
+    {
+      widgets: registry,
+      respondToWidget,
+      disabled: isSending,
+      children: /* @__PURE__ */ jsxs11(
+        "div",
+        {
+          className: ["chat-root", className].filter(Boolean).join(" "),
+          style,
+          "data-theme": resolvedTheme,
+          children: [
+            /* @__PURE__ */ jsxs11("div", { className: "chat-toolbar", children: [
+              /* @__PURE__ */ jsx20(
+                "button",
+                {
+                  type: "button",
+                  className: "chat-theme-toggle",
+                  onClick: () => void createThread(),
+                  "aria-label": "Start a new chat",
+                  title: "New chat",
+                  disabled: isSending,
+                  children: /* @__PURE__ */ jsx20(PenSquare, { size: 16, strokeWidth: 1.75 })
+                }
+              ),
+              showThemeToggle && /* @__PURE__ */ jsx20(ThemeToggle, {})
+            ] }),
+            /* @__PURE__ */ jsx20("div", { className: "chat-messages", ref: messagesRef, children: /* @__PURE__ */ jsx20(Message, {}) }),
+            /* @__PURE__ */ jsx20("div", { className: "chat-composer", children: /* @__PURE__ */ jsx20(
+              ChatComposer,
+              {
+                showModelSelector,
+                collapsedVariant,
+                defaultExpanded
+              }
+            ) })
+          ]
+        }
+      )
+    }
+  );
+}
+function Chat({
+  adapter,
+  className,
+  defaultThreadId,
+  defaultProvider,
+  registryUrl,
+  style,
+  widgets,
+  theme,
+  defaultTheme = "system",
+  onThemeChange,
+  showThemeToggle = true,
+  showModelSelector = true,
+  collapsedVariant = "pill",
+  defaultExpanded = false
+}) {
+  return /* @__PURE__ */ jsx20(
+    ThemeProvider,
+    {
+      theme,
+      defaultTheme,
+      onThemeChange,
+      children: /* @__PURE__ */ jsx20(
+        ChatContextProvider,
+        {
+          adapter,
+          defaultThreadId,
+          defaultProvider,
+          registryUrl,
+          children: /* @__PURE__ */ jsx20(
+            ChatShell,
+            {
+              className,
+              style,
+              widgets,
+              showThemeToggle,
+              showModelSelector,
+              collapsedVariant,
+              defaultExpanded
+            }
+          )
+        }
+      )
+    }
+  );
+}
+
+// src/index.ts
+import { defineAdapter } from "@sarchauhan/adapter";
+import {
+  applyAgentEvent,
+  createAgentMessageState,
+  createWidgetData,
+  normalizeAgentMessage,
+  normalizeAgentParts as normalizeAgentParts2,
+  reduceAgentEvents
+} from "@sarchauhan/protocol";
+export {
+  ArtifactWidget,
+  ArtifactsWidget,
+  BaseWidget,
+  Chat,
+  ChatComposer,
+  ChatContextProvider,
+  LoadingState,
+  Message,
+  MessageContent,
+  MessageFeedback,
+  MessageUsage,
+  PatchWidget,
+  ProviderId,
+  QuestionWidget,
+  ReadFileWidget,
+  ResponsiveDetail,
+  SearchWidget,
+  SubagentWidget,
+  TextSwap,
+  ThemeProvider,
+  ThemeToggle,
+  ThinkingBlock,
+  WidgetProvider,
+  WidgetRenderer,
+  applyAgentEvent,
+  calibrateCheckPath,
+  clearErrorShake,
+  closeDropdown,
+  computeDiff,
+  computeTextDiff,
+  computeToolState,
+  computeToolWidget,
+  createAgentMessageState,
+  createArtifactData,
+  createSubagentData,
+  createWidgetData,
+  createWidgetRegistry,
+  defineAdapter,
+  defineWidget,
+  dropdownOrigins,
+  formatArtifactSize,
+  formatElapsed,
+  formatElapsedWords,
+  iconSwapStates,
+  isProviderId,
+  motion,
+  motionData,
+  motionRoot,
+  normalizeAgentMessage,
+  normalizeAgentParts2 as normalizeAgentParts,
+  normalizeSearchResults,
+  openDropdown,
+  parseArtifact,
+  parseRegistryConfig,
+  parseSubagent,
+  prebuiltWidgets,
+  prefersReducedMotion,
+  readDurationMs,
+  reduceAgentEvents,
+  safeArtifactUrl,
+  safeResultUrl,
+  successCheckStates,
+  swapText,
+  triggerErrorShake,
+  useChat,
+  useComposer,
+  useDropdownPresence,
+  useMessages,
+  useModel,
+  useTheme,
+  useThread,
+  useWidgets
+};
+//# sourceMappingURL=index.mjs.map