@truefoundry/trueforge-ui 0.3.0-rc.0 → 0.3.0-rc.10

package/dist/chunk-JKEBMGLH.js

@@ -0,0 +1,682 @@
+import {
+  ComposerBusyProvider,
+  useComposerBusyState,
+  useOptionalCustomActionRenderers
+} from "./chunk-BSIPI3KV.js";
+import {
+  ASK_USER_CUSTOM_OPTION,
+  ApprovalFocusProvider,
+  AssistantMessageContainer,
+  Button,
+  ComposerAttachmentsContainer,
+  MessageAttachmentsContainer,
+  SlotsProvider,
+  UserMessageContainer,
+  isNewChatView,
+  preloadMarkdownOpenUI,
+  useActiveSessionCanManage,
+  useMCPAuth,
+  useOptionalApprovalFocus,
+  useSlot,
+  useSlotIsDefault
+} from "./chunk-GG23N2GW.js";
+import {
+  DraftCatalogProvider,
+  useDraftCatalog
+} from "./chunk-3ZW74FHC.js";
+import {
+  useOptionalCatalogServer,
+  useOptionalServer,
+  useOptionalShellMode
+} from "./chunk-2GIZY3JJ.js";
+import {
+  useAui,
+  useAuiState
+} from "./chunk-M6MHLVSO.js";
+
+// src/hooks/useApprovalNav.ts
+import { useTrueFoundryApprovals } from "@truefoundry/assistant-ui-runtime";
+import { useCallback, useEffect, useRef, useState } from "react";
+function useApprovalNav() {
+  const { pending } = useTrueFoundryApprovals();
+  const focusApi = useOptionalApprovalFocus();
+  const [selection, setSelection] = useState({
+    approvalId: null,
+    index: 0
+  });
+  const focusedIdRef = useRef(null);
+  const count = pending.length;
+  const matchedIndex = selection.approvalId == null ? -1 : pending.findIndex((item) => item.approvalId === selection.approvalId);
+  const safeIndex = matchedIndex >= 0 ? matchedIndex : count === 0 ? 0 : Math.min(selection.index, count - 1);
+  const currentId = pending[safeIndex]?.approvalId;
+  useEffect(() => {
+    const approvalId = currentId ?? null;
+    if (selection.approvalId === approvalId && selection.index === safeIndex) return;
+    setSelection({ approvalId, index: safeIndex });
+  }, [currentId, safeIndex, selection.approvalId, selection.index]);
+  useEffect(() => {
+    if (currentId == null || focusApi == null) {
+      if (currentId == null) focusedIdRef.current = null;
+      return;
+    }
+    if (focusedIdRef.current === currentId) return;
+    focusedIdRef.current = currentId;
+    focusApi.focus(currentId);
+  }, [currentId, focusApi]);
+  const goPrev = useCallback(() => {
+    const index = Math.max(0, safeIndex - 1);
+    setSelection({ approvalId: pending[index]?.approvalId ?? null, index });
+  }, [pending, safeIndex]);
+  const goNext = useCallback(() => {
+    const index = Math.min(Math.max(count - 1, 0), safeIndex + 1);
+    setSelection({ approvalId: pending[index]?.approvalId ?? null, index });
+  }, [count, pending, safeIndex]);
+  const focusCurrent = useCallback(() => {
+    if (currentId == null || focusApi == null) return;
+    focusApi.focus(currentId);
+  }, [currentId, focusApi]);
+  return {
+    count,
+    index: safeIndex,
+    canPrev: safeIndex > 0,
+    canNext: safeIndex < count - 1,
+    goPrev,
+    goNext,
+    focusCurrent
+  };
+}
+
+// src/containers/ApprovalNavContainer.tsx
+import { jsx } from "react/jsx-runtime";
+function ApprovalNavContainer() {
+  const ApprovalNavBanner = useSlot("ApprovalNavBanner");
+  const { count, index, canPrev, canNext, goPrev, goNext, focusCurrent } = useApprovalNav();
+  if (count === 0) return null;
+  return /* @__PURE__ */ jsx(
+    ApprovalNavBanner,
+    {
+      total: count,
+      current: index + 1,
+      canPrev,
+      canNext,
+      onPrev: goPrev,
+      onNext: goNext,
+      onFocusCurrent: focusCurrent
+    }
+  );
+}
+
+// src/containers/AskUserContainer.tsx
+import { useThreadIsRunning } from "@assistant-ui/core/react";
+import { useTrueFoundryToolResponses } from "@truefoundry/assistant-ui-runtime";
+import { useCallback as useCallback2, useEffect as useEffect2, useMemo, useState as useState2 } from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var EMPTY_ANSWER = { radioValue: "", custom: "" };
+function AskUserContainer({ disabled = false }) {
+  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 = useCallback2(
+    (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 || disabled || currentQuestion == null || selectedResponse.length === 0;
+  const isSubmitAllDisabled = isSubmitDisabled || !allQuestionsAnswered;
+  const onCurrentAnswerChange = useCallback2((questionId, update) => {
+    setAnswers((previous) => ({
+      ...previous,
+      [questionId]: {
+        ...previous[questionId] ?? EMPTY_ANSWER,
+        ...update
+      }
+    }));
+  }, []);
+  const onSubmit = useCallback2(() => {
+    if (disabled || item == null || !allQuestionsAnswered) return;
+    const content = getResponseForQuestion(item.toolCallId);
+    if (!content) return;
+    respond({ toolCallId: item.toolCallId, content });
+  }, [allQuestionsAnswered, disabled, getResponseForQuestion, item, respond]);
+  if (item == null || currentQuestion == null) return null;
+  return /* @__PURE__ */ jsx2(
+    AskUserPrompt,
+    {
+      questions,
+      readOnly: isRunning || disabled,
+      currentQuestion,
+      currentQuestionIndex: safeIndex,
+      currentAnswer,
+      totalQuestions: questions.length,
+      isMultiQuestion: questions.length > 1,
+      isLastQuestion: safeIndex === questions.length - 1,
+      allQuestionsAnswered,
+      isSubmitDisabled,
+      isSubmitAllDisabled,
+      onCurrentQuestionIndexChange: setCurrentQuestionIndex,
+      onCurrentAnswerChange,
+      onSubmit
+    }
+  );
+}
+
+// src/hooks/useComposerPauseView.ts
+import { useAuiState as useAuiState2 } from "@assistant-ui/react";
+import { useTrueFoundryApprovals as useTrueFoundryApprovals2, 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 = useAuiState2(threadHasPendingMcpAuth);
+  const { pending: toolResponsesPending } = useTrueFoundryToolResponses2();
+  const { pending: approvalsPending } = useTrueFoundryApprovals2();
+  const customActionRenderers = useOptionalCustomActionRenderers();
+  if (mcpPending) {
+    return { kind: "mcp" };
+  }
+  const firstPending = toolResponsesPending[0];
+  if (firstPending != null) {
+    const toolName = firstPending.toolName;
+    if (toolName != null && customActionRenderers?.[toolName] != null) {
+      return { kind: "custom", toolName };
+    }
+    return { kind: "ask-user" };
+  }
+  if (approvalsPending.length > 0) {
+    return { kind: "approval" };
+  }
+  return { kind: "compose" };
+}
+
+// src/containers/CustomActionContainer.tsx
+import { useThreadIsRunning as useThreadIsRunning2 } from "@assistant-ui/core/react";
+import { useTrueFoundryToolResponses as useTrueFoundryToolResponses3 } from "@truefoundry/assistant-ui-runtime";
+import { useCallback as useCallback3 } from "react";
+import { jsx as jsx3 } from "react/jsx-runtime";
+function CustomActionContainer({ disabled = false }) {
+  const renderers = useOptionalCustomActionRenderers();
+  const { pending, respond } = useTrueFoundryToolResponses3();
+  const isRunning = useThreadIsRunning2();
+  const item = pending[0];
+  const onSubmit = useCallback3(
+    (content) => {
+      if (disabled || item == null) return;
+      const trimmed = content.trim();
+      if (!trimmed) return;
+      respond({ toolCallId: item.toolCallId, content: trimmed });
+    },
+    [disabled, item, respond]
+  );
+  if (item == null || item.toolName == null) return null;
+  const Renderer = renderers?.[item.toolName];
+  if (Renderer == null) return null;
+  return /* @__PURE__ */ jsx3(Renderer, { args: item.args ?? {}, disabled: isRunning || disabled, onSubmit });
+}
+
+// src/containers/McpAuthContainer.tsx
+import { useThreadIsRunning as useThreadIsRunning3 } from "@assistant-ui/core/react";
+import { useTrueFoundryMcpAuth } from "@truefoundry/assistant-ui-runtime";
+import { jsx as jsx4 } from "react/jsx-runtime";
+function CatalogMcpAuthPrompt({ servers, onContinue, readOnly }) {
+  const McpAuthPrompt = useSlot("McpAuthPrompt");
+  const { handleAuthorize } = useMCPAuth();
+  const { refreshConnectors } = useDraftCatalog();
+  const handleConnect = (serverId) => {
+    void handleAuthorize(serverId, (isSuccess) => {
+      if (isSuccess) {
+        void refreshConnectors();
+      }
+    });
+  };
+  return /* @__PURE__ */ jsx4(McpAuthPrompt, { servers, onConnect: handleConnect, onContinue, readOnly });
+}
+function McpAuthContainer({ disabled = false }) {
+  const McpAuthPrompt = useSlot("McpAuthPrompt");
+  const { pending, resume } = useTrueFoundryMcpAuth();
+  const isRunning = useThreadIsRunning3();
+  const catalog = useOptionalCatalogServer();
+  if (!pending) return null;
+  if (catalog) {
+    return /* @__PURE__ */ jsx4(
+      CatalogMcpAuthPrompt,
+      {
+        servers: pending.mcpServers,
+        onContinue: () => {
+          if (!disabled) void resume();
+        },
+        readOnly: isRunning || disabled
+      }
+    );
+  }
+  const handleConnect = (serverId) => {
+    const server = pending.mcpServers.find((s) => s.id === serverId);
+    if (server?.authUrl) {
+      window.open(server.authUrl, "_blank", "noopener,noreferrer");
+    }
+  };
+  return /* @__PURE__ */ jsx4(
+    McpAuthPrompt,
+    {
+      servers: pending.mcpServers,
+      onConnect: handleConnect,
+      onContinue: () => {
+        if (!disabled) void resume();
+      },
+      readOnly: isRunning || disabled
+    }
+  );
+}
+
+// src/containers/ComposerContainer.tsx
+import { ComposerPrimitive, useAui as useAui2, useAuiState as useAuiState3 } from "@assistant-ui/react";
+import { useTrueFoundryAgentSpec, useTrueFoundryCancel } from "@truefoundry/assistant-ui-runtime";
+import { useRef as useRef2 } from "react";
+import { Fragment, jsx as jsx5, jsxs } from "react/jsx-runtime";
+function canSubmitComposer({
+  disabled,
+  hasText,
+  hasAttachments,
+  requiresModel,
+  hasModel
+}) {
+  return !disabled && (hasText || hasAttachments) && (!requiresModel || hasModel);
+}
+function ComposerBody({
+  placeholder,
+  forceDisabled = false,
+  connectedToBanner = false
+}) {
+  const ComposerShell = useSlot("ComposerShell");
+  const aui = useAui2();
+  const shell = useOptionalShellMode();
+  const hasText = useAuiState3((s) => s.composer.text.trim().length > 0);
+  const hasAttachments = useAuiState3((s) => s.composer.attachments.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 canManageSession = useActiveSessionCanManage();
+  const cancel = useTrueFoundryCancel();
+  const fileInputRef = useRef2(null);
+  const disabled = isBusy || forceDisabled || !canManageSession;
+  const canSubmit = canSubmitComposer({ disabled, hasText, hasAttachments, requiresModel, hasModel });
+  const submit = () => {
+    if (!canSubmit) return;
+    send(() => aui.composer().send());
+  };
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx5(
+      "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__ */ jsx5(
+      ComposerPrimitive.AttachmentDropzone,
+      {
+        disabled,
+        "data-slot": "aui_composer-attachment-dropzone",
+        className: "w-full rounded-[0.75rem] transition-[box-shadow] data-[dragging=true]:ring-focus-ring/20 data-[dragging=true]:ring-3",
+        children: /* @__PURE__ */ jsx5(
+          ComposerPrimitive.Root,
+          {
+            "data-slot": "aui_composer-root",
+            className: "w-full",
+            onSubmit: (event) => {
+              event.preventDefault();
+              submit();
+            },
+            children: /* @__PURE__ */ jsx5(
+              ComposerShell,
+              {
+                className: connectedToBanner ? (
+                  // Banner owns the top accent; composer keeps its normal chrome without a shared blue frame.
+                  "rounded-t-none border-t-0 focus-within:ring-0"
+                ) : void 0,
+                attachments: /* @__PURE__ */ jsx5(ComposerAttachmentsContainer, {}),
+                input: /* @__PURE__ */ jsx5(
+                  ComposerPrimitive.Input,
+                  {
+                    "data-slot": "aui_composer-input",
+                    placeholder,
+                    disabled,
+                    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,
+                canSubmit,
+                isRunning: isBusy && !forceDisabled,
+                onSubmit: submit,
+                onCancel: canManageSession ? () => {
+                  resetBusy();
+                  void cancel();
+                } : void 0,
+                onAttach: canManageSession ? () => fileInputRef.current?.click() : void 0
+              }
+            )
+          }
+        )
+      }
+    )
+  ] });
+}
+function ComposerWithOptionalDraft({
+  placeholder,
+  forceDisabled = false,
+  connectedToBanner = false
+}) {
+  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 (canMutateSpec) {
+    return /* @__PURE__ */ jsx5(DraftCatalogProvider, { children: /* @__PURE__ */ jsx5(
+      SlotsProvider,
+      {
+        overrides: {
+          ComposerLeftSection: usesDefaultLeftSection ? DraftComposerLeftSection : parentLeftSection,
+          ComposerRightSection: usesDefaultRightSection ? DraftComposerRightSection : parentRightSection
+        },
+        children: /* @__PURE__ */ jsx5(ComposerBody, { placeholder, forceDisabled, connectedToBanner })
+      }
+    ) });
+  }
+  return /* @__PURE__ */ jsx5(ComposerBody, { placeholder, forceDisabled, connectedToBanner });
+}
+function ComposerContainer({
+  placeholder = "Ask anything... (Shift+Enter for new line)"
+}) {
+  const pauseView = useComposerPauseView();
+  const canManageSession = useActiveSessionCanManage();
+  if (pauseView.kind === "mcp") {
+    return /* @__PURE__ */ jsx5(McpAuthContainer, { disabled: !canManageSession });
+  }
+  if (pauseView.kind === "custom") {
+    return /* @__PURE__ */ jsx5(CustomActionContainer, { disabled: !canManageSession });
+  }
+  if (pauseView.kind === "ask-user") {
+    return /* @__PURE__ */ jsx5(AskUserContainer, { disabled: !canManageSession });
+  }
+  if (pauseView.kind === "approval") {
+    return /* @__PURE__ */ jsxs("div", { "data-slot": "aui_composer-approval-pause", className: "flex w-full flex-col", children: [
+      /* @__PURE__ */ jsx5(ApprovalNavContainer, {}),
+      /* @__PURE__ */ jsx5(ComposerWithOptionalDraft, { placeholder, forceDisabled: true, connectedToBanner: true })
+    ] });
+  }
+  return /* @__PURE__ */ jsx5(ComposerWithOptionalDraft, { placeholder });
+}
+
+// src/containers/HistoryLoaderContainer.tsx
+import { useTrueFoundryHistoryPagination } from "@truefoundry/assistant-ui-runtime";
+import { useCallback as useCallback4, useEffect as useEffect3, useRef as useRef3, useState as useState3 } from "react";
+import { jsx as jsx6 } 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] = useState3(null);
+  const inflightRef = useRef3(false);
+  const maybeLoadOlder = useCallback4(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]);
+  useEffect3(() => {
+    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__ */ jsx6(HistoryLoader, { ref: setSentinel, isLoading: isLoadingOlderHistory });
+}
+
+// src/containers/ResumeUnavailableContainer.tsx
+import { useTrueFoundryResumeUnavailable } from "@truefoundry/assistant-ui-runtime";
+import { jsx as jsx7 } from "react/jsx-runtime";
+function ResumeUnavailableContainer() {
+  const ResumeUnavailable = useSlot("ResumeUnavailable");
+  const resumeUnavailable = useTrueFoundryResumeUnavailable();
+  if (!resumeUnavailable) return null;
+  return /* @__PURE__ */ jsx7(ResumeUnavailable, {});
+}
+
+// src/containers/UserEditComposerContainer.tsx
+import { useComposerCancel, useComposerSend, useThreadIsRunning as useThreadIsRunning4 } from "@assistant-ui/core/react";
+import { ComposerPrimitive as ComposerPrimitive2, MessagePrimitive, useAuiState as useAuiState4 } from "@assistant-ui/react";
+import { jsx as jsx8, jsxs as jsxs2 } from "react/jsx-runtime";
+function ReadOnlyMessageAttachments() {
+  const hasAttachments = useAuiState4((s) => (s.message.attachments?.length ?? 0) > 0);
+  if (!hasAttachments) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx8("div", { className: "pointer-events-none mb-2 opacity-90", children: /* @__PURE__ */ jsx8(MessageAttachmentsContainer, {}) });
+}
+function UserEditComposerContainer() {
+  const UserMessageEdit = useSlot("UserMessageEdit");
+  const MessageTimestamp = useSlot("MessageTimestamp");
+  const isRunning = useThreadIsRunning4();
+  const canManageSession = useActiveSessionCanManage();
+  const createdAt = useAuiState4((s) => s.message.createdAt);
+  const { cancel, disabled: cancelDisabled } = useComposerCancel();
+  const { disabled: sendDisabled } = useComposerSend();
+  return /* @__PURE__ */ jsx8(MessagePrimitive.Root, { "data-role": "user", children: /* @__PURE__ */ jsx8(
+    ComposerPrimitive2.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__ */ jsx8(
+        UserMessageEdit,
+        {
+          timestamp: /* @__PURE__ */ jsx8(MessageTimestamp, { createdAt }),
+          attachments: /* @__PURE__ */ jsx8(ReadOnlyMessageAttachments, {}),
+          input: /* @__PURE__ */ jsx8("div", { className: "mt-1 rounded border border-border bg-secondary-bg p-2 text-text-primary", children: /* @__PURE__ */ jsx8(
+            ComposerPrimitive2.Input,
+            {
+              "data-slot": "aui_user-edit-input",
+              disabled: isRunning || !canManageSession,
+              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__ */ jsx8(Button.Secondary, { type: "button", disabled: cancelDisabled, onClick: cancel, children: "Cancel" }),
+            /* @__PURE__ */ jsx8(ComposerPrimitive2.Send, { asChild: true, children: /* @__PURE__ */ jsx8(Button.Primary, { type: "submit", disabled: sendDisabled || isRunning || !canManageSession, children: "Save & Rerun" }) })
+          ] })
+        }
+      )
+    }
+  ) });
+}
+
+// src/containers/ThreadContainer.tsx
+import { ThreadPrimitive, useAuiState as useAuiState5 } from "@assistant-ui/react";
+import { useEffect as useEffect5 } from "react";
+
+// src/hooks/useSyncSessionTitle.ts
+import { useThreadIsRunning as useThreadIsRunning5 } from "@assistant-ui/core/react";
+import { useEffect as useEffect4, useRef as useRef4 } 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 = useThreadIsRunning5();
+  const wasRunningRef = useRef4(false);
+  const syncedRemoteIdRef = useRef4(void 0);
+  useEffect4(() => {
+    syncedRemoteIdRef.current = void 0;
+  }, [remoteId]);
+  useEffect4(() => {
+    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/containers/ThreadContainer.tsx
+import { Fragment as Fragment2, jsx as jsx9, jsxs as jsxs3 } from "react/jsx-runtime";
+function AnimatedMessageShell({ children }) {
+  return /* @__PURE__ */ jsx9("div", { className: "animate-in fade-in slide-in-from-bottom-1 fill-mode-both duration-200", children });
+}
+function ThreadMessage({ isEditing }) {
+  const role = useAuiState5((s) => s.message.role);
+  if (role === "user") {
+    if (isEditing) {
+      return /* @__PURE__ */ jsx9(UserEditComposerContainer, {});
+    }
+    return /* @__PURE__ */ jsx9(UserMessageContainer, {});
+  }
+  return /* @__PURE__ */ jsx9(AssistantMessageContainer, {});
+}
+function ThreadContainer({ composer }) {
+  useEffect5(() => {
+    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 = useAuiState5(isNewChatView);
+  const isLoading = useAuiState5((s) => s.thread.isLoading);
+  const welcomeHeading = shell?.mode.status === "active" ? shell.mode.agentName != null && shell.mode.agentName.length > 0 ? shell.mode.agentName : shell.mode.isMutable && shell.mode.isCreateAgent ? "Start building a new Agent" : void 0 : void 0;
+  return /* @__PURE__ */ jsx9(ComposerBusyProvider, { children: /* @__PURE__ */ jsx9(ApprovalFocusProvider, { children: /* @__PURE__ */ jsx9(ThreadPrimitive.Root, { asChild: true, children: /* @__PURE__ */ jsxs3(ThreadRootShell, { children: [
+    /* @__PURE__ */ jsx9(ThreadPrimitive.Viewport, { asChild: true, autoScroll: true, children: /* @__PURE__ */ jsxs3(ThreadViewportShell, { isEmpty, children: [
+      isEmpty && /* @__PURE__ */ jsx9(WelcomeScreen, { heading: welcomeHeading }),
+      isEmpty && !isLoading && composer,
+      isLoading ? /* @__PURE__ */ jsx9(MessageListSkeleton, {}) : !isEmpty && /* @__PURE__ */ jsxs3(Fragment2, { children: [
+        /* @__PURE__ */ jsx9(HistoryLoaderContainer, {}),
+        /* @__PURE__ */ jsxs3(MessageGroup, { children: [
+          /* @__PURE__ */ jsx9(ThreadPrimitive.Messages, { children: ({ message }) => /* @__PURE__ */ jsx9(AnimatedMessageShell, { children: /* @__PURE__ */ jsx9(ThreadMessage, { isEditing: message.role === "user" && message.composer.isEditing }) }) }),
+          /* @__PURE__ */ jsx9(ResumeUnavailableContainer, {})
+        ] })
+      ] })
+    ] }) }),
+    !isLoading && !isEmpty && /* @__PURE__ */ jsxs3(ThreadComposerAreaShell, { isEmpty, children: [
+      /* @__PURE__ */ jsx9(ThreadPrimitive.ScrollToBottom, { asChild: true, children: /* @__PURE__ */ jsx9(ScrollToBottomButton, {}) }),
+      composer
+    ] })
+  ] }) }) }) });
+}
+
+// src/containers/Thread.tsx
+import { jsx as jsx10 } from "react/jsx-runtime";
+function Thread() {
+  return /* @__PURE__ */ jsx10(ThreadContainer, { composer: /* @__PURE__ */ jsx10(ComposerContainer, {}) });
+}
+
+export {
+  useApprovalNav,
+  ApprovalNavContainer,
+  AskUserContainer,
+  threadHasPendingMcpAuth,
+  useComposerPauseView,
+  CustomActionContainer,
+  McpAuthContainer,
+  ComposerContainer,
+  HistoryLoaderContainer,
+  ResumeUnavailableContainer,
+  UserEditComposerContainer,
+  ThreadContainer,
+  Thread
+};
+//# sourceMappingURL=chunk-JKEBMGLH.js.map