Skip to content

An AI-powered search engine with a generative UI

feat: implement Research Process UI with grouped sections

Yoshiki Miurafb81abd24f6f
diff --git a/components/collapsible-message.tsx b/components/collapsible-message.tsx
index 8fdb7662..9c4fa322 100644
--- a/components/collapsible-message.tsx
+++ b/components/collapsible-message.tsx
@@ -64,7 +64,8 @@ export function CollapsibleMessage({
<div
className={cn(
'flex-1 overflow-hidden',
- variant === 'default' && 'rounded-lg border bg-card',
+ variant === 'default' && showBorder && 'rounded-lg border bg-card',
+ variant === 'default' && !showBorder && 'rounded-lg bg-card',
variant === 'process' && 'rounded-lg border bg-card',
variant === 'process-sub' && 'rounded-md border bg-card/50'
)}
diff --git a/components/fetch-section.tsx b/components/fetch-section.tsx
index 701b583e..d4fc2a2a 100644
--- a/components/fetch-section.tsx
+++ b/components/fetch-section.tsx
@@ -52,6 +52,7 @@ export function FetchSection({ tool }: FetchSectionProps) {
contentLength={contentLength}
status={displayStatus}
error={error}
+ borderless={borderless}
/>
</div>
)
diff --git a/components/process-rail.tsx b/components/process-rail.tsx
new file mode 100644
index 00000000..ecbed42c
--- /dev/null
+++ b/components/process-rail.tsx
@@ -0,0 +1,40 @@
+import { cn } from '@/lib/utils'
+
+interface ProcessRailProps {
+ isFirst: boolean
+ isLast: boolean
+ isSubStep?: boolean
+}
+
+export function ProcessRail({
+ isFirst,
+ isLast,
+ isSubStep = false
+}: ProcessRailProps) {
+ return (
+ <div className="relative flex flex-col items-center w-5 h-full">
+ {/* Connector line above */}
+ {!isFirst && (
+ <div className="absolute w-px bg-border/50 -top-full h-full" />
+ )}
+
+ {/* Dot positioned at header center - aligned with "Thoughts" text */}
+ <div
+ className={cn(
+ 'absolute rounded-full z-10',
+ isSubStep
+ ? 'h-1.5 w-1.5 bg-muted-foreground/50'
+ : 'h-2 w-2 bg-muted-foreground'
+ )}
+ style={{ top: '0.5rem' }} // Align with header text baseline
+ />
+
+ {/* Connector line below */}
+ {!isLast && (
+ <div className="absolute w-px bg-border/50"
+ style={{ top: '1.125rem', bottom: '-100%', height: 'calc(100% + 100%)' }}
+ />
+ )}
+ </div>
+ )
+}
\ No newline at end of file
diff --git a/components/reasoning-section.tsx b/components/reasoning-section.tsx
index 314022ab..c95197b2 100644
--- a/components/reasoning-section.tsx
+++ b/components/reasoning-section.tsx
@@ -20,12 +20,18 @@ export interface ReasoningSectionProps {
content: ReasoningContent
isOpen: boolean
onOpenChange: (open: boolean) => void
+ showIcon?: boolean
+ variant?: 'default' | 'minimal' | 'process' | 'process-sub'
+ isSingle?: boolean // Whether this is a single item or part of a group
}
export function ReasoningSection({
content,
isOpen,
- onOpenChange
+ onOpenChange,
+ showIcon = false,
+ variant = 'default',
+ isSingle = true
}: ReasoningSectionProps) {
const { open } = useArtifact()
// Show a short preview when collapsed; switch to a generic label when expanded
@@ -70,7 +76,18 @@ export function ReasoningSection({
const reasoningHeader = (
<ProcessHeader
- label={headerLabel}
+ label={
+ !isSingle ? (
+ <div className="flex items-center gap-2 min-w-0 overflow-hidden">
+ <div className="w-4 h-4 shrink-0 flex items-center justify-center">
+ <div className="w-1.5 h-1.5 rounded-full bg-muted-foreground" />
+ </div>
+ <span className="truncate block min-w-0 max-w-full">{headerLabel}</span>
+ </div>
+ ) : (
+ headerLabel
+ )
+ }
onInspect={() =>
open({ type: 'reasoning', text: content.reasoning } as ReasoningPart)
}
@@ -91,9 +108,9 @@ export function ReasoningSection({
header={reasoningHeader}
isOpen={isOpen}
onOpenChange={onOpenChange}
- showBorder={true}
- showIcon={false}
- variant="default"
+ showBorder={isSingle}
+ showIcon={showIcon}
+ variant={variant}
showSeparator={false}
>
<div className="[&_p]:text-xs [&_p]:text-muted-foreground/80">
diff --git a/components/render-message.tsx b/components/render-message.tsx
index 4fe5fb16..46108648 100644
--- a/components/render-message.tsx
+++ b/components/render-message.tsx
@@ -13,6 +13,7 @@ import { AnswerSection } from './answer-section'
import { DataSection } from './data-section'
import { DynamicToolDisplay } from './dynamic-tool-display'
import { ReasoningSection } from './reasoning-section'
+import ResearchProcessSection from './research-process-section'
import { ToolSection } from './tool-section'
import { UserFileSection } from './user-file-section'
import { UserTextSection } from './user-text-section'
@@ -79,95 +80,75 @@ export function RenderMessage({
)
}
- return (
- <>
- {message.parts?.map((part: any, index: number) => {
- // Check if there's a next part in this message
- const hasNextPart = message.parts && index < message.parts.length - 1
+ // New rendering: interleave text parts with grouped non-text segments
+ const elements: React.ReactNode[] = []
+ let buffer: any[] = []
+ const flushBuffer = (keySuffix: string) => {
+ if (buffer.length === 0) return
+ elements.push(
+ <ResearchProcessSection
+ key={`${messageId}-proc-${keySuffix}`}
+ message={message}
+ messageId={messageId}
+ parts={buffer}
+ getIsOpen={getIsOpen}
+ onOpenChange={onOpenChange}
+ onQuerySelect={onQuerySelect}
+ status={status}
+ addToolResult={addToolResult}
+ />
+ )
+ buffer = []
+ }
+
+ message.parts?.forEach((part: any, index: number) => {
+ if (part.type === 'text') {
+ // Flush accumulated non-text first
+ flushBuffer(`seg-${index}`)
- switch (part.type) {
- case 'tool-search':
- case 'tool-fetch':
- case 'tool-askQuestion':
- case 'tool-todoWrite':
- case 'tool-todoRead':
- return (
- <ToolSection
- key={`${messageId}-tool-${index}`}
- tool={part as any}
- isOpen={getIsOpen(part.toolCallId, part.type, hasNextPart)}
- onOpenChange={open => onOpenChange(part.toolCallId, open)}
- addToolResult={addToolResult}
- status={status}
- onQuerySelect={onQuerySelect}
- />
- )
- case 'dynamic-tool':
- return (
- <DynamicToolDisplay
- key={`${messageId}-dynamic-tool-${index}`}
- part={part as DynamicToolPart}
- />
- )
- case 'text':
- // Find if this is the last text part in this message
- const remainingParts = message.parts?.slice(index + 1) || []
- const hasMoreTextParts = remainingParts.some(p => p.type === 'text')
- const isLastTextPart = !hasMoreTextParts
+ const remainingParts = message.parts?.slice(index + 1) || []
+ const hasMoreTextParts = remainingParts.some(p => p.type === 'text')
+ const isLastTextPart = !hasMoreTextParts
+ const isStreamingComplete = status !== 'streaming' && status !== 'submitted'
+ const shouldShowActions = isLastTextPart && (isLatestMessage ? isStreamingComplete : true)
- // Check if streaming is complete
- const isStreamingComplete =
- status !== 'streaming' && status !== 'submitted'
+ elements.push(
+ <AnswerSection
+ key={`${messageId}-text-${index}`}
+ content={part.text}
+ isOpen={getIsOpen(messageId, part.type, index < (message.parts?.length ?? 0) - 1)}
+ onOpenChange={open => onOpenChange(messageId, open)}
+ chatId={chatId}
+ showActions={shouldShowActions}
+ messageId={messageId}
+ metadata={message.metadata as UIMessageMetadata | undefined}
+ reload={reload}
+ status={status}
+ citationMaps={citationMaps}
+ />
+ )
+ } else if (
+ part.type === 'tool-search' ||
+ part.type === 'tool-fetch' ||
+ part.type === 'tool-askQuestion' ||
+ part.type === 'tool-todoWrite' ||
+ part.type === 'tool-todoRead' ||
+ part.type === 'reasoning' ||
+ part.type?.startsWith?.('data-')
+ ) {
+ buffer.push(part)
+ } else if (part.type === 'dynamic-tool') {
+ flushBuffer(`seg-${index}`)
+ elements.push(
+ <DynamicToolDisplay
+ key={`${messageId}-dynamic-tool-${index}`}
+ part={part as DynamicToolPart}
+ />
+ )
+ }
+ })
+ // Flush tail
+ flushBuffer('tail')
- // Show actions only on the last text part of each message
- // For the latest message, also check if streaming is complete
- const shouldShowActions =
- isLastTextPart && (isLatestMessage ? isStreamingComplete : true)
- return (
- <AnswerSection
- key={`${messageId}-text-${index}`}
- content={part.text}
- isOpen={getIsOpen(messageId, part.type, hasNextPart)}
- onOpenChange={open => onOpenChange(messageId, open)}
- chatId={chatId}
- showActions={shouldShowActions}
- messageId={messageId}
- metadata={message.metadata as UIMessageMetadata | undefined}
- reload={reload}
- status={status}
- citationMaps={citationMaps}
- />
- )
- case 'reasoning':
- return (
- <ReasoningSection
- key={`${messageId}-reasoning-${index}`}
- content={{
- reasoning: part.text,
- isDone: index !== (message.parts?.length ?? 0) - 1
- }}
- isOpen={getIsOpen(
- `${messageId}-reasoning-${index}`,
- part.type,
- hasNextPart
- )}
- onOpenChange={open =>
- onOpenChange(`${messageId}-reasoning-${index}`, open)
- }
- />
- )
- case 'data-relatedQuestions':
- return (
- <DataSection
- key={`${messageId}-${part.type}-${index}`}
- part={part}
- onQuerySelect={onQuerySelect}
- />
- )
- default:
- return null
- }
- })}
- </>
- )
+ return <>{elements}</>
}
diff --git a/components/research-process-section.tsx b/components/research-process-section.tsx
index d0be1156..28a68b46 100644
--- a/components/research-process-section.tsx
+++ b/components/research-process-section.tsx
@@ -1,472 +1,179 @@
'use client'
-import { useEffect, useMemo, useState } from 'react'
+import { UseChatHelpers } from '@ai-sdk/react'
import type {
- DataRelatedQuestionsPart,
- ToolPart,
- UIMessage
+ UIDataTypes,
+ UIMessage,
+ UITools
} from '@/lib/types/ai'
-import type { DynamicToolPart } from '@/lib/types/dynamic-tools'
import { cn } from '@/lib/utils'
-import { DataSection } from './data-section'
-import { DynamicToolDisplay } from './dynamic-tool-display'
import { ReasoningSection } from './reasoning-section'
import { ToolSection } from './tool-section'
-// Define part types used in UIMessage
-type TextPart = {
- type: 'text'
- text: string
-}
-
-type ReasoningPart = {
- type: 'reasoning'
- text: string
-}
-
-// Union of all possible message parts
-type MessagePart =
- | TextPart
- | ReasoningPart
- | ToolPart
- | DynamicToolPart
- | DataRelatedQuestionsPart
-
-// Types for process steps
-type StepVariant = 'single' | 'group' | 'sub'
-
-type BaseStep = {
- id: string
- variant: StepVariant
- type: 'reasoning' | 'tool' | 'data' | 'dynamic-tool'
- toolType?: string
- part: MessagePart
-}
-
-type ProcessStep = BaseStep & {
- variant: 'single' | 'sub'
-}
-
-type ProcessToolGroupStep = BaseStep & {
- variant: 'group'
- groupTitle: string
- steps: ProcessStep[]
-}
-
-type ProcessStepType = ProcessStep | ProcessToolGroupStep
-
-interface ResearchProcessSectionProps {
+type Props = {
message: UIMessage
messageId: string
getIsOpen: (id: string, partType?: string, hasNextPart?: boolean) => boolean
- onOpenChange: (id: string) => void
-}
-
-// Segment type for grouping parts between text boundaries
-type Segment = {
- id: string
- parts: MessagePart[]
+ onOpenChange: (id: string, open: boolean) => void
+ onQuerySelect: (query: string) => void
+ status?: UseChatHelpers<UIMessage<unknown, UIDataTypes, UITools>>['status']
+ addToolResult?: (params: { toolCallId: string; result: any }) => void
+ parts?: AnyPart[]
}
-// Convert message parts into segments split by text parts
-function toSegments(message: UIMessage): Segment[] {
- const parts = (message.parts ?? []) as MessagePart[]
- const segments: Segment[] = []
- let current: MessagePart[] = []
- let segIndex = 0
+type AnyPart = any
- for (let i = 0; i < parts.length; i++) {
- const p = parts[i]
+function splitByText(parts: AnyPart[]): AnyPart[][] {
+ const segments: AnyPart[][] = []
+ let curr: AnyPart[] = []
+ for (const p of parts || []) {
if (p.type === 'text') {
- if (current.length) {
- segments.push({ id: `${message.id}-seg-${segIndex++}`, parts: current })
- current = []
- }
- continue
+ if (curr.length) segments.push(curr), (curr = [])
+ } else {
+ curr.push(p)
}
- current.push(p)
- }
- if (current.length) {
- segments.push({ id: `${message.id}-seg-${segIndex++}`, parts: current })
}
+ if (curr.length) segments.push(curr)
return segments
}
-// Create a reasoning step
-function makeReasoningStep(
- segId: string,
- index: number,
- part: MessagePart
-): ProcessStep {
- return {
- id: `${segId}-${index}`,
- variant: 'single',
- type: 'reasoning',
- part
- }
-}
-
-// Create a single tool step
-function makeSingleToolStep(
- segId: string,
- index: number,
- part: MessagePart
-): ProcessStep {
- const toolType = part.type.replace('tool-', '')
- return {
- id: `${segId}-${index}`,
- variant: 'single',
- type: 'tool',
- toolType,
- part
- }
-}
-
-// Create a tool group with sub-steps
-function makeToolGroup(
- segId: string,
- index: number,
- toolType: string,
- groupParts: MessagePart[]
-): ProcessToolGroupStep {
- return {
- id: `${segId}-${index}`,
- variant: 'group',
- type: 'tool',
- toolType,
- groupTitle: getToolGroupTitle(toolType),
- steps: groupParts.map((p, i) => ({
- id: `${segId}-${index}-${i}`,
- variant: 'sub' as const,
- type: 'tool' as const,
- toolType,
- part: p
- })),
- part: groupParts[0] // Use first part as representative
- }
-}
-
-// Create a data step
-function makeDataStep(
- segId: string,
- index: number,
- part: MessagePart
-): ProcessStep {
- return {
- id: `${segId}-${index}`,
- variant: 'single',
- type: 'data',
- part
- }
-}
-
-// Create a dynamic tool step
-function makeDynamicToolStep(
- segId: string,
- index: number,
- part: MessagePart
-): ProcessStep {
- return {
- id: `${segId}-${index}`,
- variant: 'single',
- type: 'dynamic-tool',
- part
- }
-}
-
-// Get display title for tool groups
-function getToolGroupTitle(toolType: string): string {
- const titles: Record<string, string> = {
- search: 'Search',
- fetch: 'Fetch',
- todoWrite: 'Update Tasks',
- todoRead: 'Read Tasks',
- askQuestion: 'Question',
- dynamicTool: 'Tool'
- }
- return titles[toolType] || toolType
-}
-
-// Convert segments into process steps with grouping
-function toProcessSteps(segment: Segment): ProcessStepType[] {
- const steps: ProcessStepType[] = []
+function groupTools(segment: AnyPart[]): AnyPart[][] {
+ const groups: AnyPart[][] = []
let i = 0
-
- while (i < segment.parts.length) {
- const p = segment.parts[i]
-
- if (p.type === 'reasoning') {
- steps.push(makeReasoningStep(segment.id, i, p))
- i++
- continue
- }
-
- if (p.type === 'dynamic-tool') {
- steps.push(makeDynamicToolStep(segment.id, i, p))
- i++
- continue
- }
-
- if (p.type.startsWith('tool-')) {
- const toolType = p.type.slice(5)
- const groupParts: MessagePart[] = [p]
+ while (i < segment.length) {
+ const p = segment[i]
+ if (p.type?.startsWith?.('tool-')) {
+ const group: AnyPart[] = [p]
let j = i + 1
-
- // Collect consecutive tool parts of the same type
- while (j < segment.parts.length && segment.parts[j].type === p.type) {
- groupParts.push(segment.parts[j])
+ while (j < segment.length && segment[j].type === p.type) {
+ group.push(segment[j])
j++
}
-
- if (groupParts.length === 1) {
- steps.push(makeSingleToolStep(segment.id, i, p))
- } else {
- steps.push(makeToolGroup(segment.id, i, toolType, groupParts))
- }
+ groups.push(group)
i = j
- continue
- }
-
- if (p.type.startsWith('data-')) {
- steps.push(makeDataStep(segment.id, i, p))
- i++
- continue
+ } else {
+ groups.push([p])
+ i += 1
}
-
- // Skip unknown part types
- i++
- }
-
- return steps
-}
-
-// Accordion hook for managing open/close state within tool groups
-function useAccordion(
- initialOpenId?: string,
- options = { allowNoneOpen: false }
-) {
- const [openId, setOpenId] = useState<string | undefined>(initialOpenId)
-
- const onToggle = (id: string) => {
- setOpenId(prev => {
- if (prev === id) {
- // Keep open by default unless allowNoneOpen
- return options.allowNoneOpen ? undefined : id
- }
- return id // Open new, close previous
- })
}
-
- return { openId, onToggle }
+ return groups
}
-// Rail component for visual timeline
-function ProcessRail({
- isFirst,
- isLast,
- isSubStep = false
-}: {
- isFirst: boolean
- isLast: boolean
- isSubStep?: boolean
-}) {
- return (
- <div className="absolute left-0 top-0 bottom-0 w-8 flex flex-col items-center">
- {/* Connector line above */}
- {!isFirst && <div className="absolute top-0 w-px h-3 bg-border/50" />}
-
- {/* Dot */}
- <div
- className={cn(
- 'mt-3 rounded-full',
- isSubStep
- ? 'h-1.5 w-1.5 bg-muted-foreground/50'
- : 'h-2 w-2 bg-muted-foreground'
- )}
- />
-
- {/* Connector line below */}
- {!isLast && <div className="absolute top-5 w-px bottom-0 bg-border/50" />}
- </div>
- )
-}
-
-// Render a single step or tool group
-function ProcessStepRenderer({
- step,
- messageId,
- isFirst,
- isLast,
- getIsOpen,
- onOpenChange
-}: {
- step: ProcessStepType
- messageId: string
- isFirst: boolean
- isLast: boolean
- getIsOpen: (id: string, partType?: string, hasNextPart?: boolean) => boolean
- onOpenChange: (id: string) => void
-}) {
- const [accordionOpenId, setAccordionOpenId] = useState<string | undefined>()
-
- // Initialize accordion with latest sub-step open
- useEffect(() => {
- if (step.variant === 'group' && step.steps.length > 0) {
- const lastStep = step.steps[step.steps.length - 1]
- setAccordionOpenId(lastStep.id)
- }
- }, [step])
-
- if (step.variant === 'group') {
- // Render tool group with sub-steps
- return (
- <div className="relative pl-8">
- <ProcessRail isFirst={isFirst} isLast={isLast} />
-
- {/* Group header */}
- <div className="mb-2">
- <div className="text-xs font-medium text-muted-foreground">
- {step.groupTitle}
- </div>
- </div>
-
- {/* Sub-steps */}
- <div className="space-y-1">
- {step.steps.map((subStep, idx) => {
- const isSubFirst = idx === 0
- const isSubLast = idx === step.steps.length - 1
- const isSubOpen = accordionOpenId === subStep.id
-
- return (
- <div key={subStep.id} className="relative">
- {/* Sub-step rail */}
- <div className="absolute -left-4 top-0 bottom-0 w-4 flex flex-col items-center">
- {!isSubFirst && (
- <div className="absolute top-0 w-px h-2 bg-border/30" />
- )}
- <div className="mt-2 h-1.5 w-1.5 rounded-full bg-muted-foreground/50" />
- {!isSubLast && (
- <div className="absolute top-3.5 w-px bottom-0 bg-border/30" />
- )}
- </div>
-
- {/* Sub-step content */}
- <div className="pl-4">
- {renderPart(
- subStep.part,
- messageId,
- isSubOpen,
- () =>
- setAccordionOpenId(isSubOpen ? undefined : subStep.id),
- true
- )}
- </div>
- </div>
- )
- })}
- </div>
- </div>
- )
- }
-
- // Render single step
- const isOpen = getIsOpen(step.id, step.part.type)
-
- return (
- <div className="relative pl-8">
- <ProcessRail isFirst={isFirst} isLast={isLast} />
- {renderPart(
- step.part,
- messageId,
- isOpen,
- () => onOpenChange(step.id),
- false
- )}
- </div>
- )
+function getRailState(index: number, total: number): RailState {
+ if (total <= 1) return 'single'
+ if (index === 0) return 'first'
+ if (index === total - 1) return 'last'
+ return 'middle'
}
-// Render a part based on its type
-function renderPart(
- part: MessagePart,
- messageId: string,
- isOpen: boolean,
- onOpenChange: () => void,
- isSubStep: boolean
-): React.ReactNode {
- switch (part.type) {
- case 'reasoning':
- const reasoningPart = part as ReasoningPart
- return (
- <ReasoningSection
- content={{ reasoning: reasoningPart.text, isDone: true }}
- isOpen={isOpen}
- onOpenChange={onOpenChange}
- />
- )
-
- case 'tool-search':
- case 'tool-fetch':
- case 'tool-askQuestion':
- case 'tool-todoWrite':
- case 'tool-todoRead':
- return (
- <ToolSection
- tool={part as ToolPart}
- isOpen={isOpen}
- onOpenChange={onOpenChange}
- onQuerySelect={() => {}}
- />
- )
-
- case 'dynamic-tool':
- return <DynamicToolDisplay part={part as DynamicToolPart} />
-
- case 'data-relatedQuestions':
- return (
- <DataSection
- part={part as DataRelatedQuestionsPart}
- onQuerySelect={() => {}}
- />
- )
-
- default:
- return null
- }
-}
+type RailState = 'single' | 'first' | 'middle' | 'last'
export function ResearchProcessSection({
message,
messageId,
getIsOpen,
- onOpenChange
-}: ResearchProcessSectionProps) {
- // Convert message to segments and process steps
- const segments = useMemo(() => toSegments(message), [message])
- const allSteps = useMemo(
- () => segments.flatMap(segment => toProcessSteps(segment)),
- [segments]
- )
+ onOpenChange,
+ onQuerySelect,
+ status,
+ addToolResult,
+ parts: partsOverride
+}: Props) {
+ const allParts = partsOverride ?? (message.parts || [])
+ const segments = partsOverride ? [allParts] : splitByText(allParts)
- if (allSteps.length === 0) {
- return null
- }
+ if (segments.length === 0) return null
return (
- <div className="space-y-3">
- {allSteps.map((step, index) => (
- <ProcessStepRenderer
- key={step.id}
- step={step}
- messageId={messageId}
- isFirst={index === 0}
- isLast={index === allSteps.length - 1}
- getIsOpen={getIsOpen}
- onOpenChange={onOpenChange}
- />
- ))}
+ <div className="space-y-2">
+ {segments.map((seg, sidx) => {
+ const groups = groupTools(seg)
+ const isSingle = groups.length === 1 && groups[0].length === 1
+ const containerClass = cn(
+ !isSingle && 'rounded-lg border bg-card'
+ )
+
+ return (
+ <div key={`${messageId}-seg-${sidx}`} className={containerClass}>
+ {groups.map((grp, gidx) => {
+ const isToolGroup = grp[0].type?.startsWith?.('tool-') && grp.length > 1
+
+ return (
+ <div key={`${messageId}-grp-${sidx}-${gidx}`} className={cn('space-y-1')}>
+ {grp.map((part, pidx) => {
+ const railState = getRailState(pidx, grp.length)
+ const hasNext = pidx < grp.length - 1
+ if (part.type === 'reasoning') {
+ const rid = `${messageId}-reasoning-${sidx}-${gidx}-${pidx}`
+ return (
+ <div
+ key={rid}
+ className="relative"
+ >
+ {/* rail inside content: using process variant to tighten paddings */}
+ <div className="absolute left-1.5 top-0 bottom-0 w-px bg-transparent" />
+ <ReasoningSection
+ content={{ reasoning: part.text, isDone: !hasNext }}
+ isOpen={getIsOpen(rid, 'reasoning', hasNext)}
+ onOpenChange={open => onOpenChange(rid, open)}
+ isSingle={isSingle}
+ />
+ </div>
+ )
+ }
+
+ if (part.type?.startsWith?.('tool-')) {
+ // Render via ToolSection but borderless
+ const id = part.toolCallId
+ return (
+ <div
+ key={id}
+ className="relative"
+ >
+ {/* Rail */}
+ {isToolGroup && (
+ <>
+ <span
+ className={cn(
+ 'absolute left-1.5 w-px bg-border/50',
+ railState === 'single' && 'top-2 bottom-2',
+ railState === 'first' && 'top-2 bottom-0',
+ railState === 'middle' && 'top-0 bottom-0',
+ railState === 'last' && 'top-0 bottom-2'
+ )}
+ />
+ <span className="absolute left-1 top-2 h-2 w-2 rounded-full bg-muted-foreground/70" />
+ </>
+ )}
+ <ToolSection
+ tool={part}
+ isOpen={getIsOpen(id, part.type, hasNext)}
+ onOpenChange={open => onOpenChange(id, open)}
+ status={status}
+ addToolResult={addToolResult}
+ onQuerySelect={onQuerySelect}
+ borderless={!isSingle}
+ />
+ </div>
+ )
+ }
+
+ if (part.type?.startsWith?.('data-')) {
+ // For now, render nothing here; existing renderer handles data parts elsewhere
+ return null
+ }
+
+ return null
+ })}
+ </div>
+ )
+ })}
+ </div>
+ )
+ })}
</div>
)
}
+
+export default ResearchProcessSection
\ No newline at end of file
diff --git a/components/search-section.tsx b/components/search-section.tsx
index b3b63a73..8196a799 100644
--- a/components/search-section.tsx
+++ b/components/search-section.tsx
@@ -25,13 +25,15 @@ interface SearchSectionProps {
isOpen: boolean
onOpenChange: (open: boolean) => void
status?: UseChatHelpers<UIMessage<unknown, UIDataTypes, UITools>>['status']
+ borderless?: boolean
}
export function SearchSection({
tool,
isOpen,
onOpenChange,
- status
+ status,
+ borderless
}: SearchSectionProps) {
const isLoading = status === 'submitted' || status === 'streaming'
@@ -84,6 +86,8 @@ export function SearchSection({
isOpen={isOpen}
onOpenChange={onOpenChange}
showIcon={false}
+ showBorder={!borderless}
+ variant="default"
>
{searchResults &&
searchResults.images &&
diff --git a/components/tool-section.tsx b/components/tool-section.tsx
index 948d33bd..19928d28 100644
--- a/components/tool-section.tsx
+++ b/components/tool-section.tsx
@@ -16,6 +16,7 @@ interface ToolSectionProps {
status?: UseChatHelpers<UIMessage<unknown, UIDataTypes, UITools>>['status']
addToolResult?: (params: { toolCallId: string; result: any }) => void
onQuerySelect: (query: string) => void
+ borderless?: boolean
}
export function ToolSection({
@@ -24,7 +25,8 @@ export function ToolSection({
onOpenChange,
status,
addToolResult,
- onQuerySelect
+ onQuerySelect,
+ borderless = false
}: ToolSectionProps) {
// Special handling for ask_question tool
if (tool.type === 'tool-askQuestion') {
@@ -72,6 +74,7 @@ export function ToolSection({
isOpen={isOpen}
onOpenChange={onOpenChange}
status={status}
+ borderless={borderless}
/>
)
case 'tool-fetch':
@@ -81,6 +84,7 @@ export function ToolSection({
isOpen={isOpen}
onOpenChange={onOpenChange}
status={status}
+ borderless={borderless}
/>
)
case 'tool-todoWrite':
@@ -94,6 +98,7 @@ export function ToolSection({
toolCallId={tool.toolCallId}
isOpen={isOpen}
onOpenChange={onOpenChange}
+ borderless={borderless}
/>
)
case 'tool-todoRead':
@@ -107,6 +112,7 @@ export function ToolSection({
toolCallId={tool.toolCallId}
isOpen={isOpen}
onOpenChange={onOpenChange}
+ borderless={borderless}
/>
)
default:
diff --git a/components/tool-todo-display.tsx b/components/tool-todo-display.tsx
index 007e6fa8..9fef0566 100644
--- a/components/tool-todo-display.tsx
+++ b/components/tool-todo-display.tsx
@@ -27,6 +27,7 @@ interface ToolTodoDisplayProps {
toolCallId: string
isOpen?: boolean
onOpenChange?: (open: boolean) => void
+ borderless?: boolean
}
export function ToolTodoDisplay({
@@ -35,7 +36,8 @@ export function ToolTodoDisplay({
output,
toolCallId,
isOpen = false,
- onOpenChange
+ onOpenChange,
+ borderless = false
}: ToolTodoDisplayProps) {
const { open: openArtifact } = useArtifact()
// Calculate counts for display
@@ -103,7 +105,7 @@ export function ToolTodoDisplay({
header={header}
isOpen={isOpen}
onOpenChange={onOpenChange}
- showBorder={true}
+ showBorder={!borderless}
showIcon={false}
variant="default"
showSeparator={false}