@love-moon/app-sdk 0.4.2 → 0.5.1

package/dist/react/index.js

@@ -113,6 +113,8 @@ function reducer(state, action) {
       return { ...state, error: action.error };
     case "TASK_FINISHED":
       return { ...state, runtime: null };
+    case "RESET_TASK":
+      return { ...INITIAL_STATE, connectionState: state.connectionState, loadingHistory: true };
     default:
       return state;
   }
@@ -197,7 +199,7 @@ function ChatProvider(props) {
         void runCatchUp();
       }, delayMs);
     };
-    dispatch({ type: "LOADING_HISTORY", loading: true });
+    dispatch({ type: "RESET_TASK" });
     activeAdapter.fetchHistory(taskId, { signal: abort.signal }).then((page) => {
       if (cancelled) return;
       dispatch({
@@ -336,7 +338,28 @@ function ChatProvider(props) {
         dispatch({ type: "LOADING_HISTORY", loading: false });
       }
     };
-    return { state, taskId, adapter, send, interrupt, loadEarlier };
+    const restart = async (opts) => {
+      const fn = adapterRef.current.restart;
+      if (!fn) return;
+      try {
+        await fn(taskIdRef.current, opts);
+      } catch (err) {
+        onErrorRef.current?.(err);
+        dispatch({ type: "SET_ERROR", error: extractError(err) });
+      }
+    };
+    return {
+      state,
+      taskId,
+      adapter,
+      send,
+      interrupt,
+      loadEarlier,
+      restart,
+      // `adapter` is in the dep array, so this re-derives whenever the adapter
+      // reference changes (the next subscribe also picks up the change).
+      restartSupported: typeof adapter.restart === "function"
+    };
   }, [state, taskId, adapter]);
   return /* @__PURE__ */ jsx(ChatContext.Provider, { value, children: props.children });
 }
@@ -360,128 +383,1049 @@ function extractError(err) {
 }
 
 // src/react/components/MessageList.tsx
-import { useEffect as useEffect2, useLayoutEffect, useRef as useRef2 } from "react";
+import {
+  useCallback,
+  useEffect as useEffect4,
+  useLayoutEffect,
+  useMemo as useMemo2,
+  useRef as useRef4,
+  useState as useState2
+} from "react";
+
+// src/react/components/MessageBubble.tsx
+import { useEffect as useEffect2, useRef as useRef2, useState } from "react";
 import { jsx as jsx2, jsxs } from "react/jsx-runtime";
