@devries-cameron20 / composio Mirror · read-only
Fork 0

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

next
tsx 243 lines 6.6 KB
Raw
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 }