Open History to see the last commit
1import { For, Show } from 'solid-js'
2import { ThinkingPart } from './thinking-part'
3import type { JSX } from 'solid-js'
4import type { UIMessage } from '@tanstack/ai-solid'
5
6export interface ToolCallRenderProps {
7 id: string
8 name: string
9 arguments: string
10 state: string
11 approval?: any
12 output?: any
13}
14
15export interface ChatMessageProps {
16 /** The message to render */
17 message: UIMessage
18 /** Base CSS class name */
19 class?: string
20 /** Additional class for user messages */
21 userClass?: string
22 /** Additional class for assistant messages */
23 assistantClass?: string
24 /** Custom renderer for text parts */
25 textPartRenderer?: (props: { content: string }) => JSX.Element
26 /** Custom renderer for thinking parts */
27 thinkingPartRenderer?: (props: {
28 content: string
29 isComplete?: boolean
30 }) => JSX.Element
31 /** Named tool renderers - use the tool name as the key */
32 toolsRenderer?: Record<string, (props: ToolCallRenderProps) => JSX.Element>
33 /** Default tool renderer when tool name not found in toolsRenderer */
34 defaultToolRenderer?: (props: ToolCallRenderProps) => JSX.Element
35 /** Custom renderer for tool result parts */
36 toolResultRenderer?: (props: {
37 toolCallId: string
38 content: string
39 state: string
40 }) => JSX.Element
41}
42
43/**
44 * Message component - renders a single message with all its parts
45 *
46 * This component natively understands TanStack AI's parts-based message format:
47 * - thinking parts: rendered as collapsible thinking/reasoning sections (auto-collapses when complete)
48 * - text parts: rendered as content
49 * - tool-call parts: rendered with state, approvals, etc.
50 * - tool-result parts: rendered with results
51 *
52 * @example Basic usage
53 * ```tsx
54 * <Chat.Message message={message} />
55 * ```
56 *
57 * @example With role-based styling
58 * ```tsx
59 * <ChatMessage
60 * message={message}
61 * class="flex"
62 * userClass="justify-end"
63 * assistantClass="justify-start"
64 * />
65 * ```
66 *
67 * @example With custom thinking renderer
68 * ```tsx
69 * <ChatMessage
70 * message={message}
71 * thinkingPartRenderer={({ content, isComplete }) => (
72 * <details open={!isComplete}>
73 * <summary>Thinking...</summary>
74 * <pre>{content}</pre>
75 * </details>
76 * )}
77 * />
78 * ```
79 *
80 * @example With named tool renderers
81 * ```tsx
82 * <ChatMessage
83 * message={message}
84 * toolsRenderer={{
85 * recommendGuitar: ({ id, arguments: args }) => <GuitarCard {...JSON.parse(args)} />,
86 * weatherLookup: ({ id, arguments: args }) => <WeatherWidget {...JSON.parse(args)} />,
87 * }}
88 * defaultToolRenderer={() => null}
89 * />
90 * ```
91 */
92export function ChatMessage(props: ChatMessageProps) {
93 // Combine classes based on role
94 const roleClass = () =>
95 props.message.role === 'user'
96 ? (props.userClass ?? '')
97 : (props.assistantClass ?? '')
98
99 const combinedClass = () =>
100 [props.class ?? '', roleClass()].filter(Boolean).join(' ')
101
102 return (
103 <div
104 class={combinedClass() || undefined}
105 data-message-id={props.message.id}
106 data-message-role={props.message.role}
107 data-message-created={props.message.createdAt?.toISOString()}
108 >
109 <For each={props.message.parts}>
110 {(part, index) => {
111 // Check if thinking is complete (if there's a text part after this thinking part)
112 const isThinkingComplete = () =>
113 part.type === 'thinking' &&
114 props.message.parts
115 .slice(index() + 1)
116 .some((p) => p.type === 'text')
117
118 return (
119 <MessagePart
120 part={part}
121 isThinkingComplete={isThinkingComplete()}
122 textPartRenderer={props.textPartRenderer}
123 thinkingPartRenderer={props.thinkingPartRenderer}
124 toolsRenderer={props.toolsRenderer}
125 defaultToolRenderer={props.defaultToolRenderer}
126 toolResultRenderer={props.toolResultRenderer}
127 />
128 )
129 }}
130 </For>
131 </div>
132 )
133}
134
135function MessagePart(props: {
136 part: any
137 isThinkingComplete?: boolean
138 textPartRenderer?: ChatMessageProps['textPartRenderer']
139 thinkingPartRenderer?: ChatMessageProps['thinkingPartRenderer']
140 toolsRenderer?: ChatMessageProps['toolsRenderer']
141 defaultToolRenderer?: ChatMessageProps['defaultToolRenderer']
142 toolResultRenderer?: ChatMessageProps['toolResultRenderer']
143}) {
144 // Text part
145 if (props.part.type === 'text') {
146 if (props.textPartRenderer) {
147 return <>{props.textPartRenderer({ content: props.part.content })}</>
148 }
149 return (
150 <div data-part-type="text" data-part-content>
151 {props.part.content}
152 </div>
153 )
154 }
155
156 // Thinking part
157 if (props.part.type === 'thinking') {
158 if (props.thinkingPartRenderer) {
159 return (
160 <>
161 {props.thinkingPartRenderer({
162 content: props.part.content,
163 isComplete: props.isThinkingComplete,
164 })}
165 </>
166 )
167 }
168 return (
169 <ThinkingPart
170 content={props.part.content}
171 isComplete={props.isThinkingComplete}
172 />
173 )
174 }
175
176 // Tool call part
177 if (props.part.type === 'tool-call') {
178 const toolProps: ToolCallRenderProps = {
179 id: props.part.id,
180 name: props.part.name,
181 arguments: props.part.arguments,
182 state: props.part.state,
183 approval: props.part.approval,
184 output: props.part.output,
185 }
186
187 // Check if there's a specific renderer for this tool
188 if (props.toolsRenderer?.[props.part.name]) {
189 return <>{props.toolsRenderer[props.part.name]?.(toolProps)}</>
190 }
191
192 // Use default tool renderer if provided
193 if (props.defaultToolRenderer) {
194 return <>{props.defaultToolRenderer(toolProps)}</>
195 }
196
197 // Fallback to built-in default renderer
198 return (
199 <div
200 data-part-type="tool-call"
201 data-tool-name={props.part.name}
202 data-tool-state={props.part.state}
203 data-tool-id={props.part.id}
204 >
205 <div data-tool-header>
206 <strong>{props.part.name}</strong>
207 <span data-tool-state-badge>{props.part.state}</span>
208 </div>
209 <Show when={props.part.arguments}>
210 <div data-tool-arguments>
211 <pre>{props.part.arguments}</pre>
212 </div>
213 </Show>
214 <Show when={props.part.approval}>
215 <div data-tool-approval>
216 {props.part.approval.approved !== undefined
217 ? props.part.approval.approved
218 ? '✓ Approved'
219 : '✗ Denied'
220 : '⏳ Awaiting approval...'}
221 </div>
222 </Show>
223 <Show when={props.part.output}>
224 <div data-tool-output>
225 <pre>{JSON.stringify(props.part.output, null, 2)}</pre>
226 </div>
227 </Show>
228 </div>
229 )
230 }
231
232 // Tool result part
233 if (props.part.type === 'tool-result') {
234 if (props.toolResultRenderer) {
235 return (
236 <>
237 {props.toolResultRenderer({
238 toolCallId: props.part.toolCallId,
239 content: props.part.content,
240 state: props.part.state,
241 })}
242 </>
243 )
244 }
245
246 return (
247 <div
248 data-part-type="tool-result"
249 data-tool-call-id={props.part.toolCallId}
250 data-tool-result-state={props.part.state}
251 >
252 <div data-tool-result-content>{props.part.content}</div>
253 </div>
254 )
255 }
256
257 return null
258}