"use client"
import { useCallback, useState, type FC, type PropsWithChildren } from "react"
import {
AlertCircleIcon,
CheckIcon,
ChevronDownIcon,
LoaderIcon,
XCircleIcon,
} from "lucide-react"
import {
Collapsible,
CollapsibleContent,
CollapsibleTrigger,
} from "@/registry/tonic/ui/collapsible"
import { Button } from "@/registry/tonic/ui/button"
import { Textarea } from "@/registry/tonic/ui/textarea"
import { cn } from "@/lib/utils"
const ANIMATION_DURATION = 200
export type ToolFallbackStatusType =
| "running"
| "complete"
| "incomplete"
| "requires-action"
export type ToolFallbackStatus = {
type: ToolFallbackStatusType
reason?: string
error?: unknown
}
export type ToolFallbackRootProps = Omit<
React.ComponentProps<typeof Collapsible>,
"open" | "onOpenChange"
> & {
open?: boolean
onOpenChange?: (open: boolean) => void
defaultOpen?: boolean
}
function ToolFallbackRoot({
className,
open: controlledOpen,
onOpenChange: controlledOnOpenChange,
defaultOpen = false,
children,
...props
}: ToolFallbackRootProps) {
const [uncontrolledOpen, setUncontrolledOpen] = useState(defaultOpen)
const isControlled = controlledOpen !== undefined
const isOpen = isControlled ? controlledOpen : uncontrolledOpen
const handleOpenChange = useCallback(
(next: boolean) => {
if (!isControlled) setUncontrolledOpen(next)
controlledOnOpenChange?.(next)
},
[isControlled, controlledOnOpenChange]
)
return (
<Collapsible
data-slot="tool-fallback-root"
open={isOpen}
onOpenChange={handleOpenChange}
className={cn("group/tool-fallback-root w-full", className)}
style={
{
"--animation-duration": `${ANIMATION_DURATION}ms`,
} as React.CSSProperties
}
{...props}
>
{children}
</Collapsible>
)
}
const statusIconMap: Record<ToolFallbackStatusType, React.ElementType> = {
running: LoaderIcon,
complete: CheckIcon,
incomplete: XCircleIcon,
"requires-action": AlertCircleIcon,
}
export function formatToolDuration(ms: number) {
if (ms < 1000) return "<1s"
const seconds = ms / 1000
if (seconds < 10) return `${(Math.floor(seconds * 10) / 10).toFixed(1)}s`
if (seconds < 60) return `${Math.floor(seconds)}s`
return `${Math.floor(seconds / 60)}m ${Math.floor(seconds % 60)}s`
}
function ToolFallbackTrigger({
toolName,
status,
elapsedMs,
className,
...props
}: React.ComponentProps<typeof CollapsibleTrigger> & {
toolName: string
status?: ToolFallbackStatus
elapsedMs?: number
}) {
const statusType = status?.type ?? "complete"
const isRunning = statusType === "running"
const isCancelled =
status?.type === "incomplete" && status.reason === "cancelled"
const Icon = statusIconMap[statusType]
const label = isCancelled
? `Cancelled ${toolName}`
: isRunning
? `Running ${toolName}`
: toolName
return (
<CollapsibleTrigger
data-slot="tool-fallback-trigger"
className={cn(
"group/trigger text-muted-foreground hover:text-foreground/70 flex w-fit origin-left items-center gap-1.5 py-0.5 text-[15px] leading-6 transition-[color,scale] active:scale-[0.98]",
className
)}
{...props}
>
<Icon
className={cn(
"size-3.5 shrink-0 opacity-70",
isCancelled && "text-muted-foreground",
isRunning && "animate-spin [animation-duration:0.6s]"
)}
/>
<span
className={cn(
"inline-block text-start font-normal",
isCancelled && "text-muted-foreground line-through",
isRunning && "shimmer motion-reduce:animate-none"
)}
>
{label}
</span>
{elapsedMs !== undefined ? (
<span className="text-muted-foreground text-[15px] leading-6 tabular-nums opacity-80">
{formatToolDuration(elapsedMs)}
</span>
) : null}
<ChevronDownIcon
className={cn(
"size-3.5 shrink-0 opacity-50 transition-transform duration-(--animation-duration) ease-[cubic-bezier(0.32,0.72,0,1)] motion-reduce:transition-none",
"-rotate-90 group-data-[state=open]/tool-fallback-root:rotate-0"
)}
/>
</CollapsibleTrigger>
)
}
function ToolFallbackContent({
className,
children,
...props
}: React.ComponentProps<typeof CollapsibleContent>) {
return (
<CollapsibleContent
data-slot="tool-fallback-content"
className={cn("relative overflow-hidden text-sm outline-none", className)}
{...props}
>
<div className="flex flex-col gap-2 ps-6 pt-1 pb-2">{children}</div>
</CollapsibleContent>
)
}
function ToolFallbackArgs({
argsText,
className,
...props
}: React.ComponentProps<"div"> & { argsText?: string }) {
if (!argsText) return null
return (
<div data-slot="tool-fallback-args" className={cn(className)} {...props}>
<pre className="bg-muted/50 text-foreground/90 rounded-md p-2.5 text-xs whitespace-pre-wrap">
{argsText}
</pre>
</div>
)
}
function formatUnknownValue(value: unknown, space?: number): string {
if (typeof value === "string") return value
try {
if (value instanceof Error) return String(value)
const json = JSON.stringify(value, null, space)
if (json !== undefined) return json
} catch {
/* ignore */
}
try {
return String(value)
} catch {
return "[Unserializable value]"
}
}
function ToolFallbackResult({
result,
className,
...props
}: React.ComponentProps<"div"> & { result?: unknown }) {
if (result === undefined) return null
return (
<div data-slot="tool-fallback-result" className={cn(className)} {...props}>
<p className="text-muted-foreground text-xs font-medium">Result:</p>
<pre className="bg-muted/50 text-foreground/90 mt-1 rounded-md p-2.5 text-xs whitespace-pre-wrap">
{formatUnknownValue(result, 2)}
</pre>
</div>
)
}
function ToolFallbackError({
status,
className,
...props
}: React.ComponentProps<"div"> & { status?: ToolFallbackStatus }) {
if (status?.type !== "incomplete") return null
const error = status.error
const errorText =
error === undefined || error === null ? null : formatUnknownValue(error)
if (!errorText) return null
const isCancelled = status.reason === "cancelled"
return (
<div data-slot="tool-fallback-error" className={cn(className)} {...props}>
<p className="text-muted-foreground font-semibold">
{isCancelled ? "Cancelled reason:" : "Error:"}
</p>
<p className="text-muted-foreground">{errorText}</p>
</div>
)
}
export type ToolFallbackApprovalProps = {
onApprove?: (feedback?: string) => void
onDeny?: (feedback?: string) => void
acceptsText?: boolean
className?: string
}
function ToolFallbackApproval({
onApprove,
onDeny,
acceptsText = false,
className,
}: ToolFallbackApprovalProps) {
const [feedback, setFeedback] = useState("")
if (!onApprove && !onDeny) return null
return (
<div
data-slot="tool-fallback-approval"
className={cn("flex flex-col gap-2", className)}
>
{acceptsText ? (
<Textarea
value={feedback}
onChange={(event) => setFeedback(event.target.value)}
placeholder="Optional note"
className="min-h-16 text-sm"
/>
) : null}
<div className="flex flex-wrap gap-2">
{onApprove ? (
<Button
type="button"
size="sm"
onClick={() => onApprove(feedback || undefined)}
>
Allow
</Button>
) : null}
{onDeny ? (
<Button
type="button"
size="sm"
variant="outline"
onClick={() => onDeny(feedback || undefined)}
>
Deny
</Button>
) : null}
</div>
</div>
)
}
const ToolFallback: FC<
PropsWithChildren<{
toolName: string
status?: ToolFallbackStatus
elapsedMs?: number
argsText?: string
result?: unknown
defaultOpen?: boolean
onApprove?: (feedback?: string) => void
onDeny?: (feedback?: string) => void
acceptsText?: boolean
}>
> & {
Root: typeof ToolFallbackRoot
Trigger: typeof ToolFallbackTrigger
Content: typeof ToolFallbackContent
Args: typeof ToolFallbackArgs
Result: typeof ToolFallbackResult
Error: typeof ToolFallbackError
Approval: typeof ToolFallbackApproval
} = ({
toolName,
status,
elapsedMs,
argsText,
result,
defaultOpen,
onApprove,
onDeny,
acceptsText,
children,
}) => (
<ToolFallbackRoot defaultOpen={defaultOpen}>
<ToolFallbackTrigger
toolName={toolName}
status={status}
elapsedMs={elapsedMs}
/>
<ToolFallbackContent>
<ToolFallbackError status={status} />
<ToolFallbackArgs argsText={argsText} />
{status?.type === "requires-action" ? (
<ToolFallbackApproval
onApprove={onApprove}
onDeny={onDeny}
acceptsText={acceptsText}
/>
) : null}
<ToolFallbackResult result={result} />
{children}
</ToolFallbackContent>
</ToolFallbackRoot>
)
ToolFallback.Root = ToolFallbackRoot
ToolFallback.Trigger = ToolFallbackTrigger
ToolFallback.Content = ToolFallbackContent
ToolFallback.Args = ToolFallbackArgs
ToolFallback.Result = ToolFallbackResult
ToolFallback.Error = ToolFallbackError
ToolFallback.Approval = ToolFallbackApproval
export {
ToolFallback,
ToolFallbackRoot,
ToolFallbackTrigger,
ToolFallbackContent,
ToolFallbackArgs,
ToolFallbackResult,
ToolFallbackError,
ToolFallbackApproval,
}