@truefoundry/trueforge-ui 0.0.0 → 0.1.0-rc.0

package/dist/chunk-UXZOL5GO.js

@@ -0,0 +1,2088 @@
+import {
+  useAui,
+  useAuiState
+} from "./chunk-M6MHLVSO.js";
+import {
+  ASK_USER_CUSTOM_OPTION,
+  BottomSheet,
+  Button,
+  DraftCatalogProvider,
+  SearchInput_default,
+  SlotsProvider,
+  USER_MESSAGE_ATTACHMENT_PREVIEW_REM,
+  canReuseMutableShell,
+  preloadMarkdownOpenUI,
+  readThreadAgentName,
+  threadListIndicesByRecency,
+  threadListItemIsMutable,
+  useIsMobile,
+  useSearchAgentsList,
+  useSlot,
+  useSlotIsDefault,
+  useToasterOptional
+} from "./chunk-XSHXH6EI.js";
+import {
+  Icon,
+  auiButtonClass,
+  libraryAgentId,
+  useCompactLayout,
+  useOptionalServer,
+  useOptionalShellMode
+} from "./chunk-UHGSHDBM.js";
+import {
+  cn
+} from "./chunk-UBOFEI77.js";
+
+// src/containers/AgentStepsContainer.tsx
+import { useEffect, useRef, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+function AgentStepsContainer({
+  children,
+  toolCount,
+  thinkingCount,
+  hasFinal
+}) {
+  const AgentStepsCard = useSlot("AgentStepsCard");
+  const [expanded, setExpanded] = useState(true);
+  const collapsedByFinal = useRef(false);
+  useEffect(() => {
+    if (hasFinal && !collapsedByFinal.current) {
+      collapsedByFinal.current = true;
+      setExpanded(false);
+    }
+  }, [hasFinal]);
+  return /* @__PURE__ */ jsx(
+    AgentStepsCard,
+    {
+      toolCount,
+      thinkingCount,
+      expanded,
+      onToggle: () => setExpanded((prev) => !prev),
+      children
+    }
+  );
+}
+
+// src/containers/AskUserContainer.tsx
+import { useThreadIsRunning } from "@assistant-ui/core/react";
+import { useTrueFoundryToolResponses } from "@truefoundry/assistant-ui-runtime";
+import { useCallback, useEffect as useEffect2, useMemo, useState as useState2 } from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var EMPTY_ANSWER = { radioValue: "", custom: "" };
+function AskUserContainer() {
+  const AskUserPrompt = useSlot("AskUserPrompt");
+  const { pending, respond } = useTrueFoundryToolResponses();
+  const isRunning = useThreadIsRunning();
+  const item = pending[0];
+  const questions = useMemo(
+    () => item == null ? [] : [
+      {
+        id: item.toolCallId,
+        question: item.question ?? "Answer required",
+        options: item.options ?? []
+      }
+    ],
+    [item]
+  );
+  const [currentQuestionIndex, setCurrentQuestionIndex] = useState2(0);
+  const [answers, setAnswers] = useState2({});
+  useEffect2(() => {
+    setCurrentQuestionIndex(0);
+    setAnswers({});
+  }, [item?.toolCallId]);
+  const safeIndex = Math.min(currentQuestionIndex, Math.max(questions.length - 1, 0));
+  const currentQuestion = questions[safeIndex];
+  const currentAnswer = currentQuestion == null ? EMPTY_ANSWER : answers[currentQuestion.id] ?? EMPTY_ANSWER;
+  const getResponseForQuestion = useCallback(
+    (questionId) => {
+      const answer = answers[questionId] ?? EMPTY_ANSWER;
+      return answer.radioValue === ASK_USER_CUSTOM_OPTION ? answer.custom.trim() : answer.radioValue.trim();
+    },
+    [answers]
+  );
+  const allQuestionsAnswered = useMemo(
+    () => questions.every((question) => getResponseForQuestion(question.id)),
+    [getResponseForQuestion, questions]
+  );
+  const selectedResponse = currentAnswer.radioValue === ASK_USER_CUSTOM_OPTION ? currentAnswer.custom.trim() : currentAnswer.radioValue.trim();
+  const isSubmitDisabled = isRunning || currentQuestion == null || selectedResponse.length === 0;
+  const isSubmitAllDisabled = isSubmitDisabled || !allQuestionsAnswered;
+  const onCurrentAnswerChange = useCallback((questionId, update) => {
+    setAnswers((previous) => ({
+      ...previous,
+      [questionId]: {
+        ...previous[questionId] ?? EMPTY_ANSWER,
+        ...update
+      }
+    }));
+  }, []);
+  const onSubmit = useCallback(() => {
+    if (item == null || !allQuestionsAnswered) return;
+    const content = getResponseForQuestion(item.toolCallId);
+    if (!content) return;
+    respond({ toolCallId: item.toolCallId, content });
+  }, [allQuestionsAnswered, getResponseForQuestion, item, respond]);
+  if (item == null || currentQuestion == null) return null;
+  return /* @__PURE__ */ jsx2(
+    AskUserPrompt,
+    {
+      questions,
+      readOnly: isRunning,
+      currentQuestion,
+      currentQuestionIndex: safeIndex,
+      currentAnswer,
+      totalQuestions: questions.length,
+      isMultiQuestion: questions.length > 1,
+      isLastQuestion: safeIndex === questions.length - 1,
+      allQuestionsAnswered,
+      isSubmitDisabled,
+      isSubmitAllDisabled,
+      onCurrentQuestionIndexChange: setCurrentQuestionIndex,
+      onCurrentAnswerChange,
+      onSubmit
+    }
+  );
+}
+
+// src/utils/computeAgentStepsSplit.ts
+function computeAgentStepsSplit(parts, isRunning) {
+  const finalTexts = [];
+  let cutIdx = parts.length;
+  for (let i = parts.length - 1; i >= 0; i--) {
+    const part = parts[i];
+    if (!part) continue;
+    if (part.type === "text") {
+      const text = part.text ?? "";
+      const trimmed = text.trim();
+      if (trimmed) {
+        finalTexts.unshift({ index: i, content: text });
+        cutIdx = i;
+      } else {
+        cutIdx = i;
+      }
+    } else {
+      break;
+    }
+  }
+  const trailingChars = finalTexts.reduce((sum, t) => sum + t.content.length, 0);
+  const hasAgentStepsBeforeCut = parts.slice(0, cutIdx).some((p) => p.type === "tool-call" || p.type === "reasoning");
+  const finalConfirmed = finalTexts.length > 0 && (!isRunning || trailingChars >= 500 || !hasAgentStepsBeforeCut);
+  const actualCutIndex = finalConfirmed ? cutIdx : parts.length;
+  let toolCount = 0;
+  let thinkingCount = 0;
+  for (let i = 0; i < actualCutIndex; i++) {
+    const part = parts[i];
+    if (!part) continue;
+    if (part.type === "tool-call") {
+      toolCount++;
+    } else if (part.type === "reasoning") {
+      thinkingCount++;
+    }
+  }
+  return {
+    cutIndex: actualCutIndex,
+    hasFinal: finalConfirmed,
+    toolCount,
+    thinkingCount
+  };
+}
+
+// src/containers/AssistantTextContainer.tsx
+import {
+  useAuiState as useAuiState2,
+  useSmooth
+} from "@assistant-ui/react";
+import { useTrueFoundryDownloadSandboxFile } from "@truefoundry/assistant-ui-runtime";
+import { useCallback as useCallback2, useMemo as useMemo2, useRef as useRef3 } from "react";
+
+// src/hooks/useThrottledMarkdownText.ts
+import { useEffect as useEffect3, useRef as useRef2, useState as useState3 } from "react";
+var MARKDOWN_SMOOTH_BACKLOG_CHARS = 4 * 1024;
+var LARGE_MARKDOWN_THROTTLE_MS = 100;
+function useThrottledMarkdownText(text, {
+  isComplete,
+  enabled,
+  throttleMs = LARGE_MARKDOWN_THROTTLE_MS
+}) {
+  const [committed, setCommitted] = useState3(text);
+  const lastCommittedRef = useRef2(text);
+  const lastCommitAtRef = useRef2(Date.now());
+  const pendingRef = useRef2(text);
+  const wasEnabledRef = useRef2(enabled);
+  useEffect3(() => {
+    pendingRef.current = text;
+    const commit = (value) => {
+      if (value.length < lastCommittedRef.current.length && value !== lastCommittedRef.current) {
+        return;
+      }
+      lastCommittedRef.current = value;
+      lastCommitAtRef.current = Date.now();
+      setCommitted(value);
+    };
+    if (!enabled) {
+      wasEnabledRef.current = false;
+      lastCommittedRef.current = text;
+      lastCommitAtRef.current = Date.now();
+      setCommitted(text);
+      return;
+    }
+    if (!wasEnabledRef.current) {
+      wasEnabledRef.current = true;
+      commit(text);
+      return;
+    }
+    if (lastCommittedRef.current === text) return;
+    if (isComplete) {
+      commit(text);
+      return;
+    }
+    const elapsed = Date.now() - lastCommitAtRef.current;
+    if (elapsed >= throttleMs) {
+      commit(text);
+      return;
+    }
+    const id = setTimeout(() => {
+      commit(pendingRef.current);
+    }, throttleMs - elapsed);
+    return () => clearTimeout(id);
+  }, [text, isComplete, enabled, throttleMs]);
+  return enabled ? committed : text;
+}
+
+// src/containers/AssistantTextContainer.tsx
+import { jsx as jsx3 } from "react/jsx-runtime";
+function filenameFromPath(path) {
+  return path.split("/").pop() || "download";
+}
+function triggerBrowserDownload(blob, filename) {
+  if (typeof document === "undefined") return;
+  const url = URL.createObjectURL(blob);
+  const anchor = document.createElement("a");
+  anchor.href = url;
+  anchor.download = filename;
+  anchor.click();
+  URL.revokeObjectURL(url);
+}
+function AssistantTextContainer() {
+  const Markdown = useSlot("Markdown");
+  const toaster = useToasterOptional();
+  const downloadSandboxFile = useTrueFoundryDownloadSandboxFile();
+  const downloadRef = useRef3({ downloadSandboxFile, toaster });
+  downloadRef.current = { downloadSandboxFile, toaster };
+  const partState = useAuiState2((s) => s.part);
+  const pacedModeRef = useRef3(false);
+  const smoothedPart = useSmooth(
+    partState,
+    pacedModeRef.current ? false : {
+      drainMs: 150,
+      maxCharIntervalMs: 4,
+      maxCharsPerFrame: 128,
+      minCommitMs: 48
+    }
+  );
+  const networkComplete = partState.status?.type !== "running";
+  const smoothLag = partState.text.length - smoothedPart.text.length;
+  if (!pacedModeRef.current && !networkComplete && smoothLag >= MARKDOWN_SMOOTH_BACKLOG_CHARS) {
+    pacedModeRef.current = true;
+  }
+  const usePacedMode = pacedModeRef.current;
+  const pacedText = useThrottledMarkdownText(partState.text, {
+    enabled: usePacedMode,
+    isComplete: networkComplete
+  });
+  const text = usePacedMode ? pacedText : smoothedPart.text;
+  const isStreaming = usePacedMode ? !networkComplete || text !== partState.text : smoothedPart.status?.type === "running";
+  const handleDownloadArtifact = useCallback2(async (path) => {
+    const { downloadSandboxFile: downloadSandboxFile2, toaster: toaster2 } = downloadRef.current;
+    try {
+      triggerBrowserDownload(await downloadSandboxFile2(path), filenameFromPath(path));
+    } catch (error) {
+      if (toaster2 != null) {
+        toaster2.showError(error);
+      } else {
+        console.error("Failed to download sandbox artifact", error);
+      }
+    }
+  }, []);
+  return useMemo2(
+    () => /* @__PURE__ */ jsx3(Markdown, { content: text, isStreaming, onDownloadArtifact: handleDownloadArtifact }),
+    [Markdown, text, isStreaming, handleDownloadArtifact]
+  );
+}
+
+// src/containers/ReasoningContainer.tsx
+import { useAuiState as useAuiState3 } from "@assistant-ui/react";
+import { useCallback as useCallback3, useRef as useRef4, useState as useState4 } from "react";
+import { jsx as jsx4 } from "react/jsx-runtime";
+function ReasoningContainer({ group }) {
+  const ReasoningCard = useSlot("ReasoningCard");
+  const content = useAuiState3(
+    (s) => group.indices.map((i) => s.message.parts[i]).filter((p) => p != null && p.type === "reasoning").map((p) => p.text ?? "").join("")
+  );
+  const streaming = useAuiState3((s) => {
+    if (s.message.status?.type !== "running") return false;
+    const lastIndex = s.message.parts.length - 1;
+    if (lastIndex < 0) return false;
+    if (s.message.parts[lastIndex]?.type !== "reasoning") return false;
+    const lastGroupIndex = group.indices[group.indices.length - 1];
+    return lastGroupIndex !== void 0 && lastIndex >= group.indices[0] && lastIndex <= lastGroupIndex;
+  });
+  const [expanded, setExpanded] = useState4(streaming);
+  const [prevStreaming, setPrevStreaming] = useState4(streaming);
+  const [isMultiLine, setIsMultiLine] = useState4(false);
+  const observerRef = useRef4(null);
+  if (streaming !== prevStreaming) {
+    setPrevStreaming(streaming);
+    if (streaming) setExpanded(true);
+  }
+  const contentRef = useCallback3(
+    (node) => {
+      observerRef.current?.disconnect();
+      observerRef.current = null;
+      if (node == null || streaming) return;
+      const check = () => {
+        const lineHeight = Number.parseFloat(getComputedStyle(node).lineHeight) || 24;
+        setIsMultiLine(node.scrollHeight > lineHeight * 1.5);
+      };
+      check();
+      observerRef.current = new ResizeObserver(check);
+      observerRef.current.observe(node);
+    },
+    [streaming]
+  );
+  const reasoningTimeText = null;
+  const previewText = content.replace(/\s+/g, " ").trim();
+  const isShortText = !streaming && content.length > 0 && !isMultiLine;
+  const headingText = "Reasoning";
+  return /* @__PURE__ */ jsx4(
+    ReasoningCard,
+    {
+      content,
+      isStreaming: streaming,
+      expanded,
+      isMultiLine,
+      reasoningTimeText,
+      previewText,
+      headingText,
+      contentRef: isShortText ? contentRef : void 0,
+      onToggle: () => setExpanded((prev) => !prev)
+    }
+  );
+}
+
+// src/containers/ToolApprovalContainer.tsx
+import { useCallback as useCallback4, useMemo as useMemo3, useState as useState5 } from "react";
+import { jsx as jsx5 } from "react/jsx-runtime";
+function ToolApprovalContainer({ toolName = "", options, onSelectOption }) {
+  const ToolApprovalBar = useSlot("ToolApprovalBar");
+  const [selectedDenyOptionId, setSelectedDenyOptionId] = useState5(null);
+  const [denialReason, setDenialReason] = useState5("");
+  const [showReasonError, setShowReasonError] = useState5(false);
+  const approveOptions = useMemo3(
+    () => options.filter((option) => option.isAllow).map((option, index) => ({
+      ...option,
+      variant: index === 0 ? "primary" : "secondary",
+      requiresReason: false
+    })),
+    [options]
+  );
+  const denyOptions = useMemo3(
+    () => options.filter((option) => !option.isAllow).map((option) => ({
+      ...option,
+      variant: "secondary",
+      requiresReason: option.confirm != null
+    })),
+    [options]
+  );
+  const selectedDenyOption = denyOptions.find((option) => option.id === selectedDenyOptionId);
+  const onDenyOptionChange = useCallback4((optionId) => {
+    setSelectedDenyOptionId(optionId);
+    setDenialReason("");
+    setShowReasonError(false);
+  }, []);
+  const onDenialReasonChange = useCallback4((reason) => {
+    setDenialReason(reason);
+    setShowReasonError(false);
+  }, []);
+  const onReasonSubmit = useCallback4(() => {
+    const reason = denialReason.trim();
+    if (!reason) {
+      setShowReasonError(true);
+      return;
+    }
+    if (selectedDenyOptionId) {
+      onSelectOption(selectedDenyOptionId, reason);
+      onDenyOptionChange(null);
+    }
+  }, [denialReason, onDenyOptionChange, onSelectOption, selectedDenyOptionId]);
+  return /* @__PURE__ */ jsx5(
+    ToolApprovalBar,
+    {
+      toolName,
+      approveOptions: approveOptions.length > 0 ? approveOptions : void 0,
+      denyOptions: denyOptions.length > 0 ? denyOptions : void 0,
+      selectedDenyOption,
+      denialReason,
+      showReasonError,
+      onSelect: onSelectOption,
+      onDenyOptionChange,
+      onDenialReasonChange,
+      onReasonSubmit
+    }
+  );
+}
+
+// src/containers/ToolCallContentBlockContainer.tsx
+import { useCallback as useCallback5, useEffect as useEffect4, useRef as useRef5, useState as useState6 } from "react";
+import { jsx as jsx6 } from "react/jsx-runtime";
+function ToolCallContentBlockContainer(props) {
+  const ToolCallContentBlock = useSlot("ToolCallContentBlock");
+  const { isJson, onContentHeightChange: notifyContentHeightChange, resizable } = props;
+  const [fullscreen, setFullscreen] = useState6(false);
+  const [contentHeightRem, setContentHeightRem] = useState6();
+  const observerRef = useRef5(null);
+  const contentNodeRef = useRef5(null);
+  const hasMeasuredRef = useRef5(false);
+  const contentRef = useCallback5(
+    (node) => {
+      observerRef.current?.disconnect();
+      observerRef.current = null;
+      contentNodeRef.current = node;
+      hasMeasuredRef.current = false;
+      if (node == null) return;
+      setContentHeightRem(void 0);
+      if (!resizable) return;
+      const updateHeight = () => {
+        if (!hasMeasuredRef.current && isJson !== false) return;
+        const renderedHeight = node.getBoundingClientRect().height;
+        const height = hasMeasuredRef.current && renderedHeight > 0 ? renderedHeight : node.scrollHeight;
+        hasMeasuredRef.current = true;
+        setContentHeightRem(height / 16);
+      };
+      updateHeight();
+      observerRef.current = new ResizeObserver(updateHeight);
+      observerRef.current.observe(node);
+    },
+    [isJson, resizable]
+  );
+  const onContentHeightChange = useCallback5(
+    (height) => {
+      const node = contentNodeRef.current;
+      if (node == null) return;
+      const renderedHeight = node.getBoundingClientRect().height;
+      hasMeasuredRef.current = true;
+      setContentHeightRem((renderedHeight > 0 ? renderedHeight : Math.max(height, node.scrollHeight)) / 16);
+      notifyContentHeightChange?.(height);
+    },
+    [notifyContentHeightChange]
+  );
+  useEffect4(
+    () => () => {
+      observerRef.current?.disconnect();
+    },
+    []
+  );
+  return /* @__PURE__ */ jsx6(
+    ToolCallContentBlock,
+    {
+      ...props,
+      fullscreen,
+      onFullscreenChange: setFullscreen,
+      contentHeightRem,
+      contentRef,
+      onContentHeightChange
+    }
+  );
+}
+
+// src/containers/ToolCallContainer.tsx
+import {
+  MessagePartPrimitive,
+  MessagePrimitive,
+  useToolCallElapsed
+} from "@assistant-ui/react";
+import { useTrueFoundryRespondToToolApproval } from "@truefoundry/assistant-ui-runtime";
+import { useState as useState8 } from "react";
+
+// src/utils/toolCallParsing.ts
+import { parse as parsePartialJson } from "partial-json";
+var SUB_AGENT_TOOL_NAME = "create_sub_agent";
+var ASK_USER_TOOL_NAME = "ask_user_question";
+var SANDBOX_TOOL_NAMES = /* @__PURE__ */ new Set(["exec", "sandbox_exec"]);
+var MCP_META_TOOLS = /* @__PURE__ */ new Set(["call_tool", "list_tools", "get_tool_info"]);
+var APPROVAL_OPTION_DEFAULT_LABELS = {
+  "allow-once": "Allow",
+  "allow-always": "Always allow",
+  "reject-once": "Deny",
+  "reject-always": "Always deny"
+};
+var isAllowKind = (kind) => kind === "allow-once" || kind === "allow-always";
+function parseJsonIncrementally(content) {
+  try {
+    return { success: true, value: JSON.parse(content), isPartial: false };
+  } catch {
+    const trimmed = content.trim();
+    if (trimmed[0] !== "{" && trimmed[0] !== "[") return { success: false };
+    try {
+      return { success: true, value: parsePartialJson(content), isPartial: true };
+    } catch {
+      return { success: false };
+    }
+  }
+}
+function isUnknownRecord(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+function parseAskUserQuestionArgs(argsText) {
+  if (!argsText) return {};
+  try {
+    const parsed = JSON.parse(argsText);
+    if (parsed == null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return {};
+    }
+    const record = parsed;
+    const question = typeof record.question === "string" ? record.question : void 0;
+    const options = Array.isArray(record.options) ? record.options.filter((item) => typeof item === "string") : void 0;
+    return { question, options };
+  } catch {
+    return {};
+  }
+}
+function getAskUserAnswerResult(result) {
+  if (result === void 0 || result === null) return void 0;
+  if (typeof result === "string") {
+    const trimmed = result.trim();
+    return trimmed.length > 0 ? trimmed : void 0;
+  }
+  if (typeof result === "object" && "content" in result) {
+    const content = result.content;
+    if (typeof content === "string" && content.trim()) {
+      return content.trim();
+    }
+  }
+  return void 0;
+}
+function hasPendingAskUserResponse(part) {
+  return part.interrupt != null && part.result === void 0;
+}
+function hasPendingToolApproval(approval) {
+  return approval != null && approval.approved === void 0 && approval.resolution === void 0;
+}
+function buildApprovalOptions(options) {
+  const declared = options?.filter((o) => Object.hasOwn(APPROVAL_OPTION_DEFAULT_LABELS, o.kind));
+  if (declared && declared.length > 0) {
+    const allow = declared.filter((o) => isAllowKind(o.kind));
+    const reject = declared.filter((o) => !isAllowKind(o.kind));
+    const mapped = [...allow, ...reject].map((o) => ({
+      id: o.id,
+      label: o.label ?? APPROVAL_OPTION_DEFAULT_LABELS[o.kind] ?? o.id,
+      isAllow: isAllowKind(o.kind),
+      grants: o.grants,
+      confirm: o.confirm != null ? typeof o.confirm === "object" ? o.confirm : {} : void 0
+    }));
+    if (reject.length === 0) {
+      mapped.push({ id: "__deny", label: "Deny", isAllow: false, confirm: {} });
+    }
+    return mapped;
+  }
+  return [
+    { id: "__allow", label: "Allow", isAllow: true },
+    { id: "__deny", label: "Deny", isAllow: false, confirm: {} }
+  ];
+}
+function formatDuration(ms) {
+  if (ms < 1e3) return "<1s";
+  const seconds = ms / 1e3;
+  if (seconds < 10) return `${(Math.floor(seconds * 10) / 10).toFixed(1)}s`;
+  if (seconds < 60) return `${Math.floor(seconds)}s`;
+  return `${Math.floor(seconds / 60)}m ${Math.floor(seconds % 60)}s`;
+}
+function toStatus(statusType) {
+  if (statusType === "complete") return "success";
+  if (statusType === "incomplete") return "error";
+  return "running";
+}
+function parseSandboxArgs(argsText) {
+  if (!argsText) return {};
+  const parsed = parseJsonIncrementally(argsText);
+  if (!parsed.success || !isUnknownRecord(parsed.value)) return { argsJson: argsText };
+  return {
+    command: typeof parsed.value.command === "string" ? parsed.value.command : void 0,
+    intent: typeof parsed.value.intent === "string" ? parsed.value.intent : void 0,
+    argsJson: parsed.isPartial ? argsText : JSON.stringify(parsed.value, null, 2)
+  };
+}
+function parseSandboxResult(result) {
+  if (result === void 0) return {};
+  const parsed = parseJsonIncrementally(result);
+  if (!parsed.success || !isUnknownRecord(parsed.value)) return { resultText: result };
+  const response = isUnknownRecord(parsed.value.response) ? parsed.value.response : void 0;
+  const exitCode = typeof response?.exitCode === "number" ? response.exitCode : null;
+  const resultText = typeof response?.result === "string" ? response.result : void 0;
+  return {
+    exitCode,
+    resultText,
+    resultJson: parsed.isPartial ? result : JSON.stringify(parsed.value, null, 2)
+  };
+}
+function parseMcpToolArgs(argsText) {
+  if (!argsText) return {};
+  try {
+    const parsed = JSON.parse(argsText);
+    return {
+      mcpServer: parsed.mcp_server,
+      innerToolName: parsed.tool_name,
+      input: parsed.input
+    };
+  } catch {
+    return {};
+  }
+}
+function getJsonDisplayValue(content) {
+  if (!content?.trim()) return { value: "", isJson: false };
+  const trimmed = content.trim();
+  if (trimmed[0] !== "{" && trimmed[0] !== "[") {
+    return { value: content, isJson: false };
+  }
+  try {
+    const parsed = JSON.parse(content);
+    return { value: JSON.stringify(parsed, null, 2), isJson: true };
+  } catch {
+    return { value: content, isJson: false };
+  }
+}
+function getToolResultContent(content) {
+  try {
+    if (!content) return { isJson: false, data: "" };
+    const parsedResult = typeof content === "string" && content.trim().startsWith("{") ? JSON.parse(content) : content;
+    if (typeof parsedResult === "object" && parsedResult != null && Array.isArray(parsedResult.content)) {
+      const text = parsedResult.content[0]?.text || "";
+      const display2 = getJsonDisplayValue(typeof text === "string" ? text : JSON.stringify(text));
+      return { data: display2.value, isJson: display2.isJson };
+    }
+    const display = getJsonDisplayValue(typeof parsedResult === "string" ? parsedResult : JSON.stringify(parsedResult));
+    return { data: display.value, isJson: display.isJson };
+  } catch {
+    return { data: String(content), isJson: false };
+  }
+}
+function resolveSubAgentMeta(part) {
+  const artifactSubAgent = part.artifact?.subAgents?.[0];
+  const firstNested = part.messages?.[0];
+  const subAgent = firstNested?.metadata?.custom?.subAgent;
+  return {
+    agentName: subAgent?.title ?? subAgent?.name ?? artifactSubAgent?.title ?? artifactSubAgent?.agentInfo?.name ?? part.toolName,
+    instruction: subAgent?.input ?? artifactSubAgent?.agentInfo?.input ?? "",
+    stepCount: part.messages?.length ?? 0
+  };
+}
+function mcpDisplayName(toolName, mcpServer, innerToolName) {
+  if (toolName === "call_tool" && innerToolName) {
+    return mcpServer ? `call_tool: ${innerToolName} (${mcpServer})` : `call_tool: ${innerToolName}`;
+  }
+  if (toolName === "get_tool_info" && innerToolName && mcpServer) {
+    return `get_tool_info: ${innerToolName} (${mcpServer})`;
+  }
+  return toolName;
+}
+
+// src/containers/nestedApprovalBridge.ts
+import { createContext, useContext } from "react";
+var NestedApprovalBridgeContext = createContext(null);
+function useNestedApprovalBridge() {
+  return useContext(NestedApprovalBridgeContext);
+}
+
+// src/containers/SandboxToolCallContainer.tsx
+import { useMemo as useMemo4, useState as useState7 } from "react";
+import { jsx as jsx7 } from "react/jsx-runtime";
+function SandboxToolCallContainer(props) {
+  const SandboxToolCallCard = useSlot("SandboxToolCallCard");
+  const [viewMode, setViewMode] = useState7("terminal");
+  const hasContent = useMemo4(() => {
+    if (viewMode === "code") return Boolean(props.argsJson || props.resultJson);
+    return Boolean(props.command || props.resultText || props.resultJson);
+  }, [props.argsJson, props.command, props.resultJson, props.resultText, viewMode]);
+  return /* @__PURE__ */ jsx7(SandboxToolCallCard, { ...props, viewMode, hasContent, onViewModeChange: setViewMode });
+}
+
+// src/containers/ToolCallContainer.tsx
+import { jsx as jsx8 } from "react/jsx-runtime";
+function NestedSubAgentAssistantMessage() {
+  const AssistantMessageBubble = useSlot("AssistantMessageBubble");
+  return /* @__PURE__ */ jsx8("div", { className: "mb-3 min-w-0", children: /* @__PURE__ */ jsx8(MessagePrimitive.Root, { "data-role": "assistant", children: /* @__PURE__ */ jsx8(AssistantMessageBubble, { children: /* @__PURE__ */ jsx8(
+    MessagePrimitive.Parts,
+    {
+      components: {
+        Text: AssistantTextContainer,
+        Reasoning: AssistantTextContainer,
+        tools: { Fallback: ToolCallContainer }
+      }
+    }
+  ) }) }) });
+}
+function ToolApprovalSlot({ part }) {
+  const nestedBridge = useNestedApprovalBridge();
+  const respond = (response) => {
+    if (nestedBridge) {
+      nestedBridge(response);
+      return;
+    }
+    part.respondToApproval(response);
+  };
+  const onSelectOption = (optionId, reason) => {
+    if (optionId === "__allow") return respond({ approved: true });
+    if (optionId === "__deny") return respond({ approved: false, reason });
+    return respond({ optionId, reason });
+  };
+  return /* @__PURE__ */ jsx8(
+    ToolApprovalContainer,
+    {
+      toolName: part.toolName,
+      options: buildApprovalOptions(part.approval?.options),
+      onSelectOption
+    }
+  );
+}
+function RequestResponseSlots({
+  request,
+  response
+}) {
+  return {
+    requestSlot: request.value ? /* @__PURE__ */ jsx8(
+      ToolCallContentBlockContainer,
+      {
+        title: "Request",
+        content: request.value,
+        isJson: request.isJson,
+        maxHeight: "10.5rem"
+      }
+    ) : response.data ? /* @__PURE__ */ jsx8(ToolCallContentBlockContainer, { title: "Request", content: "{}", isJson: true, maxHeight: "10.5rem" }) : void 0,
+    responseSlot: response.data ? /* @__PURE__ */ jsx8(ToolCallContentBlockContainer, { title: "Response", content: response.data, isJson: response.isJson, resizable: true }) : void 0
+  };
+}
+var ToolCallContainer = (part) => {
+  const ToolCallCard = useSlot("ToolCallCard");
+  const SubAgentCard = useSlot("SubAgentCard");
+  const AskUserPrompt = useSlot("AskUserPrompt");
+  const respondToNestedApproval = useTrueFoundryRespondToToolApproval();
+  const elapsedMs = useToolCallElapsed();
+  const isRequiresAction = part.status?.type === "requires-action";
+  const isSubAgent = part.toolName === SUB_AGENT_TOOL_NAME;
+  const isSandbox = SANDBOX_TOOL_NAMES.has(part.toolName);
+  const [expanded, setExpanded] = useState8(isRequiresAction);
+  const [prevRequiresAction, setPrevRequiresAction] = useState8(isRequiresAction);
+  if (isRequiresAction !== prevRequiresAction) {
+    setPrevRequiresAction(isRequiresAction);
+    if (isRequiresAction) setExpanded(true);
+  }
+  const showApproval = isRequiresAction && hasPendingToolApproval(part.approval);
+  const durationText = elapsedMs === void 0 ? void 0 : formatDuration(elapsedMs);
+  const status = toStatus(part.status?.type);
+  const onToggle = () => setExpanded((prev) => !prev);
+  if (part.toolName === ASK_USER_TOOL_NAME) {
+    if (hasPendingAskUserResponse(part)) {
+      return null;
+    }
+    const answer = getAskUserAnswerResult(part.result);
+    if (answer == null) {
+      return null;
+    }
+    const { question, options = [] } = parseAskUserQuestionArgs(part.argsText);
+    const isCustom = options.length > 0 && !options.includes(answer);
+    return /* @__PURE__ */ jsx8(
+      AskUserPrompt,
+      {
+        questions: [],
+        answeredQuestions: [
+          {
+            id: part.toolCallId,
+            question: question ?? "Question",
+            options,
+            answer,
+            isCustom
+          }
+        ],
+        onSubmit: () => {
+        },
+        readOnly: true
+      }
+    );
+  }
+  if (isSubAgent) {
+    const { agentName, instruction, stepCount } = resolveSubAgentMeta(part);
+    const bridge = (response) => {
+      if (part.approval == null) return;
+      const approved = "approved" in response ? response.approved : void 0;
+      if (approved === void 0) return;
+      respondToNestedApproval({ approvalId: part.approval.id, approved });
+    };
+    return /* @__PURE__ */ jsx8("div", { "data-slot": "tool-call-card", "data-variant": "sub-agent", className: "w-full", children: /* @__PURE__ */ jsx8(
+      SubAgentCard,
+      {
+        status,
+        expanded,
+        onToggle,
+        durationText,
+        agentName,
+        instruction,
+        stepCount,
+        children: /* @__PURE__ */ jsx8(NestedApprovalBridgeContext.Provider, { value: bridge, children: /* @__PURE__ */ jsx8(
+          MessagePartPrimitive.Messages,
+          {
+            components: {
+              AssistantMessage: NestedSubAgentAssistantMessage,
+              UserMessage: () => null
+            }
+          }
+        ) })
+      }
+    ) });
+  }
+  const resultString = part.result === void 0 ? void 0 : typeof part.result === "string" ? part.result : JSON.stringify(part.result, null, 2);
+  if (isSandbox) {
+    const { command, intent, argsJson } = parseSandboxArgs(part.argsText);
+    const { exitCode, resultText, resultJson } = parseSandboxResult(resultString);
+    return /* @__PURE__ */ jsx8(
+      SandboxToolCallContainer,
+      {
+        name: part.toolName,
+        intent,
+        status,
+        expanded,
+        onToggle,
+        durationText,
+        command,
+        exitCode,
+        argsJson,
+        resultText,
+        resultJson
+      }
+    );
+  }
+  if (MCP_META_TOOLS.has(part.toolName)) {
+    const { mcpServer, innerToolName, input } = parseMcpToolArgs(part.argsText);
+    const argsDisplay2 = getJsonDisplayValue(part.argsText);
+    const resultDisplay2 = getToolResultContent(part.result);
+    if (part.toolName === "list_tools" && mcpServer) {
+      const slots3 = RequestResponseSlots({
+        request: argsDisplay2,
+        response: resultDisplay2
+      });
+      return /* @__PURE__ */ jsx8(
+        ToolCallCard,
+        {
+          toolName: `Listing tools \xB7 ${mcpServer}`,
+          icon: "mcp-server",
+          expanded,
+          onToggle,
+          awaiting: status === "running",
+          awaitingText: durationText ?? "Awaiting Response\u2026",
+          showResponseLine: status !== "running" && !!resultDisplay2.data,
+          mcpServerName: mcpServer,
+          ...slots3
+        }
+      );
+    }
+    const inputDisplay = input !== void 0 ? getJsonDisplayValue(JSON.stringify(input, null, 2)) : argsDisplay2;
+    const slots2 = RequestResponseSlots({
+      request: inputDisplay,
+      response: resultDisplay2
+    });
+    return /* @__PURE__ */ jsx8(
+      ToolCallCard,
+      {
+        toolName: mcpDisplayName(part.toolName, mcpServer, innerToolName),
+        icon: "mcp-server",
+        expanded,
+        onToggle,
+        awaiting: status === "running",
+        awaitingText: durationText ?? "Awaiting Response\u2026",
+        showResponseLine: status !== "running" && resultDisplay2.data !== void 0,
+        mcpServerName: mcpServer,
+        ...slots2,
+        approvalSlot: showApproval ? /* @__PURE__ */ jsx8(ToolApprovalSlot, { part }) : void 0
+      }
+    );
+  }
+  const argsDisplay = getJsonDisplayValue(part.argsText);
+  const resultDisplay = getToolResultContent(part.result);
+  const slots = RequestResponseSlots({
+    request: argsDisplay,
+    response: resultDisplay
+  });
+  return /* @__PURE__ */ jsx8(
+    ToolCallCard,
+    {
+      toolName: part.toolName,
+      expanded,
+      onToggle,
+      awaiting: status === "running",
+      awaitingText: durationText ?? "Awaiting Response\u2026",
+      showResponseLine: status !== "running" && resultDisplay.data !== void 0,
+      ...slots,
+      approvalSlot: showApproval ? /* @__PURE__ */ jsx8(ToolApprovalSlot, { part }) : void 0
+    }
+  );
+};
+
+// src/containers/AssistantMessageContainer.tsx
+import { useActionBarCopy, useMessageError, useThreadIsRunning as useThreadIsRunning2 } from "@assistant-ui/core/react";
+import { MessagePrimitive as MessagePrimitive2, useAuiState as useAuiState5 } from "@assistant-ui/react";
+import { useTrueFoundryResumeUnavailable } from "@truefoundry/assistant-ui-runtime";
+
+// src/containers/MessageImageContainer.tsx
+import { useAuiState as useAuiState4 } from "@assistant-ui/react";
+import { jsx as jsx9 } from "react/jsx-runtime";
+function MessageImageContainer() {
+  const AttachmentCard = useSlot("AttachmentCard");
+  const AttachmentPreviewDialog = useSlot("AttachmentPreviewDialog");
+  const image = useAuiState4((s) => s.part.type === "image" ? s.part.image : "");
+  const filename = useAuiState4((s) => s.part.type === "image" ? s.part.filename : void 0);
+  if (!image) {
+    return null;
+  }
+  const card = /* @__PURE__ */ jsx9(
+    AttachmentCard,
+    {
+      name: filename ?? "image",
+      previewSrc: image,
+      isImage: true,
+      size: "preview",
+      previewRem: USER_MESSAGE_ATTACHMENT_PREVIEW_REM
+    }
+  );
+  return /* @__PURE__ */ jsx9(AttachmentPreviewDialog, { previewSrc: image, children: /* @__PURE__ */ jsx9("div", { className: "aui-message-image", children: card }) });
+}
+
+// src/containers/AssistantMessageContainer.tsx
+import { jsx as jsx10 } from "react/jsx-runtime";
+function AssistantLeafPartContainer({ part }) {
+  switch (part.type) {
+    case "text":
+    case "reasoning":
+      return /* @__PURE__ */ jsx10(AssistantTextContainer, {});
+    case "image":
+      return /* @__PURE__ */ jsx10(MessageImageContainer, {});
+    case "tool-call":
+      return /* @__PURE__ */ jsx10(ToolCallContainer, { ...part });
+    default:
+      return null;
+  }
+}
+function AssistantMessageContainer() {
+  const AssistantMessageBubble = useSlot("AssistantMessageBubble");
+  const MessageActionBar = useSlot("MessageActionBar");
+  const MessageErrorBanner = useSlot("MessageErrorBanner");
+  const MessageIndicator = useSlot("MessageIndicator");
+  const isThreadRunning = useThreadIsRunning2();
+  const resumeUnavailable = useTrueFoundryResumeUnavailable();
+  const error = useMessageError();
+  const createdAt = useAuiState5((s) => s.message.createdAt);
+  const isMessageRunning = useAuiState5((s) => s.message.status?.type === "running");
+  const { copy, isCopied } = useActionBarCopy({
+    copyToClipboard: (text) => navigator.clipboard.writeText(text)
+  });
+  const parts = useAuiState5((s) => s.message.parts);
+  const { cutIndex, hasFinal, toolCount, thinkingCount } = computeAgentStepsSplit(parts, isMessageRunning);
+  const groupBy = (part, _context) => {
+    const index = parts.findIndex((p) => p === part);
+    if (index === -1) return null;
+    if (part.type === "text" && index >= cutIndex) {
+      return null;
+    }
+    if (index < cutIndex) {
+      if (part.type === "reasoning") {
+        return ["group-agentSteps", "group-reasoning"];
+      }
+      return ["group-agentSteps"];
+    }
+    return null;
+  };
+  return /* @__PURE__ */ jsx10(MessagePrimitive2.Root, { "data-role": "assistant", children: /* @__PURE__ */ jsx10(
+    AssistantMessageBubble,
+    {
+      error: error !== void 0 ? /* @__PURE__ */ jsx10(MessageErrorBanner, { message: String(error) }) : void 0,
+      actionBar: !isThreadRunning ? /* @__PURE__ */ jsx10(MessageActionBar, { isCopied, onCopy: copy, createdAt }) : void 0,
+      children: /* @__PURE__ */ jsx10(MessagePrimitive2.GroupedParts, { groupBy, children: ({ part, children }) => {
+        switch (part.type) {
+          case "group-agentSteps":
+            return /* @__PURE__ */ jsx10(AgentStepsContainer, { toolCount, thinkingCount, hasFinal, children });
+          case "group-reasoning":
+            return /* @__PURE__ */ jsx10(ReasoningContainer, { group: part });
+          case "text": {
+            const index = parts.findIndex((p) => p === part);
+            if (index >= 0 && index < cutIndex) {
+              return /* @__PURE__ */ jsx10("div", { className: "mb-2 ml-[1.75rem] text-xs text-text-secondary [&_.markdown-body]:text-inherit", children: /* @__PURE__ */ jsx10(AssistantTextContainer, {}) });
+            }
+            return /* @__PURE__ */ jsx10(AssistantTextContainer, {});
+          }
+          case "reasoning":
+          case "tool-call":
+          case "image":
+          case "data":
+            return /* @__PURE__ */ jsx10(AssistantLeafPartContainer, { part });
+          case "indicator":
+            return resumeUnavailable ? null : /* @__PURE__ */ jsx10(MessageIndicator, {});
+          default:
+            return null;
+        }
+      } })
+    }
+  ) });
+}
+
+// src/containers/AttachmentsContainer.tsx
+import { ComposerPrimitive, MessagePrimitive as MessagePrimitive3, useAui as useAui2, useAuiState as useAuiState7 } from "@assistant-ui/react";
+
+// src/containers/useAttachmentPreviewSrc.ts
+import { useAuiState as useAuiState6 } from "@assistant-ui/react";
+import { useEffect as useEffect5, useState as useState9 } from "react";
+function isImageAttachment(type, contentType) {
+  return type === "image" || (contentType?.startsWith("image/") ?? false);
+}
+function useFileObjectUrl(file) {
+  const [src, setSrc] = useState9(void 0);
+  useEffect5(() => {
+    if (!file) {
+      setSrc(void 0);
+      return;
+    }
+    const objectUrl = URL.createObjectURL(file);
+    setSrc(objectUrl);
+    return () => URL.revokeObjectURL(objectUrl);
+  }, [file]);
+  return src;
+}
+function useAttachmentPreviewSrc() {
+  const type = useAuiState6((s) => s.attachment.type);
+  const contentType = useAuiState6((s) => s.attachment.contentType);
+  const file = useAuiState6((s) => "file" in s.attachment ? s.attachment.file : void 0);
+  const contentSrc = useAuiState6((s) => {
+    if (!isImageAttachment(s.attachment.type, s.attachment.contentType)) return void 0;
+    const imagePart = s.attachment.content?.find((part) => part.type === "image");
+    if (imagePart?.type === "image" && imagePart.image) return imagePart.image;
+    return void 0;
+  });
+  const image = isImageAttachment(type, contentType);
+  const fileSrc = useFileObjectUrl(image ? file : void 0);
+  if (!image) return void 0;
+  return fileSrc ?? contentSrc;
+}
+
+// src/containers/AttachmentsContainer.tsx
+import { jsx as jsx11 } from "react/jsx-runtime";
+function ComposerAttachmentItem() {
+  const AttachmentPreviewDialog = useSlot("AttachmentPreviewDialog");
+  const AttachmentCard = useSlot("AttachmentCard");
+  const aui = useAui2();
+  const name = useAuiState7((s) => s.attachment.name);
+  const contentType = useAuiState7((s) => s.attachment.contentType);
+  const type = useAuiState7((s) => s.attachment.type);
+  const isImage = isImageAttachment(type, contentType);
+  const previewSrc = useAttachmentPreviewSrc();
+  return /* @__PURE__ */ jsx11(AttachmentPreviewDialog, { previewSrc, children: /* @__PURE__ */ jsx11(
+    AttachmentCard,
+    {
+      name,
+      contentType,
+      previewSrc,
+      isImage,
+      size: "chip",
+      onRemove: () => void aui.attachment().remove()
+    }
+  ) });
+}
+function MessageAttachmentItem() {
+  const AttachmentPreviewDialog = useSlot("AttachmentPreviewDialog");
+  const AttachmentCard = useSlot("AttachmentCard");
+  const name = useAuiState7((s) => s.attachment.name);
+  const contentType = useAuiState7((s) => s.attachment.contentType);
+  const type = useAuiState7((s) => s.attachment.type);
+  const isImage = isImageAttachment(type, contentType);
+  const previewSrc = useAttachmentPreviewSrc();
+  const card = /* @__PURE__ */ jsx11(
+    AttachmentCard,
+    {
+      name,
+      contentType,
+      previewSrc,
+      isImage,
+      size: isImage ? "preview" : "chip",
+      previewRem: USER_MESSAGE_ATTACHMENT_PREVIEW_REM
+    }
+  );
+  if (isImage && previewSrc) {
+    return /* @__PURE__ */ jsx11(AttachmentPreviewDialog, { previewSrc, children: card });
+  }
+  return card;
+}
+function ComposerAttachmentsContainer() {
+  return /* @__PURE__ */ jsx11("div", { className: "aui-composer-attachments flex w-full flex-row flex-wrap items-center gap-2 empty:hidden", children: /* @__PURE__ */ jsx11(ComposerPrimitive.Attachments, { children: () => /* @__PURE__ */ jsx11(ComposerAttachmentItem, {}) }) });
+}
+function MessageAttachmentsContainer() {
+  return /* @__PURE__ */ jsx11("div", { className: "aui-user-message-attachments-end col-span-full col-start-1 row-start-1 flex w-full flex-row justify-end gap-2", children: /* @__PURE__ */ jsx11(MessagePrimitive3.Attachments, { children: () => /* @__PURE__ */ jsx11(MessageAttachmentItem, {}) }) });
+}
+function ComposerAttachmentPickerContainer() {
+  const AttachmentPickerButton = useSlot("AttachmentPickerButton");
+  return /* @__PURE__ */ jsx11(ComposerPrimitive.AddAttachment, { asChild: true, children: /* @__PURE__ */ jsx11(AttachmentPickerButton, {}) });
+}
+
+// src/hooks/useComposerBusyState.ts
+import { useThreadIsRunning as useThreadIsRunning3 } from "@assistant-ui/core/react";
+import { createContext as createContext2, createElement, useCallback as useCallback6, useContext as useContext2, useEffect as useEffect6, useState as useState10 } from "react";
+var ComposerBusyContext = createContext2(null);
+var busyFailureListeners = /* @__PURE__ */ new Set();
+function notifyComposerBusyFailure() {
+  for (const listener of busyFailureListeners) {
+    listener();
+  }
+}
+function useComposerBusyStateValue() {
+  const isRunning = useThreadIsRunning3();
+  const [isSubmitting, setIsSubmitting] = useState10(false);
+  useEffect6(() => {
+    if (!isRunning) {
+      setIsSubmitting(false);
+    }
+  }, [isRunning]);
+  useEffect6(() => {
+    const clearSubmitting = () => {
+      setIsSubmitting(false);
+    };
+    busyFailureListeners.add(clearSubmitting);
+    return () => {
+      busyFailureListeners.delete(clearSubmitting);
+    };
+  }, []);
+  const isBusy = isRunning || isSubmitting;
+  const resetBusy = useCallback6(() => {
+    setIsSubmitting(false);
+  }, []);
+  const send = useCallback6((sendFn) => {
+    setIsSubmitting(true);
+    try {
+      const result = sendFn();
+      if (result != null && typeof result.then === "function") {
+        void result.catch(() => {
+          setIsSubmitting(false);
+        });
+      }
+    } catch {
+      setIsSubmitting(false);
+    }
+  }, []);
+  return { isBusy, isRunning, isSubmitting, send, resetBusy };
+}
+function ComposerBusyProvider({ children }) {
+  const value = useComposerBusyStateValue();
+  return createElement(ComposerBusyContext.Provider, { value }, children);
+}
+function useComposerBusyState() {
+  const value = useContext2(ComposerBusyContext);
+  if (value == null) {
+    throw new Error("useComposerBusyState must be used within ComposerBusyProvider");
+  }
+  return value;
+}
+
+// src/hooks/useComposerPauseView.ts
+import { useAuiState as useAuiState8 } from "@assistant-ui/react";
+import { useTrueFoundryToolResponses as useTrueFoundryToolResponses2 } from "@truefoundry/assistant-ui-runtime";
+function threadHasPendingMcpAuth(s) {
+  const messages = s.thread.messages;
+  const last = messages[messages.length - 1];
+  if (last?.role !== "assistant") return false;
+  if (last.status?.type !== "requires-action") return false;
+  return last.metadata?.custom?.pendingMcpAuth === true;
+}
+function useComposerPauseView() {
+  const mcpPending = useAuiState8(threadHasPendingMcpAuth);
+  const { pending: toolResponsesPending } = useTrueFoundryToolResponses2();
+  if (mcpPending) {
+    return { kind: "mcp" };
+  }
+  if (toolResponsesPending.length > 0) {
+    return { kind: "ask-user" };
+  }
+  return { kind: "compose" };
+}
+
+// src/containers/McpAuthContainer.tsx
+import { useThreadIsRunning as useThreadIsRunning4 } from "@assistant-ui/core/react";
+import { useTrueFoundryMcpAuth } from "@truefoundry/assistant-ui-runtime";
+import { jsx as jsx12 } from "react/jsx-runtime";
+function McpAuthContainer() {
+  const McpAuthPrompt = useSlot("McpAuthPrompt");
+  const { pending, resume } = useTrueFoundryMcpAuth();
+  const isRunning = useThreadIsRunning4();
+  if (!pending) return null;
+  const handleConnect = (serverId) => {
+    const server = pending.mcpServers.find((s) => s.id === serverId);
+    if (server?.authUrl) {
+      window.open(server.authUrl, "_blank", "noopener,noreferrer");
+    }
+  };
+  return /* @__PURE__ */ jsx12(
+    McpAuthPrompt,
+    {
+      servers: pending.mcpServers,
+      onConnect: handleConnect,
+      onContinue: () => void resume(),
+      readOnly: isRunning
+    }
+  );
+}
+
+// src/containers/ComposerContainer.tsx
+import { ComposerPrimitive as ComposerPrimitive2, useAui as useAui3, useAuiState as useAuiState9 } from "@assistant-ui/react";
+import { useTrueFoundryAgentSpec, useTrueFoundryCancel } from "@truefoundry/assistant-ui-runtime";
+import { useRef as useRef6 } from "react";
+import { Fragment, jsx as jsx13, jsxs } from "react/jsx-runtime";
+function ComposerBody({ placeholder }) {
+  const ComposerShell = useSlot("ComposerShell");
+  const aui = useAui3();
+  const shell = useOptionalShellMode();
+  const hasText = useAuiState9((s) => s.composer.text.trim().length > 0);
+  const { agentSpec } = useTrueFoundryAgentSpec();
+  const requiresModel = shell == null || shell.mode.status === "active" && shell.mode.isMutable;
+  const hasModel = Boolean(agentSpec?.model?.name?.trim());
+  const { isBusy, send, resetBusy } = useComposerBusyState();
+  const cancel = useTrueFoundryCancel();
+  const fileInputRef = useRef6(null);
+  const canSubmit = !isBusy && hasText && (!requiresModel || hasModel);
+  const submit = () => {
+    if (!canSubmit) return;
+    send(() => aui.composer().send());
+  };
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx13(
+      "input",
+      {
+        ref: fileInputRef,
+        type: "file",
+        multiple: true,
+        hidden: true,
+        onChange: (event) => {
+          const files = event.target.files;
+          if (files) {
+            for (const file of files) {
+              void aui.composer().addAttachment(file);
+            }
+          }
+          event.target.value = "";
+        }
+      }
+    ),
+    /* @__PURE__ */ jsx13(
+      ComposerPrimitive2.AttachmentDropzone,
+      {
+        disabled: isBusy,
+        "data-slot": "aui_composer-attachment-dropzone",
+        className: "w-full rounded-[var(--composer-radius,1.5rem)] transition-[box-shadow] data-[dragging=true]:ring-focus-ring/20 data-[dragging=true]:ring-3",
+        children: /* @__PURE__ */ jsx13(
+          ComposerPrimitive2.Root,
+          {
+            "data-slot": "aui_composer-root",
+            className: "w-full",
+            onSubmit: (event) => {
+              event.preventDefault();
+              submit();
+            },
+            children: /* @__PURE__ */ jsx13(
+              ComposerShell,
+              {
+                attachments: /* @__PURE__ */ jsx13(ComposerAttachmentsContainer, {}),
+                input: /* @__PURE__ */ jsx13(
+                  ComposerPrimitive2.Input,
+                  {
+                    "data-slot": "aui_composer-input",
+                    placeholder,
+                    disabled: isBusy,
+                    submitMode: "enter",
+                    "aria-label": "Message input",
+                    className: "text-text-primary placeholder:text-text-secondary/80 max-h-[10lh] min-h-10 w-full resize-none overflow-y-auto rounded-lg border-none bg-transparent px-1 py-1 text-base leading-normal shadow-none outline-none disabled:cursor-not-allowed"
+                  }
+                ),
+                disabled: isBusy,
+                canSubmit,
+                isRunning: isBusy,
+                onSubmit: submit,
+                onCancel: () => {
+                  resetBusy();
+                  void cancel();
+                },
+                onAttach: () => fileInputRef.current?.click()
+              }
+            )
+          }
+        )
+      }
+    )
+  ] });
+}
+function ComposerContainer({
+  placeholder = "Ask anything... (Shift+Enter for new line)"
+}) {
+  const pauseView = useComposerPauseView();
+  const shell = useOptionalShellMode();
+  const parentLeftSection = useSlot("ComposerLeftSection");
+  const parentRightSection = useSlot("ComposerRightSection");
+  const usesDefaultLeftSection = useSlotIsDefault("ComposerLeftSection");
+  const usesDefaultRightSection = useSlotIsDefault("ComposerRightSection");
+  const DraftComposerLeftSection = useSlot("DraftComposerLeftSection");
+  const DraftComposerRightSection = useSlot("DraftComposerRightSection");
+  const canMutateSpec = shell?.mode.status === "active" && shell.mode.isMutable;
+  if (pauseView.kind === "mcp") {
+    return /* @__PURE__ */ jsx13(McpAuthContainer, {});
+  }
+  if (pauseView.kind === "ask-user") {
+    return /* @__PURE__ */ jsx13(AskUserContainer, {});
+  }
+  if (canMutateSpec) {
+    return /* @__PURE__ */ jsx13(DraftCatalogProvider, { children: /* @__PURE__ */ jsx13(
+      SlotsProvider,
+      {
+        overrides: {
+          ComposerLeftSection: usesDefaultLeftSection ? DraftComposerLeftSection : parentLeftSection,
+          ComposerRightSection: usesDefaultRightSection ? DraftComposerRightSection : parentRightSection
+        },
+        children: /* @__PURE__ */ jsx13(ComposerBody, { placeholder })
+      }
+    ) });
+  }
+  return /* @__PURE__ */ jsx13(ComposerBody, { placeholder });
+}
+
+// src/containers/HistoryLoaderContainer.tsx
+import { useTrueFoundryHistoryPagination } from "@truefoundry/assistant-ui-runtime";
+import { useCallback as useCallback7, useEffect as useEffect7, useRef as useRef7, useState as useState11 } from "react";
+import { jsx as jsx14 } from "react/jsx-runtime";
+var TOP_THRESHOLD_PX = 200;
+var VIEWPORT_SELECTOR = '[data-slot="aui_thread-viewport"]';
+function HistoryLoaderContainer() {
+  const HistoryLoader = useSlot("HistoryLoader");
+  const { hasOlderHistory, isLoadingOlderHistory, loadOlderHistory } = useTrueFoundryHistoryPagination();
+  const [sentinel, setSentinel] = useState11(null);
+  const inflightRef = useRef7(false);
+  const maybeLoadOlder = useCallback7(async () => {
+    if (inflightRef.current) return;
+    inflightRef.current = true;
+    const viewport = sentinel?.closest(VIEWPORT_SELECTOR) ?? null;
+    const prevScrollHeight = viewport?.scrollHeight ?? 0;
+    const prevScrollTop = viewport?.scrollTop ?? 0;
+    try {
+      await loadOlderHistory();
+      requestAnimationFrame(() => {
+        if (viewport == null) return;
+        const delta = viewport.scrollHeight - prevScrollHeight;
+        if (delta > 0) {
+          viewport.scrollTo({ top: prevScrollTop + delta, behavior: "instant" });
+        }
+      });
+    } catch {
+    } finally {
+      inflightRef.current = false;
+    }
+  }, [sentinel, loadOlderHistory]);
+  useEffect7(() => {
+    if (sentinel == null || !hasOlderHistory) return;
+    const viewport = sentinel.closest(VIEWPORT_SELECTOR);
+    const observer = new IntersectionObserver(
+      (entries) => {
+        if (entries.some((entry) => entry.isIntersecting)) {
+          void maybeLoadOlder();
+        }
+      },
+      { root: viewport, rootMargin: `${TOP_THRESHOLD_PX}px 0px 0px 0px` }
+    );
+    observer.observe(sentinel);
+    return () => observer.disconnect();
+  }, [sentinel, hasOlderHistory, maybeLoadOlder]);
+  if (!hasOlderHistory) return null;
+  return /* @__PURE__ */ jsx14(HistoryLoader, { ref: setSentinel, isLoading: isLoadingOlderHistory });
+}
+
+// src/containers/ResumeUnavailableContainer.tsx
+import { useTrueFoundryResumeUnavailable as useTrueFoundryResumeUnavailable2 } from "@truefoundry/assistant-ui-runtime";
+import { jsx as jsx15 } from "react/jsx-runtime";
+function ResumeUnavailableContainer() {
+  const ResumeUnavailable = useSlot("ResumeUnavailable");
+  const resumeUnavailable = useTrueFoundryResumeUnavailable2();
+  if (!resumeUnavailable) return null;
+  return /* @__PURE__ */ jsx15(ResumeUnavailable, {});
+}
+
+// src/containers/UserEditComposerContainer.tsx
+import { useComposerCancel, useComposerSend, useThreadIsRunning as useThreadIsRunning5 } from "@assistant-ui/core/react";
+import { ComposerPrimitive as ComposerPrimitive3, MessagePrimitive as MessagePrimitive4, useAuiState as useAuiState10 } from "@assistant-ui/react";
+import { jsx as jsx16, jsxs as jsxs2 } from "react/jsx-runtime";
+function ReadOnlyMessageAttachments() {
+  const hasAttachments = useAuiState10((s) => (s.message.attachments?.length ?? 0) > 0);
+  if (!hasAttachments) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx16("div", { className: "pointer-events-none mb-2 opacity-90", children: /* @__PURE__ */ jsx16(MessageAttachmentsContainer, {}) });
+}
+function UserEditComposerContainer() {
+  const UserMessageEdit = useSlot("UserMessageEdit");
+  const MessageTimestamp = useSlot("MessageTimestamp");
+  const isRunning = useThreadIsRunning5();
+  const createdAt = useAuiState10((s) => s.message.createdAt);
+  const { cancel, disabled: cancelDisabled } = useComposerCancel();
+  const { disabled: sendDisabled } = useComposerSend();
+  return /* @__PURE__ */ jsx16(MessagePrimitive4.Root, { "data-role": "user", children: /* @__PURE__ */ jsx16(
+    ComposerPrimitive3.Root,
+    {
+      "data-slot": "aui_user-edit-composer-root",
+      className: "fade-in slide-in-from-bottom-1 animate-in flex w-full justify-end px-2 duration-150",
+      children: /* @__PURE__ */ jsx16(
+        UserMessageEdit,
+        {
+          timestamp: /* @__PURE__ */ jsx16(MessageTimestamp, { createdAt }),
+          attachments: /* @__PURE__ */ jsx16(ReadOnlyMessageAttachments, {}),
+          input: /* @__PURE__ */ jsx16("div", { className: "mt-1 rounded border border-border bg-secondary-bg p-2 text-text-primary", children: /* @__PURE__ */ jsx16(
+            ComposerPrimitive3.Input,
+            {
+              "data-slot": "aui_user-edit-input",
+              disabled: isRunning,
+              submitMode: "enter",
+              "aria-label": "Edit message",
+              className: "max-h-32 min-h-10 w-full resize-none border-none bg-transparent p-0 text-base leading-[1.34] outline-none focus:shadow-none"
+            }
+          ) }),
+          footer: /* @__PURE__ */ jsxs2("div", { className: "flex items-center justify-end gap-2", children: [
+            /* @__PURE__ */ jsx16(Button, { variant: "secondary", type: "button", disabled: cancelDisabled, onClick: cancel, children: "Cancel" }),
+            /* @__PURE__ */ jsx16(ComposerPrimitive3.Send, { asChild: true, children: /* @__PURE__ */ jsx16(Button, { type: "submit", disabled: sendDisabled || isRunning, children: "Save & Rerun" }) })
+          ] })
+        }
+      )
+    }
+  ) });
+}
+
+// src/containers/UserMessageContainer.tsx
+import { useActionBarCopy as useActionBarCopy2, useActionBarEdit, useThreadIsRunning as useThreadIsRunning6 } from "@assistant-ui/core/react";
+import { MessagePrimitive as MessagePrimitive5, useAui as useAui4, useAuiState as useAuiState11 } from "@assistant-ui/react";
+import { jsx as jsx17 } from "react/jsx-runtime";
+function UserMessageContainer() {
+  const UserMessageBubble = useSlot("UserMessageBubble");
+  const UserMessageActionBar = useSlot("UserMessageActionBar");
+  const isRunning = useThreadIsRunning6();
+  const aui = useAui4();
+  const createdAt = useAuiState11((s) => s.message.createdAt);
+  const text = useAuiState11(
+    (s) => s.message.content.filter((part) => part.type === "text").map((part) => part.text).join("\n")
+  );
+  const { edit, disabled: editDisabled } = useActionBarEdit();
+  const { copy, isCopied } = useActionBarCopy2({
+    copyToClipboard: (value) => navigator.clipboard.writeText(value)
+  });
+  return /* @__PURE__ */ jsx17(MessagePrimitive5.Root, { "data-role": "user", children: /* @__PURE__ */ jsx17(
+    UserMessageBubble,
+    {
+      text,
+      attachments: /* @__PURE__ */ jsx17(MessageAttachmentsContainer, {}),
+      editAction: !isRunning ? /* @__PURE__ */ jsx17(
+        UserMessageActionBar,
+        {
+          isCopied,
+          editDisabled,
+          createdAt,
+          onCopy: copy,
+          onEdit: edit,
+          onRetry: () => {
+            aui.message().composer().beginEdit();
+            aui.message().composer().send({ startRun: true });
+          }
+        }
+      ) : void 0
+    }
+  ) });
+}
+
+// src/containers/ThreadContainer.tsx
+import { ThreadPrimitive, useAuiState as useAuiState12 } from "@assistant-ui/react";
+import { useEffect as useEffect9 } from "react";
+
+// src/hooks/useSyncSessionTitle.ts
+import { useThreadIsRunning as useThreadIsRunning7 } from "@assistant-ui/core/react";
+import { useEffect as useEffect8, useRef as useRef8 } from "react";
+function useSyncSessionTitle() {
+  const server = useOptionalServer();
+  const aui = useAui();
+  const remoteId = useAuiState((s) => s.threadListItem.remoteId);
+  const title = useAuiState((s) => s.threadListItem.title);
+  const isRunning = useThreadIsRunning7();
+  const wasRunningRef = useRef8(false);
+  const syncedRemoteIdRef = useRef8(void 0);
+  useEffect8(() => {
+    syncedRemoteIdRef.current = void 0;
+  }, [remoteId]);
+  useEffect8(() => {
+    const finishedTurn = wasRunningRef.current && !isRunning;
+    wasRunningRef.current = isRunning;
+    if (!finishedTurn || server == null || remoteId == null) {
+      return;
+    }
+    if (syncedRemoteIdRef.current === remoteId) {
+      return;
+    }
+    if (title != null && title.trim() !== "") {
+      syncedRemoteIdRef.current = remoteId;
+      return;
+    }
+    let cancelled = false;
+    void server.getSession({ sessionId: remoteId }).then((session) => {
+      if (cancelled) return;
+      const nextTitle = typeof session.title === "string" ? session.title.trim() : "";
+      if (nextTitle.length === 0) return;
+      syncedRemoteIdRef.current = remoteId;
+      return aui.threadListItem().rename(nextTitle);
+    }).catch(() => void 0);
+    return () => {
+      cancelled = true;
+    };
+  }, [aui, isRunning, remoteId, server, title]);
+}
+
+// src/utils/isNewChatView.ts
+var isNewChatView = (s) => s.thread.messages.length === 0 && (!s.thread.isLoading || s.threads.isLoading) && s.threadListItem.remoteId == null;
+
+// src/containers/ThreadContainer.tsx
+import { Fragment as Fragment2, jsx as jsx18, jsxs as jsxs3 } from "react/jsx-runtime";
+function AnimatedMessageShell({ children }) {
+  return /* @__PURE__ */ jsx18("div", { className: "animate-in fade-in slide-in-from-bottom-1 fill-mode-both duration-200", children });
+}
+function ThreadMessage({ isEditing }) {
+  const role = useAuiState12((s) => s.message.role);
+  if (role === "user") {
+    if (isEditing) {
+      return /* @__PURE__ */ jsx18(UserEditComposerContainer, {});
+    }
+    return /* @__PURE__ */ jsx18(UserMessageContainer, {});
+  }
+  return /* @__PURE__ */ jsx18(AssistantMessageContainer, {});
+}
+function ThreadContainer({ composer }) {
+  useEffect9(() => {
+    void preloadMarkdownOpenUI();
+  }, []);
+  useSyncSessionTitle();
+  const shell = useOptionalShellMode();
+  const WelcomeScreen = useSlot("WelcomeScreen");
+  const MessageListSkeleton = useSlot("MessageListSkeleton");
+  const ScrollToBottomButton = useSlot("ScrollToBottomButton");
+  const MessageGroup = useSlot("MessageGroup");
+  const ThreadComposerAreaShell = useSlot("ThreadComposerAreaShell");
+  const ThreadRootShell = useSlot("ThreadRootShell");
+  const ThreadViewportShell = useSlot("ThreadViewportShell");
+  const isEmpty = useAuiState12(isNewChatView);
+  const isLoading = useAuiState12((s) => s.thread.isLoading);
+  const welcomeHeading = shell?.mode.status === "active" ? shell.mode.agentName : void 0;
+  return /* @__PURE__ */ jsx18(ComposerBusyProvider, { children: /* @__PURE__ */ jsx18(ThreadPrimitive.Root, { asChild: true, children: /* @__PURE__ */ jsxs3(ThreadRootShell, { children: [
+    /* @__PURE__ */ jsx18(ThreadPrimitive.Viewport, { asChild: true, autoScroll: true, children: /* @__PURE__ */ jsxs3(ThreadViewportShell, { isEmpty, children: [
+      isEmpty && /* @__PURE__ */ jsx18(WelcomeScreen, { heading: welcomeHeading }),
+      isEmpty && !isLoading && composer,
+      isLoading ? /* @__PURE__ */ jsx18(MessageListSkeleton, {}) : !isEmpty && /* @__PURE__ */ jsxs3(Fragment2, { children: [
+        /* @__PURE__ */ jsx18(HistoryLoaderContainer, {}),
+        /* @__PURE__ */ jsxs3(MessageGroup, { children: [
+          /* @__PURE__ */ jsx18(ThreadPrimitive.Messages, { children: ({ message }) => /* @__PURE__ */ jsx18(AnimatedMessageShell, { children: /* @__PURE__ */ jsx18(ThreadMessage, { isEditing: message.role === "user" && message.composer.isEditing }) }) }),
+          /* @__PURE__ */ jsx18(ResumeUnavailableContainer, {})
+        ] })
+      ] })
+    ] }) }),
+    !isLoading && !isEmpty && /* @__PURE__ */ jsxs3(ThreadComposerAreaShell, { isEmpty, children: [
+      /* @__PURE__ */ jsx18(ThreadPrimitive.ScrollToBottom, { asChild: true, children: /* @__PURE__ */ jsx18(ScrollToBottomButton, {}) }),
+      composer
+    ] })
+  ] }) }) });
+}
+
+// src/containers/Thread.tsx
+import { jsx as jsx19 } from "react/jsx-runtime";
+function Thread() {
+  return /* @__PURE__ */ jsx19(ThreadContainer, { composer: /* @__PURE__ */ jsx19(ComposerContainer, {}) });
+}
+
+// src/containers/ThreadListContainer.tsx
+import {
+  ThreadListItemByIndexProvider,
+  ThreadListItemMorePrimitive,
+  ThreadListItemPrimitive,
+  ThreadListPrimitive,
+  useAui as useAui5,
+  useAuiState as useAuiState13
+} from "@assistant-ui/react";
+import { useEffect as useEffect12, useMemo as useMemo5, useRef as useRef11, useState as useState14 } from "react";
+
+// src/atoms/AgentHistoryFilterButton.tsx
+import { useEffect as useEffect11, useId as useId2, useLayoutEffect, useRef as useRef10, useState as useState13 } from "react";
+import { createPortal } from "react-dom";
+
+// src/atoms/primitives/DropdownMenu.tsx
+import React, { useEffect as useEffect10, useId, useRef as useRef9, useState as useState12 } from "react";
+import { jsx as jsx20, jsxs as jsxs4 } from "react/jsx-runtime";
+function DropdownMenuItem({ className, ...props }) {
+  return /* @__PURE__ */ jsx20(
+    "button",
+    {
+      role: "menuitem",
+      type: "button",
+      className: cn(
+        "flex w-full cursor-pointer select-none items-center gap-2 rounded-sm px-2 py-1.5 text-sm outline-none",
+        "transition-colors hover:bg-ghost-button-hover",
+        "focus:bg-dropdown-selected-item-bg focus:text-dropdown-selected-item-text",
+        "aria-selected:bg-dropdown-selected-item-bg aria-selected:text-dropdown-selected-item-text",
+        "disabled:pointer-events-none disabled:opacity-50",
+        className
+      ),
+      ...props
+    }
+  );
+}
+
+// src/atoms/AgentHistoryFilterButton.tsx
+import { Fragment as Fragment3, jsx as jsx21, jsxs as jsxs5 } from "react/jsx-runtime";
+function themePortalRoot(from) {
+  return from?.closest(".aui-theme-root") ?? document.body;
+}
+function AgentHistoryFilterButton() {
+  const shell = useOptionalShellMode();
+  const server = useOptionalServer();
+  const isMobile = useIsMobile();
+  const compact = useCompactLayout();
+  const useSheet = isMobile || compact;
+  const [open, setOpen] = useState13(false);
+  const [query, setQuery] = useState13("");
+  const [menuPos, setMenuPos] = useState13(null);
+  const buttonRef = useRef10(null);
+  const menuRef = useRef10(null);
+  const menuId = useId2();
+  const enabled = shell?.isLibraryEnabled === true && server != null;
+  const selected = shell?.historyAgentFilter ?? null;
+  useEffect11(() => {
+    if (!open) setQuery("");
+  }, [open]);
+  const { agents, isInitialLoading, isSearching, loadingMore, hasMore, listRef, sentinelRef } = useSearchAgentsList({
+    enabled: open && enabled,
+    query
+  });
+  useLayoutEffect(() => {
+    if (!open || useSheet) {
+      setMenuPos(null);
+      return;
+    }
+    const update = () => {
+      const rect = buttonRef.current?.getBoundingClientRect();
+      if (!rect) return;
+      setMenuPos({ top: rect.top, left: rect.right + 4 });
+    };
+    update();
+    window.addEventListener("resize", update);
+    window.addEventListener("scroll", update, true);
+    return () => {
+      window.removeEventListener("resize", update);
+      window.removeEventListener("scroll", update, true);
+    };
+  }, [open, useSheet]);
+  useEffect11(() => {
+    if (!open || useSheet) return;
+    const handler = (e) => {
+      const target = e.target;
+      if (buttonRef.current?.contains(target) || menuRef.current?.contains(target)) return;
+      setOpen(false);
+    };
+    document.addEventListener("mousedown", handler);
+    return () => document.removeEventListener("mousedown", handler);
+  }, [open, useSheet]);
+  if (!enabled) return null;
+  const pick = (agentId) => {
+    shell?.setHistoryAgentFilter(agentId);
+    setOpen(false);
+  };
+  const filterBody = /* @__PURE__ */ jsxs5(Fragment3, { children: [
+    /* @__PURE__ */ jsxs5("div", { className: "p-1", onMouseDown: (e) => e.stopPropagation(), children: [
+      /* @__PURE__ */ jsx21(SearchInput_default, { query, setQuery, placeholder: "Search agents" }),
+      isSearching ? /* @__PURE__ */ jsx21("p", { className: "text-text-secondary px-1 pt-1 text-[11px]", role: "status", children: "Searching\u2026" }) : null
+    ] }),
+    /* @__PURE__ */ jsxs5(
+      "div",
+      {
+        ref: listRef,
+        className: cn("mt-1 overflow-y-auto", useSheet ? "min-h-0 flex-1 px-1 pb-2" : "min-h-48 max-h-64"),
+        children: [
+          query.trim() === "" ? /* @__PURE__ */ jsxs5(
+            DropdownMenuItem,
+            {
+              className: cn(
+                "justify-between",
+                selected == null && "bg-dropdown-selected-item-bg text-dropdown-selected-item-text"
+              ),
+              onClick: () => pick(null),
+              children: [
+                "All chats",
+                selected == null ? /* @__PURE__ */ jsx21(Icon, { name: "check", className: "size-3.5 shrink-0" }) : null
+              ]
+            }
+          ) : null,
+          isInitialLoading ? /* @__PURE__ */ jsx21("p", { className: "px-2 py-3 text-center text-xs text-text-secondary", children: "Loading\u2026" }) : agents.length === 0 ? /* @__PURE__ */ jsx21("p", { className: "text-text-secondary px-2 py-6 text-center text-xs", role: "status", children: query.trim() ? `No agents match "${query.trim()}".` : "No agents yet." }) : /* @__PURE__ */ jsxs5(Fragment3, { children: [
+            agents.map((agent) => {
+              const id = libraryAgentId(agent);
+              const active = selected === id;
+              return /* @__PURE__ */ jsxs5(
+                DropdownMenuItem,
+                {
+                  className: cn(
+                    "justify-between gap-2 text-left",
+                    active && "bg-dropdown-selected-item-bg text-dropdown-selected-item-text"
+                  ),
+                  onClick: () => pick(id),
+                  children: [
+                    /* @__PURE__ */ jsx21("span", { className: "min-w-0 truncate", children: agent.name }),
+                    active ? /* @__PURE__ */ jsx21(Icon, { name: "check", className: "size-3.5 shrink-0" }) : null
+                  ]
+                },
+                id
+              );
+            }),
+            hasMore ? /* @__PURE__ */ jsx21("div", { ref: sentinelRef, className: "flex h-6 shrink-0 items-center justify-center", "aria-hidden": true, children: loadingMore ? /* @__PURE__ */ jsx21("span", { className: "text-text-secondary text-[11px]", role: "status", children: "Loading more\u2026" }) : null }) : null
+          ] })
+        ]
+      }
+    )
+  ] });
+  return /* @__PURE__ */ jsxs5("div", { className: "relative shrink-0", children: [
+    /* @__PURE__ */ jsxs5(
+      "button",
+      {
+        ref: buttonRef,
+        type: "button",
+        "aria-label": selected != null ? `Filter chat history by agent (${selected})` : "Filter chat history by agent",
+        "aria-haspopup": useSheet ? "dialog" : "menu",
+        "aria-expanded": open,
+        "aria-controls": open ? menuId : void 0,
+        title: "Filter by agent",
+        className: auiButtonClass({
+          variant: "ghost",
+          size: "icon",
+          className: cn(
+            "relative size-7 shrink-0 text-text-secondary hover:bg-ghost-button-hover hover:text-ghost-button-text",
+            selected != null && "text-text-primary"
+          )
+        }),
+        onClick: () => setOpen((v) => !v),
+        children: [
+          /* @__PURE__ */ jsx21(Icon, { name: "funnel", className: "size-3.5" }),
+          selected != null ? /* @__PURE__ */ jsx21(
+            "span",
+            {
+              className: "bg-primary-button-bg absolute top-1 right-1 size-1.5 rounded-full",
+              "aria-hidden": true,
+              "data-testid": "history-filter-active-dot"
+            }
+          ) : null
+        ]
+      }
+    ),
+    useSheet && open ? /* @__PURE__ */ jsx21(BottomSheet, { open: true, onOpenChange: setOpen, id: menuId, "aria-label": "Filter agents", children: /* @__PURE__ */ jsx21("div", { className: "flex min-h-0 flex-1 flex-col p-2", role: "menu", children: filterBody }) }) : null,
+    !useSheet && open && menuPos != null ? createPortal(
+      /* @__PURE__ */ jsx21(
+        "div",
+        {
+          ref: menuRef,
+          id: menuId,
+          role: "menu",
+          "aria-label": "Filter agents",
+          style: { top: menuPos.top, left: menuPos.left },
+          className: "font-sans-flex fixed z-50 w-56 rounded-md border border-border bg-card-bg p-1 text-text-primary shadow-md",
+          children: filterBody
+        }
+      ),
+      themePortalRoot(buttonRef.current)
+    ) : null
+  ] });
+}
+
+// src/containers/ThreadListContainer.tsx
+import { Fragment as Fragment4, jsx as jsx22, jsxs as jsxs6 } from "react/jsx-runtime";
+var deleteItemClass = "flex w-full cursor-pointer select-none items-center gap-2 rounded-sm px-2 py-1.5 text-sm outline-none text-failure-bg hover:bg-ghost-button-hover hover:text-failure-bg focus:bg-ghost-button-hover focus:text-failure-bg data-[highlighted]:bg-ghost-button-hover data-[highlighted]:text-failure-bg";
+function ThreadListItemDeleteMenu() {
+  const compact = useCompactLayout();
+  const isMobile = useIsMobile();
+  const [sheetOpen, setSheetOpen] = useState14(false);
+  const useSheet = isMobile || compact;
+  const moreButtonClass = auiButtonClass({
+    variant: "ghost",
+    size: "icon",
+    className: "size-7 shrink-0 text-text-secondary hover:bg-transparent hover:text-text-primary"
+  });
+  if (useSheet) {
+    return /* @__PURE__ */ jsxs6(Fragment4, { children: [
+      /* @__PURE__ */ jsx22(
+        "button",
+        {
+          type: "button",
+          "aria-label": "Session actions",
+          title: "Session actions",
+          "aria-haspopup": "dialog",
+          "aria-expanded": sheetOpen,
+          className: moreButtonClass,
+          onClick: () => setSheetOpen(true),
+          children: /* @__PURE__ */ jsx22(Icon, { name: "ellipsis", className: "size-3.5" })
+        }
+      ),
+      sheetOpen ? /* @__PURE__ */ jsx22(BottomSheet, { open: true, onOpenChange: setSheetOpen, "aria-label": "Session actions", children: /* @__PURE__ */ jsx22("div", { className: "flex flex-col gap-1 p-2", role: "menu", children: /* @__PURE__ */ jsxs6(ThreadListItemPrimitive.Delete, { className: deleteItemClass, onClick: () => setSheetOpen(false), children: [
+        /* @__PURE__ */ jsx22(Icon, { name: "trash", className: "size-3.5" }),
+        "Delete"
+      ] }) }) }) : null
+    ] });
+  }
+  return /* @__PURE__ */ jsxs6(ThreadListItemMorePrimitive.Root, { sharedFocusGroup: true, children: [
+    /* @__PURE__ */ jsx22(
+      ThreadListItemMorePrimitive.Trigger,
+      {
+        "aria-label": "Session actions",
+        title: "Session actions",
+        className: moreButtonClass,
+        children: /* @__PURE__ */ jsx22(Icon, { name: "ellipsis", className: "size-3.5" })
+      }
+    ),
+    /* @__PURE__ */ jsx22(
+      ThreadListItemMorePrimitive.Content,
+      {
+        align: "end",
+        sideOffset: 4,
+        className: "z-50 min-w-[8rem] rounded-md border border-border bg-card-bg p-1 text-text-primary shadow-md",
+        children: /* @__PURE__ */ jsx22(ThreadListItemPrimitive.Delete, { asChild: true, children: /* @__PURE__ */ jsxs6(ThreadListItemMorePrimitive.Item, { className: deleteItemClass, children: [
+          /* @__PURE__ */ jsx22(Icon, { name: "trash", className: "size-3.5" }),
+          "Delete"
+        ] }) })
+      }
+    )
+  ] });
+}
+function ThreadListItemRow({
+  onThreadOpen,
+  canDeleteSession
+}) {
+  const aui = useAui5();
+  const shell = useOptionalShellMode();
+  const ThreadListRow = useSlot("ThreadListRow");
+  const id = useAuiState13((s) => s.threadListItem.id);
+  const remoteId = useAuiState13((s) => s.threadListItem.remoteId);
+  const title = useAuiState13((s) => s.threadListItem.title);
+  const lastMessageAt = useAuiState13((s) => s.threadListItem.lastMessageAt);
+  const custom = useAuiState13((s) => s.threadListItem.custom);
+  const mainThreadId = useAuiState13((s) => s.threads.mainThreadId);
+  const agentName = readThreadAgentName(custom);
+  const showDelete = canDeleteSession && remoteId != null;
+  return /* @__PURE__ */ jsx22(ThreadListItemPrimitive.Root, { className: "min-w-0", children: /* @__PURE__ */ jsx22(
+    ThreadListRow,
+    {
+      title: title ?? "New Chat",
+      active: id === mainThreadId,
+      agentName,
+      lastMessageAt,
+      onSelect: () => {
+        onThreadOpen?.();
+        shell?.setSettingsOpen(false);
+        const sessionMutable = threadListItemIsMutable(custom);
+        const sameImmutable = !sessionMutable && shell?.mode.status === "active" && !shell.mode.isMutable && (agentName == null ? shell.mode.agentName == null && shell.mode.agentId == null : shell.mode.agentName === agentName || shell.mode.agentId === agentName);
+        const sameMutable = canReuseMutableShell({
+          sessionMutable,
+          shellMutable: shell?.mode.status === "active" && shell.mode.isMutable,
+          ...shell?.mode.status === "active" && shell.mode.isMutable ? { shellAgentName: shell.mode.agentName, shellAgentId: shell.mode.agentId } : {},
+          remoteId,
+          pendingSessionId: shell?.pendingSessionId
+        });
+        if ((sameImmutable || sameMutable) && remoteId != null) {
+          void Promise.resolve(aui.threads().switchToThread(id)).catch(() => void 0);
+          return;
+        }
+        if (remoteId != null) {
+          shell?.openHistorySession({
+            sessionId: remoteId,
+            isMutable: sessionMutable,
+            ...agentName != null ? { agentName } : {}
+          });
+          return;
+        }
+        void Promise.resolve(aui.threads().switchToThread(id)).catch(() => void 0);
+      },
+      actions: showDelete ? /* @__PURE__ */ jsx22(ThreadListItemDeleteMenu, {}) : void 0
+    }
+  ) });
+}
+function useThreadListIndicesByRecency() {
+  const threadIds = useAuiState13((s) => s.threads.threadIds);
+  const threadItems = useAuiState13((s) => s.threads.threadItems);
+  return useMemo5(() => threadListIndicesByRecency({ threadIds, threadItems }), [threadIds, threadItems]);
+}
+function ThreadListItemsByRecency({
+  onThreadOpen,
+  canDeleteSession
+}) {
+  const indices = useThreadListIndicesByRecency();
+  const threadIds = useAuiState13((s) => s.threads.threadIds);
+  return /* @__PURE__ */ jsx22(Fragment4, { children: indices.map((index) => {
+    const key = threadIds[index] ?? String(index);
+    return /* @__PURE__ */ jsx22(ThreadListItemByIndexProvider, { index, archived: false, children: /* @__PURE__ */ jsx22(ThreadListItemRow, { onThreadOpen, canDeleteSession }) }, key);
+  }) });
+}
+var THREAD_LIST_VIEWPORT_SLOT = "aui_thread-list-viewport";
+var LOAD_MORE_BOTTOM_PX = 80;
+function ChatHistorySection({ children, viewportRef }) {
+  const [expanded, setExpanded] = useState14(true);
+  const shell = useOptionalShellMode();
+  const showFilter = shell?.isLibraryEnabled === true;
+  return /* @__PURE__ */ jsxs6("div", { className: "flex min-h-0 flex-1 flex-col", children: [
+    /* @__PURE__ */ jsxs6("div", { className: "flex shrink-0 items-center gap-1 px-1 py-1", children: [
+      /* @__PURE__ */ jsxs6(
+        "button",
+        {
+          type: "button",
+          "aria-expanded": expanded,
+          className: "flex min-w-0 flex-1 items-center gap-1 rounded-md px-1.5 py-1 text-left text-sm font-medium text-text-secondary hover:bg-ghost-button-hover hover:text-text-primary",
+          onClick: () => setExpanded((v) => !v),
+          children: [
+            /* @__PURE__ */ jsx22("span", { className: "truncate", children: "Chat History" }),
+            /* @__PURE__ */ jsx22(
+              Icon,
+              {
+                name: "chevron-down",
+                className: cn("size-3.5 shrink-0 transition-transform", !expanded && "-rotate-90")
+              }
+            )
+          ]
+        }
+      ),
+      showFilter ? /* @__PURE__ */ jsx22(AgentHistoryFilterButton, {}) : null
+    ] }),
+    expanded ? /* @__PURE__ */ jsx22(
+      "div",
+      {
+        ref: viewportRef,
+        "data-slot": THREAD_LIST_VIEWPORT_SLOT,
+        className: "flex min-h-0 flex-1 flex-col gap-0.5 overflow-y-auto",
+        children
+      }
+    ) : null
+  ] });
+}
+function ThreadListContainer({ onThreadOpen } = {}) {
+  const aui = useAui5();
+  const server = useOptionalServer();
+  const isLoading = useAuiState13((s) => s.threads.isLoading);
+  const hasMore = useAuiState13((s) => s.threads.hasMore);
+  const threadIds = useAuiState13((s) => s.threads.threadIds);
+  const shell = useOptionalShellMode();
+  const ThreadListShell = useSlot("ThreadListShell");
+  const ThreadListNewButton = useSlot("ThreadListNewButton");
+  const AgentsLibraryButton = useSlot("AgentsLibraryButton");
+  const ThreadListRowSkeleton = useSlot("ThreadListRowSkeleton");
+  const ThreadListEmptyState = useSlot("ThreadListEmptyState");
+  const viewportRef = useRef11(null);
+  const loadMoreInflightRef = useRef11(false);
+  const hasMoreRef = useRef11(hasMore);
+  const auiRef = useRef11(aui);
+  hasMoreRef.current = hasMore;
+  auiRef.current = aui;
+  const showNewChat = shell?.isNewChatEnabled !== false;
+  const isIdle = shell?.mode.status === "idle";
+  const canDeleteSession = typeof server?.deleteSession === "function";
+  useEffect12(() => {
+    if (isIdle) return;
+    const viewport = viewportRef.current;
+    if (!viewport) return;
+    let cancelled = false;
+    let chainRaf = 0;
+    const tryLoadMore = () => {
+      if (cancelled || !hasMoreRef.current || loadMoreInflightRef.current) return;
+      if (viewport.scrollTop <= 0) return;
+      const remaining = viewport.scrollHeight - viewport.scrollTop - viewport.clientHeight;
+      if (remaining > LOAD_MORE_BOTTOM_PX) return;
+      loadMoreInflightRef.current = true;
+      void Promise.resolve(auiRef.current.threads().loadMore()).finally(() => {
+        loadMoreInflightRef.current = false;
+        if (cancelled) return;
+        chainRaf = requestAnimationFrame(() => tryLoadMore());
+      });
+    };
+    viewport.addEventListener("scroll", tryLoadMore, { passive: true });
+    return () => {
+      cancelled = true;
+      cancelAnimationFrame(chainRaf);
+      viewport.removeEventListener("scroll", tryLoadMore);
+    };
+  }, [isIdle]);
+  const handleNewChat = () => {
+    onThreadOpen?.();
+    if (shell?.isComposerEnabled) {
+      shell.openDraft();
+      return;
+    }
+    shell?.setSettingsOpen(false);
+    void Promise.resolve(aui.threads().switchToNewThread()).catch(() => void 0);
+  };
+  let listBody;
+  if (isIdle) {
+    listBody = /* @__PURE__ */ jsx22(ThreadListEmptyState, {});
+  } else if (isLoading) {
+    listBody = /* @__PURE__ */ jsx22(ThreadListRowSkeleton, {});
+  } else if (threadIds.length === 0) {
+    listBody = /* @__PURE__ */ jsx22(ThreadListEmptyState, {});
+  } else {
+    listBody = /* @__PURE__ */ jsx22(ThreadListPrimitive.Root, { className: "flex min-h-0 flex-col gap-0.5", children: /* @__PURE__ */ jsx22(ThreadListItemsByRecency, { onThreadOpen, canDeleteSession }) });
+  }
+  return /* @__PURE__ */ jsx22(
+    ThreadListShell,
+    {
+      header: /* @__PURE__ */ jsxs6("div", { className: "flex flex-col gap-1", children: [
+        showNewChat ? /* @__PURE__ */ jsx22(ThreadListNewButton, { onClick: handleNewChat }) : null,
+        /* @__PURE__ */ jsx22(
+          AgentsLibraryButton,
+          {
+            onSelectAgent: () => {
+              onThreadOpen?.();
+            }
+          }
+        )
+      ] }),
+      children: /* @__PURE__ */ jsxs6(ChatHistorySection, { viewportRef, children: [
+        listBody,
+        !isIdle && hasMore ? /* @__PURE__ */ jsx22("div", { className: "h-4 shrink-0", "aria-hidden": true }) : null
+      ] })
+    }
+  );
+}
+
+export {
+  AgentStepsContainer,
+  AskUserContainer,
+  computeAgentStepsSplit,
+  AssistantTextContainer,
+  ReasoningContainer,
+  ToolApprovalContainer,
+  ToolCallContentBlockContainer,
+  ToolCallContainer,
+  AssistantMessageContainer,
+  ComposerAttachmentsContainer,
+  MessageAttachmentsContainer,
+  ComposerAttachmentPickerContainer,
+  notifyComposerBusyFailure,
+  ComposerBusyProvider,
+  useComposerBusyState,
+  threadHasPendingMcpAuth,
+  useComposerPauseView,
+  McpAuthContainer,
+  ComposerContainer,
+  HistoryLoaderContainer,
+  ResumeUnavailableContainer,
+  UserEditComposerContainer,
+  UserMessageContainer,
+  ThreadContainer,
+  Thread,
+  ThreadListContainer
+};
+//# sourceMappingURL=chunk-UXZOL5GO.js.map