-function MessageList({ labels, renderMessageContent }) {
-  const { state, loadEarlier } = useChat();
-  const containerRef = useRef2(null);
-  const lastMessageCountRef = useRef2(state.messages.length);
-  useLayoutEffect(() => {
+var TOUCH_DOUBLE_TAP_MS = 320;
+var isInteractiveTarget = (target) => target instanceof HTMLElement && Boolean(target.closest("a, button, audio, video, summary, input, textarea, select"));
+var prefersTapTimestamp = () => {
+  if (typeof window === "undefined" || typeof window.matchMedia !== "function") {
+    return false;
+  }
+  return window.matchMedia("(hover: none), (pointer: coarse)").matches;
+};
+var formatTime = (dateStr) => {
+  if (!dateStr) return "";
+  const date = new Date(dateStr);
+  if (Number.isNaN(date.getTime())) return "";
+  return date.toLocaleString(void 0, {
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit"
+  });
+};
+var formatBytes = (value) => {
+  if (!Number.isFinite(value) || value < 1024) {
+    return `${Math.max(0, Math.round(value || 0))} B`;
+  }
+  if (value < 1024 * 1024) return `${(value / 1024).toFixed(1)} KB`;
+  if (value < 1024 * 1024 * 1024) return `${(value / (1024 * 1024)).toFixed(1)} MB`;
+  return `${(value / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+};
+var attachmentKind = (att) => {
+  const mime = (att.mimeType || "").toLowerCase();
+  if (mime.startsWith("image/")) return "image";
+  if (mime.startsWith("video/")) return "video";
+  if (mime.startsWith("audio/")) return "audio";
+  return "file";
+};
+var getAppOriginName = (message) => {
+  const metadata = message.metadata;
+  if (!metadata || typeof metadata !== "object") return null;
+  const audit = metadata.audit;
+  if (!audit || typeof audit !== "object") return null;
+  const actor = audit.actor;
+  if (actor !== "app") return null;
+  const name = audit.appDisplayName;
+  return typeof name === "string" && name.trim() ? name.trim() : "app";
+};
+function MessageBubble({
+  message,
+  renderMessageContent,
+  onRequestMenu,
+  showAppOriginChip = false
+}) {
+  const lastTouchEndAtRef = useRef2(0);
+  const [timestampVisible, setTimestampVisible] = useState(false);
+  useEffect2(() => {
+    setTimestampVisible(false);
+  }, [message.id]);
+  const content = renderMessageContent ? renderMessageContent(message) : message.content;
+  const attachments = message.attachments ?? [];
+  const appOriginName = showAppOriginChip ? getAppOriginName(message) : null;
+  const timeText = formatTime(message.createdAt);
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: "conductor-bubble-group" + (timestampVisible ? " conductor-bubble-group--timestamp-visible" : ""),
+      children: [
+        timeText ? /* @__PURE__ */ jsx2("span", { className: "conductor-bubble__time", children: timeText }) : null,
+        /* @__PURE__ */ jsxs(
+          "div",
+          {
+            className: "conductor-bubble",
+            role: "button",
+            tabIndex: 0,
+            onClick: (event) => {
+              if (isInteractiveTarget(event.target)) return;
+              if (prefersTapTimestamp()) {
+                setTimestampVisible((current) => !current);
+              }
+            },
+            onDoubleClick: (event) => {
+              if (isInteractiveTarget(event.target)) return;
+              onRequestMenu(message);
+            },
+            onTouchEnd: (event) => {
+              if (isInteractiveTarget(event.target)) {
+                lastTouchEndAtRef.current = 0;
+                return;
+              }
+              const now = Date.now();
+              if (now - lastTouchEndAtRef.current <= TOUCH_DOUBLE_TAP_MS) {
+                lastTouchEndAtRef.current = 0;
+                event.preventDefault();
+                onRequestMenu(message);
+                return;
+              }
+              lastTouchEndAtRef.current = now;
+            },
+            onKeyDown: (event) => {
+              if (event.key === "Enter" || event.key === " ") {
+                event.preventDefault();
+                onRequestMenu(message);
+              }
+            },
+            children: [
+              appOriginName ? /* @__PURE__ */ jsxs("span", { className: "conductor-bubble__origin", children: [
+                "via ",
+                appOriginName
+              ] }) : null,
+              content
+            ]
+          }
+        ),
+        attachments.length > 0 ? /* @__PURE__ */ jsx2("div", { className: "conductor-bubble__attachments", children: attachments.map((att) => {
+          const kind = attachmentKind(att);
+          return /* @__PURE__ */ jsxs("div", { className: "conductor-attachment", "data-kind": kind, children: [
+            kind === "image" ? /* @__PURE__ */ jsx2(
+              "a",
+              {
+                href: att.url,
+                target: "_blank",
+                rel: "noreferrer",
+                className: "conductor-attachment__media-link",
+                children: /* @__PURE__ */ jsx2("img", { src: att.url, alt: att.filename, className: "conductor-attachment__image" })
+              }
+            ) : null,
+            kind === "video" ? /* @__PURE__ */ jsx2("video", { controls: true, preload: "metadata", className: "conductor-attachment__video", src: att.url }) : null,
+            kind === "audio" ? /* @__PURE__ */ jsx2("audio", { controls: true, className: "conductor-attachment__audio", src: att.url }) : null,
+            kind === "file" ? /* @__PURE__ */ jsxs("a", { href: att.url, target: "_blank", rel: "noreferrer", className: "conductor-attachment__file", children: [
+              /* @__PURE__ */ jsx2("span", { className: "conductor-attachment__name", children: att.filename }),
+              /* @__PURE__ */ jsx2("span", { className: "conductor-attachment__size", children: formatBytes(att.sizeBytes) })
+            ] }) : /* @__PURE__ */ jsxs("div", { className: "conductor-attachment__meta", children: [
+              /* @__PURE__ */ jsx2("span", { className: "conductor-attachment__name", children: att.filename }),
+              /* @__PURE__ */ jsx2("span", { className: "conductor-attachment__size", children: formatBytes(att.sizeBytes) })
+            ] })
+          ] }, att.id);
+        }) }) : null
+      ]
+    }
+  );
+}
+
+// src/react/components/QuestionNav.tsx
+import { useEffect as useEffect3, useRef as useRef3 } from "react";
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+function QuestionNav({
+  count,
+  activeIndex,
+  onJump,
+  visible = true,
+  label = "Jump to question"
+}) {
+  const buttonRefs = useRef3(/* @__PURE__ */ new Map());
+  useEffect3(() => {
+    if (!visible) return;
+    const node = buttonRefs.current.get(activeIndex);
+    if (!node || typeof node.scrollIntoView !== "function") return;
+    node.scrollIntoView({ block: "nearest", inline: "nearest" });
+  }, [activeIndex, visible, count]);
+  if (count === 0) return null;
+  const visibilityClass = visible ? "conductor-question-nav--visible" : "conductor-question-nav--hidden";
+  return /* @__PURE__ */ jsx3(
+    "nav",
+    {
+      "aria-label": label,
+      "aria-hidden": !visible,
+      className: `conductor-question-nav ${visibilityClass}`,
+      children: Array.from({ length: count }, (_, i) => /* @__PURE__ */ jsxs2("div", { className: "conductor-question-nav__group", children: [
+        i > 0 && /* @__PURE__ */ jsx3("span", { className: "conductor-question-nav__sep", "aria-hidden": "true" }),
+        /* @__PURE__ */ jsx3(
+          "button",
+          {
+            type: "button",
+            ref: (node) => {
+              if (node) {
+                buttonRefs.current.set(i, node);
+              } else {
+                buttonRefs.current.delete(i);
+              }
+            },
+            tabIndex: visible ? 0 : -1,
+            "aria-label": `${label} ${i + 1}`,
+            title: `${i + 1}`,
+            onClick: () => onJump(i),
+            className: "conductor-question-nav__btn",
+            children: /* @__PURE__ */ jsx3(
+              "span",
+              {
+                className: "conductor-question-nav__dot" + (activeIndex === i ? " conductor-question-nav__dot--active" : "")
+              }
+            )
+          }
+        )
+      ] }, i))
+    }
+  );
+}
+
+// src/react/components/MessageList.tsx
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+var SCROLL_STORAGE_PREFIX = "conductor-sdk-task-scroll:";
+var SCROLL_BOTTOM_THRESHOLD_PX = 40;
+var SCROLL_TOP_LOAD_THRESHOLD_PX = 24;
+var SCROLL_TO_BOTTOM_BUTTON_MIN_OVERFLOW_PX = 40;
+var SCROLL_DIRECTION_THRESHOLD_PX = 4;
+var QUESTION_ACTIVE_OFFSET_PX = 80;
+var QUESTION_JUMP_TOP_PADDING_PX = 12;
+var COPY_FEEDBACK_MS = 1500;
+var SCROLL_PERSIST_DEBOUNCE_MS = 150;
+var getScrollStorageKey = (taskId) => `${SCROLL_STORAGE_PREFIX}${taskId}`;
+var getMaxScrollTop = (el) => Math.max(0, el.scrollHeight - el.clientHeight);
+var clampScrollTop = (el, scrollTop) => Math.min(Math.max(scrollTop, 0), getMaxScrollTop(el));
+var isNearBottom = (el) => getMaxScrollTop(el) - el.scrollTop <= SCROLL_BOTTOM_THRESHOLD_PX;
+var isUserSide = (m) => m.role === "user" || m.role === "sdk";
+var readStoredScrollState = (taskId) => {
+  if (typeof window === "undefined") return null;
+  try {
+    const raw = window.sessionStorage.getItem(getScrollStorageKey(taskId));
+    if (!raw) return null;
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null && Number.isFinite(parsed.scrollTop) && typeof parsed.stickToBottom === "boolean") {
+      return { scrollTop: Math.max(0, parsed.scrollTop), stickToBottom: parsed.stickToBottom };
+    }
+  } catch {
+  }
+  return null;
+};
+var writeStoredScrollState = (taskId, state) => {
+  if (typeof window === "undefined") return;
+  try {
+    window.sessionStorage.setItem(getScrollStorageKey(taskId), JSON.stringify(state));
+  } catch {
+  }
+};
+async function copyText(text) {
+  try {
+    if (navigator.clipboard && window.isSecureContext) {
+      await navigator.clipboard.writeText(text);
+      return true;
+    }
+  } catch {
+  }
+  try {
+    const textarea = document.createElement("textarea");
+    textarea.value = text;
+    textarea.setAttribute("readonly", "");
+    textarea.style.position = "fixed";
+    textarea.style.top = "-1000px";
+    textarea.style.left = "-1000px";
+    document.body.appendChild(textarea);
+    textarea.select();
+    const ok = typeof document.execCommand === "function" && document.execCommand("copy");
+    document.body.removeChild(textarea);
+    return Boolean(ok);
+  } catch {
+    return false;
+  }
+}
+function MessageList({
+  labels,
+  renderMessageContent,
+  showAppOriginChip,
+  readOnly = false
+}) {
+  const { state, loadEarlier, send, interrupt, restart, restartSupported, taskId } = useChat();
+  const containerRef = useRef4(null);
+  const [showScrollToBottom, setShowScrollToBottom] = useState2(false);
+  const [showQuestionNav, setShowQuestionNav] = useState2(false);
+  const [activeQuestion, setActiveQuestion] = useState2(0);
+  const [menuMessage, setMenuMessage] = useState2(null);
+  const [copied, setCopied] = useState2(false);
+  const [restartPending, setRestartPending] = useState2(false);
+  const questionRefs = useRef4(/* @__PURE__ */ new Map());
+  const isJumpingRef = useRef4(false);
+  const lastScrollTopRef = useRef4(0);
+  const activeQuestionRafRef = useRef4(null);
+  const copyTimeoutRef = useRef4(null);
+  const scrollWriteTimerRef = useRef4(null);
+  const pendingScrollStateRef = useRef4(null);
+  const previousMessageCountRef = useRef4(state.messages.length);
+  const pendingRestoreScrollStateRef = useRef4(null);
+  const pendingPrependAnchorRef = useRef4(null);
+  const autoLoadUntilFilledRef = useRef4(false);
+  const shouldRestoreScrollRef = useRef4(true);
+  const shouldStickToBottomRef = useRef4(true);
+  const messages = state.messages;
+  const hasMoreBefore = state.hasMoreBefore;
+  const oldestMessageId = state.oldestMessageId;
+  const loadingHistory = state.loadingHistory;
+  const replyInProgress = state.runtime?.replyInProgress === true;
+  const canInterrupt = replyInProgress && Boolean(state.latestReplyId);
+  const questionIndexById = useMemo2(() => {
+    const map = /* @__PURE__ */ new Map();
+    let q = 0;
+    for (const m of messages) {
+      if (isUserSide(m)) {
+        map.set(m.id, q);
+        q += 1;
+      }
+    }
+    return map;
+  }, [messages]);
+  const userQuestionCount = questionIndexById.size;
+  const writeScrollNow = useCallback(
+    (override) => {
+      if (scrollWriteTimerRef.current !== null) {
+        window.clearTimeout(scrollWriteTimerRef.current);
+        scrollWriteTimerRef.current = null;
+      }
+      const el = containerRef.current;
+      const next = override ?? pendingScrollStateRef.current ?? (el ? { scrollTop: clampScrollTop(el, el.scrollTop), stickToBottom: isNearBottom(el) } : null);
+      pendingScrollStateRef.current = null;
+      if (next) writeStoredScrollState(taskId, next);
+    },
+    [taskId]
+  );
+  const persistScroll = useCallback(
+    (scrollTop) => {
+      const el = containerRef.current;
+      if (!el) return;
+      const next = typeof scrollTop === "number" ? clampScrollTop(el, scrollTop) : clampScrollTop(el, el.scrollTop);
+      const stick = isNearBottom(el);
+      const canScroll = getMaxScrollTop(el) > SCROLL_TO_BOTTOM_BUTTON_MIN_OVERFLOW_PX;
+      shouldStickToBottomRef.current = stick;
+      setShowScrollToBottom(canScroll && !stick);
+      pendingScrollStateRef.current = { scrollTop: next, stickToBottom: stick };
+      if (scrollWriteTimerRef.current === null) {
+        scrollWriteTimerRef.current = window.setTimeout(() => {
+          scrollWriteTimerRef.current = null;
+          if (pendingScrollStateRef.current) {
+            writeStoredScrollState(taskId, pendingScrollStateRef.current);
+            pendingScrollStateRef.current = null;
+          }
+        }, SCROLL_PERSIST_DEBOUNCE_MS);
+      }
+    },
+    [taskId]
+  );
+  const scrollToBottom = useCallback(() => {
     const el = containerRef.current;
     if (!el) return;
-    const grew = state.messages.length > lastMessageCountRef.current;
-    lastMessageCountRef.current = state.messages.length;
-    if (!grew) return;
-    const distanceFromBottom = el.scrollHeight - el.scrollTop - el.clientHeight;
-    if (distanceFromBottom < 120) {
-      el.scrollTop = el.scrollHeight;
-    }
-  }, [state.messages.length]);
-  useEffect2(() => {
+    const next = getMaxScrollTop(el);
+    lastScrollTopRef.current = next;
+    el.scrollTop = next;
+    shouldStickToBottomRef.current = true;
+    setShowScrollToBottom(false);
+    setShowQuestionNav(false);
+    writeScrollNow({ scrollTop: next, stickToBottom: true });
+  }, [writeScrollNow]);
+  const handleJumpToQuestion = useCallback((questionIndex) => {
+    const node = questionRefs.current.get(questionIndex);
+    const el = containerRef.current;
+    if (!node || !el) return;
+    isJumpingRef.current = true;
+    const containerTop = el.getBoundingClientRect().top;
+    const elTop = node.getBoundingClientRect().top;
+    const next = clampScrollTop(
+      el,
+      el.scrollTop + (elTop - containerTop) - QUESTION_JUMP_TOP_PADDING_PX
+    );
+    lastScrollTopRef.current = next;
+    el.scrollTop = next;
+    setActiveQuestion(questionIndex);
+    window.setTimeout(() => {
+      isJumpingRef.current = false;
+    }, 120);
+  }, []);
+  const loadOlder = useCallback(
+    async (options) => {
+      if (!oldestMessageId || loadingHistory) return;
+      if (options?.continueUntilFilled) autoLoadUntilFilledRef.current = true;
+      const el = containerRef.current;
+      if (el) {
+        pendingPrependAnchorRef.current = {
+          previousScrollHeight: el.scrollHeight,
+          previousScrollTop: el.scrollTop
+        };
+      }
+      await loadEarlier();
+    },
+    [oldestMessageId, loadingHistory, loadEarlier]
+  );
+  const maybeContinueAutoLoad = useCallback(() => {
+    const el = containerRef.current;
+    if (!autoLoadUntilFilledRef.current || !el || loadingHistory) return;
+    if (!hasMoreBefore || !oldestMessageId) {
+      autoLoadUntilFilledRef.current = false;
+      return;
+    }
+    if (el.scrollHeight > el.clientHeight + SCROLL_TOP_LOAD_THRESHOLD_PX) {
+      autoLoadUntilFilledRef.current = false;
+      return;
+    }
+    void loadOlder({ continueUntilFilled: true });
+  }, [loadingHistory, hasMoreBefore, oldestMessageId, loadOlder]);
+  const handleScroll = useCallback(() => {
+    persistScroll();
+    const el = containerRef.current;
+    if (!el) return;
+    const current = el.scrollTop;
+    const delta = current - lastScrollTopRef.current;
+    if (!isJumpingRef.current && userQuestionCount > 1) {
+      if (delta <= -SCROLL_DIRECTION_THRESHOLD_PX) {
+        setShowQuestionNav(true);
+      } else if (delta >= SCROLL_DIRECTION_THRESHOLD_PX) {
+        setShowQuestionNav(false);
+      }
+    }
+    if (!isJumpingRef.current && questionRefs.current.size > 0 && activeQuestionRafRef.current === null) {
+      activeQuestionRafRef.current = window.requestAnimationFrame(() => {
+        activeQuestionRafRef.current = null;
+        if (isJumpingRef.current) return;
+        const c = containerRef.current;
+        if (!c) return;
+        const containerTop = c.getBoundingClientRect().top;
+        let closest = 0;
+        let closestDist = Infinity;
+        questionRefs.current.forEach((node, idx) => {
+          const dist = Math.abs(
+            node.getBoundingClientRect().top - containerTop - QUESTION_ACTIVE_OFFSET_PX
+          );
+          if (dist < closestDist) {
+            closestDist = dist;
+            closest = idx;
+          }
+        });
+        setActiveQuestion((cur) => cur === closest ? cur : closest);
+      });
+    }
+    lastScrollTopRef.current = current;
+    if (!hasMoreBefore || loadingHistory || !oldestMessageId) {
+      if (!hasMoreBefore || !oldestMessageId) autoLoadUntilFilledRef.current = false;
+      return;
+    }
+    if (current <= SCROLL_TOP_LOAD_THRESHOLD_PX) {
+      void loadOlder({ continueUntilFilled: true });
+      return;
+    }
+    autoLoadUntilFilledRef.current = false;
+  }, [persistScroll, userQuestionCount, hasMoreBefore, loadingHistory, oldestMessageId, loadOlder]);
+  useLayoutEffect(() => {
+    pendingRestoreScrollStateRef.current = readStoredScrollState(taskId);
+    pendingPrependAnchorRef.current = null;
+    autoLoadUntilFilledRef.current = false;
+    shouldRestoreScrollRef.current = true;
+    shouldStickToBottomRef.current = true;
+    previousMessageCountRef.current = messages.length;
+    questionRefs.current = /* @__PURE__ */ new Map();
+    isJumpingRef.current = false;
+    lastScrollTopRef.current = 0;
+    if (activeQuestionRafRef.current !== null) {
+      window.cancelAnimationFrame(activeQuestionRafRef.current);
+      activeQuestionRafRef.current = null;
+    }
+    setShowScrollToBottom(false);
+    setShowQuestionNav(false);
+    setActiveQuestion(0);
+    setMenuMessage(null);
+    setCopied(false);
+  }, [taskId]);
+  useLayoutEffect(() => {
     const el = containerRef.current;
     if (!el) return;
-    el.scrollTop = el.scrollHeight;
+    if (pendingPrependAnchorRef.current) {
+      const { previousScrollHeight, previousScrollTop } = pendingPrependAnchorRef.current;
+      const delta = el.scrollHeight - previousScrollHeight;
+      const next = clampScrollTop(el, previousScrollTop + delta);
+      lastScrollTopRef.current = next;
+      el.scrollTop = next;
+      persistScroll(next);
+      pendingPrependAnchorRef.current = null;
+      previousMessageCountRef.current = messages.length;
+      maybeContinueAutoLoad();
+      return;
+    }
+    if (shouldRestoreScrollRef.current) {
+      const belongsToTask = messages.length === 0 || messages[0].taskId === taskId;
+      if (!belongsToTask) return;
+      if (loadingHistory && messages.length === 0) return;
+      const stored = pendingRestoreScrollStateRef.current;
+      if (stored?.stickToBottom) {
+        scrollToBottom();
+      } else if (stored) {
+        const next = clampScrollTop(el, stored.scrollTop);
+        lastScrollTopRef.current = next;
+        el.scrollTop = next;
+        persistScroll(next);
+      } else {
+        scrollToBottom();
+      }
+      shouldRestoreScrollRef.current = false;
+      pendingRestoreScrollStateRef.current = null;
+      previousMessageCountRef.current = messages.length;
+      maybeContinueAutoLoad();
+      return;
+    }
+    const prevCount = previousMessageCountRef.current;
+    if (messages.length > prevCount) {
+      const lastMsg = messages[messages.length - 1];
+      const localSend = lastMsg ? isUserSide(lastMsg) && lastMsg.id.startsWith("pending:") : false;
+      if (shouldStickToBottomRef.current || localSend) {
+        scrollToBottom();
+      } else {
+        persistScroll();
+      }
+    } else {
+      persistScroll();
+    }
+    previousMessageCountRef.current = messages.length;
+    maybeContinueAutoLoad();
+  }, [loadingHistory, messages.length, taskId, persistScroll, scrollToBottom, maybeContinueAutoLoad]);
+  useEffect4(
+    () => () => {
+      writeScrollNow();
+    },
+    [taskId, writeScrollNow]
+  );
+  useEffect4(
+    () => () => {
+      if (activeQuestionRafRef.current !== null) {
+        window.cancelAnimationFrame(activeQuestionRafRef.current);
+        activeQuestionRafRef.current = null;
+      }
+      if (copyTimeoutRef.current !== null) {
+        window.clearTimeout(copyTimeoutRef.current);
+        copyTimeoutRef.current = null;
+      }
+      if (scrollWriteTimerRef.current !== null) {
+        window.clearTimeout(scrollWriteTimerRef.current);
+        scrollWriteTimerRef.current = null;
+      }
+    },
+    []
+  );
+  const closeMenu = useCallback(() => {
+    if (copyTimeoutRef.current !== null) {
+      window.clearTimeout(copyTimeoutRef.current);
+      copyTimeoutRef.current = null;
+    }
+    setCopied(false);
+    setMenuMessage(null);
+  }, []);
+  const openMenu = useCallback((message) => {
+    if (copyTimeoutRef.current !== null) {
+      window.clearTimeout(copyTimeoutRef.current);
+      copyTimeoutRef.current = null;
+    }
+    setCopied(false);
+    setMenuMessage(message);
   }, []);
-  return /* @__PURE__ */ jsxs("div", { ref: containerRef, className: "conductor-message-list", role: "log", "aria-live": "polite", children: [
-    state.hasMoreBefore && /* @__PURE__ */ jsx2("div", { className: "conductor-load-earlier", children: /* @__PURE__ */ jsx2(
+  useEffect4(() => {
+    if (!menuMessage) return;
+    const onKeyDown = (event) => {
+      if (event.key === "Escape") closeMenu();
+    };
+    window.addEventListener("keydown", onKeyDown);
+    return () => window.removeEventListener("keydown", onKeyDown);
+  }, [menuMessage, closeMenu]);
+  const handleCopy = useCallback(async () => {
+    if (!menuMessage) return;
+    const ok = await copyText(menuMessage.content);
+    if (!ok) {
+      closeMenu();
+      return;
+    }
+    setCopied(true);
+    copyTimeoutRef.current = window.setTimeout(() => {
+      closeMenu();
+    }, COPY_FEEDBACK_MS);
+  }, [menuMessage, closeMenu]);
+  const handleResend = useCallback(() => {
+    if (!menuMessage || !menuMessage.content.trim()) return;
+    void send(menuMessage.content);
+    closeMenu();
+  }, [menuMessage, send, closeMenu]);
+  const handleInterrupt = useCallback(() => {
+    void interrupt();
+    closeMenu();
+  }, [interrupt, closeMenu]);
+  const handleRestart = useCallback(async () => {
+    if (!restartSupported || restartPending) return;
+    setRestartPending(true);
+    closeMenu();
+    try {
+      await restart({ restartMode: "refresh_session" });
+    } finally {
+      setRestartPending(false);
+    }
+  }, [restartSupported, restartPending, restart, closeMenu]);
+  const menuIsUserSide = menuMessage ? isUserSide(menuMessage) : false;
+  const showEmptyState = messages.length === 0 && !loadingHistory;
+  return /* @__PURE__ */ jsxs3("div", { className: "conductor-message-list-viewport", children: [
+    /* @__PURE__ */ jsxs3(
+      "div",
+      {
+        ref: containerRef,
+        className: "conductor-message-list",
+        role: "log",
+        "aria-live": "polite",
+        onScroll: handleScroll,
+        children: [
+          hasMoreBefore && /* @__PURE__ */ jsx4("div", { className: "conductor-load-earlier", children: /* @__PURE__ */ jsx4(
+            "button",
+            {
+              type: "button",
+              onClick: () => {
+                void loadOlder({ continueUntilFilled: true });
+              },
+              disabled: loadingHistory,
+              children: loadingHistory ? "\u2026" : labels.loadEarlier
+            }
+          ) }),
+          showEmptyState ? /* @__PURE__ */ jsxs3("div", { className: "conductor-empty", children: [
+            /* @__PURE__ */ jsx4(
+              "svg",
+              {
+                className: "conductor-empty__icon",
+                fill: "none",
+                stroke: "currentColor",
+                strokeWidth: 1.5,
+                viewBox: "0 0 24 24",
+                "aria-hidden": "true",
+                children: /* @__PURE__ */ jsx4(
+                  "path",
+                  {
+                    strokeLinecap: "round",
+                    strokeLinejoin: "round",
+                    d: "M8 12h.01M12 12h.01M16 12h.01M21 12c0 4.418-4.03 8-9 8a9.863 9.863 0 01-4.255-.949L3 20l1.395-3.72C3.512 15.042 3 13.574 3 12c0-4.418 4.03-8 9-8s9 3.582 9 8z"
+                  }
+                )
+              }
+            ),
+            /* @__PURE__ */ jsx4("p", { className: "conductor-empty__title", children: labels.emptyTitle }),
+            /* @__PURE__ */ jsx4("p", { className: "conductor-empty__body", children: labels.emptyBody }),
+            restartSupported && !readOnly ? /* @__PURE__ */ jsx4(
+              "button",
+              {
+                type: "button",
+                className: "conductor-button conductor-empty__restart",
+                "data-testid": "conductor-empty-restart",
+                disabled: restartPending,
+                onClick: () => {
+                  void handleRestart();
+                },
+                children: restartPending ? labels.restartPending : labels.restart
+              }
+            ) : null
+          ] }) : null,
+          messages.map((m) => {
+            const isUser = isUserSide(m);
+            const isPending = m.id.startsWith("pending:");
+            const qIdx = questionIndexById.get(m.id);
+            return /* @__PURE__ */ jsx4(
+              "div",
+              {
+                ref: (node) => {
+                  if (qIdx == null) return;
+                  if (node) {
+                    questionRefs.current.set(qIdx, node);
+                  } else {
+                    questionRefs.current.delete(qIdx);
+                  }
+                },
+                className: "conductor-message " + (isUser ? "conductor-message--user" : "conductor-message--assistant") + (isPending ? " conductor-message--pending" : ""),
+                "data-role": m.role,
+                "data-message-id": m.id,
+                children: /* @__PURE__ */ jsx4(
+                  MessageBubble,
+                  {
+                    message: m,
+                    renderMessageContent,
+                    onRequestMenu: openMenu,
+                    showAppOriginChip
+                  }
+                )
+              },
+              m.id
+            );
+          })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx4(
+      QuestionNav,
+      {
+        count: userQuestionCount,
+        activeIndex: activeQuestion,
+        visible: showQuestionNav && userQuestionCount > 1,
+        onJump: handleJumpToQuestion,
+        label: labels.jumpToQuestion
+      }
+    ),
+    showScrollToBottom && /* @__PURE__ */ jsx4(
       "button",
       {
         type: "button",
-        onClick: () => {
-          void loadEarlier();
-        },
-        disabled: state.loadingHistory,
-        children: state.loadingHistory ? "\u2026" : labels.loadEarlier
-      }
-    ) }),
-    state.messages.length === 0 && !state.loadingHistory && /* @__PURE__ */ jsx2("div", { className: "conductor-empty" }),
-    state.messages.map((m) => {
-      const isUser = m.role === "user" || m.role === "sdk";
-      const isPending = m.id.startsWith("pending:");
-      const content = renderMessageContent ? renderMessageContent(m) : m.content;
-      return /* @__PURE__ */ jsx2(
-        "div",
-        {
-          className: "conductor-message " + (isUser ? "conductor-message--user" : "conductor-message--assistant") + (isPending ? " conductor-message--pending" : ""),
-          "data-role": m.role,
-          "data-message-id": m.id,
-          children: /* @__PURE__ */ jsx2("div", { className: "conductor-bubble", children: content })
-        },
-        m.id
-      );
-    })
+        className: "conductor-scroll-to-bottom",
+        "aria-label": labels.scrollToBottom,
+        "data-testid": "conductor-scroll-to-bottom",
+        onClick: scrollToBottom,
+        children: /* @__PURE__ */ jsxs3(
+          "svg",
+          {
+            viewBox: "0 0 24 24",
+            fill: "none",
+            stroke: "currentColor",
+            strokeWidth: 2,
+            strokeLinecap: "round",
+            strokeLinejoin: "round",
+            "aria-hidden": "true",
+            children: [
+              /* @__PURE__ */ jsx4("path", { d: "M12 5v14" }),
+              /* @__PURE__ */ jsx4("path", { d: "m19 12-7 7-7-7" })
+            ]
+          }
+        )
+      }
+    ),
+    menuMessage && /* @__PURE__ */ jsxs3(
+      "div",
+      {
+        className: "conductor-bubble-menu-overlay",
+        onClick: closeMenu,
+        "data-testid": "conductor-bubble-menu",
+        children: [
+          /* @__PURE__ */ jsx4("div", { className: "conductor-bubble-menu-backdrop" }),
+          /* @__PURE__ */ jsxs3(
+            "div",
+            {
+              className: "conductor-bubble-menu-sheet",
+              role: "menu",
+              onClick: (event) => event.stopPropagation(),
+              children: [
+                /* @__PURE__ */ jsx4("div", { className: "conductor-bubble-menu-handle", "aria-hidden": "true" }),
+                /* @__PURE__ */ jsxs3("div", { className: "conductor-bubble-menu-actions", children: [
+                  /* @__PURE__ */ jsx4(
+                    "button",
+                    {
+                      type: "button",
+                      className: "conductor-bubble-menu-item",
+                      "data-testid": "conductor-bubble-menu-copy",
+                      onClick: () => {
+                        void handleCopy();
+                      },
+                      children: copied ? labels.copied : labels.copy
+                    }
+                  ),
+                  menuIsUserSide && !readOnly && /* @__PURE__ */ jsx4(
+                    "button",
+                    {
+                      type: "button",
+                      className: "conductor-bubble-menu-item",
+                      "data-testid": "conductor-bubble-menu-resend",
+                      disabled: !menuMessage.content.trim(),
+                      onClick: handleResend,
+                      children: labels.resend
+                    }
+                  ),
+                  canInterrupt && !readOnly && /* @__PURE__ */ jsx4(
+                    "button",
+                    {
+                      type: "button",
+                      className: "conductor-bubble-menu-item",
+                      "data-testid": "conductor-bubble-menu-interrupt",
+                      onClick: handleInterrupt,
+                      children: labels.interrupt
+                    }
+                  ),
+                  restartSupported && !readOnly && /* @__PURE__ */ jsx4(
+                    "button",
+                    {
+                      type: "button",
+                      className: "conductor-bubble-menu-item",
+                      "data-testid": "conductor-bubble-menu-restart",
+                      disabled: restartPending,
+                      onClick: () => {
+                        void handleRestart();
+                      },
+                      children: restartPending ? labels.restartPending : labels.restart
+                    }
+                  )
+                ] })
+              ]
+            }
+          )
+        ]
+      }
+    )
   ] });
 }
 
 // src/react/components/MessageInput.tsx
-import { useCallback, useLayoutEffect as useLayoutEffect2, useRef as useRef3, useState } from "react";
-import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
-function MessageInput({ labels, disabled }) {
-  const { state, send, interrupt } = useChat();
-  const [value, setValue] = useState("");
-  const taRef = useRef3(null);
-  const isComposingRef = useRef3(false);
+import {
+  useCallback as useCallback2,
+  useEffect as useEffect5,
+  useLayoutEffect as useLayoutEffect2,
+  useMemo as useMemo3,
+  useRef as useRef5,
+  useState as useState3
+} from "react";
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+var DRAFT_STORAGE_PREFIX = "conductor-sdk-task-draft:";
+var MAX_HISTORY_ITEMS = 200;
+var INPUT_SCROLL_THRESHOLD_RATIO = 0.75;
+var INTERRUPT_PENDING_TIMEOUT_MS = 5e3;
+var getDraftStorageKey = (taskId) => `${DRAFT_STORAGE_PREFIX}${taskId}`;
+var deriveSentHistory = (messages) => {
+  const seen = /* @__PURE__ */ new Set();
+  const reversed = [];
+  for (let i = messages.length - 1; i >= 0; i -= 1) {
+    const message = messages[i];
+    if (!message || message.role !== "user") continue;
+    const trimmed = (message.content ?? "").trim();
+    if (!trimmed || seen.has(trimmed)) continue;
+    seen.add(trimmed);
+    reversed.push(trimmed);
+    if (reversed.length >= MAX_HISTORY_ITEMS) break;
+  }
+  reversed.reverse();
+  return reversed;
+};
+function MessageInput({ labels, disabled, autoFocus = false }) {
+  const { state, send, interrupt, taskId } = useChat();
+  const [value, setValue] = useState3("");
+  const [interruptPending, setInterruptPending] = useState3(false);
+  const taRef = useRef5(null);
+  const isComposingRef = useRef5(false);
+  const skipDraftSaveRef = useRef5(true);
+  const historyCursorRef = useRef5(null);
+  const historyDraftRef = useRef5("");
+  const interruptTimeoutRef = useRef5(null);
+  const sentHistory = useMemo3(() => deriveSentHistory(state.messages), [state.messages]);
+  const replyInProgress = state.runtime?.replyInProgress === true;
+  const canInterrupt = replyInProgress && Boolean(state.latestReplyId);
+  useEffect5(() => {
+    if (typeof window === "undefined") return;
+    skipDraftSaveRef.current = true;
+    historyCursorRef.current = null;
+    historyDraftRef.current = "";
+    try {
+      setValue(window.sessionStorage.getItem(getDraftStorageKey(taskId)) ?? "");
+    } catch {
+      setValue("");
+    }
+  }, [taskId]);
+  useEffect5(() => {
+    if (typeof window === "undefined") return;
+    if (skipDraftSaveRef.current) {
+      skipDraftSaveRef.current = false;
+      return;
+    }
+    try {
+      const key = getDraftStorageKey(taskId);
+      if (!value) window.sessionStorage.removeItem(key);
+      else window.sessionStorage.setItem(key, value);
+    } catch {
+    }
+  }, [value, taskId]);
   useLayoutEffect2(() => {
     const el = taRef.current;
     if (!el) return;
     el.style.height = "auto";
-    el.style.height = `${Math.min(el.scrollHeight, 5 * 24 + 16)}px`;
+    const computed = window.getComputedStyle(el);
+    const lineHeight = Number.parseFloat(computed.lineHeight) || 20;
+    const maxHeight = Math.max(
+      lineHeight * 2,
+      Math.floor(window.innerHeight * INPUT_SCROLL_THRESHOLD_RATIO)
+    );
+    const shouldScroll = el.scrollHeight > maxHeight;
+    el.style.height = `${shouldScroll ? maxHeight : el.scrollHeight}px`;
+    el.style.overflowY = shouldScroll ? "auto" : "hidden";
   }, [value]);
-  const handleSend = useCallback(() => {
+  useEffect5(() => {
+    if (!autoFocus || disabled) return;
+    const el = taRef.current;
+    if (!el) return;
+    el.focus({ preventScroll: true });
+    const end = el.value.length;
+    el.setSelectionRange(end, end);
+  }, [autoFocus, disabled, taskId]);
+  useEffect5(() => {
+    if (!replyInProgress && interruptPending) {
+      setInterruptPending(false);
+      if (interruptTimeoutRef.current !== null) {
+        window.clearTimeout(interruptTimeoutRef.current);
+        interruptTimeoutRef.current = null;
+      }
+    }
+  }, [replyInProgress, interruptPending]);
+  useEffect5(
+    () => () => {
+      if (interruptTimeoutRef.current !== null) {
+        window.clearTimeout(interruptTimeoutRef.current);
+      }
+    },
+    []
+  );
+  const moveCaretToEnd = useCallback2((next) => {
+    const el = taRef.current;
+    if (!el) return;
+    const pos = (next ?? el.value).length;
+    requestAnimationFrame(() => {
+      el.focus({ preventScroll: true });
+      el.setSelectionRange(pos, pos);
+    });
+  }, []);
+  const handleSend = useCallback2(() => {
     if (!value.trim() || disabled) return;
     void send(value);
+    historyCursorRef.current = null;
+    historyDraftRef.current = "";
     setValue("");
   }, [send, value, disabled]);
-  const handleKeyDown = useCallback(
+  const triggerInterrupt = useCallback2(() => {
+    if (!canInterrupt || interruptPending || disabled) return;
+    setInterruptPending(true);
+    void interrupt();
+    if (interruptTimeoutRef.current !== null) window.clearTimeout(interruptTimeoutRef.current);
+    interruptTimeoutRef.current = window.setTimeout(() => {
+      interruptTimeoutRef.current = null;
+      setInterruptPending(false);
+    }, INTERRUPT_PENDING_TIMEOUT_MS);
+  }, [canInterrupt, interruptPending, interrupt, disabled]);
+  const handleKeyDown = useCallback2(
     (e) => {
       const nativeComposing = e.nativeEvent.isComposing === true;
-      if (isComposingRef.current || nativeComposing) return;
-      if (e.key === "Enter" && !e.shiftKey) {
+      const composing = isComposingRef.current || nativeComposing;
+      if (e.key === "ArrowUp") {
+        if (composing || e.altKey || e.ctrlKey || e.metaKey || e.shiftKey) return;
+        if (sentHistory.length === 0) return;
+        e.preventDefault();
+        let next;
+        if (historyCursorRef.current === null) {
+          historyDraftRef.current = value;
+          next = sentHistory[sentHistory.length - 1];
+        } else {
+          const idx = sentHistory.lastIndexOf(historyCursorRef.current);
+          if (idx === -1) next = sentHistory[sentHistory.length - 1];
+          else if (idx > 0) next = sentHistory[idx - 1];
+          else next = sentHistory[0];
+        }
+        historyCursorRef.current = next;
+        setValue(next);
+        moveCaretToEnd(next);
+        return;
+      }
+      if (e.key === "ArrowDown") {
+        if (composing || e.altKey || e.ctrlKey || e.metaKey || e.shiftKey) return;
+        if (historyCursorRef.current === null) return;
+        e.preventDefault();
+        const idx = sentHistory.lastIndexOf(historyCursorRef.current);
+        if (idx === -1 || idx >= sentHistory.length - 1) {
+          historyCursorRef.current = null;
+          setValue(historyDraftRef.current);
+          moveCaretToEnd(historyDraftRef.current);
+          return;
+        }
+        const next = sentHistory[idx + 1];
+        historyCursorRef.current = next;
+        setValue(next);
+        moveCaretToEnd(next);
+        return;
+      }
+      if (e.key === "Escape") {
+        if (composing || value.trim() || !canInterrupt || interruptPending) return;
         e.preventDefault();
-        handleSend();
+        triggerInterrupt();
+        return;
       }
+      if (e.key !== "Enter" || composing) return;
+      if (e.shiftKey) return;
+      if (e.ctrlKey || e.metaKey) {
+        e.preventDefault();
+        const el = taRef.current;
+        if (!el) return;
+        const start = el.selectionStart;
+        const end = el.selectionEnd;
+        const next = value.slice(0, start) + "\n" + value.slice(end);
+        setValue(next);
+        window.setTimeout(() => {
+          el.selectionStart = el.selectionEnd = start + 1;
+        }, 0);
+        return;
+      }
+      e.preventDefault();
+      handleSend();
     },
-    [handleSend]
+    [
+      sentHistory,
+      value,
+      canInterrupt,
+      interruptPending,
+      triggerInterrupt,
+      handleSend,
+      moveCaretToEnd
+    ]
   );
-  const handleCompositionStart = useCallback(() => {
-    isComposingRef.current = true;
-  }, []);
-  const handleCompositionEnd = useCallback(() => {
-    isComposingRef.current = false;
-  }, []);
-  const replyInProgress = state.runtime?.replyInProgress === true;
-  const canInterrupt = replyInProgress && Boolean(state.latestReplyId);
-  return /* @__PURE__ */ jsxs2("div", { className: "conductor-message-input", children: [
-    /* @__PURE__ */ jsx3(
+  const canSend = Boolean(value.trim()) && !disabled;
+  return /* @__PURE__ */ jsxs4("div", { className: "conductor-message-input", children: [
+    /* @__PURE__ */ jsx5(
       "textarea",
       {
         ref: taRef,
         value,
         onChange: (e) => setValue(e.target.value),
         onKeyDown: handleKeyDown,
-        onCompositionStart: handleCompositionStart,
-        onCompositionEnd: handleCompositionEnd,
+        onCompositionStart: () => {
+          isComposingRef.current = true;
+        },
+        onCompositionEnd: () => {
+          isComposingRef.current = false;
+        },
         placeholder: labels.inputPlaceholder,
         rows: 1,
         className: "conductor-message-input__textarea",
         disabled
       }
     ),
-    /* @__PURE__ */ jsx3("div", { className: "conductor-message-input__actions", children: canInterrupt ? /* @__PURE__ */ jsx3(
+    /* @__PURE__ */ jsx5("div", { className: "conductor-message-input__actions", children: canInterrupt && !disabled ? /* @__PURE__ */ jsx5(
       "button",
       {
         type: "button",
         className: "conductor-button conductor-button--interrupt",
-        onClick: () => void interrupt(),
-        children: labels.interrupt
+        onClick: triggerInterrupt,
+        disabled: interruptPending,
+        children: interruptPending ? "\u2026" : labels.interrupt
       }
-    ) : /* @__PURE__ */ jsx3(
+    ) : /* @__PURE__ */ jsx5(
       "button",
       {
         type: "button",
         className: "conductor-button conductor-button--send",
         onClick: handleSend,
-        disabled: !value.trim() || disabled,
+        disabled: !canSend,
         children: labels.send
       }
     ) })
@@ -489,28 +1433,34 @@ function MessageInput({ labels, disabled }) {
 }
 
 // src/react/components/RuntimeStatusBar.tsx
-import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
 function RuntimeStatusBar({ labels }) {
   const { state } = useChat();
   const runtime = state.runtime;
   const isThinking = runtime?.replyInProgress === true || runtime?.state === "thinking";
-  const text = pickStatusText(runtime?.state, runtime?.statusLine, labels);
+  const text = pickStatusText(
+    runtime?.state,
+    runtime?.statusLine,
+    runtime?.statusDoneLine,
+    labels
+  );
   const showConnection = state.connectionState !== "connected" && state.connectionState !== "offline";
-  return /* @__PURE__ */ jsxs3("div", { className: "conductor-runtime-status", role: "status", "aria-live": "polite", children: [
-    /* @__PURE__ */ jsx4(
+  return /* @__PURE__ */ jsxs5("div", { className: "conductor-runtime-status", role: "status", "aria-live": "polite", children: [
+    /* @__PURE__ */ jsx6(
       "span",
       {
         className: "conductor-runtime-indicator" + (isThinking ? " conductor-runtime-indicator--active" : ""),
         "aria-hidden": "true"
       }
     ),
-    /* @__PURE__ */ jsx4("span", { className: "conductor-runtime-text", children: text }),
-    state.error && /* @__PURE__ */ jsx4("span", { className: "conductor-runtime-error", role: "alert", children: state.error.message }),
-    showConnection && /* @__PURE__ */ jsx4("span", { className: "conductor-runtime-connection", children: state.connectionState === "reconnecting" ? "\u2026" : "" })
+    /* @__PURE__ */ jsx6("span", { className: "conductor-runtime-text", children: text }),
+    state.error && /* @__PURE__ */ jsx6("span", { className: "conductor-runtime-error", role: "alert", children: state.error.message }),
+    showConnection && /* @__PURE__ */ jsx6("span", { className: "conductor-runtime-connection", children: state.connectionState === "reconnecting" ? "\u2026" : "" })
   ] });
 }
-function pickStatusText(state, statusLine, labels) {
-  if (statusLine) return statusLine;
+function pickStatusText(state, statusLine, statusDoneLine, labels) {
+  if (statusLine && statusLine.trim()) return statusLine;
+  if (statusDoneLine && statusDoneLine.trim()) return statusDoneLine;
   switch (state) {
     case "thinking":
       return labels.statusThinking;
@@ -526,7 +1476,7 @@ function pickStatusText(state, statusLine, labels) {
 }
 
 // src/react/ChatView.tsx
-import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+import { jsx as jsx7, jsxs as jsxs6 } from "react/jsx-runtime";
 var DEFAULT_LABELS = {
   statusThinking: "Thinking\u2026",
   statusToolCall: "Calling tool\u2026",
@@ -536,29 +1486,39 @@ var DEFAULT_LABELS = {
   send: "Send",
   interrupt: "Stop",
   restart: "Restart",
-  loadEarlier: "Load earlier messages"
+  loadEarlier: "Load earlier messages",
+  copy: "Copy",
+  copied: "Copied",
+  resend: "Resend",
+  scrollToBottom: "Scroll to latest message",
+  jumpToQuestion: "Jump to question",
+  emptyTitle: "No messages yet",
+  emptyBody: "Send a message to get started \u2014 the conversation will appear here.",
+  restartPending: "Restarting\u2026"
 };
 function ChatView(props) {
   const labels = { ...DEFAULT_LABELS, ...props.labels ?? {} };
   const themeStyle = props.theme ? toCssVariableStyle(props.theme) : void 0;
   const className = ["conductor-chat-view", props.className].filter(Boolean).join(" ");
-  return /* @__PURE__ */ jsx5(
+  return /* @__PURE__ */ jsx7(
     "div",
     {
       className,
       "data-task-id": props.taskId,
       "data-layout": props.layout ?? "auto",
       style: themeStyle,
-      children: /* @__PURE__ */ jsxs4(ChatProvider, { taskId: props.taskId, adapter: props.adapter, onError: props.onError, children: [
-        /* @__PURE__ */ jsx5(RuntimeStatusBar, { labels }),
-        /* @__PURE__ */ jsx5(
+      children: /* @__PURE__ */ jsxs6(ChatProvider, { taskId: props.taskId, adapter: props.adapter, onError: props.onError, children: [
+        /* @__PURE__ */ jsx7(RuntimeStatusBar, { labels }),
+        /* @__PURE__ */ jsx7(
           MessageList,
           {
             labels,
-            renderMessageContent: props.renderMessageContent
+            renderMessageContent: props.renderMessageContent,
+            showAppOriginChip: props.showAppOriginChip,
+            readOnly: props.readOnly
           }
         ),
-        /* @__PURE__ */ jsx5(MessageInput, { labels, disabled: props.readOnly })
+        /* @__PURE__ */ jsx7(MessageInput, { labels, disabled: props.readOnly, autoFocus: props.autoFocus })
       ] })
     }
   );
@@ -711,7 +1671,7 @@ function createRestAdapter(options) {
     if (!text) return void 0;
     return JSON.parse(text);
   }
-  return {
+  const adapter = {
     async fetchHistory(taskId, opts) {
       if (!taskId) {
         throw new ConductorAppError({
@@ -824,6 +1784,23 @@ function createRestAdapter(options) {
       );
     }
   };
+  if (options.enableRestart) {
+    adapter.restart = async (taskId, opts) => {
+      if (!taskId) {
+        throw new ConductorAppError({
+          code: "invalid_input",
+          message: "restart requires a taskId"
+        });
+      }
+      const restartMode = opts?.restartMode?.trim();
+      await jsonFetch(
+        "POST",
+        `/tasks/${encodeURIComponent(taskId)}/restart`,
+        { body: restartMode ? { restart_mode: restartMode } : {} }
+      );
+    };
+  }
+  return adapter;
 }
 function buildUrl(base, path, query) {
   const cleanPath = path.startsWith("/") ? path : `/${path}`;