@sarchauhan/chat 0.0.0-stage → 0.0.1

package/dist/index.js

@@ -0,0 +1,4386 @@
+"use client";
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ArtifactWidget: () => ArtifactWidget,
+  ArtifactsWidget: () => ArtifactsWidget,
+  BaseWidget: () => BaseWidget,
+  Chat: () => Chat,
+  ChatComposer: () => ChatComposer,
+  ChatContextProvider: () => ChatContextProvider,
+  LoadingState: () => LoadingState,
+  Message: () => Message,
+  MessageContent: () => MessageContent,
+  MessageFeedback: () => MessageFeedback,
+  MessageUsage: () => MessageUsage,
+  PatchWidget: () => PatchWidget,
+  ProviderId: () => ProviderId,
+  QuestionWidget: () => QuestionWidget,
+  ReadFileWidget: () => ReadFileWidget,
+  ResponsiveDetail: () => ResponsiveDetail,
+  SearchWidget: () => SearchWidget,
+  SubagentWidget: () => SubagentWidget,
+  TextSwap: () => TextSwap,
+  ThemeProvider: () => ThemeProvider,
+  ThemeToggle: () => ThemeToggle,
+  ThinkingBlock: () => ThinkingBlock,
+  WidgetProvider: () => WidgetProvider,
+  WidgetRenderer: () => WidgetRenderer,
+  applyAgentEvent: () => import_protocol7.applyAgentEvent,
+  calibrateCheckPath: () => calibrateCheckPath,
+  clearErrorShake: () => clearErrorShake,
+  closeDropdown: () => closeDropdown,
+  computeDiff: () => computeDiff,
+  computeTextDiff: () => computeTextDiff,
+  computeToolState: () => computeToolState,
+  computeToolWidget: () => computeToolWidget,
+  createAgentMessageState: () => import_protocol7.createAgentMessageState,
+  createArtifactData: () => import_protocol6.createArtifactData,
+  createSubagentData: () => import_protocol6.createSubagentData,
+  createWidgetData: () => import_protocol7.createWidgetData,
+  createWidgetRegistry: () => createWidgetRegistry,
+  defineAdapter: () => import_adapter.defineAdapter,
+  defineWidget: () => defineWidget,
+  dropdownOrigins: () => dropdownOrigins,
+  formatArtifactSize: () => formatArtifactSize,
+  formatElapsed: () => formatElapsed,
+  formatElapsedWords: () => formatElapsedWords,
+  iconSwapStates: () => iconSwapStates,
+  isProviderId: () => isProviderId,
+  motion: () => motion,
+  motionData: () => motionData,
+  motionRoot: () => motionRoot,
+  normalizeAgentMessage: () => import_protocol7.normalizeAgentMessage,
+  normalizeAgentParts: () => import_protocol7.normalizeAgentParts,
+  normalizeSearchResults: () => normalizeSearchResults,
+  openDropdown: () => openDropdown,
+  parseArtifact: () => import_protocol6.parseArtifact,
+  parseRegistryConfig: () => parseRegistryConfig,
+  parseSubagent: () => import_protocol6.parseSubagent,
+  prebuiltWidgets: () => prebuiltWidgets,
+  prefersReducedMotion: () => prefersReducedMotion,
+  readDurationMs: () => readDurationMs,
+  reduceAgentEvents: () => import_protocol7.reduceAgentEvents,
+  safeArtifactUrl: () => safeArtifactUrl,
+  safeResultUrl: () => safeResultUrl,
+  successCheckStates: () => successCheckStates,
+  swapText: () => swapText,
+  triggerErrorShake: () => triggerErrorShake,
+  useChat: () => useChat,
+  useComposer: () => useComposer,
+  useDropdownPresence: () => useDropdownPresence,
+  useMessages: () => useMessages,
+  useModel: () => useModel,
+  useTheme: () => useTheme,
+  useThread: () => useThread,
+  useWidgets: () => useWidgets
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/components/Chat.tsx
+var import_lucide_react19 = require("lucide-react");
+var import_react30 = require("react");
+
+// src/theme/theme.context.tsx
+var import_react = require("react");
+var import_jsx_runtime = require("react/jsx-runtime");
+var ThemeContext = (0, import_react.createContext)(null);
+var STORAGE_KEY = "sarchauhan-chat-theme";
+var getSystemTheme = () => {
+  if (typeof window === "undefined" || !window.matchMedia) {
+    return "light";
+  }
+  return window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
+};
+var resolveTheme = (theme) => theme === "system" ? getSystemTheme() : theme;
+function ThemeProvider({
+  children,
+  defaultTheme = "system",
+  theme: controlledTheme,
+  onThemeChange,
+  storageKey = STORAGE_KEY
+}) {
+  const [uncontrolledTheme, setUncontrolledTheme] = (0, import_react.useState)(defaultTheme);
+  const theme = controlledTheme != null ? controlledTheme : uncontrolledTheme;
+  const [resolvedTheme, setResolvedTheme] = (0, import_react.useState)(
+    theme === "dark" ? "dark" : "light"
+  );
+  (0, import_react.useEffect)(() => {
+    if (controlledTheme !== void 0) {
+      return;
+    }
+    const stored = window.localStorage.getItem(storageKey);
+    if (stored === "light" || stored === "dark" || stored === "system") {
+      setUncontrolledTheme(stored);
+    }
+  }, [controlledTheme, storageKey]);
+  (0, import_react.useEffect)(() => {
+    setResolvedTheme(resolveTheme(theme));
+    if (theme !== "system" || typeof window === "undefined") {
+      return;
+    }
+    const media = window.matchMedia("(prefers-color-scheme: dark)");
+    const onChange = () => setResolvedTheme(getSystemTheme());
+    media.addEventListener("change", onChange);
+    return () => media.removeEventListener("change", onChange);
+  }, [theme]);
+  const setTheme = (0, import_react.useCallback)(
+    (next) => {
+      onThemeChange == null ? void 0 : onThemeChange(next);
+      if (controlledTheme === void 0) {
+        setUncontrolledTheme(next);
+        if (typeof window !== "undefined") {
+          window.localStorage.setItem(storageKey, next);
+        }
+      }
+    },
+    [controlledTheme, onThemeChange, storageKey]
+  );
+  const toggleTheme = (0, import_react.useCallback)(() => {
+    const next = resolvedTheme === "dark" ? "light" : "dark";
+    setTheme(next);
+  }, [resolvedTheme, setTheme]);
+  const value = (0, import_react.useMemo)(
+    () => ({
+      theme,
+      resolvedTheme,
+      setTheme,
+      toggleTheme
+    }),
+    [resolvedTheme, setTheme, theme, toggleTheme]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ThemeContext.Provider, { value, children });
+}
+function useTheme() {
+  const context = (0, import_react.useContext)(ThemeContext);
+  if (!context) {
+    throw new Error("useTheme must be used inside ThemeProvider");
+  }
+  return context;
+}
+
+// src/theme/theme.toggle.tsx
+var import_lucide_react = require("lucide-react");
+var import_jsx_runtime2 = require("react/jsx-runtime");
+function ThemeToggle({ className }) {
+  const { resolvedTheme, toggleTheme } = useTheme();
+  const isDark = resolvedTheme === "dark";
+  return /* @__PURE__ */ (0, import_jsx_runtime2.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__ */ (0, import_jsx_runtime2.jsx)(import_lucide_react.Sun, { size: 16, strokeWidth: 1.75 }) : /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_lucide_react.Moon, { size: 16, strokeWidth: 1.75 })
+    }
+  );
+}
+
+// src/components/Chat/chat.tsx
+var import_lucide_react7 = require("lucide-react");
+var import_react13 = require("react");
+
+// src/lib/utils.ts
+var import_clsx = require("clsx");
+var import_tailwind_merge = require("tailwind-merge");
+function cn(...inputs) {
+  return (0, import_tailwind_merge.twMerge)((0, import_clsx.clsx)(inputs));
+}
+
+// src/motion/classes.ts
+var motion = {
+  textSwap: "t-text-swap",
+  isExit: "is-exit",
+  isEnterStart: "is-enter-start",
+  iconSwap: "t-icon-swap",
+  icon: "t-icon",
+  successCheck: "t-success-check",
+  dropdown: "t-dropdown",
+  isOpen: "is-open",
+  isClosing: "is-closing",
+  inputWrap: "t-input-wrap",
+  input: "t-input",
+  errorMsg: "t-error-msg",
+  isError: "is-error",
+  isShaking: "is-shaking"
+};
+var iconSwapStates = ["a", "b"];
+var successCheckStates = ["out", "in"];
+var dropdownOrigins = [
+  "top-left",
+  "top-center",
+  "top-right",
+  "bottom-left",
+  "bottom-center",
+  "bottom-right"
+];
+var motionData = {
+  state: "data-state",
+  icon: "data-icon",
+  origin: "data-origin",
+  open: "data-open"
+};
+
+// src/motion/helpers.ts
+var CHAT_ROOT = ".chat-root";
+var prefersReducedMotion = () => typeof window !== "undefined" && window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+var motionRoot = (node) => {
+  var _a;
+  return (_a = node == null ? void 0 : node.closest(CHAT_ROOT)) != null ? _a : typeof document !== "undefined" ? document.querySelector(CHAT_ROOT) : null;
+};
+var readRaw = (name, node) => {
+  const root = motionRoot(node);
+  if (!root) {
+    return "";
+  }
+  return getComputedStyle(root).getPropertyValue(name);
+};
+var readDurationMs = (name, fallback, node) => {
+  const value = parseFloat(readRaw(name, node));
+  return Number.isFinite(value) ? value : fallback;
+};
+var revertTimers = /* @__PURE__ */ new WeakMap();
+var shakeTimers = /* @__PURE__ */ new WeakMap();
+var swapText = (el, next, options) => {
+  var _a;
+  if (prefersReducedMotion()) {
+    el.textContent = next;
+    (_a = options == null ? void 0 : options.onSwap) == null ? void 0 : _a.call(options);
+    return;
+  }
+  const dur = readDurationMs("--text-swap-dur", 200, el);
+  el.classList.add(motion.isExit);
+  return window.setTimeout(() => {
+    var _a2;
+    el.classList.remove(motion.isExit);
+    el.classList.add(motion.isEnterStart);
+    el.textContent = next;
+    (_a2 = options == null ? void 0 : options.onSwap) == null ? void 0 : _a2.call(options);
+    void el.offsetHeight;
+    el.classList.remove(motion.isEnterStart);
+  }, dur);
+};
+var openDropdown = (el) => {
+  el.classList.remove(motion.isClosing);
+  el.classList.add(motion.isOpen);
+};
+var closeDropdown = (el, onClosed) => {
+  el.classList.remove(motion.isOpen);
+  el.classList.add(motion.isClosing);
+  const closeMs = prefersReducedMotion() ? 0 : readDurationMs("--dropdown-close-dur", 150, el);
+  return window.setTimeout(() => {
+    el.classList.remove(motion.isClosing);
+    onClosed == null ? void 0 : onClosed();
+  }, closeMs);
+};
+var triggerErrorShake = (wrap, options) => {
+  var _a;
+  const input = wrap.matches(`.${motion.input}`) ? wrap : (_a = wrap.querySelector(`.${motion.input}`)) != null ? _a : wrap;
+  wrap.classList.add(motion.isError);
+  input.classList.add(motion.isError);
+  input.classList.remove(motion.isShaking);
+  void input.offsetWidth;
+  input.classList.add(motion.isShaking);
+  const existingShake = shakeTimers.get(input);
+  if (existingShake) {
+    window.clearTimeout(existingShake);
+  }
+  const shakeMs = readDurationMs("--shake-dur-a", 80, wrap) * 2 + readDurationMs("--shake-dur-b", 60, wrap) * 2;
+  shakeTimers.set(
+    input,
+    window.setTimeout(() => {
+      input.classList.remove(motion.isShaking);
+      shakeTimers.delete(input);
+    }, shakeMs + 20)
+  );
+  const existingRevert = revertTimers.get(wrap);
+  if (existingRevert) {
+    window.clearTimeout(existingRevert);
+    revertTimers.delete(wrap);
+  }
+  if ((options == null ? void 0 : options.revert) === false) {
+    return;
+  }
+  const hold = readDurationMs("--revert-hold", 3e3, wrap);
+  revertTimers.set(
+    wrap,
+    window.setTimeout(() => {
+      revertTimers.delete(wrap);
+      wrap.classList.remove(motion.isError);
+      input.classList.remove(motion.isError);
+    }, shakeMs + hold)
+  );
+};
+var clearErrorShake = (wrap) => {
+  var _a;
+  const input = wrap.matches(`.${motion.input}`) ? wrap : (_a = wrap.querySelector(`.${motion.input}`)) != null ? _a : wrap;
+  const existingRevert = revertTimers.get(wrap);
+  if (existingRevert) {
+    window.clearTimeout(existingRevert);
+    revertTimers.delete(wrap);
+  }
+  const existingShake = shakeTimers.get(input);
+  if (existingShake) {
+    window.clearTimeout(existingShake);
+    shakeTimers.delete(input);
+  }
+  wrap.classList.remove(motion.isError);
+  input.classList.remove(motion.isError, motion.isShaking);
+};
+var calibrateCheckPath = (path) => {
+  const len = Math.ceil(path.getTotalLength());
+  path.style.strokeDasharray = String(len);
+  path.style.strokeDashoffset = String(len);
+};
+
+// src/motion/text-swap.tsx
+var import_react2 = require("react");
+var import_jsx_runtime3 = require("react/jsx-runtime");
+function TextSwap({ text, className, ...props }) {
+  const ref = (0, import_react2.useRef)(null);
+  const shownRef = (0, import_react2.useRef)(text);
+  (0, import_react2.useEffect)(() => {
+    const el = ref.current;
+    if (!el || shownRef.current === text) {
+      return;
+    }
+    if (prefersReducedMotion()) {
+      shownRef.current = text;
+      el.textContent = text;
+      return;
+    }
+    const dur = readDurationMs("--text-swap-dur", 200, el);
+    el.classList.add(motion.isExit);
+    const timer = window.setTimeout(() => {
+      el.classList.remove(motion.isExit);
+      el.classList.add(motion.isEnterStart);
+      el.textContent = text;
+      shownRef.current = text;
+      void el.offsetHeight;
+      el.classList.remove(motion.isEnterStart);
+    }, dur);
+    return () => window.clearTimeout(timer);
+  }, [text]);
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { ref, className: cn(motion.textSwap, className), ...props, children: shownRef.current });
+}
+
+// src/motion/use-dropdown-presence.ts
+var import_react3 = require("react");
+var resolveRoot = (root) => root && "current" in root ? root.current : root != null ? root : null;
+function useDropdownPresence(open, root) {
+  const [mounted, setMounted] = (0, import_react3.useState)(open);
+  const [phase, setPhase] = (0, import_react3.useState)(open ? "open" : "rest");
+  const mountedRef = (0, import_react3.useRef)(open);
+  mountedRef.current = mounted;
+  (0, import_react3.useEffect)(() => {
+    const node = resolveRoot(root);
+    if (open) {
+      setMounted(true);
+      setPhase("rest");
+      const frame = window.requestAnimationFrame(() => {
+        window.requestAnimationFrame(() => setPhase("open"));
+      });
+      return () => window.cancelAnimationFrame(frame);
+    }
+    if (!mountedRef.current) {
+      return;
+    }
+    setPhase("closing");
+    const closeMs = prefersReducedMotion() ? 0 : readDurationMs("--dropdown-close-dur", 150, node);
+    const timer = window.setTimeout(() => {
+      setMounted(false);
+      setPhase("rest");
+    }, closeMs);
+    return () => window.clearTimeout(timer);
+  }, [open, root]);
+  const className = phase === "open" ? motion.isOpen : phase === "closing" ? motion.isClosing : void 0;
+  return { mounted, phase, className };
+}
+
+// src/components/Chat/chat.attachments.tsx
+var import_lucide_react2 = require("lucide-react");
+var import_react10 = require("react");
+
+// src/components/Chat/context/index.ts
+var import_react9 = require("react");
+
+// src/components/Chat/context/composer.context.tsx
+var import_react8 = require("react");
+
+// src/components/Chat/chat.tooltip.tsx
+var import_react4 = require("react");
+var import_react_dom = require("react-dom");
+var import_jsx_runtime4 = require("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 = (0, import_react4.memo)(function ChatTooltip2({
+  onAddReference
+}) {
+  const [selectionAction, setSelectionAction] = (0, import_react4.useState)(null);
+  const rangeRef = (0, import_react4.useRef)(null);
+  const textRef = (0, import_react4.useRef)("");
+  (0, import_react4.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 (0, import_react_dom.createPortal)(
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+      "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
+var import_react7 = require("react");
+var import_react_dom2 = require("react-dom");
+
+// src/lib/message/user.ts
+var REFERENCE_PREFIX = "Use the following selected references as context:\n\n";
+var USER_MESSAGE_MARKER = "\n\nUser message:\n";
+var REFERENCE_PATTERN = /<reference \d+>\n([\s\S]*?)\n<\/reference \d+>/g;
+var getMessageTextContent = (message) => message.parts.filter((part) => part.type === "text").map((part) => part.text).join("\n");
+var parseUserReferenceMessage = (content) => {
+  if (!content.startsWith(REFERENCE_PREFIX)) {
+    return null;
+  }
+  const markerIndex = content.indexOf(USER_MESSAGE_MARKER);
+  if (markerIndex === -1) {
+    return null;
+  }
+  const references = [...content.slice(REFERENCE_PREFIX.length, markerIndex).matchAll(REFERENCE_PATTERN)].map((match) => match[1].trim()).filter(Boolean);
+  return references.length ? { references, message: content.slice(markerIndex + USER_MESSAGE_MARKER.length) } : null;
+};
+var getUserDisplayText = (message) => {
+  var _a, _b;
+  const text = getMessageTextContent(message);
+  return (_b = (_a = parseUserReferenceMessage(text)) == null ? void 0 : _a.message) != null ? _b : text;
+};
+
+// src/components/Chat/context/model.context.tsx
+var import_react5 = require("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
+var import_jsx_runtime5 = require("react/jsx-runtime");
+var ModelContext = (0, import_react5.createContext)(null);
+function ModelProvider({
+  children,
+  defaultProvider = "mock" /* MOCK */,
+  registryUrl = "/api/ai/registry"
+}) {
+  const [registry, setRegistry] = (0, import_react5.useState)(defaultRegistry);
+  const [provider, setProviderState] = (0, import_react5.useState)(defaultProvider);
+  const [model, setModelState] = (0, import_react5.useState)(
+    () => {
+      var _a, _b;
+      return (_b = (_a = defaultRegistry.providers.find((entry) => entry.id === defaultProvider)) == null ? void 0 : _a.defaultModel) != null ? _b : "";
+    }
+  );
+  const [thinkingLevels, setThinkingLevelsState] = (0, import_react5.useState)(() => {
+    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 = (0, import_react5.useRef)(provider);
+  const modelRef = (0, import_react5.useRef)(model);
+  const thinkingLevelsRef = (0, import_react5.useRef)(thinkingLevels);
+  providerRef.current = provider;
+  modelRef.current = model;
+  thinkingLevelsRef.current = thinkingLevels;
+  (0, import_react5.useEffect)(() => {
+    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]);
+  (0, import_react5.useEffect)(() => {
+    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 = (0, import_react5.useCallback)((nextProvider, nextModel) => {
+    setProviderState(nextProvider);
+    if (nextModel) {
+      setModelState(nextModel);
+    }
+  }, []);
+  const getThinkingLevel = (0, import_react5.useCallback)(
+    (providerId, modelId) => thinkingLevels[`${providerId}::${modelId}`],
+    [thinkingLevels]
+  );
+  const setThinkingLevel = (0, import_react5.useCallback)((providerId, modelId, level) => {
+    setThinkingLevelsState((prev) => ({ ...prev, [`${providerId}::${modelId}`]: level }));
+  }, []);
+  const setModel = (0, import_react5.useCallback)((nextModel) => {
+    setModelState(nextModel);
+  }, []);
+  const value = (0, import_react5.useMemo)(
+    () => ({
+      registry,
+      provider,
+      model,
+      thinkingLevels,
+      getThinkingLevel,
+      setThinkingLevel,
+      setProvider,
+      setModel,
+      providerRef,
+      modelRef,
+      thinkingLevelsRef
+    }),
+    [model, provider, registry, setModel, setProvider, thinkingLevels, getThinkingLevel, setThinkingLevel]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(ModelContext.Provider, { value, children });
+}
+function useModel() {
+  const context = (0, import_react5.useContext)(ModelContext);
+  if (!context) {
+    throw new Error("useModel must be used inside ModelProvider");
+  }
+  return context;
+}
+
+// src/components/Chat/context/thread.context.tsx
+var import_react6 = require("react");
+var import_jsx_runtime6 = require("react/jsx-runtime");
+var ThreadContext = (0, import_react6.createContext)(null);
+function ThreadProvider({
+  adapter,
+  children,
+  defaultThreadId
+}) {
+  const [threads, setThreads] = (0, import_react6.useState)([]);
+  const [activeThreadId, setActiveThreadId] = (0, import_react6.useState)(defaultThreadId != null ? defaultThreadId : null);
+  const [isLoadingThread, setIsLoadingThread] = (0, import_react6.useState)(true);
+  const activeThreadIdRef = (0, import_react6.useRef)(activeThreadId);
+  activeThreadIdRef.current = activeThreadId;
+  const adapterRef = (0, import_react6.useRef)(adapter);
+  adapterRef.current = adapter;
+  (0, import_react6.useEffect)(() => {
+    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 = (0, import_react6.useCallback)(async (threadId) => {
+    setActiveThreadId((current) => current === threadId ? current : threadId);
+  }, []);
+  const createThread = (0, import_react6.useCallback)(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 = (0, import_react6.useCallback)(
+    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 = (0, import_react6.useMemo)(
+    () => ({
+      threads,
+      activeThreadId,
+      isLoadingThread,
+      activeThreadIdRef,
+      setThreads,
+      setIsLoadingThread,
+      selectThread,
+      createThread,
+      deleteThread
+    }),
+    [
+      activeThreadId,
+      createThread,
+      deleteThread,
+      isLoadingThread,
+      selectThread,
+      threads
+    ]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(ThreadContext.Provider, { value, children });
+}
+function useThread() {
+  const context = (0, import_react6.useContext)(ThreadContext);
+  if (!context) {
+    throw new Error("useThread must be used inside ThreadProvider");
+  }
+  return context;
+}
+
+// src/components/Chat/context/messages.context.tsx
+var import_jsx_runtime7 = require("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 = (0, import_react7.createContext)(null);
+function MessagesProvider({ adapter, children }) {
+  const { activeThreadId, activeThreadIdRef, setThreads, setIsLoadingThread } = useThread();
+  const { providerRef, modelRef, thinkingLevelsRef } = useModel();
+  const [messages, setMessages] = (0, import_react7.useState)([]);
+  const [status, setStatus] = (0, import_react7.useState)("ready");
+  const [isWaitingForResponse, setIsWaitingForResponse] = (0, import_react7.useState)(false);
+  const messagesRef = (0, import_react7.useRef)(messages);
+  const statusRef = (0, import_react7.useRef)(status);
+  const adapterRef = (0, import_react7.useRef)(adapter);
+  const abortRef = (0, import_react7.useRef)(null);
+  messagesRef.current = messages;
+  statusRef.current = status;
+  adapterRef.current = adapter;
+  (0, import_react7.useEffect)(() => {
+    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 = (0, import_react7.useCallback)(
+    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 = (0, import_react7.useCallback)(
+    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];
+      (0, import_react_dom2.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 = (0, import_react7.useCallback)(
+    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 = (0, import_react7.useCallback)(() => {
+    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 = (0, import_react7.useMemo)(
+    () => ({
+      messages,
+      status,
+      isSending,
+      isWaitingForResponse,
+      sendMessage,
+      editAndResendMessage,
+      stopResponse
+    }),
+    [editAndResendMessage, isSending, isWaitingForResponse, messages, sendMessage, status, stopResponse]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(MessagesContext.Provider, { value, children });
+}
+function useMessages() {
+  const context = (0, import_react7.useContext)(MessagesContext);
+  if (!context) {
+    throw new Error("useMessages must be used inside MessagesProvider");
+  }
+  return context;
+}
+
+// src/components/Chat/context/composer.context.tsx
+var import_jsx_runtime8 = require("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 = (0, import_react8.createContext)(null);
+function ComposerProvider({ children }) {
+  const { activeThreadId, activeThreadIdRef, isLoadingThread, setThreads } = useThread();
+  const { providerRef, modelRef } = useModel();
+  const { sendMessage, isSending } = useMessages();
+  const [input, setInputState] = (0, import_react8.useState)("");
+  const [references, setReferences] = (0, import_react8.useState)([]);
+  const [attachments, setAttachments] = (0, import_react8.useState)([]);
+  const inputRef = (0, import_react8.useRef)(input);
+  const referencesRef = (0, import_react8.useRef)(references);
+  const attachmentsRef = (0, import_react8.useRef)(attachments);
+  inputRef.current = input;
+  referencesRef.current = references;
+  attachmentsRef.current = attachments;
+  const setInput = (0, import_react8.useCallback)((value2) => {
+    setInputState(value2);
+  }, []);
+  const addReference = (0, import_react8.useCallback)((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 = (0, import_react8.useCallback)((id) => {
+    setReferences((current) => current.filter((reference) => reference.id !== id));
+  }, []);
+  const clearReferences = (0, import_react8.useCallback)(() => {
+    setReferences([]);
+  }, []);
+  const addFiles = (0, import_react8.useCallback)(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 = (0, import_react8.useCallback)((id) => {
+    setAttachments((current) => current.filter((attachment) => attachment.id !== id));
+  }, []);
+  const disabled = isSending || isLoadingThread || !activeThreadId;
+  const canSend = !disabled && (!!input.trim() || attachments.length > 0);
+  const disabledRef = (0, import_react8.useRef)(disabled);
+  disabledRef.current = disabled;
+  const submitInput = (0, import_react8.useCallback)(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 = (0, import_react8.useMemo)(
+    () => ({
+      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__ */ (0, import_jsx_runtime8.jsxs)(ComposerContext.Provider, { value, children: [
+    children,
+    /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(ChatTooltip, { onAddReference: addReference })
+  ] });
+}
+function useComposer() {
+  const context = (0, import_react8.useContext)(ComposerContext);
+  if (!context) {
+    throw new Error("useComposer must be used inside ComposerProvider");
+  }
+  return context;
+}
+
+// src/components/Chat/context/chat.provider.tsx
+var import_jsx_runtime9 = require("react/jsx-runtime");
+function ChatContextProvider({
+  adapter,
+  children,
+  defaultProvider = "mock" /* MOCK */,
+  defaultThreadId,
+  registryUrl = "/api/ai/registry"
+}) {
+  return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(ModelProvider, { defaultProvider, registryUrl, children: /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(ThreadProvider, { adapter, defaultThreadId, children: /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(MessagesProvider, { adapter, children: /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(ComposerProvider, { children }) }) }) });
+}
+
+// src/components/Chat/context/index.ts
+function useChat() {
+  const composer = useComposer();
+  const messages = useMessages();
+  const model = useModel();
+  const thread = useThread();
+  return (0, import_react9.useMemo)(() => {
+    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
+var import_jsx_runtime10 = require("react/jsx-runtime");
+var isImageMediaType = (mediaType) => mediaType.startsWith("image/");
+var ChatAttachments = () => {
+  const { attachments, removeAttachment } = useComposer();
+  if (attachments.length === 0) {
+    return null;
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("div", { className: "chat-attachments", children: attachments.map((attachment) => {
+    const image = isImageMediaType(attachment.mediaType);
+    return /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)(
+      "div",
+      {
+        className: image ? "chat-attachment chat-attachment-image" : "chat-attachment chat-attachment-file",
+        children: [
+          image ? /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("img", { src: attachment.url, alt: attachment.filename }) : /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)(import_jsx_runtime10.Fragment, { children: [
+            /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(import_lucide_react2.FileText, { size: 14, "aria-hidden": "true" }),
+            /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("span", { className: "chat-attachment-name", children: attachment.filename })
+          ] }),
+          /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
+            "button",
+            {
+              type: "button",
+              className: "chat-attachment-remove",
+              "aria-label": `Remove ${attachment.filename}`,
+              onClick: () => removeAttachment(attachment.id),
+              children: /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(import_lucide_react2.X, { size: 12 })
+            }
+          )
+        ]
+      },
+      attachment.id
+    );
+  }) });
+};
+var ChatAttachButton = () => {
+  const { disabled, addFiles } = useComposer();
+  const inputRef = (0, import_react10.useRef)(null);
+  return /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)(import_jsx_runtime10.Fragment, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
+      "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__ */ (0, import_jsx_runtime10.jsx)(import_lucide_react2.Paperclip, { size: 16 })
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
+      "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
+var import_react11 = require("react");
+var import_jsx_runtime11 = require("react/jsx-runtime");
+var ChatInput = ({
+  placeholder = "Message...",
+  expanded = true
+}) => {
+  const { input, setInput, disabled, submitInput, attachments } = useComposer();
+  const ref = (0, import_react11.useRef)(null);
+  const hasDraft = input.trim().length > 0 || attachments.length > 0;
+  (0, import_react11.useEffect)(() => {
+    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__ */ (0, import_jsx_runtime11.jsx)("div", { className: "chat-composer-input", children: /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+    "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
+var import_lucide_react3 = require("lucide-react");
+var import_jsx_runtime12 = require("react/jsx-runtime");
+var ChatReferences = () => {
+  const { references, removeReference } = useComposer();
+  if (references.length === 0) {
+    return null;
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)("div", { className: "chat-references", children: references.map((reference, index) => /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)("div", { className: "chat-reference", title: reference.text, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime12.jsx)("span", { className: "chat-reference-text", children: reference.text }),
+    /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
+      "button",
+      {
+        type: "button",
+        className: "chat-icon-button",
+        "aria-label": `Remove reference ${index + 1}`,
+        onClick: () => removeReference(reference.id),
+        children: /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_lucide_react3.X, { size: 12 })
+      }
+    )
+  ] }, reference.id)) });
+};
+
+// src/components/Chat/chat.send.tsx
+var import_lucide_react4 = require("lucide-react");
+var import_jsx_runtime13 = require("react/jsx-runtime");
+var ChatSend = () => {
+  const { canSend, submitInput } = useComposer();
+  const { status, stopResponse, isSending } = useMessages();
+  return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
+    "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__ */ (0, import_jsx_runtime13.jsx)(import_lucide_react4.Square, { size: 14, fill: "currentColor" }) : /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_lucide_react4.Send, { size: 16 })
+    }
+  );
+};
+
+// src/components/Chat/chat.select.tsx
+var import_react12 = require("react");
+
+// src/ui/select.tsx
+var import_lucide_react5 = require("lucide-react");
+var import_radix_ui = require("radix-ui");
+var import_jsx_runtime14 = require("react/jsx-runtime");
+function Select({
+  ...props
+}) {
+  return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_radix_ui.Select.Root, { "data-slot": "select", ...props });
+}
+function SelectGroup({
+  ...props
+}) {
+  return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_radix_ui.Select.Group, { "data-slot": "select-group", ...props });
+}
+function SelectTrigger({
+  className,
+  size = "default",
+  children,
+  ...props
+}) {
+  return /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(
+    import_radix_ui.Select.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__ */ (0, import_jsx_runtime14.jsx)(import_radix_ui.Select.Icon, { asChild: true, children: /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_lucide_react5.ChevronDownIcon, { className: "size-4 opacity-50" }) })
+      ]
+    }
+  );
+}
+function SelectContent({
+  className,
+  children,
+  portalContainer,
+  position = "item-aligned",
+  align = "center",
+  ...props
+}) {
+  return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_radix_ui.Select.Portal, { container: portalContainer, children: /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(
+    import_radix_ui.Select.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__ */ (0, import_jsx_runtime14.jsx)(SelectScrollUpButton, {}),
+        /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
+          import_radix_ui.Select.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__ */ (0, import_jsx_runtime14.jsx)(SelectScrollDownButton, {})
+      ]
+    }
+  ) });
+}
+function SelectLabel({
+  className,
+  ...props
+}) {
+  return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
+    import_radix_ui.Select.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__ */ (0, import_jsx_runtime14.jsxs)(
+    import_radix_ui.Select.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__ */ (0, import_jsx_runtime14.jsx)(
+          "span",
+          {
+            "data-slot": "select-item-indicator",
+            className: "absolute right-2 flex size-3.5 items-center justify-center",
+            children: /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_radix_ui.Select.ItemIndicator, { children: /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_lucide_react5.CheckIcon, { className: "size-4" }) })
+          }
+        ),
+        /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_radix_ui.Select.ItemText, { children })
+      ]
+    }
+  );
+}
+function SelectScrollUpButton({
+  className,
+  ...props
+}) {
+  return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
+    import_radix_ui.Select.ScrollUpButton,
+    {
+      "data-slot": "select-scroll-up-button",
+      className: cn(
+        "flex cursor-default items-center justify-center py-1",
+        className
+      ),
+      ...props,
+      children: /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_lucide_react5.ChevronUpIcon, { className: "size-4" })
+    }
+  );
+}
+function SelectScrollDownButton({
+  className,
+  ...props
+}) {
+  return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
+    import_radix_ui.Select.ScrollDownButton,
+    {
+      "data-slot": "select-scroll-down-button",
+      className: cn(
+        "flex cursor-default items-center justify-center py-1",
+        className
+      ),
+      ...props,
+      children: /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_lucide_react5.ChevronDownIcon, { className: "size-4" })
+    }
+  );
+}
+
+// src/components/Chat/chat.select.tsx
+var import_lucide_react6 = require("lucide-react");
+var import_jsx_runtime15 = require("react/jsx-runtime");
+var SELECT_ORIGIN = "top-left";
+var THINKING_ORIGIN = "top-right";
+var ProviderBadge = ({ logo, name }) => {
+  if (logo) {
+    return /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+      "img",
+      {
+        className: "chat-model-provider-logo",
+        src: logo,
+        alt: "",
+        "aria-hidden": "true"
+      }
+    );
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("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] = (0, import_react12.useState)(null);
+  const [query, setQuery] = (0, import_react12.useState)("");
+  const [thinkingOpen, setThinkingOpen] = (0, import_react12.useState)(null);
+  const [menuOpen, setMenuOpen] = (0, import_react12.useState)(false);
+  const rootRef = (0, import_react12.useRef)(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 = (0, import_react12.useMemo)(() => {
+    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 = (0, import_react12.useCallback)((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__ */ (0, import_jsx_runtime15.jsx)("div", { ref: setRootElement, children: /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(
+    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__ */ (0, import_jsx_runtime15.jsx)(SelectTrigger, { className: "chat-model-trigger", children: /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("span", { className: "chat-model-selected", children: [
+          selectedModel ? /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(ProviderBadge, { logo: selectedProvider == null ? void 0 : selectedProvider.logo, name: providerName }) : null,
+          /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("span", { children: modelLabel })
+        ] }) }),
+        /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(
+          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__ */ (0, import_jsx_runtime15.jsx)("div", { className: "chat-model-search", children: /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+                "input",
+                {
+                  autoFocus: true,
+                  placeholder: "Search models",
+                  value: query,
+                  onChange: (event) => setQuery(event.target.value),
+                  onKeyDown: (event) => event.stopPropagation(),
+                  className: "chat-model-search-input"
+                }
+              ) }),
+              /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("div", { className: "chat-model-list", children: filteredProviders.length === 0 ? /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("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__ */ (0, import_jsx_runtime15.jsx)(import_react12.Fragment, { children: /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(SelectGroup, { className: "chat-model-group", children: [
+                  hideLabel ? null : /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(SelectLabel, { className: "chat-model-label", children: [
+                    /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(ProviderBadge, { logo: entry.logo, name: providerName2 }),
+                    /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("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__ */ (0, import_jsx_runtime15.jsx)(
+                      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__ */ (0, import_jsx_runtime15.jsxs)("div", { className: "chat-model-row", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(SelectItem, { value: itemKey, className: "chat-model-item", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("span", { className: "chat-model-item-label", children: item.label }),
+      item.description ? /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("span", { className: "chat-model-item-hint", children: item.description }) : thinking && activeThinking ? /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("span", { className: "chat-model-item-hint", children: activeThinking }) : null
+    ] }),
+    thinking ? /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(import_jsx_runtime15.Fragment, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+        "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__ */ (0, import_jsx_runtime15.jsx)(import_lucide_react6.Ellipsis, { className: "chat-model-thinking-icon" })
+        }
+      ),
+      menu.mounted ? /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+        "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__ */ (0, import_jsx_runtime15.jsxs)(
+              "button",
+              {
+                type: "button",
+                className: "chat-model-thinking-option",
+                "data-active": isActive ? "true" : "false",
+                onClick: (event) => {
+                  event.preventDefault();
+                  event.stopPropagation();
+                  onPickThinking(level);
+                },
+                children: [
+                  /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("span", { children: level }),
+                  isActive ? /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(import_lucide_react6.Check, { className: "chat-model-thinking-check" }) : null
+                ]
+              },
+              level
+            );
+          })
+        }
+      ) : null
+    ] }) : null
+  ] });
+};
+
+// src/components/Chat/chat.tsx
+var import_jsx_runtime16 = require("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 = (0, import_react13.useRef)(null);
+  const [focused, setFocused] = (0, import_react13.useState)(defaultExpanded);
+  const expanded = focused || input.trim().length > 0 || attachments.length > 0 || references.length > 0;
+  (0, import_react13.useEffect)(() => {
+    if (status !== "error" || !shellRef.current) {
+      return;
+    }
+    triggerErrorShake(shellRef.current);
+  }, [status]);
+  (0, import_react13.useEffect)(() => {
+    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__ */ (0, import_jsx_runtime16.jsxs)(
+    "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__ */ (0, import_jsx_runtime16.jsx)(import_lucide_react7.MessageCircle, { className: "chat-composer-collapsed-icon", size: 18, "aria-hidden": "true" }),
+        /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(ChatAttachments, {}),
+        /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(ChatReferences, {}),
+        /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(ChatInput, { expanded }),
+        /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)("div", { className: "chat-composer-row", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)("div", { className: "chat-composer-tools", children: [
+            /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(ChatAttachButton, {}),
+            showModelSelector && expanded && collapsedVariant === "circle" ? /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(ChatSelect, {}) : null
+          ] }),
+          /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(ChatSend, {})
+        ] })
+      ]
+    }
+  );
+};
+
+// src/components/Message/message.item.tsx
+var import_lucide_react18 = require("lucide-react");
+var import_react29 = require("react");
+var import_protocol5 = require("@sarchauhan/protocol");
+
+// src/components/Message/message.content.tsx
+var import_protocol3 = require("@sarchauhan/protocol");
+var import_lucide_react14 = require("lucide-react");
+var import_react26 = require("react");
+
+// src/lib/message/segment.ts
+var splitThinkingSegments = (content) => {
+  const segments = [];
+  let cursor = 0;
+  while (cursor < content.length) {
+    const openingIndex = content.indexOf("<thinking>", cursor);
+    if (openingIndex === -1) {
+      segments.push({
+        type: "markdown",
+        content: content.slice(cursor)
+      });
+      break;
+    }
+    if (openingIndex > cursor) {
+      segments.push({
+        type: "markdown",
+        content: content.slice(cursor, openingIndex)
+      });
+    }
+    const thinkingStart = openingIndex + "<thinking>".length;
+    const closingIndex = content.indexOf("</thinking>", thinkingStart);
+    if (closingIndex === -1) {
+      segments.push({
+        type: "thinking",
+        content: content.slice(thinkingStart).trim(),
+        isComplete: false
+      });
+      break;
+    }
+    segments.push({
+      type: "thinking",
+      content: content.slice(thinkingStart, closingIndex).trim(),
+      isComplete: true
+    });
+    cursor = closingIndex + "</thinking>".length;
+  }
+  if (!segments.length) {
+    return [{ type: "markdown", content }];
+  }
+  return segments;
+};
+
+// src/widgets/artifact.tsx
+var import_react15 = require("react");
+var import_lucide_react9 = require("lucide-react");
+
+// src/widgets/responsive-detail.tsx
+var import_react14 = require("react");
+var import_radix_ui2 = require("radix-ui");
+var import_lucide_react8 = require("lucide-react");
+var import_jsx_runtime17 = require("react/jsx-runtime");
+function ResponsiveDetail({ title, description = "Details from this conversation", trigger, children }) {
+  const origin = (0, import_react14.useRef)(null);
+  const [presentation, setPresentation] = (0, import_react14.useState)({ theme: "light", style: {} });
+  return /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("div", { ref: origin, className: "chat-detail-origin", children: /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)(import_radix_ui2.Dialog.Root, { onOpenChange: (open) => {
+    var _a, _b;
+    if (!open || !origin.current) return;
+    const host = (_a = origin.current.closest(".chat-root")) != null ? _a : origin.current;
+    const computed = window.getComputedStyle(host);
+    const tokens = {};
+    for (let index = 0; index < computed.length; index++) {
+      const name = computed.item(index);
+      if (name.startsWith("--chat-")) tokens[name] = computed.getPropertyValue(name);
+    }
+    const requested = host.getAttribute("data-theme");
+    const dark = requested === "dark" || requested === "system" && ((_b = window.matchMedia) == null ? void 0 : _b.call(window, "(prefers-color-scheme: dark)").matches);
+    setPresentation({ theme: dark ? "dark" : "light", style: tokens });
+  }, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(import_radix_ui2.Dialog.Trigger, { asChild: true, children: trigger }),
+    /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)(import_radix_ui2.Dialog.Portal, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(import_radix_ui2.Dialog.Overlay, { className: "chat-detail-overlay" }),
+      /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)(import_radix_ui2.Dialog.Content, { className: "chat-root chat-detail-panel", "data-theme": presentation.theme, style: presentation.style, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("div", { className: "chat-detail-handle", "aria-hidden": "true" }),
+        /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)("header", { className: "chat-detail-header", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)("div", { children: [
+            /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(import_radix_ui2.Dialog.Title, { className: "chat-detail-title", children: title }),
+            /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(import_radix_ui2.Dialog.Description, { className: "chat-detail-description", children: description })
+          ] }),
+          /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(import_radix_ui2.Dialog.Close, { className: "chat-detail-close", "aria-label": "Close details", children: /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(import_lucide_react8.X, { size: 18, "aria-hidden": "true" }) })
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("div", { className: "chat-detail-body", children })
+      ] })
+    ] })
+  ] }) });
+}
+
+// src/widgets/artifact.tsx
+var import_jsx_runtime18 = require("react/jsx-runtime");
+function safeArtifactUrl(value, image = false) {
+  if (!value || /[\u0000-\u0020\u007f]/.test(value)) return void 0;
+  if (/^blob:/i.test(value)) {
+    try {
+      new URL(value);
+      return value;
+    } catch {
+      return void 0;
+    }
+  }
+  if (image && /^data:image\/(?:png|jpeg|gif|webp|avif);base64,[a-z0-9+/=]+$/i.test(value)) return value;
+  try {
+    const parsed = new URL(value, "https://chat.invalid");
+    if (!["https:", "http:"].includes(parsed.protocol)) return void 0;
+    return value;
+  } catch {
+    return void 0;
+  }
+}
+function formatArtifactSize(bytes) {
+  if (bytes === void 0 || !Number.isFinite(bytes) || bytes < 0) return void 0;
+  if (bytes < 1024) return bytes + " B";
+  if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(1) + " KB";
+  return (bytes / (1024 * 1024)).toFixed(1) + " MB";
+}
+function ArtifactWidget({ artifact, className = "" }) {
+  var _a;
+  const { filename, mediaType, content, sizeBytes, error } = artifact;
+  const state = (_a = artifact.status) != null ? _a : "ready";
+  const image = mediaType.startsWith("image/");
+  const [failedUrl, setFailedUrl] = (0, import_react15.useState)();
+  const previewUrl = image ? safeArtifactUrl(artifact.url, true) : void 0;
+  const link = safeArtifactUrl(artifact.url, image);
+  const ready = state === "ready";
+  const preview = ready && (previewUrl && failedUrl !== previewUrl || content !== void 0);
+  const Icon = image ? import_lucide_react9.Image : import_lucide_react9.FileText;
+  const label = state === "creating" ? "Creating\u2026" : state === "error" ? "Could not create file" : "Created";
+  const metadata = [mediaType, formatArtifactSize(sizeBytes)].filter(Boolean).join(" \xB7 ");
+  return /* @__PURE__ */ (0, import_jsx_runtime18.jsxs)("section", { className: "chat-prebuilt chat-artifact " + className, "aria-label": "Artifact: " + filename, "data-state": state, children: [
+    ready && previewUrl && failedUrl !== previewUrl ? /* @__PURE__ */ (0, import_jsx_runtime18.jsx)("div", { className: "chat-artifact-thumbnail", children: /* @__PURE__ */ (0, import_jsx_runtime18.jsx)("img", { src: previewUrl, alt: filename, loading: "lazy", onError: () => setFailedUrl(previewUrl) }) }) : null,
+    /* @__PURE__ */ (0, import_jsx_runtime18.jsxs)("div", { className: "chat-artifact-row", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime18.jsx)("span", { className: "chat-artifact-icon", children: /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(Icon, { size: 20, "aria-hidden": "true" }) }),
+      /* @__PURE__ */ (0, import_jsx_runtime18.jsxs)("div", { className: "chat-artifact-heading", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime18.jsx)("strong", { title: filename, children: filename }),
+        /* @__PURE__ */ (0, import_jsx_runtime18.jsx)("span", { children: metadata })
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime18.jsx)("span", { className: "chat-artifact-state", role: "status", children: label })
+    ] }),
+    state === "error" && error ? /* @__PURE__ */ (0, import_jsx_runtime18.jsx)("p", { className: "chat-widget-error", role: "alert", children: error }) : null,
+    ready && image && previewUrl && failedUrl === previewUrl ? /* @__PURE__ */ (0, import_jsx_runtime18.jsx)("p", { className: "chat-widget-empty", children: "Image preview unavailable." }) : null,
+    ready && (preview || link) ? /* @__PURE__ */ (0, import_jsx_runtime18.jsxs)("footer", { className: "chat-artifact-actions", children: [
+      preview ? /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(ResponsiveDetail, { title: filename, description: metadata, trigger: /* @__PURE__ */ (0, import_jsx_runtime18.jsx)("button", { type: "button", children: "Preview" }), children: image && previewUrl && failedUrl !== previewUrl ? /* @__PURE__ */ (0, import_jsx_runtime18.jsx)("img", { className: "chat-artifact-full-image", src: previewUrl, alt: filename, onError: () => setFailedUrl(previewUrl) }) : /* @__PURE__ */ (0, import_jsx_runtime18.jsx)("pre", { className: "chat-artifact-text", tabIndex: 0, children: content }) }) : null,
+      link ? /* @__PURE__ */ (0, import_jsx_runtime18.jsxs)(import_jsx_runtime18.Fragment, { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime18.jsxs)("a", { href: link, target: "_blank", rel: "noreferrer", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(import_lucide_react9.ExternalLink, { size: 14, "aria-hidden": "true" }),
+          "Open"
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime18.jsxs)("a", { href: link, download: filename, target: "_blank", rel: "noreferrer", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(import_lucide_react9.Download, { size: 14, "aria-hidden": "true" }),
+          "Download"
+        ] })
+      ] }) : null
+    ] }) : null
+  ] });
+}
+function ArtifactsWidget({ artifacts, className = "" }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime18.jsx)("div", { className: "chat-artifacts " + className, children: artifacts.map((artifact) => /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(ArtifactWidget, { artifact }, artifact.id)) });
+}
+
+// src/widgets/compute.ts
+var import_protocol = require("@sarchauhan/protocol");
+var record = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+var string = (...values) => values.find((value) => typeof value === "string");
+var number = (...values) => values.find(
+  (value) => typeof value === "number" && Number.isFinite(value)
+);
+var aliases = {
+  read: "read-file",
+  read_file: "read-file",
+  readFile: "read-file",
+  "read-file": "read-file",
+  patch: "patch",
+  apply_patch: "patch",
+  edit_file: "patch",
+  edit: "patch",
+  search: "search",
+  grep: "search",
+  file_search: "search",
+  web_search: "search",
+  question: "question",
+  ask_question: "question"
+};
+function computeToolState(part) {
+  if (part.state === "output-error") return "error";
+  if (part.state === "output-denied") return "denied";
+  if (part.state === "approval-requested") return "approval";
+  return part.state === "output-available" && !part.preliminary ? "complete" : "running";
+}
+function normalizeSearchResults(value) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((item) => {
+    const result = record(item);
+    const path = string(result.path, result.file, result.url);
+    if (!path) return [];
+    return [
+      {
+        path,
+        line: number(result.line, result.lineNumber),
+        text: string(result.text, result.snippet, result.content),
+        title: string(result.title),
+        url: string(result.url)
+      }
+    ];
+  });
+}
+function computeToolWidget(part) {
+  var _a, _b, _c;
+  const name = aliases[part.toolName];
+  if (!name) {
+    const output2 = record(part.output);
+    if (part.state !== "output-available") return null;
+    if (Array.isArray(output2.artifacts)) {
+      const artifacts = output2.artifacts.flatMap((value) => {
+        const artifact2 = (0, import_protocol.parseArtifact)(value);
+        return artifact2 ? [artifact2] : [];
+      });
+      return artifacts.length ? { type: "widget", name: "artifacts", id: part.toolCallId, props: { artifacts } } : null;
+    }
+    const artifact = (0, import_protocol.parseArtifact)(output2.artifact);
+    return artifact ? { type: "widget", name: "artifact", id: part.toolCallId, props: { artifact } } : null;
+  }
+  const input = record(part.input), output = record(part.output);
+  const values = { ...input, ...output };
+  const common2 = { state: computeToolState(part), error: part.errorText };
+  let props;
+  if (name === "read-file") {
+    const path = string(
+      values.path,
+      values.file,
+      values.filename,
+      values.file_path
+    );
+    if (!path) return null;
+    props = {
+      ...common2,
+      path,
+      content: string(output.content, output.text, part.output),
+      startLine: number(values.startLine, values.start_line, values.offset),
+      language: string(values.language)
+    };
+    if (part.state === "output-available" && props.content === void 0)
+      return null;
+  } else if (name === "patch") {
+    const before = string(values.before, values.old_string, values.oldText);
+    const after = string(values.after, values.new_string, values.newText);
+    const diff = (_a = string(
+      output.diff,
+      output.patch,
+      input.diff,
+      input.patch,
+      part.input,
+      part.output
+    )) != null ? _a : before !== void 0 && after !== void 0 ? computeTextDiff(
+      before,
+      after,
+      string(values.path, values.file_path, "file")
+    ) : void 0;
+    if (diff === void 0 || diff && !/^(@@|diff --git|--- |\*\*\* Begin Patch)/m.test(diff))
+      return null;
+    props = {
+      ...common2,
+      path: string(values.path, values.file, values.file_path),
+      diff
+    };
+  } else if (name === "search") {
+    const query = string(values.query, values.pattern, values.search);
+    if (query === void 0) return null;
+    const results = (_c = (_b = output.results) != null ? _b : output.matches) != null ? _c : Array.isArray(part.output) ? part.output : void 0;
+    if (part.state === "output-available" && !Array.isArray(results))
+      return null;
+    props = {
+      ...common2,
+      query,
+      results: normalizeSearchResults(results),
+      total: number(output.total, output.totalCount)
+    };
+  } else {
+    if (["output-error", "output-denied", "approval-requested"].includes(
+      part.state
+    ))
+      return null;
+    const prompt = string(input.prompt, input.question);
+    if (!prompt) return null;
+    props = { ...input, prompt };
+  }
+  return {
+    type: "widget",
+    name,
+    id: part.toolCallId,
+    props,
+    interactive: name === "question" && part.state === "input-available"
+  };
+}
+function computeDiff(diff) {
+  let oldLine = 0, newLine = 0, inHunk = false, oldRemaining = 0, newRemaining = 0, additions = 0, deletions = 0;
+  const lines = diff.replace(/\r\n/g, "\n").split("\n").map((text) => {
+    var _a, _b;
+    const hunk = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/.exec(text);
+    if (hunk) {
+      oldLine = Number(hunk[1]);
+      newLine = Number(hunk[3]);
+      oldRemaining = Number((_a = hunk[2]) != null ? _a : 1);
+      newRemaining = Number((_b = hunk[4]) != null ? _b : 1);
+      inHunk = true;
+      return { kind: "header", text };
+    }
+    if (oldRemaining === 0 && newRemaining === 0) inHunk = false;
+    if (!inHunk && /^(diff --git|--- |\+\+\+ |\*\*\* )/.test(text)) {
+      inHunk = false;
+      return { kind: "header", text };
+    }
+    if (text.startsWith("@@")) {
+      inHunk = false;
+      return { kind: "header", text };
+    }
+    if (text.startsWith("+")) {
+      additions++;
+      if (inHunk) newRemaining--;
+      return { kind: "add", text, newLine: inHunk ? newLine++ : void 0 };
+    }
+    if (text.startsWith("-")) {
+      deletions++;
+      if (inHunk) oldRemaining--;
+      return {
+        kind: "remove",
+        text,
+        oldLine: inHunk ? oldLine++ : void 0
+      };
+    }
+    if (inHunk && text.startsWith(" ")) {
+      oldRemaining--;
+      newRemaining--;
+      return {
+        kind: "context",
+        text,
+        oldLine: oldLine++,
+        newLine: newLine++
+      };
+    }
+    return { kind: "header", text };
+  });
+  return { lines, additions, deletions };
+}
+function safeResultUrl(url) {
+  try {
+    const parsed = new URL(url != null ? url : "");
+    return ["https:", "http:"].includes(parsed.protocol) ? parsed.href : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function computeTextDiff(before, after, path = "file") {
+  if (before === after) return "";
+  const split = (text) => text === "" ? [] : text.replace(/\r\n/g, "\n").replace(/\n$/, "").split("\n");
+  const oldLines = split(before), newLines = split(after);
+  let prefix = 0, suffix = 0;
+  while (prefix < oldLines.length && prefix < newLines.length && oldLines[prefix] === newLines[prefix])
+    prefix++;
+  while (suffix < oldLines.length - prefix && suffix < newLines.length - prefix && oldLines[oldLines.length - 1 - suffix] === newLines[newLines.length - 1 - suffix])
+    suffix++;
+  if (before.endsWith("\n") !== after.endsWith("\n")) suffix = 0;
+  if (prefix === oldLines.length && prefix === newLines.length) {
+    prefix = Math.max(0, prefix - 1);
+    suffix = 0;
+  }
+  const start = Math.max(0, prefix - 3), tail = Math.min(3, suffix);
+  const oldEnd = oldLines.length - suffix, newEnd = newLines.length - suffix;
+  const oldCount = oldEnd + tail - start, newCount = newEnd + tail - start;
+  const label = path.replace(/[\r\n]/g, "");
+  const body = [
+    ...oldLines.slice(start, prefix).map((line) => " " + line),
+    ...oldLines.slice(prefix, oldEnd).flatMap((line, index) => [
+      "-" + line,
+      ...prefix + index === oldLines.length - 1 && !before.endsWith("\n") ? ["\"] : []
+    ]),
+    ...newLines.slice(prefix, newEnd).flatMap((line, index) => [
+      "+" + line,
+      ...prefix + index === newLines.length - 1 && !after.endsWith("\n") ? ["\"] : []
+    ]),
+    ...oldLines.slice(oldEnd, oldEnd + tail).map((line) => " " + line)
+  ];
+  return [
+    `--- a/${label}`,
+    `+++ b/${label}`,
+    `@@ -${oldCount ? start + 1 : start},${oldCount} +${newCount ? start + 1 : start},${newCount} @@`,
+    ...body
+  ].join("\n");
+}
+
+// src/widgets/registry.tsx
+var import_protocol2 = require("@sarchauhan/protocol");
+
+// src/widgets/subagent.tsx
+var import_react16 = require("react");
+var import_lucide_react10 = require("lucide-react");
+var import_jsx_runtime19 = require("react/jsx-runtime");
+var Depth = (0, import_react16.createContext)(0);
+var labels = { queued: "Queued", running: "Working", completed: "Completed", failed: "Failed", cancelled: "Cancelled" };
+function SubagentWidget({ subagent, className = "" }) {
+  const depth = (0, import_react16.useContext)(Depth);
+  const { title, task, state, summary, progress, messages = [], artifacts = [], error } = subagent;
+  const Icon = state === "completed" ? import_lucide_react10.CircleCheck : state === "failed" ? import_lucide_react10.CircleX : state === "running" ? import_lucide_react10.LoaderCircle : import_lucide_react10.Bot;
+  const canInspect = depth < 3;
+  const transcript = messages.filter((message) => message.role !== "system");
+  return /* @__PURE__ */ (0, import_jsx_runtime19.jsxs)("section", { className: "chat-prebuilt chat-subagent " + className, "data-state": state, "aria-label": "Subagent: " + title, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime19.jsxs)("div", { className: "chat-subagent-heading", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime19.jsx)("span", { className: "chat-subagent-icon", children: /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(Icon, { size: 18, "aria-hidden": "true" }) }),
+      /* @__PURE__ */ (0, import_jsx_runtime19.jsxs)("div", { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime19.jsx)("strong", { children: title }),
+        /* @__PURE__ */ (0, import_jsx_runtime19.jsx)("span", { className: "chat-subagent-state", role: "status", children: labels[state] })
+      ] }),
+      canInspect ? /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(
+        ResponsiveDetail,
+        {
+          title,
+          description: task || "Subagent activity in this conversation",
+          trigger: /* @__PURE__ */ (0, import_jsx_runtime19.jsxs)("button", { className: "chat-subagent-inspect", type: "button", "aria-label": "View activity for " + title, children: [
+            "View activity",
+            /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(import_lucide_react10.ArrowUpRight, { size: 14, "aria-hidden": "true" })
+          ] }),
+          children: /* @__PURE__ */ (0, import_jsx_runtime19.jsxs)(Depth.Provider, { value: depth + 1, children: [
+            /* @__PURE__ */ (0, import_jsx_runtime19.jsxs)("div", { className: "chat-subagent-overview", children: [
+              /* @__PURE__ */ (0, import_jsx_runtime19.jsx)("span", { className: "chat-subagent-state", children: labels[state] }),
+              progress !== void 0 ? /* @__PURE__ */ (0, import_jsx_runtime19.jsxs)("span", { children: [
+                Math.round(progress * 100),
+                "%"
+              ] }) : null
+            ] }),
+            summary ? /* @__PURE__ */ (0, import_jsx_runtime19.jsx)("p", { className: "chat-subagent-summary", children: summary }) : null,
+            error ? /* @__PURE__ */ (0, import_jsx_runtime19.jsx)("p", { className: "chat-widget-error", role: "alert", children: error }) : null,
+            transcript.length ? /* @__PURE__ */ (0, import_jsx_runtime19.jsx)("div", { className: "chat-subagent-transcript", children: transcript.map((message) => /* @__PURE__ */ (0, import_jsx_runtime19.jsxs)("article", { className: "chat-subagent-message", children: [
+              /* @__PURE__ */ (0, import_jsx_runtime19.jsx)("div", { className: "chat-subagent-role", children: message.role === "user" ? "Task" : title }),
+              /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(MessageContent, { parts: message.parts, isUser: message.role === "user" })
+            ] }, message.id)) }) : /* @__PURE__ */ (0, import_jsx_runtime19.jsx)("p", { className: "chat-widget-empty", children: state === "queued" ? "Waiting to start." : state === "running" ? "Activity will appear as the agent works." : "No activity was recorded." }),
+            artifacts.length ? /* @__PURE__ */ (0, import_jsx_runtime19.jsxs)("div", { className: "chat-subagent-artifacts", children: [
+              /* @__PURE__ */ (0, import_jsx_runtime19.jsx)("h4", { children: "Created files" }),
+              /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(ArtifactsWidget, { artifacts })
+            ] }) : null
+          ] })
+        }
+      ) : null
+    ] }),
+    task ? /* @__PURE__ */ (0, import_jsx_runtime19.jsx)("p", { className: "chat-subagent-task", children: task }) : null,
+    summary ? /* @__PURE__ */ (0, import_jsx_runtime19.jsx)("p", { className: "chat-subagent-summary", children: summary }) : null,
+    state === "running" && progress !== void 0 ? /* @__PURE__ */ (0, import_jsx_runtime19.jsx)("progress", { className: "chat-subagent-progress", value: progress, max: 1, "aria-label": "Progress for " + title }) : null,
+    state === "failed" && error ? /* @__PURE__ */ (0, import_jsx_runtime19.jsx)("p", { className: "chat-widget-error", role: "alert", children: error }) : null
+  ] });
+}
+
+// src/widgets/patch.tsx
+var import_react17 = require("react");
+
+// src/widgets/tool-frame.tsx
+var import_lucide_react11 = require("lucide-react");
+var import_jsx_runtime20 = require("react/jsx-runtime");
+function ToolFrame({
+  label,
+  title,
+  meta,
+  state = "complete",
+  error,
+  className = "",
+  children
+}) {
+  const status = {
+    running: "Working",
+    complete: "Done",
+    error: "Failed",
+    denied: "Denied",
+    approval: "Needs approval"
+  }[state];
+  return /* @__PURE__ */ (0, import_jsx_runtime20.jsxs)(
+    "details",
+    {
+      className: `chat-prebuilt chat-tool-widget ${className}`,
+      "data-state": state,
+      open: state !== "complete",
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime20.jsxs)("summary", { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(import_lucide_react11.ChevronDown, { size: 14, "aria-hidden": "true" }),
+          /* @__PURE__ */ (0, import_jsx_runtime20.jsx)("span", { className: "chat-tool-widget-label", children: label }),
+          /* @__PURE__ */ (0, import_jsx_runtime20.jsx)("span", { className: "chat-tool-widget-title", title, children: title }),
+          /* @__PURE__ */ (0, import_jsx_runtime20.jsx)("span", { className: "chat-tool-widget-meta", children: meta }),
+          /* @__PURE__ */ (0, import_jsx_runtime20.jsx)("span", { className: "chat-tool-widget-status", role: "status", children: status })
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime20.jsx)("div", { className: "chat-tool-widget-body", children: error ? /* @__PURE__ */ (0, import_jsx_runtime20.jsx)("p", { className: "chat-widget-error", role: "alert", children: error }) : children })
+      ]
+    }
+  );
+}
+
+// src/widgets/patch.tsx
+var import_jsx_runtime21 = require("react/jsx-runtime");
+function PatchWidget({
+  path = "File changes",
+  diff: rawDiff,
+  before,
+  after,
+  maxLines = 100,
+  ...props
+}) {
+  const diff = (0, import_react17.useMemo)(
+    () => rawDiff != null ? rawDiff : before !== void 0 && after !== void 0 ? computeTextDiff(before, after, path) : "",
+    [rawDiff, before, after, path]
+  );
+  const [expanded, setExpanded] = (0, import_react17.useState)(false);
+  const { lines, additions, deletions } = (0, import_react17.useMemo)(
+    () => computeDiff(diff),
+    [diff]
+  );
+  const limit = Math.max(1, maxLines);
+  return /* @__PURE__ */ (0, import_jsx_runtime21.jsxs)(
+    ToolFrame,
+    {
+      ...props,
+      label: "Patch",
+      title: path,
+      meta: /* @__PURE__ */ (0, import_jsx_runtime21.jsxs)(import_jsx_runtime21.Fragment, { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime21.jsxs)("span", { className: "chat-diff-add-count", children: [
+          "+",
+          additions
+        ] }),
+        " ",
+        /* @__PURE__ */ (0, import_jsx_runtime21.jsxs)("span", { className: "chat-diff-remove-count", children: [
+          "\u2212",
+          deletions
+        ] })
+      ] }),
+      children: [
+        diff ? /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(
+          "div",
+          {
+            className: "chat-code-preview chat-diff",
+            role: "region",
+            "aria-label": `Diff for ${path}`,
+            tabIndex: 0,
+            children: (expanded ? lines : lines.slice(0, limit)).map((line, index) => /* @__PURE__ */ (0, import_jsx_runtime21.jsxs)("div", { className: "chat-code-line", "data-kind": line.kind, children: [
+              /* @__PURE__ */ (0, import_jsx_runtime21.jsx)("span", { className: "chat-line-number", "aria-hidden": "true", children: line.oldLine }),
+              /* @__PURE__ */ (0, import_jsx_runtime21.jsx)("span", { className: "chat-line-number", "aria-hidden": "true", children: line.newLine }),
+              /* @__PURE__ */ (0, import_jsx_runtime21.jsx)("code", { children: line.text || " " })
+            ] }, index))
+          }
+        ) : /* @__PURE__ */ (0, import_jsx_runtime21.jsx)("p", { className: "chat-widget-empty", children: "No changes supplied." }),
+        !expanded && lines.length > limit ? /* @__PURE__ */ (0, import_jsx_runtime21.jsxs)(
+          "button",
+          {
+            className: "chat-widget-more",
+            type: "button",
+            onClick: () => setExpanded(true),
+            children: [
+              "Show full diff (",
+              lines.length,
+              " lines)"
+            ]
+          }
+        ) : null
+      ]
+    }
+  );
+}
+
+// src/widgets/question.tsx
+var import_react18 = require("react");
+var import_lucide_react12 = require("lucide-react");
+var import_jsx_runtime22 = require("react/jsx-runtime");
+function QuestionWidget({
+  prompt,
+  description,
+  options = [],
+  multiple = false,
+  allowCustom = false,
+  disabled = false,
+  onSubmit,
+  className = ""
+}) {
+  const id = (0, import_react18.useId)();
+  const [selected, setSelected] = (0, import_react18.useState)([]), [text, setText] = (0, import_react18.useState)("");
+  const [status, setStatus] = (0, import_react18.useState)("idle");
+  const [error, setError] = (0, import_react18.useState)();
+  const submitting = (0, import_react18.useRef)(false);
+  const choices = options.map(
+    (option) => typeof option === "string" ? { label: option, value: option } : option
+  );
+  const locked = disabled || status !== "idle" || !onSubmit;
+  return /* @__PURE__ */ (0, import_jsx_runtime22.jsxs)(
+    "form",
+    {
+      className: `chat-prebuilt chat-question ${className}`,
+      "aria-labelledby": `${id}-prompt`,
+      onSubmit: async (event) => {
+        event.preventDefault();
+        if (locked || submitting.current || !selected.length && !text.trim())
+          return;
+        submitting.current = true;
+        setStatus("sending");
+        setError(void 0);
+        try {
+          await (onSubmit == null ? void 0 : onSubmit({
+            values: selected,
+            ...text.trim() ? { text: text.trim() } : {}
+          }));
+          setStatus("sent");
+        } catch (cause) {
+          setError(
+            cause instanceof Error ? cause.message : "Could not send your answer. Try again."
+          );
+          setStatus("idle");
+        } finally {
+          submitting.current = false;
+        }
+      },
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("div", { className: "chat-question-eyebrow", children: "Your input" }),
+        /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("h3", { id: `${id}-prompt`, children: prompt }),
+        description ? /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("p", { className: "chat-question-description", children: description }) : null,
+        /* @__PURE__ */ (0, import_jsx_runtime22.jsxs)("fieldset", { disabled: locked, children: [
+          /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("legend", { className: "chat-sr-only", children: multiple ? "Select one or more options" : "Select an option" }),
+          choices.map((option, index) => /* @__PURE__ */ (0, import_jsx_runtime22.jsxs)(
+            "label",
+            {
+              className: "chat-question-option",
+              "data-selected": selected.includes(option.value),
+              children: [
+                /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(
+                  "input",
+                  {
+                    type: multiple ? "checkbox" : "radio",
+                    name: id,
+                    value: option.value,
+                    checked: selected.includes(option.value),
+                    onChange: () => setSelected(
+                      (current) => multiple ? current.includes(option.value) ? current.filter((value) => value !== option.value) : [...current, option.value] : [option.value]
+                    )
+                  }
+                ),
+                /* @__PURE__ */ (0, import_jsx_runtime22.jsxs)("span", { children: [
+                  /* @__PURE__ */ (0, import_jsx_runtime22.jsxs)("span", { className: "chat-question-option-title", children: [
+                    option.label,
+                    option.recommended ? /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("small", { children: "Recommended" }) : null
+                  ] }),
+                  option.description ? /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("span", { className: "chat-question-option-description", children: option.description }) : null
+                ] })
+              ]
+            },
+            `${option.value}-${index}`
+          )),
+          allowCustom || !choices.length ? /* @__PURE__ */ (0, import_jsx_runtime22.jsxs)("label", { className: "chat-question-custom", children: [
+            choices.length ? "Additional context" : "Your answer",
+            /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(
+              "textarea",
+              {
+                rows: 2,
+                value: text,
+                onChange: (event) => setText(event.target.value),
+                placeholder: "Type your answer\u2026"
+              }
+            )
+          ] }) : null
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime22.jsxs)("footer", { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("span", { role: "status", children: status === "sent" ? "Answer sent" : status === "sending" ? "Sending\u2026" : multiple ? "Choose one or more" : choices.length ? "Choose and confirm" : "Write and confirm" }),
+          /* @__PURE__ */ (0, import_jsx_runtime22.jsxs)(
+            "button",
+            {
+              type: "submit",
+              disabled: locked || !selected.length && !text.trim(),
+              children: [
+                status === "sent" ? /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(import_lucide_react12.Check, { size: 14, "aria-hidden": "true" }) : /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(import_lucide_react12.ArrowUp, { size: 14, "aria-hidden": "true" }),
+                status === "sent" ? "Submitted" : "Confirm"
+              ]
+            }
+          )
+        ] }),
+        error ? /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("p", { className: "chat-widget-error", role: "alert", children: error }) : null
+      ]
+    }
+  );
+}
+
+// src/widgets/read-file.tsx
+var import_react19 = require("react");
+var import_jsx_runtime23 = require("react/jsx-runtime");
+function ReadFileWidget({
+  path,
+  content,
+  startLine = 1,
+  language,
+  maxLines = 80,
+  ...props
+}) {
+  var _a;
+  const [expanded, setExpanded] = (0, import_react19.useState)(false);
+  const lines = (_a = content == null ? void 0 : content.split(/\r?\n/)) != null ? _a : [];
+  const limit = Math.max(1, maxLines);
+  const firstLine = Math.max(1, Math.floor(startLine));
+  return /* @__PURE__ */ (0, import_jsx_runtime23.jsxs)(
+    ToolFrame,
+    {
+      ...props,
+      label: "Read file",
+      title: path,
+      meta: lines.length ? `${lines.length} lines` : language,
+      children: [
+        content === void 0 ? /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("p", { className: "chat-widget-empty", children: props.state === "running" ? "Reading file\u2026" : "No file content supplied." }) : /* @__PURE__ */ (0, import_jsx_runtime23.jsx)(
+          "div",
+          {
+            className: "chat-code-preview",
+            role: "region",
+            "aria-label": `Contents of ${path}`,
+            tabIndex: 0,
+            children: (expanded ? lines : lines.slice(0, limit)).map((line, index) => /* @__PURE__ */ (0, import_jsx_runtime23.jsxs)("div", { className: "chat-code-line", children: [
+              /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("span", { className: "chat-line-number", "aria-hidden": "true", children: firstLine + index }),
+              /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("code", { children: line || " " })
+            ] }, index))
+          }
+        ),
+        !expanded && lines.length > limit ? /* @__PURE__ */ (0, import_jsx_runtime23.jsxs)(
+          "button",
+          {
+            className: "chat-widget-more",
+            type: "button",
+            onClick: () => setExpanded(true),
+            children: [
+              "Show ",
+              lines.length - limit,
+              " more lines"
+            ]
+          }
+        ) : null
+      ]
+    }
+  );
+}
+
+// src/widgets/search.tsx
+var import_react20 = require("react");
+var import_jsx_runtime24 = require("react/jsx-runtime");
+function SearchWidget({
+  query,
+  results = [],
+  total,
+  maxResults = 5,
+  ...props
+}) {
+  const [expanded, setExpanded] = (0, import_react20.useState)(false);
+  const limit = Math.max(1, maxResults);
+  const count = Math.max(results.length, total != null ? total : 0);
+  return /* @__PURE__ */ (0, import_jsx_runtime24.jsxs)(
+    ToolFrame,
+    {
+      ...props,
+      label: "Search",
+      title: query,
+      meta: `${count} ${count === 1 ? "result" : "results"}`,
+      children: [
+        !results.length ? /* @__PURE__ */ (0, import_jsx_runtime24.jsx)("p", { className: "chat-widget-empty", children: props.state === "running" ? "Searching\u2026" : "No results found." }) : /* @__PURE__ */ (0, import_jsx_runtime24.jsx)("ol", { className: "chat-search-results", children: (expanded ? results : results.slice(0, limit)).map(
+          (result, index) => {
+            const href = safeResultUrl(result.url);
+            const label = /* @__PURE__ */ (0, import_jsx_runtime24.jsxs)(import_jsx_runtime24.Fragment, { children: [
+              result.title || result.path,
+              result.line ? /* @__PURE__ */ (0, import_jsx_runtime24.jsxs)("span", { className: "chat-search-line", children: [
+                ":",
+                result.line
+              ] }) : null
+            ] });
+            return /* @__PURE__ */ (0, import_jsx_runtime24.jsxs)("li", { children: [
+              href ? /* @__PURE__ */ (0, import_jsx_runtime24.jsx)("a", { href, target: "_blank", rel: "noreferrer", children: label }) : /* @__PURE__ */ (0, import_jsx_runtime24.jsx)("div", { className: "chat-search-path", children: label }),
+              result.text ? /* @__PURE__ */ (0, import_jsx_runtime24.jsx)("p", { children: result.text }) : null
+            ] }, `${result.path}-${result.line}-${index}`);
+          }
+        ) }),
+        !expanded && results.length > limit ? /* @__PURE__ */ (0, import_jsx_runtime24.jsxs)(
+          "button",
+          {
+            className: "chat-widget-more",
+            type: "button",
+            onClick: () => setExpanded(true),
+            children: [
+              "Show ",
+              results.length - limit,
+              " more results"
+            ]
+          }
+        ) : null
+      ]
+    }
+  );
+}
+
+// src/widgets/registry.tsx
+var import_jsx_runtime25 = require("react/jsx-runtime");
+var str = (value, fallback = "") => typeof value === "string" ? value : fallback;
+var num = (value) => typeof value === "number" && Number.isFinite(value) ? value : void 0;
+var common = (props) => ({
+  state: props.state === "running" || props.state === "error" || props.state === "denied" || props.state === "approval" ? props.state : "complete",
+  error: typeof props.error === "string" ? props.error : void 0
+});
+function Read(props) {
+  return /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(
+    ReadFileWidget,
+    {
+      ...common(props),
+      path: str(props.path, "File"),
+      content: typeof props.content === "string" ? props.content : void 0,
+      startLine: num(props.startLine),
+      language: str(props.language)
+    }
+  );
+}
+function Patch(props) {
+  return /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(
+    PatchWidget,
+    {
+      ...common(props),
+      path: str(props.path, "File changes"),
+      diff: typeof props.diff === "string" ? props.diff : void 0,
+      before: typeof props.before === "string" ? props.before : void 0,
+      after: typeof props.after === "string" ? props.after : void 0
+    }
+  );
+}
+function Search(props) {
+  return /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(
+    SearchWidget,
+    {
+      ...common(props),
+      query: str(props.query),
+      results: normalizeSearchResults(props.results),
+      total: num(props.total)
+    }
+  );
+}
+function Question(props) {
+  const options = Array.isArray(props.options) ? props.options.flatMap((item) => {
+    if (typeof item === "string") return [{ label: item, value: item }];
+    if (!item || typeof item !== "object" || typeof item.label !== "string" || typeof item.value !== "string")
+      return [];
+    return [
+      {
+        label: item.label,
+        value: item.value,
+        description: str(item.description),
+        recommended: item.recommended === true
+      }
+    ];
+  }) : [];
+  return /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(
+    QuestionWidget,
+    {
+      prompt: str(props.prompt, "Your answer"),
+      description: str(props.description),
+      options,
+      multiple: props.multiple === true,
+      allowCustom: props.allowCustom === true,
+      disabled: !props.widget.interactive || props.widget.disabled,
+      onSubmit: async (answer) => {
+        const labels2 = answer.values.map(
+          (value) => {
+            var _a, _b;
+            return (_b = (_a = options.find((option) => option.value === value)) == null ? void 0 : _a.label) != null ? _b : value;
+          }
+        );
+        await props.widget.respond(
+          answer,
+          [...labels2, answer.text].filter(Boolean).join(", "),
+          "answer"
+        );
+      }
+    }
+  );
+}
+function Artifact(props) {
+  var _a;
+  const artifact = (0, import_protocol2.parseArtifact)((_a = props.artifact) != null ? _a : props);
+  return artifact ? /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(ArtifactWidget, { artifact }) : /* @__PURE__ */ (0, import_jsx_runtime25.jsx)("p", { className: "chat-widget-empty", children: "File details are unavailable." });
+}
+function Artifacts(props) {
+  const artifacts = Array.isArray(props.artifacts) ? props.artifacts.flatMap((value) => {
+    const artifact = (0, import_protocol2.parseArtifact)(value);
+    return artifact ? [artifact] : [];
+  }) : [];
+  return /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(ArtifactsWidget, { artifacts });
+}
+function Subagent(props) {
+  var _a;
+  const subagent = (0, import_protocol2.parseSubagent)((_a = props.subagent) != null ? _a : props);
+  return subagent ? /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(SubagentWidget, { subagent }) : /* @__PURE__ */ (0, import_jsx_runtime25.jsx)("p", { className: "chat-widget-empty", children: "Agent details are unavailable." });
+}
+var prebuiltWidgets = {
+  artifact: { name: "artifact", component: Artifact, shell: false },
+  artifacts: { name: "artifacts", component: Artifacts, shell: false },
+  subagent: { name: "subagent", component: Subagent, shell: false },
+  "read-file": { name: "read-file", component: Read, shell: false },
+  patch: { name: "patch", component: Patch, shell: false },
+  search: { name: "search", component: Search, shell: false },
+  question: { name: "question", component: Question, shell: false }
+};
+
+// src/components/Widget/widget.context.tsx
+var import_react21 = require("react");
+var import_jsx_runtime26 = require("react/jsx-runtime");
+function defineWidget(name, component, options = {}) {
+  return {
+    name,
+    component,
+    shell: true,
+    ...options
+  };
+}
+function createWidgetRegistry(widgets = {}) {
+  if (Array.isArray(widgets)) {
+    return Object.fromEntries(widgets.map((widget) => [widget.name, widget]));
+  }
+  return widgets;
+}
+function readWidgetValue(value, props, controls) {
+  return typeof value === "function" ? value(props, controls) : value;
+}
+function getWidgetShellProps(definition, props, controls) {
+  var _a;
+  const title = readWidgetValue(definition.title, props, controls);
+  return {
+    label: (_a = readWidgetValue(definition.label, props, controls)) != null ? _a : definition.name.replace(/[-_]/g, " "),
+    title: title != null ? title : definition.name,
+    status: readWidgetValue(definition.status, props, controls),
+    meta: readWidgetValue(definition.meta, props, controls),
+    className: readWidgetValue(definition.className, props, controls)
+  };
+}
+function isWidgetDefinition(entry) {
+  return Boolean(entry && typeof entry === "object" && "component" in entry);
+}
+var WidgetContext = (0, import_react21.createContext)(null);
+function WidgetProvider({
+  widgets = {},
+  respondToWidget,
+  disabled = false,
+  children
+}) {
+  const registry = (0, import_react21.useMemo)(() => ({ ...prebuiltWidgets, ...createWidgetRegistry(widgets) }), [widgets]);
+  const value = (0, import_react21.useMemo)(
+    () => ({
+      widgets: registry,
+      respondToWidget,
+      disabled
+    }),
+    [disabled, registry, respondToWidget]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime26.jsx)(WidgetContext.Provider, { value, children });
+}
+function useWidgets() {
+  const context = (0, import_react21.useContext)(WidgetContext);
+  if (!context) {
+    return {
+      widgets: prebuiltWidgets,
+      respondToWidget: async () => void 0,
+      disabled: true
+    };
+  }
+  return context;
+}
+function resolveWidgetPart(part, registry) {
+  var _a;
+  return (_a = registry[part.name]) != null ? _a : null;
+}
+
+// src/ui/button.tsx
+var import_class_variance_authority = require("class-variance-authority");
+var import_radix_ui3 = require("radix-ui");
+var import_jsx_runtime27 = require("react/jsx-runtime");
+var buttonVariants = (0, import_class_variance_authority.cva)(
+  "inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-md text-sm font-medium transition-all disabled:pointer-events-none disabled:opacity-50 [&_svg]:pointer-events-none [&_svg:not([class*='size-'])]:size-4 shrink-0 [&_svg]:shrink-0 outline-none focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-[3px] aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive",
+  {
+    variants: {
+      variant: {
+        default: "bg-primary text-primary-foreground hover:bg-primary/90",
+        destructive: "bg-destructive text-white hover:bg-destructive/90 focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40 dark:bg-destructive/60",
+        outline: "border bg-background shadow-xs hover:bg-accent hover:text-accent-foreground dark:bg-input/30 dark:border-input dark:hover:bg-input/50",
+        secondary: "bg-secondary text-secondary-foreground hover:bg-secondary/80",
+        ghost: "hover:bg-accent hover:text-accent-foreground dark:hover:bg-accent/50",
+        link: "text-primary underline-offset-4 hover:underline"
+      },
+      size: {
+        default: "h-9 px-4 py-2 has-[>svg]:px-3",
+        xs: "h-6 gap-1 rounded-md px-2 text-xs has-[>svg]:px-1.5 [&_svg:not([class*='size-'])]:size-3",
+        sm: "h-8 rounded-md gap-1.5 px-3 has-[>svg]:px-2.5",
+        lg: "h-10 rounded-md px-6 has-[>svg]:px-4",
+        icon: "size-9",
+        "icon-xs": "size-6 rounded-md [&_svg:not([class*='size-'])]:size-3",
+        "icon-sm": "size-8",
+        "icon-lg": "size-10"
+      }
+    },
+    defaultVariants: {
+      variant: "default",
+      size: "default"
+    }
+  }
+);
+function Button({
+  className,
+  variant = "default",
+  size = "default",
+  asChild = false,
+  skeleton = false,
+  disabled,
+  ...props
+}) {
+  const Comp = asChild ? import_radix_ui3.Slot.Root : "button";
+  return /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(
+    Comp,
+    {
+      "data-slot": "button",
+      "data-variant": variant,
+      "data-size": size,
+      "data-skeleton": skeleton ? "true" : void 0,
+      "aria-busy": skeleton ? true : void 0,
+      disabled: skeleton || disabled,
+      className: cn(buttonVariants({ variant, size, className })),
+      ...props
+    }
+  );
+}
+
+// src/components/Message/message.skeleton.tsx
+var import_jsx_runtime28 = require("react/jsx-runtime");
+var TextSkeleton = () => /* @__PURE__ */ (0, import_jsx_runtime28.jsxs)("div", { className: "chat-text-skeleton", role: "status", "aria-label": "Assistant is writing", children: [
+  /* @__PURE__ */ (0, import_jsx_runtime28.jsx)("span", { className: "chat-skeleton-bar" }),
+  /* @__PURE__ */ (0, import_jsx_runtime28.jsx)("span", { className: "chat-skeleton-bar" }),
+  /* @__PURE__ */ (0, import_jsx_runtime28.jsx)("span", { className: "chat-skeleton-bar chat-skeleton-bar-short" })
+] });
+var WidgetActionSkeleton = () => /* @__PURE__ */ (0, import_jsx_runtime28.jsxs)("div", { className: "chat-widget-action-skeleton", "aria-label": "Widget actions are loading", children: [
+  /* @__PURE__ */ (0, import_jsx_runtime28.jsx)(Button, { skeleton: true, size: "sm", variant: "secondary", type: "button", tabIndex: -1, "aria-hidden": "true", children: "Confirm" }),
+  /* @__PURE__ */ (0, import_jsx_runtime28.jsx)(Button, { skeleton: true, size: "sm", variant: "outline", type: "button", tabIndex: -1, "aria-hidden": "true", children: "Cancel" })
+] });
+
+// src/components/Widget/widget.renderer.tsx
+var import_react22 = require("react");
+
+// src/components/Widget/base.widget.tsx
+var import_jsx_runtime29 = require("react/jsx-runtime");
+function BaseWidget({
+  label,
+  title,
+  status,
+  meta,
+  className,
+  children
+}) {
+  return /* @__PURE__ */ (0, import_jsx_runtime29.jsxs)("section", { className: cn("chat-widget-card", className), "aria-label": label, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime29.jsxs)("header", { className: "chat-widget-header", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime29.jsxs)("div", { className: "chat-widget-heading", children: [
+        label ? /* @__PURE__ */ (0, import_jsx_runtime29.jsxs)("div", { className: "chat-widget-label-row", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime29.jsx)("span", { className: "chat-widget-status-dot", "aria-hidden": "true" }),
+          /* @__PURE__ */ (0, import_jsx_runtime29.jsx)("span", { className: "chat-widget-label", children: label })
+        ] }) : null,
+        /* @__PURE__ */ (0, import_jsx_runtime29.jsx)("div", { className: "chat-widget-title", children: title })
+      ] }),
+      status ? /* @__PURE__ */ (0, import_jsx_runtime29.jsx)("div", { className: "chat-widget-status", children: status }) : null
+    ] }),
+    children ? /* @__PURE__ */ (0, import_jsx_runtime29.jsx)("div", { className: "chat-widget-body", children }) : null,
+    meta ? /* @__PURE__ */ (0, import_jsx_runtime29.jsx)("div", { className: "chat-widget-meta", children: meta }) : null
+  ] });
+}
+
+// src/components/Widget/widget.renderer.tsx
+var import_jsx_runtime30 = require("react/jsx-runtime");
+function WidgetRenderer({
+  part,
+  pending = false
+}) {
+  const { widgets, respondToWidget, disabled } = useWidgets();
+  const entry = resolveWidgetPart(part, widgets);
+  const [submitted, setSubmitted] = (0, import_react22.useState)(false);
+  const responsePending = (0, import_react22.useRef)(false);
+  const widgetDisabled = disabled || submitted;
+  const respond = async (value, label, actionId) => {
+    if (!part.interactive || disabled || submitted || responsePending.current) {
+      return;
+    }
+    responsePending.current = true;
+    setSubmitted(true);
+    try {
+      await respondToWidget({
+        widgetId: part.id,
+        name: part.name,
+        actionId,
+        value,
+        label
+      });
+    } catch (error) {
+      setSubmitted(false);
+      throw error;
+    } finally {
+      responsePending.current = false;
+    }
+  };
+  const controls = {
+    widgetId: part.id,
+    widgetName: part.name,
+    interactive: Boolean(part.interactive),
+    disabled: widgetDisabled,
+    respond,
+    respondWith: async (response) => {
+      await respond(response.value, response.label, response.actionId);
+    }
+  };
+  const frame = (node) => /* @__PURE__ */ (0, import_jsx_runtime30.jsxs)("div", { className: "chat-widget", "data-pending": pending ? "true" : void 0, children: [
+    node,
+    pending ? /* @__PURE__ */ (0, import_jsx_runtime30.jsx)(WidgetActionSkeleton, {}) : null
+  ] });
+  if (!entry) {
+    return frame(
+      /* @__PURE__ */ (0, import_jsx_runtime30.jsx)(
+        BaseWidget,
+        {
+          label: "Unhandled widget",
+          title: part.name,
+          status: "Raw props",
+          className: "chat-widget-missing",
+          children: /* @__PURE__ */ (0, import_jsx_runtime30.jsx)("pre", { className: "agent-tool-code", children: JSON.stringify(part.props, null, 2) })
+        }
+      )
+    );
+  }
+  if (isWidgetDefinition(entry)) {
+    const Component2 = entry.component;
+    const content = /* @__PURE__ */ (0, import_jsx_runtime30.jsx)(Component2, { ...part.props, widget: controls });
+    if (entry.shell === false) {
+      return frame(content);
+    }
+    return frame(
+      /* @__PURE__ */ (0, import_jsx_runtime30.jsx)(BaseWidget, { ...getWidgetShellProps(entry, part.props, controls), children: content })
+    );
+  }
+  const Component = entry;
+  return frame(
+    /* @__PURE__ */ (0, import_jsx_runtime30.jsx)(
+      Component,
+      {
+        id: part.id,
+        name: part.name,
+        props: part.props,
+        interactive: part.interactive,
+        disabled: widgetDisabled,
+        onRespond: async (response) => {
+          if (!part.interactive || disabled || submitted || responsePending.current) {
+            return;
+          }
+          responsePending.current = true;
+          setSubmitted(true);
+          try {
+            await respondToWidget(response);
+          } catch (error) {
+            setSubmitted(false);
+            throw error;
+          } finally {
+            responsePending.current = false;
+          }
+        }
+      }
+    )
+  );
+}
+
+// src/components/Message/message.markdown.tsx
+var import_react23 = require("react");
+var import_code_markdown = require("@sarchauhan/code-markdown");
+var import_react_markdown = __toESM(require("react-markdown"));
+var import_remark_gfm = __toESM(require("remark-gfm"));
+
+// src/components/Message/message.markdown.theme.ts
+var chatCodeThemes = {
+  light: {
+    name: "chat-light",
+    shikiTheme: "github-light",
+    colors: {
+      background: "#ffffff",
+      foreground: "#0d0d0d",
+      comment: "#6e6e80",
+      keyword: "#9b174c",
+      string: "#166534",
+      function: "#1d4ed8",
+      variable: "#0d0d0d",
+      number: "#7c3aed",
+      operator: "#9b174c",
+      punctuation: "#6e6e80",
+      type: "#0369a1",
+      tag: "#166534",
+      attribute: "#1d4ed8",
+      constant: "#b45309",
+      surface: "#f7f7f8",
+      overlay: "#d8d8df",
+      subtext: "#6e6e80"
+    }
+  },
+  dark: {
+    name: "chat-dark",
+    shikiTheme: "github-dark",
+    colors: {
+      background: "#212121",
+      foreground: "#ececec",
+      comment: "#8f8f8f",
+      keyword: "#ff7b72",
+      string: "#a5d6a7",
+      function: "#79c0ff",
+      variable: "#ececec",
+      number: "#d2a8ff",
+      operator: "#ff7b72",
+      punctuation: "#b4b4b4",
+      type: "#79c0ff",
+      tag: "#7ee787",
+      attribute: "#79c0ff",
+      constant: "#ffa657",
+      surface: "#2f2f2f",
+      overlay: "#454545",
+      subtext: "#b4b4b4"
+    }
+  }
+};
+
+// src/components/Message/message.markdown.tsx
+var import_jsx_runtime31 = require("react/jsx-runtime");
+var markdownPlugins = {
+  remark: [import_remark_gfm.default],
+  rehype: []
+};
+var SUPPORTED_LANGUAGES = /* @__PURE__ */ new Set([
+  "c",
+  "h",
+  "cpp",
+  "cxx",
+  "cc",
+  "hpp",
+  "hxx",
+  "go",
+  "javascript",
+  "js",
+  "jsx",
+  "mjs",
+  "python",
+  "py",
+  "rust",
+  "rs",
+  "typescript",
+  "ts",
+  "tsx"
+]);
+var isSupportedLanguage = (value) => SUPPORTED_LANGUAGES.has(value);
+var getCodeLanguage = (className) => {
+  var _a;
+  const match = className == null ? void 0 : className.match(/language-([\w-]+)/);
+  const language = (_a = match == null ? void 0 : match[1]) == null ? void 0 : _a.toLowerCase();
+  return language && isSupportedLanguage(language) ? language : "typescript";
+};
+var getTextContent = (value) => {
+  if (typeof value === "string" || typeof value === "number") {
+    return String(value);
+  }
+  if (Array.isArray(value)) {
+    return value.map(getTextContent).join("");
+  }
+  return "";
+};
+var MarkdownCodeBlock = ({
+  code,
+  language
+}) => {
+  const { resolvedTheme } = useTheme();
+  return /* @__PURE__ */ (0, import_jsx_runtime31.jsx)(
+    import_code_markdown.CodeMarkdown,
+    {
+      className: "chat-code-markdown",
+      language,
+      theme: chatCodeThemes[resolvedTheme],
+      showCopyButton: true,
+      showLineNumbers: true,
+      showLanguage: true,
+      children: code
+    }
+  );
+};
+var MarkdownPre = ({ className, children }) => {
+  const child = import_react23.Children.toArray(children)[0];
+  const code = (0, import_react23.isValidElement)(child) ? getTextContent(child.props.children) : getTextContent(children);
+  const codeClassName = (0, import_react23.isValidElement)(child) ? child.props.className : void 0;
+  return /* @__PURE__ */ (0, import_jsx_runtime31.jsx)("div", { className: cn("my-5", className), children: /* @__PURE__ */ (0, import_jsx_runtime31.jsx)(
+    MarkdownCodeBlock,
+    {
+      language: getCodeLanguage(codeClassName),
+      code: code.replace(/\n$/, "")
+    }
+  ) });
+};
+var markdownComponents = {
+  a: ({ className, ...props }) => /* @__PURE__ */ (0, import_jsx_runtime31.jsx)(
+    "a",
+    {
+      className: cn(
+        "font-medium text-primary underline underline-offset-2 decoration-primary/30 decoration-1 hover:decoration-primary/70",
+        className
+      ),
+      target: "_blank",
+      rel: "noreferrer noopener",
+      ...props
+    }
+  ),
+  p: ({ className, ...props }) => /* @__PURE__ */ (0, import_jsx_runtime31.jsx)(
+    "p",
+    {
+      className: cn("my-[0.85em] text-inherit chat-text-body first:mt-0 last:mb-0", className),
+      style: { fontSize: "var(--chat-body-size)", lineHeight: "var(--chat-body-leading)" },
+      ...props
+    }
+  ),
+  h1: ({ className, ...props }) => /* @__PURE__ */ (0, import_jsx_runtime31.jsx)(
+    "h1",
+    {
+      className: cn("mt-8 mb-3 chat-text-heading-1", className),
+      style: {
+        fontSize: "var(--chat-heading-1-size)",
+        lineHeight: "var(--chat-heading-1-leading)",
+        fontWeight: "var(--chat-heading-1-weight)",
+        letterSpacing: "var(--chat-heading-1-tracking)"
+      },
+      ...props
+    }
+  ),
+  h2: ({ className, ...props }) => /* @__PURE__ */ (0, import_jsx_runtime31.jsx)(
+    "h2",
+    {
+      className: cn("mt-8 mb-3", className),
+      style: {
+        fontSize: "var(--chat-fs-18)",
+        lineHeight: "var(--chat-leading-tight)",
+        fontWeight: "var(--chat-weight-semibold)",
+        letterSpacing: "var(--chat-tracking-tight)"
+      },
+      ...props
+    }
+  ),
+  h3: ({ className, ...props }) => /* @__PURE__ */ (0, import_jsx_runtime31.jsx)(
+    "h3",
+    {
+      className: cn("mt-6 mb-2", className),
+      style: {
+        fontSize: "var(--chat-fs-16)",
+        lineHeight: "var(--chat-leading-tight)",
+        fontWeight: "var(--chat-weight-semibold)",
+        letterSpacing: "var(--chat-tracking-tight)"
+      },
+      ...props
+    }
+  ),
+  h4: ({ className, ...props }) => /* @__PURE__ */ (0, import_jsx_runtime31.jsx)(
+    "h4",
+    {
+      className: cn("mt-6 mb-2", className),
+      style: {
+        fontSize: "var(--chat-fs-15)",
+        lineHeight: "var(--chat-leading-tight)",
+        fontWeight: "var(--chat-weight-semibold)",
+        letterSpacing: "var(--chat-tracking-normal)"
+      },
+      ...props
+    }
+  ),
+  ul: ({ className, ...props }) => /* @__PURE__ */ (0, import_jsx_runtime31.jsx)(
+    "ul",
+    {
+      className: cn("my-4 list-disc space-y-2 pl-6 chat-text-body", className),
+      style: { fontSize: "var(--chat-body-size)", lineHeight: "var(--chat-body-leading)" },
+      ...props
+    }
+  ),
+  ol: ({ className, ...props }) => /* @__PURE__ */ (0, import_jsx_runtime31.jsx)(
+    "ol",
+    {
+      className: cn("my-4 list-decimal space-y-2 pl-6 chat-text-body", className),
+      style: { fontSize: "var(--chat-body-size)", lineHeight: "var(--chat-body-leading)" },
+      ...props
+    }
+  ),
+  li: ({ className, ...props }) => /* @__PURE__ */ (0, import_jsx_runtime31.jsx)(
+    "li",
+    {
+      className: cn("pl-1", className),
+      style: { lineHeight: "var(--chat-leading-normal)" },
+      ...props
+    }
+  ),
+  blockquote: ({ className, ...props }) => /* @__PURE__ */ (0, import_jsx_runtime31.jsx)("blockquote", { className: cn("md-blockquote", className), ...props }),
+  hr: ({ className, ...props }) => /* @__PURE__ */ (0, import_jsx_runtime31.jsx)("hr", { className: cn("my-6 h-px border-0 bg-current opacity-10", className), ...props }),
+  table: ({ className, ...props }) => /* @__PURE__ */ (0, import_jsx_runtime31.jsx)("div", { className: "md-table-wrapper", children: /* @__PURE__ */ (0, import_jsx_runtime31.jsx)("table", { className: cn("md-table", className), ...props }) }),
+  thead: ({ className, ...props }) => /* @__PURE__ */ (0, import_jsx_runtime31.jsx)("thead", { ...props }),
+  tbody: ({ className, ...props }) => /* @__PURE__ */ (0, import_jsx_runtime31.jsx)("tbody", { ...props }),
+  tr: ({ className, ...props }) => /* @__PURE__ */ (0, import_jsx_runtime31.jsx)("tr", { ...props }),
+  th: ({ className, ...props }) => /* @__PURE__ */ (0, import_jsx_runtime31.jsx)("th", { ...props }),
+  td: ({ className, ...props }) => /* @__PURE__ */ (0, import_jsx_runtime31.jsx)("td", { ...props }),
+  pre: MarkdownPre,
+  // React Markdown v10 no longer consistently provides the legacy `inline`
+  // prop. Fenced code is handled by the custom `pre` renderer above, so a
+  // standalone `code` element should always be rendered as inline code.
+  code: ({ className, children, ...props }) => /* @__PURE__ */ (0, import_jsx_runtime31.jsx)("code", { className: cn("md-inline-code", className), ...props, children })
+};
+var MarkdownContent = ({ children, className }) => /* @__PURE__ */ (0, import_jsx_runtime31.jsx)("div", { className: cn("md-content break-words text-inherit", className), children: /* @__PURE__ */ (0, import_jsx_runtime31.jsx)(
+  import_react_markdown.default,
+  {
+    remarkPlugins: markdownPlugins.remark,
+    rehypePlugins: markdownPlugins.rehype,
+    components: markdownComponents,
+    children
+  }
+) });
+
+// src/components/Message/message.thinking.tsx
+var import_lucide_react13 = require("lucide-react");
+var import_react25 = require("react");
+
+// src/components/Message/message.loading.tsx
+var import_react24 = require("react");
+var import_jsx_runtime32 = require("react/jsx-runtime");
+var useElapsedTime = (active) => {
+  const startedAtRef = (0, import_react24.useRef)(0);
+  const [elapsed, setElapsed] = (0, import_react24.useState)(0);
+  (0, import_react24.useEffect)(() => {
+    if (!active) {
+      return;
+    }
+    startedAtRef.current = Date.now();
+    setElapsed(0);
+    const timer = window.setInterval(() => {
+      setElapsed(Date.now() - startedAtRef.current);
+    }, 100);
+    return () => window.clearInterval(timer);
+  }, [active]);
+  return elapsed;
+};
+var formatElapsed = (milliseconds, showTenths = false) => {
+  const totalSeconds = Math.max(0, milliseconds / 1e3);
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds - minutes * 60;
+  const formattedSeconds = showTenths ? seconds.toFixed(1) : String(Math.floor(seconds));
+  return minutes > 0 ? `${minutes}m ${formattedSeconds}s` : `${formattedSeconds}s`;
+};
+var formatElapsedWords = (milliseconds) => {
+  const seconds = Math.max(0, Math.floor(milliseconds / 1e3));
+  if (seconds < 60) {
+    return `${seconds} ${seconds === 1 ? "second" : "seconds"}`;
+  }
+  const minutes = Math.floor(seconds / 60);
+  const remainder = seconds % 60;
+  const minuteLabel = `${minutes} ${minutes === 1 ? "minute" : "minutes"}`;
+  return remainder > 0 ? `${minuteLabel} ${remainder} ${remainder === 1 ? "second" : "seconds"}` : minuteLabel;
+};
+var PixelGrid = () => /* @__PURE__ */ (0, import_jsx_runtime32.jsx)("span", { className: "chat-pixel-grid", "aria-hidden": "true", children: Array.from({ length: 9 }, (_, index) => /* @__PURE__ */ (0, import_jsx_runtime32.jsx)("span", {}, index)) });
+var LoadingState = ({ label = "Churning", compact = false }) => {
+  const elapsed = useElapsedTime(true);
+  return /* @__PURE__ */ (0, import_jsx_runtime32.jsxs)("div", { className: `chat-loading${compact ? " chat-loading-inline" : ""}`, role: "status", "aria-live": "polite", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime32.jsx)(PixelGrid, {}),
+    /* @__PURE__ */ (0, import_jsx_runtime32.jsx)(TextSwap, { className: "chat-loading-label", text: label }),
+    /* @__PURE__ */ (0, import_jsx_runtime32.jsx)("span", { className: "chat-loading-timer", role: "timer", children: formatElapsed(elapsed, true) }),
+    /* @__PURE__ */ (0, import_jsx_runtime32.jsx)("span", { className: "chat-visually-hidden", children: "Loading conversation" })
+  ] });
+};
+
+// src/components/Message/message.thinking.tsx
+var import_jsx_runtime33 = require("react/jsx-runtime");
+var ThinkingBlock = ({ isComplete, elapsedMs, children }) => {
+  const [isOpen, setIsOpen] = (0, import_react25.useState)(true);
+  const measuredElapsed = useElapsedTime(!isComplete);
+  const elapsed = elapsedMs != null ? elapsedMs : measuredElapsed;
+  (0, import_react25.useEffect)(() => {
+    if (!isComplete) {
+      setIsOpen(true);
+    }
+  }, [isComplete]);
+  return /* @__PURE__ */ (0, import_jsx_runtime33.jsxs)(
+    "details",
+    {
+      className: cn(
+        "md-thinking",
+        isComplete ? "md-thinking-complete" : "md-thinking-pending"
+      ),
+      open: isOpen,
+      onToggle: (event) => setIsOpen(event.currentTarget.open),
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime33.jsxs)("summary", { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime33.jsx)(import_lucide_react13.Sparkles, { className: "md-thinking-sparkle", "aria-hidden": "true" }),
+          /* @__PURE__ */ (0, import_jsx_runtime33.jsx)(
+            TextSwap,
+            {
+              className: "md-thinking-label",
+              text: isComplete ? `Thought for ${formatElapsedWords(elapsed)}` : "Thinking"
+            }
+          ),
+          isComplete && /* @__PURE__ */ (0, import_jsx_runtime33.jsx)(import_lucide_react13.ChevronDown, { className: "md-thinking-chevron", "aria-hidden": "true" })
+        ] }),
+        children
+      ]
+    }
+  );
+};
+
+// src/components/Message/message.content.tsx
+var import_jsx_runtime34 = require("react/jsx-runtime");
+var isPropsRecord = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+var formatJson = (value) => {
+  if (typeof value === "string") {
+    return value;
+  }
+  try {
+    return JSON.stringify(value, null, 2);
+  } catch {
+    return String(value);
+  }
+};
+var toolDetail = (part) => {
+  var _a, _b, _c, _d, _e, _f;
+  const source = (_a = part.output) != null ? _a : part.input;
+  if (!isPropsRecord(source)) {
+    return null;
+  }
+  const value = (_f = (_e = (_d = (_c = (_b = source.path) != null ? _b : source.file) != null ? _c : source.filename) != null ? _d : source.query) != null ? _e : source.command) != null ? _f : source.url;
+  return typeof value === "string" && value.trim() ? value : null;
+};
+var toolStateLabel = (state) => {
+  switch (state) {
+    case "input-streaming":
+      return "Preparing";
+    case "input-available":
+      return "Ready";
+    case "approval-requested":
+      return "Needs approval";
+    case "approval-responded":
+      return "Approval sent";
+    case "output-available":
+      return "Done";
+    case "output-error":
+      return "Error";
+    case "output-denied":
+      return "Denied";
+    default:
+      return state;
+  }
+};
+var ReasoningBlock = ({ part }) => {
+  const isComplete = part.state !== "streaming";
+  return /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(ThinkingBlock, { isComplete, children: !!part.text.trim() && /* @__PURE__ */ (0, import_jsx_runtime34.jsx)("div", { className: "md-thinking-body", children: /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(MarkdownContent, { children: part.text }) }) });
+};
+var ToolStatusIcon = ({
+  isPending,
+  isDone
+}) => {
+  const pathRef = (0, import_react26.useRef)(null);
+  const [sawPending, setSawPending] = (0, import_react26.useState)(isPending);
+  const iconState = isPending ? "a" : "b";
+  const playCheck = Boolean(sawPending && isDone);
+  const checkState = playCheck ? "in" : "out";
+  if (isPending && !sawPending) {
+    setSawPending(true);
+  }
+  (0, import_react26.useLayoutEffect)(() => {
+    if (pathRef.current) {
+      calibrateCheckPath(pathRef.current);
+    }
+  }, [playCheck]);
+  return /* @__PURE__ */ (0, import_jsx_runtime34.jsx)("span", { className: "agent-tool-dot", "aria-hidden": "true", children: /* @__PURE__ */ (0, import_jsx_runtime34.jsxs)("span", { className: motion.iconSwap, "data-state": iconState, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime34.jsx)("span", { className: motion.icon, "data-icon": "a", children: /* @__PURE__ */ (0, import_jsx_runtime34.jsx)("span", { className: "agent-tool-spinner" }) }),
+    /* @__PURE__ */ (0, import_jsx_runtime34.jsx)("span", { className: motion.icon, "data-icon": "b", children: isDone ? playCheck ? /* @__PURE__ */ (0, import_jsx_runtime34.jsx)("span", { className: motion.successCheck, "data-state": checkState, children: /* @__PURE__ */ (0, import_jsx_runtime34.jsx)("svg", { viewBox: "0 0 12 12", width: "10", height: "10", fill: "none", children: /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(
+      "path",
+      {
+        ref: pathRef,
+        d: "M2.5 6.5 5 9l4.5-6",
+        stroke: "currentColor",
+        strokeWidth: "1.6",
+        strokeLinecap: "round",
+        strokeLinejoin: "round"
+      }
+    ) }) }) : /* @__PURE__ */ (0, import_jsx_runtime34.jsx)("svg", { viewBox: "0 0 12 12", width: "10", height: "10", fill: "none", children: /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(
+      "path",
+      {
+        d: "M2.5 6.5 5 9l4.5-6",
+        stroke: "currentColor",
+        strokeWidth: "1.6",
+        strokeLinecap: "round",
+        strokeLinejoin: "round"
+      }
+    ) }) : /* @__PURE__ */ (0, import_jsx_runtime34.jsx)("svg", { viewBox: "0 0 12 12", width: "10", height: "10", fill: "none", children: /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(
+      "path",
+      {
+        d: "M3.2 3.2 8.8 8.8M8.8 3.2 3.2 8.8",
+        stroke: "currentColor",
+        strokeWidth: "1.6",
+        strokeLinecap: "round"
+      }
+    ) }) })
+  ] }) });
+};
+var ToolBlock = ({ part }) => {
+  var _a;
+  const wrapRef = (0, import_react26.useRef)(null);
+  const isPending = part.state === "input-streaming" || part.state === "input-available" || part.state === "approval-requested";
+  const isError = part.state === "output-error" || part.state === "output-denied";
+  const isDone = !isPending && !isError;
+  const detail = toolDetail(part);
+  (0, import_react26.useEffect)(() => {
+    if (!isError || !wrapRef.current) {
+      return;
+    }
+    triggerErrorShake(wrapRef.current, { revert: false });
+  }, [isError]);
+  return /* @__PURE__ */ (0, import_jsx_runtime34.jsxs)(
+    "details",
+    {
+      ref: wrapRef,
+      className: cn(
+        "agent-tool",
+        motion.inputWrap,
+        isPending ? "agent-tool-pending" : isError ? "agent-tool-error" : "agent-tool-complete"
+      ),
+      open: isPending || isError,
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime34.jsxs)("summary", { className: cn(motion.input, isError && motion.isError), children: [
+          /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(import_lucide_react14.ChevronDown, { className: "agent-tool-chevron", "aria-hidden": "true" }),
+          /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(ToolStatusIcon, { isPending, isDone }),
+          /* @__PURE__ */ (0, import_jsx_runtime34.jsx)("span", { className: "agent-tool-name", children: (_a = part.title) != null ? _a : part.toolName }),
+          detail ? /* @__PURE__ */ (0, import_jsx_runtime34.jsx)("span", { className: "agent-tool-chip", children: detail }) : null,
+          /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(TextSwap, { className: "agent-tool-state", text: toolStateLabel(part.state) })
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime34.jsxs)("div", { className: "agent-tool-body", children: [
+          part.input !== void 0 && /* @__PURE__ */ (0, import_jsx_runtime34.jsxs)("div", { className: "agent-tool-section", children: [
+            /* @__PURE__ */ (0, import_jsx_runtime34.jsx)("div", { className: "agent-tool-section-label", children: "Input" }),
+            /* @__PURE__ */ (0, import_jsx_runtime34.jsx)("pre", { className: "agent-tool-code", children: formatJson(part.input) })
+          ] }),
+          part.output !== void 0 && /* @__PURE__ */ (0, import_jsx_runtime34.jsxs)("div", { className: "agent-tool-section", children: [
+            /* @__PURE__ */ (0, import_jsx_runtime34.jsx)("div", { className: "agent-tool-section-label", children: "Output" }),
+            /* @__PURE__ */ (0, import_jsx_runtime34.jsx)("pre", { className: "agent-tool-code", children: formatJson(part.output) })
+          ] }),
+          part.errorText && /* @__PURE__ */ (0, import_jsx_runtime34.jsxs)("div", { className: "agent-tool-section", children: [
+            /* @__PURE__ */ (0, import_jsx_runtime34.jsx)("div", { className: "agent-tool-section-label", children: "Error" }),
+            /* @__PURE__ */ (0, import_jsx_runtime34.jsx)("pre", { className: "agent-tool-code agent-tool-error", children: part.errorText })
+          ] })
+        ] })
+      ]
+    }
+  );
+};
+var SourceUrlBlock = ({ part }) => /* @__PURE__ */ (0, import_jsx_runtime34.jsxs)("a", { className: "agent-source", href: part.url, target: "_blank", rel: "noreferrer", children: [
+  /* @__PURE__ */ (0, import_jsx_runtime34.jsx)("span", { className: "agent-source-label", children: "Source" }),
+  /* @__PURE__ */ (0, import_jsx_runtime34.jsx)("span", { className: "agent-source-title", children: part.title || part.url })
+] });
+var SourceDocumentBlock = ({ part }) => /* @__PURE__ */ (0, import_jsx_runtime34.jsxs)("div", { className: "agent-source agent-source-document", children: [
+  /* @__PURE__ */ (0, import_jsx_runtime34.jsx)("span", { className: "agent-source-label", children: "Document" }),
+  /* @__PURE__ */ (0, import_jsx_runtime34.jsx)("span", { className: "agent-source-title", children: part.title }),
+  part.filename && /* @__PURE__ */ (0, import_jsx_runtime34.jsx)("span", { className: "agent-source-meta", children: part.filename })
+] });
+var FileBlock = ({ part }) => /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(ArtifactWidget, { artifact: {
+  id: part.url,
+  filename: part.filename || (part.mediaType.startsWith("image/") ? "Generated image" : "Generated file"),
+  mediaType: part.mediaType,
+  url: part.url,
+  status: "ready"
+} });
+var AgentEventBlock = ({ part }) => /* @__PURE__ */ (0, import_jsx_runtime34.jsxs)("details", { className: "agent-tool agent-event", children: [
+  /* @__PURE__ */ (0, import_jsx_runtime34.jsxs)("summary", { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime34.jsx)("span", { className: "agent-event-marker", "aria-hidden": "true" }),
+    /* @__PURE__ */ (0, import_jsx_runtime34.jsxs)("span", { className: "agent-tool-name", children: [
+      "data.",
+      part.name
+    ] })
+  ] }),
+  /* @__PURE__ */ (0, import_jsx_runtime34.jsx)("div", { className: "agent-tool-body", children: /* @__PURE__ */ (0, import_jsx_runtime34.jsx)("pre", { className: "agent-tool-code", children: formatJson(part.data) }) })
+] });
+var TextWithLegacyThinking = ({ text, isUser }) => {
+  var _a;
+  const userReferenceMessage = isUser ? parseUserReferenceMessage(text) : null;
+  const content = (_a = userReferenceMessage == null ? void 0 : userReferenceMessage.message) != null ? _a : text;
+  const segments = splitThinkingSegments(content);
+  return /* @__PURE__ */ (0, import_jsx_runtime34.jsxs)(import_jsx_runtime34.Fragment, { children: [
+    userReferenceMessage && /* @__PURE__ */ (0, import_jsx_runtime34.jsx)("div", { className: "chat-user-reference", children: userReferenceMessage.references.map((reference, index) => /* @__PURE__ */ (0, import_jsx_runtime34.jsxs)(
+      "div",
+      {
+        className: "chat-user-reference-item",
+        children: [
+          /* @__PURE__ */ (0, import_jsx_runtime34.jsxs)("div", { className: "chat-reference-label", children: [
+            "Reference ",
+            index + 1
+          ] }),
+          /* @__PURE__ */ (0, import_jsx_runtime34.jsx)("div", { className: "chat-reference-text", children: reference })
+        ]
+      },
+      `${index}-${reference.slice(0, 16)}`
+    )) }),
+    segments.map((segment, index) => {
+      var _a2;
+      if (!segment.content.trim() && segment.type !== "thinking") {
+        return null;
+      }
+      if (segment.type === "thinking" && !isUser) {
+        const isComplete = (_a2 = segment.isComplete) != null ? _a2 : true;
+        return /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(ThinkingBlock, { isComplete, children: !!segment.content.trim() && /* @__PURE__ */ (0, import_jsx_runtime34.jsx)("div", { className: "md-thinking-body", children: /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(MarkdownContent, { children: segment.content }) }) }, `thinking-${index}`);
+      }
+      return /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(MarkdownContent, { children: segment.content }, `md-${index}`);
+    })
+  ] });
+};
+var asWidgetFromTool = (part) => {
+  const source = part.state === "output-available" && part.output !== void 0 ? part.output : part.input;
+  if (!isPropsRecord(source)) {
+    return null;
+  }
+  return {
+    type: "widget",
+    name: part.toolName,
+    id: part.toolCallId,
+    props: source,
+    interactive: part.toolName === "question" || source.interactive === true
+  };
+};
+var asWidgetFromData = (part) => ({
+  type: "widget",
+  name: part.name,
+  id: part.id,
+  props: isPropsRecord(part.data) ? part.data : { value: part.data },
+  interactive: isPropsRecord(part.data) ? part.data.interactive === true : false
+});
+var PartView = ({ part, index, isUser }) => {
+  const { widgets } = useWidgets();
+  if (part.type === "widget") {
+    return isUser ? null : /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(WidgetRenderer, { part }, `widget-${part.id || index}`);
+  }
+  if (part.type === "tool" && !isUser) {
+    const entry = widgets[part.toolName];
+    const isCustom = entry && entry !== prebuiltWidgets[part.toolName];
+    const widgetPart = isCustom ? asWidgetFromTool(part) : computeToolWidget(part);
+    if (widgetPart) {
+      return /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(
+        WidgetRenderer,
+        {
+          part: widgetPart,
+          pending: part.state === "input-streaming"
+        },
+        `tool-widget-${part.toolCallId || index}`
+      );
+    }
+  }
+  if (part.type === "data" && !isUser && widgets[part.name]) {
+    const builtin = widgets[part.name] === prebuiltWidgets[part.name];
+    if (builtin && (part.name === "artifact" && !(0, import_protocol3.parseArtifact)(part.data) || part.name === "subagent" && !(0, import_protocol3.parseSubagent)(part.data))) return /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(AgentEventBlock, { part });
+    return /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(
+      WidgetRenderer,
+      {
+        part: asWidgetFromData(part)
+      },
+      `data-widget-${part.name}-${part.id || index}`
+    );
+  }
+  switch (part.type) {
+    case "text":
+      if (!isUser && part.state === "streaming" && part.text.trim().length === 0) {
+        return /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(TextSkeleton, {}, `text-${index}`);
+      }
+      return /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(TextWithLegacyThinking, { text: part.text, isUser }, `text-${index}`);
+    case "reasoning":
+      return isUser ? null : /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(ReasoningBlock, { part }, `reasoning-${index}`);
+    case "tool":
+      return isUser ? null : /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(ToolBlock, { part }, `tool-${part.toolCallId || index}`);
+    case "source-url":
+      return /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(SourceUrlBlock, { part }, `source-url-${part.sourceId || index}`);
+    case "source-document":
+      return /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(SourceDocumentBlock, { part }, `source-doc-${part.sourceId || index}`);
+    case "file":
+      return /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(FileBlock, { part }, `file-${index}`);
+    case "data":
+      if (part.name === "usage" || part.name === "context" || part.name === "context-warning") {
+        return null;
+      }
+      return /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(AgentEventBlock, { part }, `data-${part.name}-${part.id || index}`);
+    case "unknown":
+      return /* @__PURE__ */ (0, import_jsx_runtime34.jsxs)("details", { className: "agent-tool agent-event", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime34.jsxs)("summary", { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime34.jsx)("span", { className: "agent-event-marker", "aria-hidden": "true" }),
+          /* @__PURE__ */ (0, import_jsx_runtime34.jsx)("span", { className: "agent-tool-name", children: part.rawType })
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime34.jsx)("div", { className: "agent-tool-body", children: /* @__PURE__ */ (0, import_jsx_runtime34.jsx)("pre", { className: "agent-tool-code", children: formatJson(part.raw) }) })
+      ] }, `unknown-${index}`);
+    default:
+      return null;
+  }
+};
+var MessageContent = ({ parts, isUser = false }) => {
+  const agentParts = (0, import_protocol3.normalizeAgentParts)(parts);
+  return /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(
+    "div",
+    {
+      className: cn(
+        "chat-message-content break-words",
+        isUser ? "md-content-user" : "md-content-assistant"
+      ),
+      children: agentParts.map((part, index) => /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(PartView, { part, index, isUser }, `${part.type}-${index}`))
+    }
+  );
+};
+
+// src/components/Message/message.feedback.tsx
+var import_lucide_react17 = require("lucide-react");
+var import_react28 = require("react");
+
+// src/components/Message/message.copy.tsx
+var import_lucide_react15 = require("lucide-react");
+var import_react27 = require("react");
+var import_jsx_runtime35 = require("react/jsx-runtime");
+var MessageCopy = ({ text, disabled = false }) => {
+  const [isCopied, setIsCopied] = (0, import_react27.useState)(false);
+  const copyMessage = async () => {
+    await navigator.clipboard.writeText(text);
+    setIsCopied(true);
+    window.setTimeout(() => setIsCopied(false), 1500);
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime35.jsx)(
+    "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__ */ (0, import_jsx_runtime35.jsx)(import_lucide_react15.Check, { size: 16 }) : /* @__PURE__ */ (0, import_jsx_runtime35.jsx)(import_lucide_react15.Copy, { size: 16 })
+    }
+  );
+};
+
+// src/components/Message/message.regenerate.tsx
+var import_lucide_react16 = require("lucide-react");
+var import_jsx_runtime36 = require("react/jsx-runtime");
+var MessageRegenerate = ({ onRegenerate, disabled = false }) => /* @__PURE__ */ (0, import_jsx_runtime36.jsx)(
+  "button",
+  {
+    type: "button",
+    className: "chat-feedback-button",
+    title: "Regenerate response",
+    "aria-label": "Regenerate response",
+    disabled,
+    onClick: onRegenerate,
+    children: /* @__PURE__ */ (0, import_jsx_runtime36.jsx)(import_lucide_react16.RotateCcw, { size: 17 })
+  }
+);
+
+// src/components/Message/message.feedback.tsx
+var import_jsx_runtime37 = require("react/jsx-runtime");
+var MessageFeedback = ({
+  responseText,
+  onRegenerate,
+  canRegenerate,
+  disabled = false
+}) => {
+  const [feedback, setFeedback] = (0, import_react28.useState)(null);
+  if (!responseText.trim()) {
+    return null;
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime37.jsxs)("div", { className: "chat-message-feedback", "aria-label": "Message actions", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime37.jsx)(MessageCopy, { text: responseText, disabled }),
+    /* @__PURE__ */ (0, import_jsx_runtime37.jsx)(
+      MessageRegenerate,
+      {
+        onRegenerate,
+        disabled: !canRegenerate || disabled
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime37.jsx)(
+      "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__ */ (0, import_jsx_runtime37.jsx)(import_lucide_react17.ThumbsUp, { size: 18 })
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime37.jsx)(
+      "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__ */ (0, import_jsx_runtime37.jsx)(import_lucide_react17.ThumbsDown, { size: 18 })
+      }
+    )
+  ] });
+};
+
+// src/components/Message/message.usage.tsx
+var import_protocol4 = require("@sarchauhan/protocol");
+var import_jsx_runtime38 = require("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 = (0, import_protocol4.parseUsage)((_a = parts.find((part) => part.name === "usage")) == null ? void 0 : _a.data);
+  const context = (0, import_protocol4.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__ */ (0, import_jsx_runtime38.jsxs)("p", { className: "chat-message-usage", "aria-label": "Context and token usage", children: [
+    contextMetrics ? /* @__PURE__ */ (0, import_jsx_runtime38.jsxs)(import_jsx_runtime38.Fragment, { children: [
+      "Context ",
+      formatTokens(contextMetrics.currentTokens),
+      " / ",
+      formatTokens(contextMetrics.contextWindow),
+      " (",
+      Math.round(contextMetrics.currentTokens / contextMetrics.contextWindow * 100),
+      "%)"
+    ] }) : null,
+    tokenMetrics.length > 0 ? /* @__PURE__ */ (0, import_jsx_runtime38.jsxs)(import_jsx_runtime38.Fragment, { children: [
+      contextMetrics ? " \xB7 " : null,
+      "Tokens ",
+      tokenMetrics.map(([label, value]) => `${label} ${formatTokens(value)}`).join(" \xB7 ")
+    ] }) : null
+  ] });
+};
+
+// src/components/Message/message.item.tsx
+var import_jsx_runtime39 = require("react/jsx-runtime");
+var getMessageTargetId = (messageId) => `chat-message-${messageId}`;
+var MessageItem = ({ message }) => {
+  var _a;
+  const { editAndResendMessage, isSending, messages } = useMessages();
+  const [isEditing, setIsEditing] = (0, import_react29.useState)(false);
+  const [draft, setDraft] = (0, import_react29.useState)(() => getUserDisplayText(message));
+  const [isSubmittingEdit, setIsSubmittingEdit] = (0, import_react29.useState)(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 = (0, import_protocol5.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__ */ (0, import_jsx_runtime39.jsx)("div", { id: getMessageTargetId(message.id), className: "chat-message chat-message-user", children: /* @__PURE__ */ (0, import_jsx_runtime39.jsxs)("div", { className: `chat-message-user-inner${isEditing ? " is-editing" : ""}`, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime39.jsx)("div", { className: "chat-message-bubble", children: isEditing ? /* @__PURE__ */ (0, import_jsx_runtime39.jsx)(
+        "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__ */ (0, import_jsx_runtime39.jsx)(MessageContent, { parts: message.parts, isUser: true }) }),
+      isEditing ? /* @__PURE__ */ (0, import_jsx_runtime39.jsxs)("div", { className: "chat-message-actions", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime39.jsx)(
+          "button",
+          {
+            type: "button",
+            className: "chat-text-button",
+            onClick: cancelEdit,
+            disabled: isSubmittingEdit,
+            children: "Cancel"
+          }
+        ),
+        /* @__PURE__ */ (0, import_jsx_runtime39.jsx)(
+          "button",
+          {
+            type: "button",
+            className: "chat-text-button chat-text-button-done",
+            onClick: submitEdit,
+            disabled: !draft.trim() || isSubmittingEdit || isSending,
+            children: "Done"
+          }
+        )
+      ] }) : /* @__PURE__ */ (0, import_jsx_runtime39.jsx)(
+        "button",
+        {
+          type: "button",
+          className: "chat-icon-button",
+          onClick: () => {
+            setDraft(getUserDisplayText(message));
+            setIsEditing(true);
+          },
+          disabled: isSending,
+          "aria-label": "Edit and resend message",
+          children: /* @__PURE__ */ (0, import_jsx_runtime39.jsx)(import_lucide_react18.Pencil, { size: 14 })
+        }
+      )
+    ] }) });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime39.jsx)("div", { className: "chat-message chat-message-assistant", children: /* @__PURE__ */ (0, import_jsx_runtime39.jsxs)("div", { className: "chat-message-assistant-inner", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime39.jsx)(MessageContent, { parts: message.parts, isUser: false }),
+    /* @__PURE__ */ (0, import_jsx_runtime39.jsx)(MessageUsage, { parts: dataParts }),
+    isActiveAssistantMessage ? null : /* @__PURE__ */ (0, import_jsx_runtime39.jsx)(
+      MessageFeedback,
+      {
+        responseText: assistantText,
+        canRegenerate: !!previousUserMessage,
+        disabled: isSending,
+        onRegenerate: () => {
+          if (previousUserMessage) {
+            void editAndResendMessage(
+              previousUserMessage.id,
+              getUserDisplayText(previousUserMessage)
+            );
+          }
+        }
+      }
+    )
+  ] }) });
+};
+
+// src/components/Message/message.tsx
+var import_jsx_runtime40 = require("react/jsx-runtime");
+var WaitingForResponse = () => /* @__PURE__ */ (0, import_jsx_runtime40.jsx)("div", { className: "chat-response-status", role: "status", "aria-live": "polite", children: /* @__PURE__ */ (0, import_jsx_runtime40.jsx)(TextSkeleton, {}) });
+var Message = () => {
+  const { messages, isWaitingForResponse } = useMessages();
+  const { isLoadingThread } = useThread();
+  if (isLoadingThread) {
+    return /* @__PURE__ */ (0, import_jsx_runtime40.jsx)("div", { className: "chat-messages-inner", children: /* @__PURE__ */ (0, import_jsx_runtime40.jsx)("div", { className: "chat-loading chat-loading-initial", role: "status", "aria-live": "polite", children: "Loading conversation\u2026" }) });
+  }
+  if (messages.length === 0) {
+    return /* @__PURE__ */ (0, import_jsx_runtime40.jsx)("div", { className: "chat-messages-inner", children: /* @__PURE__ */ (0, import_jsx_runtime40.jsx)("div", { className: "chat-empty", children: /* @__PURE__ */ (0, import_jsx_runtime40.jsxs)("div", { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime40.jsx)("p", { className: "chat-empty-title", children: "How can I help?" }),
+      /* @__PURE__ */ (0, import_jsx_runtime40.jsx)("p", { className: "chat-empty-copy", children: "Ask a question, explore ideas, or use tools and widgets when the agent needs them." })
+    ] }) }) });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime40.jsxs)("div", { className: "chat-messages-inner", children: [
+    messages.map((message) => /* @__PURE__ */ (0, import_jsx_runtime40.jsx)(MessageItem, { message }, message.id)),
+    isWaitingForResponse ? /* @__PURE__ */ (0, import_jsx_runtime40.jsx)(WaitingForResponse, {}) : null
+  ] });
+};
+
+// src/components/Chat.tsx
+var import_jsx_runtime41 = require("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 = (0, import_react30.useMemo)(() => createWidgetRegistry(widgets), [widgets]);
+  const messagesRef = (0, import_react30.useRef)(null);
+  (0, import_react30.useLayoutEffect)(() => {
+    const container = messagesRef.current;
+    if (!container) {
+      return;
+    }
+    container.scrollTop = container.scrollHeight;
+  }, [messages, status]);
+  (0, import_react30.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 = (0, import_react30.useCallback)(
+    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__ */ (0, import_jsx_runtime41.jsx)(
+    WidgetProvider,
+    {
+      widgets: registry,
+      respondToWidget,
+      disabled: isSending,
+      children: /* @__PURE__ */ (0, import_jsx_runtime41.jsxs)(
+        "div",
+        {
+          className: ["chat-root", className].filter(Boolean).join(" "),
+          style,
+          "data-theme": resolvedTheme,
+          children: [
+            /* @__PURE__ */ (0, import_jsx_runtime41.jsxs)("div", { className: "chat-toolbar", children: [
+              /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(
+                "button",
+                {
+                  type: "button",
+                  className: "chat-theme-toggle",
+                  onClick: () => void createThread(),
+                  "aria-label": "Start a new chat",
+                  title: "New chat",
+                  disabled: isSending,
+                  children: /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(import_lucide_react19.PenSquare, { size: 16, strokeWidth: 1.75 })
+                }
+              ),
+              showThemeToggle && /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(ThemeToggle, {})
+            ] }),
+            /* @__PURE__ */ (0, import_jsx_runtime41.jsx)("div", { className: "chat-messages", ref: messagesRef, children: /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(Message, {}) }),
+            /* @__PURE__ */ (0, import_jsx_runtime41.jsx)("div", { className: "chat-composer", children: /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(
+              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__ */ (0, import_jsx_runtime41.jsx)(
+    ThemeProvider,
+    {
+      theme,
+      defaultTheme,
+      onThemeChange,
+      children: /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(
+        ChatContextProvider,
+        {
+          adapter,
+          defaultThreadId,
+          defaultProvider,
+          registryUrl,
+          children: /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(
+            ChatShell,
+            {
+              className,
+              style,
+              widgets,
+              showThemeToggle,
+              showModelSelector,
+              collapsedVariant,
+              defaultExpanded
+            }
+          )
+        }
+      )
+    }
+  );
+}
+
+// src/index.ts
+var import_adapter = require("@sarchauhan/adapter");
+var import_protocol7 = require("@sarchauhan/protocol");
+
+// src/widgets/index.ts
+var import_protocol6 = require("@sarchauhan/protocol");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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,
+  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.js.map