/** * ChatMessageList - Renders the list of chat messages * * Claude-Code-style: user messages in bordered bubbles (right-aligned), * assistant responses as plain text (left-aligned, no border/bg). * No avatars. Thinking blocks are collapsible. */ import { AlertCircle, FileText, RotateCcw, X, ZoomIn, ZoomOut } from 'lucide-react'; import React, { useCallback, useEffect, useRef, useState } from 'react'; import { useI18n } from '../../application/i18n/I18nProvider'; import type { ChatMessage } from '../../infrastructure/ai/types'; import { Dialog, DialogContent, DialogTitle } from '../ui/dialog'; import { Conversation, ConversationContent, ConversationScrollButton, } from '../ai-elements/conversation'; import { Message, MessageContent, MessageResponse } from '../ai-elements/message'; import { ToolCall } from '../ai-elements/tool-call'; import ThinkingBlock from './ThinkingBlock'; import { onApprovalRequest, onApprovalCleared, replayPendingApprovals, resolveApproval, type ApprovalRequest, } from '../../infrastructure/ai/shared/approvalGate'; interface ChatMessageListProps { messages: ChatMessage[]; isStreaming?: boolean; /** Active chat session ID — used to filter standalone MCP approval blocks */ activeSessionId?: string | null; } const ChatMessageList: React.FC = ({ messages, isStreaming, activeSessionId }) => { // Track pending approvals from the approval gate const [pendingApprovals, setPendingApprovals] = useState>(new Map()); const [resolvedApprovals, setResolvedApprovals] = useState>(new Map()); // Subscribe to approval gate events (SDK + MCP tool calls) useEffect(() => { const handler = (request: ApprovalRequest) => { setPendingApprovals(prev => new Map(prev).set(request.toolCallId, request)); }; const unsub = onApprovalRequest(handler); // Replay any approvals that fired while this component was unmounted replayPendingApprovals(handler); return unsub; }, []); // Subscribe to approval cleared/removed events (fired on session stop or timeout) useEffect(() => { return onApprovalCleared((clearedIds) => { setPendingApprovals(prev => { const m = new Map(prev); for (const id of clearedIds) m.delete(id); return m; }); }); }, []); const handleApprove = useCallback((toolCallId: string) => { resolveApproval(toolCallId, true); setPendingApprovals(prev => { const m = new Map(prev); m.delete(toolCallId); return m; }); setResolvedApprovals(prev => new Map(prev).set(toolCallId, true)); }, []); const handleReject = useCallback((toolCallId: string) => { resolveApproval(toolCallId, false); setPendingApprovals(prev => { const m = new Map(prev); m.delete(toolCallId); return m; }); setResolvedApprovals(prev => new Map(prev).set(toolCallId, false)); }, []); const [preview, setPreview] = useState<{ src: string; name: string } | null>(null); const [zoom, setZoom] = useState(100); const [dragged, setDragged] = useState(false); const imgRef = useRef(null); const dragPos = useRef({ x: 0, y: 0 }); const dragStart = useRef<{ startX: number; startY: number; origX: number; origY: number } | null>(null); const applyTransform = useCallback((z: number, x: number, y: number, animate: boolean) => { if (!imgRef.current) return; imgRef.current.style.transition = animate ? 'transform 0.25s ease' : 'none'; imgRef.current.style.transform = `scale(${z / 100}) translate(${x / (z / 100)}px, ${y / (z / 100)}px)`; }, []); const zoomRef = useRef(100); const setZoomAndRef = useCallback((fn: (z: number) => number) => { setZoom(z => { const nz = fn(z); zoomRef.current = nz; return nz; }); }, []); const zoomIn = useCallback(() => setZoomAndRef(z => { const nz = Math.min(z + 25, 200); applyTransform(nz, dragPos.current.x, dragPos.current.y, true); return nz; }), [applyTransform, setZoomAndRef]); const zoomOut = useCallback(() => setZoomAndRef(z => { const nz = Math.max(z - 25, 25); applyTransform(nz, dragPos.current.x, dragPos.current.y, true); return nz; }), [applyTransform, setZoomAndRef]); const onWheel = useCallback((e: React.WheelEvent) => { e.preventDefault(); const delta = e.deltaY > 0 ? -10 : 10; setZoomAndRef(z => { const nz = Math.max(25, Math.min(200, z + delta)); applyTransform(nz, dragPos.current.x, dragPos.current.y, false); return nz; }); }, [applyTransform, setZoomAndRef]); const openPreview = useCallback((src: string, name: string) => { setZoom(100); zoomRef.current = 100; setDragged(false); dragPos.current = { x: 0, y: 0 }; setPreview({ src, name }); }, []); const resetPreview = useCallback(() => { setZoom(100); zoomRef.current = 100; setDragged(false); dragPos.current = { x: 0, y: 0 }; applyTransform(100, 0, 0, true); }, [applyTransform]); const onPointerDown = useCallback((e: React.PointerEvent) => { e.preventDefault(); (e.target as HTMLElement).setPointerCapture(e.pointerId); dragStart.current = { startX: e.clientX, startY: e.clientY, origX: dragPos.current.x, origY: dragPos.current.y }; }, []); const onPointerMove = useCallback((e: React.PointerEvent) => { if (!dragStart.current) return; if ((e.buttons & 1) === 0) { dragStart.current = null; return; } const x = dragStart.current.origX + (e.clientX - dragStart.current.startX); const y = dragStart.current.origY + (e.clientY - dragStart.current.startY); dragPos.current = { x, y }; applyTransform(zoomRef.current, x, y, false); }, [applyTransform]); const endDrag = useCallback(() => { if (dragStart.current && (dragPos.current.x !== 0 || dragPos.current.y !== 0)) { setDragged(true); } dragStart.current = null; }, []); const { t } = useI18n(); const visibleMessages = messages.filter(m => m.role !== 'system'); const resolvedToolCallIds = new Set( visibleMessages .filter((m) => m.role === 'tool') .flatMap((m) => m.toolResults?.map((tr) => tr.toolCallId) ?? []), ); // Build maps from toolCallId → toolName / toolArgs for display const toolCallNames = new Map(); const toolCallArgs = new Map>(); for (const m of visibleMessages) { if (m.role === 'assistant' && m.toolCalls) { for (const tc of m.toolCalls) { toolCallNames.set(tc.id, tc.name); if (tc.arguments) toolCallArgs.set(tc.id, tc.arguments); } } } if (visibleMessages.length === 0 && !isStreaming) { return (

{t('ai.chat.emptyHint')}

); } const lastAssistantMessage = visibleMessages.findLast(m => m.role === 'assistant'); return ( <> {visibleMessages.map((message) => { if (message.role === 'tool') { return ( {message.toolResults?.map((tr) => (
))}
); } const isUser = message.role === 'user'; const isLastAssistant = message === lastAssistantMessage; const isThisStreaming = isStreaming && isLastAssistant; return ( {/* Thinking block */} {!isUser && message.thinking && ( )} {/* User attachments (images, files) — fallback to legacy `images` field */} {isUser && (message.attachments ?? message.images)?.length && (
{(message.attachments ?? message.images)!.map((att, i) => ( att.mediaType.startsWith('image/') ? ( {att.filename openPreview(`data:${att.mediaType};base64,${att.base64Data}`, att.filename || 'image')} /> ) : (
{att.filename || 'file'}
) ))}
)} {message.content && ( isUser ?
{message.content}
: {message.content} )} {/* Pending tool calls from the *last* assistant message are rendered after all tool-result messages (see below) for chronological order. Unresolved tool calls from earlier or cancelled messages are shown inline — as interrupted, or with approval controls if still pending. */} {(message !== lastAssistantMessage || message.executionStatus === 'cancelled') && message.toolCalls?.filter((tc) => !resolvedToolCallIds.has(tc.id), ).map((tc) => { const isPending = pendingApprovals.has(tc.id); const resolved = resolvedApprovals.get(tc.id); const approvalStatus = isPending ? 'pending' as const : resolved === true ? 'approved' as const : resolved === false ? 'denied' as const : undefined; return (
handleApprove(tc.id)} onReject={() => handleReject(tc.id)} />
); })} {/* Status text with shimmer */} {message.statusText && (
{message.statusText}
)} {/* Error info */} {message.errorInfo && (

{message.errorInfo.message}

{message.errorInfo.retryable && (

{t('ai.chat.retryHint')}

)}
)}
); })} {/* Pending tool calls from the last assistant message — rendered here (after all tool-result messages) so they appear at the bottom. */} {lastAssistantMessage?.toolCalls?.filter((tc) => !resolvedToolCallIds.has(tc.id) && lastAssistantMessage.executionStatus !== 'cancelled', ).map((tc) => { const isPending = pendingApprovals.has(tc.id); const resolved = resolvedApprovals.get(tc.id); const approvalStatus = isPending ? 'pending' as const : resolved === true ? 'approved' as const : resolved === false ? 'denied' as const : undefined; return (
handleApprove(tc.id)} onReject={() => handleReject(tc.id)} />
); })} {/* Standalone MCP/ACP approval requests (not tied to SDK tool calls) */} {Array.from(pendingApprovals.entries()) .filter(([id, req]) => id.startsWith('mcp_approval_') && (!activeSessionId || req.chatSessionId === activeSessionId)) .map(([id, req]) => { return (
handleApprove(id)} onReject={() => handleReject(id)} />
); })} {/* Streaming indicator — only when no content and no thinking yet */} {isStreaming && !lastAssistantMessage?.content && !lastAssistantMessage?.thinking && (
)}
{/* Image preview lightbox */} { if (!open) setPreview(null); }}> {/* Title bar: filename | zoom controls | close — all in one flex row */}
{preview?.name}
{zoom}%
{/* Image area with drag support */} {preview && (
{preview.name}
)}
); }; function areMessagesEqual(prev: ChatMessageListProps, next: ChatMessageListProps): boolean { if (prev.isStreaming !== next.isStreaming) return false; if (prev.activeSessionId !== next.activeSessionId) return false; if (prev.messages.length !== next.messages.length) return false; if (prev.messages === next.messages) return true; // Shallow-compare each message by reference for (let i = 0; i < prev.messages.length; i++) { if (prev.messages[i] !== next.messages[i]) { // For the last message during streaming, compare by content to avoid // re-renders when only the array reference changed but content is the same const p = prev.messages[i]; const n = next.messages[i]; if ( p.id !== n.id || p.content !== n.content || p.thinking !== n.thinking || p.role !== n.role || p.statusText !== n.statusText || p.executionStatus !== n.executionStatus || p.errorInfo !== n.errorInfo || p.toolCalls !== n.toolCalls || p.toolResults !== n.toolResults ) { return false; } } } return true; } export default React.memo(ChatMessageList, areMessagesEqual);