Composio powers 1000+ toolkits, tool search, context management, authentication, and a sandboxed workbench to help you build AI agents that turn intent into action.
Mirrored from https://github.com/Camo67/composio.git
Synced Nov 21, 04:45 UTC
| 1 | "use client" |
| 2 | |
| 3 | import { motion, useReducedMotion } from "motion/react" |
| 4 | import * as React from "react" |
| 5 | |
| 6 | import { TerminalLine } from "../shell/terminal-line" |
| 7 | |
| 8 | export type TextStreamMode = "plain" | "fade" |
| 9 | |
| 10 | export type TextSegment = { text: string; index: number } |
| 11 | |
| 12 | export type StreamTimingOverrides = { |
| 13 | /** Delay between word segments, ms (overrides speed). */ |
| 14 | segmentDelay?: number |
| 15 | /** Fade-in duration per segment in fade mode, ms (overrides speed). */ |
| 16 | fadeDuration?: number |
| 17 | } |
| 18 | |
| 19 | function clamp(value: number, min: number, max: number) { |
| 20 | return Math.min(max, Math.max(min, value)) |
| 21 | } |
| 22 | |
| 23 | /** Map a 1-100 speed knob to concrete timings. */ |
| 24 | export function resolveStreamTiming( |
| 25 | speed = 20, |
| 26 | overrides: StreamTimingOverrides = {} |
| 27 | ) { |
| 28 | const s = clamp(speed, 1, 100) |
| 29 | return { |
| 30 | segmentDelay: overrides.segmentDelay ?? Math.max(16, Math.round(170 - s * 1.4)), |
| 31 | fadeDuration: overrides.fadeDuration ?? Math.max(120, Math.round(700 - s * 4)), |
| 32 | } |
| 33 | } |
| 34 | |
| 35 | /** Split into words while keeping trailing whitespace so spacing is preserved. */ |
| 36 | function splitSegments(text: string): TextSegment[] { |
| 37 | const matches = text.match(/\S+\s*/g) ?? [] |
| 38 | return matches.map((segment, index) => ({ text: segment, index })) |
| 39 | } |
| 40 | |
| 41 | /** Estimate how long a stream will take, e.g. to drive a SessionContent pause. */ |
| 42 | export function estimateStreamDurationMs( |
| 43 | text: string, |
| 44 | options: { mode?: TextStreamMode; speed?: number } & StreamTimingOverrides = {} |
| 45 | ) { |
| 46 | const { mode = "plain", speed = 20, ...overrides } = options |
| 47 | const timing = resolveStreamTiming(speed, overrides) |
| 48 | const base = |
| 49 | splitSegments(text).length * timing.segmentDelay + 120 |
| 50 | if (mode === "plain") return base |
| 51 | return base + timing.fadeDuration |
| 52 | } |
| 53 | |
| 54 | export type UseTextStreamOptions = { |
| 55 | text: string |
| 56 | mode?: TextStreamMode |
| 57 | /** 1 (slowest) to 100 (fastest). Defaults to 20. */ |
| 58 | speed?: number |
| 59 | /** When false, nothing is revealed. */ |
| 60 | enabled?: boolean |
| 61 | /** Reveal the full text immediately (e.g. reduced motion). */ |
| 62 | instant?: boolean |
| 63 | onComplete?: () => void |
| 64 | } & StreamTimingOverrides |
| 65 | |
| 66 | /** |
| 67 | * Client-side simulated text streaming. For controlled/fake progressive output |
| 68 | * (demos, scripted sessions). For real LLM output, append tokens directly. |
| 69 | */ |
| 70 | export function useTextStream({ |
| 71 | text, |
| 72 | mode = "plain", |
| 73 | speed = 20, |
| 74 | enabled = true, |
| 75 | instant = false, |
| 76 | segmentDelay, |
| 77 | fadeDuration, |
| 78 | onComplete, |
| 79 | }: UseTextStreamOptions) { |
| 80 | const timing = resolveStreamTiming(speed, { segmentDelay, fadeDuration }) |
| 81 | const segments = React.useMemo(() => splitSegments(text), [text]) |
| 82 | const useFade = mode === "fade" && !instant |
| 83 | const streamWords = enabled && !instant && segments.length > 0 |
| 84 | |
| 85 | const initialSegments = enabled && !streamWords ? segments.length : 0 |
| 86 | const [segmentCount, setSegmentCount] = React.useState(initialSegments) |
| 87 | |
| 88 | const resetKey = `${text}::${mode}::${enabled}::${instant}` |
| 89 | const [prevResetKey, setPrevResetKey] = React.useState(resetKey) |
| 90 | if (resetKey !== prevResetKey) { |
| 91 | setPrevResetKey(resetKey) |
| 92 | setSegmentCount(initialSegments) |
| 93 | } |
| 94 | |
| 95 | const onCompleteRef = React.useRef(onComplete) |
| 96 | React.useEffect(() => { |
| 97 | onCompleteRef.current = onComplete |
| 98 | }) |
| 99 | |
| 100 | React.useEffect(() => { |
| 101 | if (!streamWords) return |
| 102 | let cancelled = false |
| 103 | let revealed = 0 |
| 104 | let timer = 0 |
| 105 | |
| 106 | const tick = () => { |
| 107 | if (cancelled) return |
| 108 | revealed += 1 |
| 109 | setSegmentCount(revealed) |
| 110 | if (revealed < segments.length) { |
| 111 | timer = window.setTimeout(tick, timing.segmentDelay) |
| 112 | } |
| 113 | } |
| 114 | |
| 115 | timer = window.setTimeout(tick, timing.segmentDelay) |
| 116 | return () => { |
| 117 | cancelled = true |
| 118 | window.clearTimeout(timer) |
| 119 | } |
| 120 | }, [streamWords, text, segments.length, timing.segmentDelay]) |
| 121 | |
| 122 | const isComplete = |
| 123 | !enabled ? false : instant || segmentCount >= segments.length |
| 124 | |
| 125 | const completedRef = React.useRef(false) |
| 126 | React.useEffect(() => { |
| 127 | if (isComplete && !completedRef.current) { |
| 128 | completedRef.current = true |
| 129 | onCompleteRef.current?.() |
| 130 | } else if (!isComplete) { |
| 131 | completedRef.current = false |
| 132 | } |
| 133 | }, [isComplete]) |
| 134 | |
| 135 | return { |
| 136 | segments, |
| 137 | visibleSegmentCount: segmentCount, |
| 138 | isComplete, |
| 139 | timing, |
| 140 | useFade, |
| 141 | streamWords, |
| 142 | } |
| 143 | } |
| 144 | |
| 145 | export type StreamTextProps = { |
| 146 | /** The text to stream. Must be a plain string. */ |
| 147 | children: string |
| 148 | /** `plain` (default) reveals word-by-word; `fade` adds a fade-in per word. */ |
| 149 | mode?: TextStreamMode |
| 150 | /** 1 (slowest) to 100 (fastest). Defaults to 26. */ |
| 151 | speed?: number |
| 152 | /** Start streaming. Set false to hold until revealed. */ |
| 153 | enabled?: boolean |
| 154 | className?: string |
| 155 | onComplete?: () => void |
| 156 | /** |
| 157 | * SessionContent integration — ms to wait after this line before revealing the |
| 158 | * next child when streaming. Not read by StreamText; SessionContent inspects |
| 159 | * the prop on the child element. Defaults to estimateStreamDurationMs(text). |
| 160 | */ |
| 161 | sessionPause?: number |
| 162 | } & StreamTimingOverrides |
| 163 | |
| 164 | /** |
| 165 | * Agent text inside a TerminalLine. Default reveals word-by-word with no |
| 166 | * transition; use mode="fade" to fade each word in. |
| 167 | */ |
| 168 | export function StreamText({ |
| 169 | children, |
| 170 | mode = "plain", |
| 171 | speed = 26, |
| 172 | enabled = true, |
| 173 | className, |
| 174 | onComplete, |
| 175 | sessionPause: _sessionPause, |
| 176 | segmentDelay, |
| 177 | fadeDuration, |
| 178 | }: StreamTextProps) { |
| 179 | const reduceMotion = useReducedMotion() |
| 180 | const { segments, visibleSegmentCount, timing, useFade, streamWords } = |
| 181 | useTextStream({ |
| 182 | text: children, |
| 183 | mode, |
| 184 | speed, |
| 185 | enabled, |
| 186 | instant: Boolean(reduceMotion), |
| 187 | segmentDelay, |
| 188 | fadeDuration, |
| 189 | onComplete, |
| 190 | }) |
| 191 | |
| 192 | if (!enabled) { |
| 193 | return <TerminalLine className={className} /> |
| 194 | } |
| 195 | |
| 196 | if (!streamWords) { |
| 197 | return ( |
| 198 | <TerminalLine className={className}> |
| 199 | {children} |
| 200 | </TerminalLine> |
| 201 | ) |
| 202 | } |
| 203 | |
| 204 | if (useFade) { |
| 205 | return ( |
| 206 | <TerminalLine className={className}> |
| 207 | {segments.map((segment) => { |
| 208 | const visible = segment.index < visibleSegmentCount |
| 209 | return ( |
| 210 | <motion.span |
| 211 | key={segment.index} |
| 212 | initial={false} |
| 213 | animate={{ opacity: visible ? 1 : 0 }} |
| 214 | transition={{ |
| 215 | duration: timing.fadeDuration / 1000, |
| 216 | ease: "easeOut", |
| 217 | }} |
| 218 | > |
| 219 | {segment.text} |
| 220 | </motion.span> |
| 221 | ) |
| 222 | })} |
| 223 | </TerminalLine> |
| 224 | ) |
| 225 | } |
| 226 | |
| 227 | return ( |
| 228 | <TerminalLine className={className}> |
| 229 | {segments.map((segment) => { |
| 230 | const visible = segment.index < visibleSegmentCount |
| 231 | return ( |
| 232 | <span |
| 233 | key={segment.index} |
| 234 | aria-hidden={!visible} |
| 235 | style={{ visibility: visible ? "visible" : "hidden" }} |
| 236 | > |
| 237 | {segment.text} |
| 238 | </span> |
| 239 | ) |
| 240 | })} |
| 241 | </TerminalLine> |
| 242 | ) |
| 243 | } |