The Open Standard for Generative UI
import type { AssistantMessage, Message } from "@openuidev/react-headless";
import {
MessageProvider,
useActiveDetailedView,
useArtifactList,
useArtifactRendererRegistry,
useThread,
useToolActivities,
} from "@openuidev/react-headless";
import clsx from "clsx";
import React, { memo, useId, useLayoutEffect, useMemo, useRef } from "react";
import { useLayoutContext } from "../../context/LayoutContext";
import { ScrollVariant, useScrollToBottom } from "../../hooks/useScrollToBottom";
import {
getLastAssistantMessageId,
getMatchedRendererActivities,
hasLangSyntax,
readMessage,
} from "../../utils/messages";
import { ToolCallTimeline, type TimelineStep } from "../ToolCall";
import { TimelineWorkingIndicator } from "../ToolCall/ToolCallTimeline";
import {
DetailedViewOverlay,
DetailedViewPanel,
DetailedViewPortalTarget,
} from "./_shared/detailed-view";
import { useAgentInterfaceLabels } from "./_shared/labelsContext";
import { useAgentInterfaceStore } from "./_shared/store";
import { TimelineEntry } from "./_shared/tool-renderer";
import type {
AssistantMessageComponent,
ToolCallTimelineComponent,
UserMessageComponent,
} from "./_shared/types";
import { Callout } from "../Callout";
import { IconButton } from "../IconButton";
import { MarkDownRenderer } from "../MarkDownRenderer";
import { AgentInterfaceTooltip } from "./_shared/AgentInterfaceTooltip";
import { GalleryHorizontalEndIcon } from "./_shared/GalleryHorizontalEndIcon";
import { AmbientLoader } from "./components/AmbientLoader";
import { ScrollToLatest } from "./components/ScrollToLatest";
import { ResizableSeparator } from "./ResizableSeparator";
import { useDetailedViewResize } from "./useDetailedViewResize";
import { UserMessageContent } from "./UserMessageContent";
export const ThreadContainer = ({
children,
className,
}: {
children?: React.ReactNode;
className?: string;
}) => {
const { layout } = useLayoutContext();
const isMobile = layout === "mobile";
const { isDetailedViewActive } = useActiveDetailedView();
const { setIsSidebarOpen } = useAgentInterfaceStore((state) => ({
setIsSidebarOpen: state.setIsSidebarOpen,
}));
const isLoadingMessages = useThread((s) => s.isLoadingMessages);
const {
containerRef,
chatPanelRef,
detailedViewPanelRef,
isDragging,
handleResize,
handleResizeStep,
handleDragStart,
handleDragEnd,
getResizeAria,
} = useDetailedViewResize({
isDetailedViewActive,
isMobile,
setIsSidebarOpen,
});
const chatPanelId = useId();
const detailPanelId = useId();
return (
<div
className={clsx("openui-agent-thread-container", className, {
"openui-agent-thread-container--detailed-view-active": isDetailedViewActive,
})}
>
{/* Loading state while a thread's messages load. Only the content below
hides (via `visibility`, which keeps layout + scroll state), so the
card itself stays on screen around the spinner. */}
{isLoadingMessages && (
<AmbientLoader
className="openui-agent-thread-container__loading"
label="Loading conversation…"
/>
)}
<div
className="openui-agent-thread-wrapper"
ref={containerRef}
style={{ visibility: isLoadingMessages ? "hidden" : undefined }}
>
{/* Chat panel - always visible */}
<div
ref={chatPanelRef}
id={chatPanelId}
className={clsx("openui-agent-thread-chat-panel", {
"openui-agent-thread-chat-panel--animating": !isDragging,
})}
>
{children}
{isMobile && <DetailedViewOverlay />}
</div>
{/* Desktop only: Resizable separator and detailed-view panel */}
{!isMobile && isDetailedViewActive && (
<>
<ResizableSeparator
onResize={handleResize}
onResizeStep={handleResizeStep}
onDragStart={handleDragStart}
onDragEnd={handleDragEnd}
getAriaValues={getResizeAria}
controlsId={`${chatPanelId} ${detailPanelId}`}
ariaLabel="Resize chat panel"
/>
<div
ref={detailedViewPanelRef}
id={detailPanelId}
className={clsx("openui-agent-thread-detailed-view-panel", {
"openui-agent-thread-detailed-view-panel--animating": !isDragging,
})}
>
<DetailedViewPortalTarget />
</div>
</>
)}
</div>
</div>
);
};
export const ScrollArea = ({
children,
className,
scrollVariant = "user-message-anchor",
userMessageSelector = ".openui-agent-thread-message-user, .openui-shell-thread-message-user",
scrollOnLoad = true,
}: {
children?: React.ReactNode;
className?: string;
/**
* Scroll to bottom once the last message is added
*/
scrollVariant?: ScrollVariant;
/**
* Selector for the user message
*/
userMessageSelector?: string;
/**
* When false, do not auto-scroll on initial load / conversation switch
* (auto-scroll then only happens while a response is generating).
*/
scrollOnLoad?: boolean;
}) => {
const ref = useRef<HTMLDivElement>(null);
const messages = useThread((s) => s.messages);
const isRunning = useThread((s) => s.isRunning);
const isLoadingMessages = useThread((s) => s.isLoadingMessages);
useScrollToBottom({
ref,
lastMessage: messages[messages.length - 1] || { id: "" },
scrollVariant,
userMessageSelector,
isRunning,
isLoadingMessages,
scrollOnLoad,
});
return (
<div className="openui-agent-thread-scroll-container">
<div
ref={ref}
className={clsx(
"openui-agent-thread-scroll-area",
{
"openui-agent-thread-scroll-area--user-message-anchor":
scrollVariant === "user-message-anchor",
},
className,
)}
>
{children}
</div>
<ScrollToLatest scrollRef={ref} />
</div>
);
};
export const AssistantMessageContainer = ({
children,
className,
}: {
children?: React.ReactNode;
className?: string;
}) => {
return (
<div className={clsx("openui-agent-thread-message-assistant", className)}>
<div className="openui-agent-thread-message-assistant__content">{children}</div>
</div>
);
};
export const UserMessageContainer = ({
children,
className,
}: {
children?: React.ReactNode;
className?: string;
}) => {
return (
<div className={clsx("openui-agent-thread-message-user", className)}>
<div className="openui-agent-thread-message-user__content">{children}</div>
</div>
);
};
const AssistantMessageContent = ({
message,
allMessages,
isLast,
}: {
message: AssistantMessage;
allMessages: Message[];
isLast: boolean;
}) => {
// One id-keyed pairing of calls↔results with real status — no positional break,
// no grouped-not-paired flow, running state from the data.
const activities = useToolActivities(message, allMessages);
return (
<>
{message.content && (
<MarkDownRenderer
textMarkdown={message.content}
className="openui-agent-thread-message-assistant__text"
/>
)}
{activities.map((activity, idx) => (
<TimelineEntry
key={activity.id}
activity={activity}
isLast={isLast && idx === activities.length - 1}
detailedViewPanel={DetailedViewPanel}
/>
))}
</>
);
};
export const RenderMessage = memo(
({
message,
className,
allMessages,
assistantMessage: CustomAssistantMessage,
userMessage: CustomUserMessage,
isStreaming,
isLast,
}: {
message: Message;
className?: string;
allMessages: Message[];
assistantMessage?: AssistantMessageComponent;
userMessage?: UserMessageComponent;
isStreaming: boolean;
/** Whether this is the last *assistant* message (drives the running shimmer). */
isLast: boolean;
}) => {
if (message.role === "tool") {
// Tool messages are rendered inline with their parent assistant message
return null;
}
if (message.role === "assistant") {
if (CustomAssistantMessage) {
return <CustomAssistantMessage message={message} isStreaming={isStreaming} />;
}
return (
<AssistantMessageContainer className={className}>
<AssistantMessageContent message={message} allMessages={allMessages} isLast={isLast} />
</AssistantMessageContainer>
);
}
if (message.role === "user") {
if (CustomUserMessage) {
return <CustomUserMessage message={message} />;
}
return (
<UserMessageContainer className={className}>
<UserMessageContent message={message} />
</UserMessageContainer>
);
}
// Other roles (system, developer, reasoning, activity) — skip by default
return null;
},
);
export const MessageLoading = () => {
return (
<div className="openui-agent-thread-message-loading">
<TimelineWorkingIndicator />
</div>
);
};
export const ThreadError = () => {
const threadError = useThread((s) => s.threadError);
if (!threadError) return null;
return (
<div className="openui-agent-thread-error">
<Callout
variant="danger"
title="Something went wrong"
description={threadError.message || "An unexpected error occurred. Please try again."}
/>
</div>
);
};
/**
* Groups a message list into turns: a run of consecutive assistant/tool
* messages becomes ONE group; every other message (user, system, …) stands alone.
* `startIndex` is the group's position in the original list.
*/
function groupIntoTurns(messages: Message[]): { messages: Message[]; startIndex: number }[] {
const groups: { messages: Message[]; startIndex: number }[] = [];
let current: { messages: Message[]; startIndex: number } | null = null;
messages.forEach((message, i) => {
if (message.role === "assistant" || message.role === "tool") {
if (!current) {
current = { messages: [], startIndex: i };
groups.push(current);
}
current.messages.push(message);
} else {
current = null;
groups.push({ messages: [message], startIndex: i });
}
});
return groups;
}
/**
* A whole turn as one unit. Owned here rather than per-message
* so the tray is a single element keyed by the turn's first segment ({@link Messages})
*/
const InterleavedTurn = ({
segments,
allMessages,
assistantMessage: CustomAssistantMessage,
toolCallTimeline: CustomToolCallTimeline,
className,
isRunning,
lastAssistantId,
}: {
segments: AssistantMessage[];
allMessages: Message[];
assistantMessage?: AssistantMessageComponent;
toolCallTimeline?: ToolCallTimelineComponent;
className?: string;
isRunning: boolean;
lastAssistantId: string | null;
}) => {
// Ignore trailing empty assistants (e.g. TEXT_MESSAGE_START after parallel
// tools with no content yet / never). Those would become `last` and blank the
// answer slot until a chat remount rebuilds from storage.
const activeSegments = useMemo(() => {
const withBody = segments.filter(
(s) => (s.content?.length ?? 0) > 0 || (s.toolCalls?.length ?? 0) > 0,
);
return withBody.length > 0 ? withBody : segments;
}, [segments]);
const last = activeSegments[activeSegments.length - 1]!;
const turnLive = isRunning && lastAssistantId === last.id;
// One id-keyed pairing across every segment's tool calls (synthetic message).
const turnMessage = useMemo(
() => ({ ...activeSegments[0]!, toolCalls: activeSegments.flatMap((s) => s.toolCalls ?? []) }),
[activeSegments],
);
const turnActivities = useToolActivities(turnMessage, allMessages);
const lastContent = readMessage(last.content ?? "", turnLive).content;
// Show the last segment as the answer once it looks like Lang, or once the run
// settles.
const answer = !turnLive || hasLangSyntax(lastContent) ? last : null;
const answerMessage = useMemo(() => (answer ? { ...answer, toolCalls: [] } : null), [answer]);
// Rows in run order: each non-answer segment's thinking prose, then its tools.
const steps = useMemo<TimelineStep[]>(() => {
const byCallId = new Map(turnActivities.map((a) => [a.toolCall.id, a]));
const rows: TimelineStep[] = [];
const claimed = new Set<string>();
for (const seg of activeSegments) {
if (seg.id !== answer?.id) {
const prose = readMessage(seg.content ?? "", turnLive && seg === last).content;
if (prose) rows.push({ type: "text", id: seg.id, text: prose });
}
for (const tc of seg.toolCalls ?? []) {
const activity = byCallId.get(tc.id);
if (activity) {
rows.push({ type: "activity", activity });
claimed.add(tc.id);
}
}
}
// Provider-executed tools (OpenUI Cloud reports, search, MCP) arrive as tool
// results whose call sits on no assistant message, so `pairToolActivity`
// synthesizes them as orphans. No segment claims those, and dropping them
// both hid the activity and could leave `rows` empty while `turnActivities`
// was not — which crashed the timeline. Append them in arrival order.
for (const activity of turnActivities) {
if (!claimed.has(activity.toolCall.id)) rows.push({ type: "activity", activity });
}
return rows;
}, [activeSegments, turnActivities, answer?.id, turnLive, last]);
// Matched renderers (artifact/search previews) render OUTSIDE the tray so
// they stay visible after it collapses.
const registry = useArtifactRendererRegistry();
const matched = getMatchedRendererActivities(registry, turnActivities);
// Hold the tray open until the answer's first tokens arrive. `answer` is
// `last` or null, so reuse the already-parsed `lastContent`.
const answerStarted = !!answer && lastContent.length > 0;
return (
<>
{turnActivities.length > 0 &&
(CustomToolCallTimeline ? (
<CustomToolCallTimeline
activities={turnActivities}
steps={steps}
isLast={turnLive}
awaitingResponse={turnLive && !answerStarted}
/>
) : (
<ToolCallTimeline
activities={turnActivities}
steps={steps}
isLast={turnLive}
forceDefault
awaitingResponse={turnLive && !answerStarted}
/>
))}
{matched.map((activity) => (
<TimelineEntry
key={activity.id}
activity={activity}
isLast={turnLive}
fallbackToDefault={false}
/>
))}
{answer && answerMessage && (
<MessageProvider key={answer.id} message={answerMessage}>
{CustomAssistantMessage ? (
<CustomAssistantMessage
message={answerMessage}
isStreaming={isRunning && lastAssistantId === answer.id}
/>
) : (
<AssistantMessageContainer className={className}>
<AssistantMessageContent
message={answerMessage}
allMessages={allMessages}
isLast={isRunning && lastAssistantId === answer.id}
/>
</AssistantMessageContainer>
)}
</MessageProvider>
)}
</>
);
};
/** Renders one turn (a group from {@link groupIntoTurns}). */
const RenderGroup = ({
group,
allMessages,
assistantMessage: CustomAssistantMessage,
toolCallTimeline,
userMessage,
className,
isRunning,
lastAssistantId,
}: {
group: Message[];
allMessages: Message[];
assistantMessage?: AssistantMessageComponent;
toolCallTimeline?: ToolCallTimelineComponent;
userMessage?: UserMessageComponent;
className?: string;
isRunning: boolean;
lastAssistantId: string | null;
}) => {
// A group is either a run of assistant/tool messages or one standalone
// non-assistant message (user/system/…). The former is always one interleaved
// turn, which owns the tool-call timeline (it reads `last` for the answer, so
// a length-one assistant group works too); the latter renders on its own.
const assistants = group.filter((m): m is AssistantMessage => m.role === "assistant");
const message = group[0]!;
return assistants.length > 0 ? (
<InterleavedTurn
segments={assistants}
allMessages={allMessages}
assistantMessage={CustomAssistantMessage}
toolCallTimeline={toolCallTimeline}
className={className}
isRunning={isRunning}
lastAssistantId={lastAssistantId}
/>
) : (
<MessageProvider key={message.id} message={message}>
<RenderMessage
message={message}
allMessages={allMessages}
assistantMessage={CustomAssistantMessage}
userMessage={userMessage}
isStreaming={isRunning && message.id === lastAssistantId}
isLast={message.id === lastAssistantId}
className={className}
/>
</MessageProvider>
);
};
/**
* Lifts a freshly sent user message up from the composer into its place in the
* thread. Runs on the bubble's DOM node (no wrapper), so custom `UserMessage`
* renderers animate too and the scroll anchor's sibling checks stay intact.
* History loads and thread switches never animate; reduced motion skips it.
*/
const USER_MESSAGE_SELECTOR =
".openui-agent-thread-message-user, .openui-shell-thread-message-user";
const SEND_ANIMATION_MAX_OFFSET = 48;
function useUserMessageSendAnimation(
containerRef: React.RefObject<HTMLDivElement | null>,
messages: Message[],
isRunning: boolean,
) {
const lastMessage = messages[messages.length - 1];
const sentId = isRunning && lastMessage?.role === "user" ? lastMessage.id : null;
const animatedId = useRef<string | null>(null);
useLayoutEffect(() => {
if (!sentId || animatedId.current === sentId) return;
animatedId.current = sentId;
const container = containerRef.current;
const bubble = Array.from(
container?.querySelectorAll<HTMLElement>(USER_MESSAGE_SELECTOR) ?? [],
).pop();
const composer = container
?.closest(".openui-agent-thread-chat-panel")
?.querySelector<HTMLElement>(".openui-agent-thread-composer__input-wrapper");
if (!bubble || !composer || typeof bubble.animate !== "function") return;
if (window.matchMedia("(prefers-reduced-motion: reduce)").matches) return;
// Hide now, start two frames later: the scroll anchor measures the bubble's
// resting position in a passive effect, and a transform would skew it.
bubble.style.opacity = "0";
let frame = requestAnimationFrame(() => {
frame = requestAnimationFrame(() => {
bubble.style.opacity = "";
// Rise toward the composer, but only a short hop so it reads as a lift.
const distance = composer.getBoundingClientRect().top - bubble.getBoundingClientRect().top;
const offset = Math.min(Math.max(distance, 0), SEND_ANIMATION_MAX_OFFSET);
bubble.animate(
[
{ transform: `translateY(${offset}px) scale(0.96)`, opacity: 0 },
{ opacity: 1, offset: 0.3 },
{ transform: "none", opacity: 1 },
],
{ duration: 360, easing: "cubic-bezier(0.22, 1, 0.36, 1)" },
);
});
});
return () => {
cancelAnimationFrame(frame);
bubble.style.opacity = "";
};
}, [sentId, containerRef]);
}
/**
* Flags user bubbles whose text wraps (`data-multiline`) so they can take
* roomier vertical padding while a single line stays a compact pill. Works on
* the DOM so the default and GenUI user renderers are both covered.
*/
const USER_BUBBLE_CONTENT_SELECTOR =
".openui-agent-thread-message-user__content, .openui-shell-thread-message-user__content";
function useMultilineUserBubbles(
containerRef: React.RefObject<HTMLDivElement | null>,
messages: Message[],
) {
useLayoutEffect(() => {
const container = containerRef.current;
if (!container || typeof ResizeObserver === "undefined") return;
const update = (bubble: HTMLElement) => {
const style = getComputedStyle(bubble);
const lineHeight = Number.parseFloat(style.lineHeight) || 0;
const textHeight =
bubble.clientHeight -
Number.parseFloat(style.paddingTop) -
Number.parseFloat(style.paddingBottom);
bubble.toggleAttribute("data-multiline", lineHeight > 0 && textHeight > lineHeight * 1.5);
};
const observer = new ResizeObserver((entries) => {
entries.forEach((entry) => update(entry.target as HTMLElement));
});
container.querySelectorAll<HTMLElement>(USER_BUBBLE_CONTENT_SELECTOR).forEach((bubble) => {
update(bubble);
observer.observe(bubble);
});
return () => observer.disconnect();
}, [containerRef, messages]);
}
export const Messages = ({
className,
loader,
assistantMessage,
userMessage,
toolCallTimeline,
}: {
className?: string;
loader?: React.ReactNode;
assistantMessage?: AssistantMessageComponent;
userMessage?: UserMessageComponent;
toolCallTimeline?: ToolCallTimelineComponent;
}) => {
const messages = useThread((s) => s.messages);
const isRunning = useThread((s) => s.isRunning);
const threadError = useThread((s) => s.threadError);
// Group the flat message list into turns ONCE per change; the arrays keep
// their identity across unrelated re-renders.
const groups = useMemo(() => groupIntoTurns(messages), [messages]);
// Id of the last *assistant* message (not the last message) so the running
// shimmer survives trailing tool messages.
const lastAssistantId = useMemo(() => getLastAssistantMessageId(messages), [messages]);
const messagesRef = useRef<HTMLDivElement>(null);
useUserMessageSendAnimation(messagesRef, messages, isRunning);
useMultilineUserBubbles(messagesRef, messages);
return (
<div ref={messagesRef} className={clsx("openui-agent-thread-messages", className)}>
{groups.map((group) => (
<RenderGroup
key={group.messages[0]!.id}
group={group.messages}
allMessages={messages}
assistantMessage={assistantMessage}
userMessage={userMessage}
toolCallTimeline={toolCallTimeline}
className={className}
isRunning={isRunning}
lastAssistantId={lastAssistantId}
/>
))}
{isRunning && <div>{loader}</div>}
{!isRunning && threadError && <ThreadError />}
</div>
);
};
export const WorkspaceToggleButton = () => {
const artifacts = useArtifactList();
const { isDetailedViewActive } = useActiveDetailedView();
const { workspaceToggle } = useAgentInterfaceLabels();
const { isWorkspaceOpen, setIsWorkspaceOpen } = useAgentInterfaceStore((state) => ({
isWorkspaceOpen: state.isWorkspaceOpen,
setIsWorkspaceOpen: state.setIsWorkspaceOpen,
}));
const hasArtifacts = Object.keys(artifacts).length > 0;
if (!hasArtifacts || isDetailedViewActive) return null;
return (
<AgentInterfaceTooltip content={workspaceToggle} side="left">
<IconButton
icon={<GalleryHorizontalEndIcon size="1em" />}
onClick={() => {
if (hasArtifacts) setIsWorkspaceOpen(!isWorkspaceOpen);
}}
size="small"
variant="tertiary"
aria-label={isWorkspaceOpen ? "Collapse workspace" : "Expand workspace"}
className="openui-agent-thread-header__workspace-toggle-button"
/>
</AgentInterfaceTooltip>
);
};
// Re-export Composer from components
export { Composer } from "./components";