@tangle-network/ui 11.12.0 → 11.13.0

package/dist/hooks/use-sdk-session.js

@@ -0,0 +1,322 @@
+import { useCallback, useMemo, useRef, useState } from "react";
+//#region src/hooks/use-sdk-session.ts
+function uid() {
+	if (typeof globalThis.crypto !== "undefined" && typeof globalThis.crypto.randomUUID === "function") try {
+		return globalThis.crypto.randomUUID();
+	} catch {}
+	return `sdk-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function toMillis(value) {
+	if (value == null) return void 0;
+	if (typeof value === "number") return value;
+	if (value instanceof Date) return value.getTime();
+	const millis = new Date(value).getTime();
+	return Number.isFinite(millis) ? millis : void 0;
+}
+function asRecord(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function asString(value) {
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function textPartsFromContent(content, attachments) {
+	const text = `${content}${attachments?.length ? `\n\nAttachments:\n${attachments.map((attachment) => `- ${attachment.name}`).join("\n")}` : ""}`.trim();
+	return text ? [{
+		type: "text",
+		text
+	}] : [];
+}
+function normalizeTime(value) {
+	const record = asRecord(value);
+	if (!record) return void 0;
+	const start = Number(record.start ?? record.startedAt ?? record.started_at);
+	const end = Number(record.end ?? record.completedAt ?? record.completed_at);
+	if (!Number.isFinite(start) && !Number.isFinite(end)) return;
+	return {
+		start: Number.isFinite(start) ? start : void 0,
+		end: Number.isFinite(end) ? end : void 0
+	};
+}
+function normalizeStatus(value, output, error) {
+	if (value === "pending" || value === "running" || value === "completed" || value === "error") return value;
+	if (typeof error === "string" && error.length > 0) return "error";
+	if (output !== void 0) return "completed";
+	return "running";
+}
+function resolveToolIdentity(rawPart) {
+	return String(rawPart.id ?? rawPart.callID ?? rawPart.callId ?? rawPart.toolUseId ?? rawPart.toolCallId ?? rawPart.tool ?? rawPart.name ?? "tool");
+}
+function normalizePart(rawPart) {
+	const type = String(rawPart.type ?? "");
+	if (type === "text") return {
+		type: "text",
+		text: asString(rawPart.text) ?? asString(rawPart.content) ?? ""
+	};
+	if (type === "reasoning") return {
+		type: "reasoning",
+		text: asString(rawPart.text) ?? asString(rawPart.content) ?? "",
+		time: normalizeTime(rawPart.time)
+	};
+	if (type === "tool") {
+		const stateRecord = asRecord(rawPart.state);
+		const input = stateRecord?.input ?? rawPart.input;
+		const output = stateRecord?.output ?? rawPart.output;
+		const error = stateRecord?.error ?? rawPart.error;
+		return {
+			type: "tool",
+			id: resolveToolIdentity(rawPart),
+			tool: String(rawPart.tool ?? rawPart.name ?? "tool"),
+			callID: rawPart.callID != null || rawPart.callId != null ? String(rawPart.callID ?? rawPart.callId) : void 0,
+			state: {
+				status: normalizeStatus(stateRecord?.status ?? rawPart.status, output, error),
+				input,
+				output,
+				error: typeof error === "string" ? error : void 0,
+				metadata: asRecord(stateRecord?.metadata) ?? asRecord(rawPart.metadata),
+				time: normalizeTime(stateRecord?.time ?? rawPart.time)
+			}
+		};
+	}
+	return null;
+}
+function getPartKey(rawPart) {
+	const type = String(rawPart.type ?? "unknown");
+	if (type === "tool") return `tool:${resolveToolIdentity(rawPart)}`;
+	if (type === "reasoning") return `reasoning:${String(rawPart.id ?? rawPart.partId ?? rawPart.index ?? "current")}`;
+	return `text:${String(rawPart.id ?? rawPart.partId ?? rawPart.index ?? "current")}`;
+}
+function mergePart(existing, incoming, delta) {
+	if (!existing) {
+		if (incoming.type === "text" && delta) return {
+			type: "text",
+			text: delta
+		};
+		return incoming;
+	}
+	if (existing.type === "text" && incoming.type === "text") return {
+		type: "text",
+		text: delta ? `${existing.text}${delta}` : incoming.text,
+		synthetic: incoming.synthetic ?? existing.synthetic
+	};
+	if (existing.type === "reasoning" && incoming.type === "reasoning") return {
+		...existing,
+		...incoming,
+		text: delta && incoming.text === existing.text ? `${existing.text}${delta}` : incoming.text || existing.text,
+		time: incoming.time ?? existing.time
+	};
+	if (existing.type === "tool" && incoming.type === "tool") return {
+		...existing,
+		...incoming,
+		state: {
+			...existing.state,
+			...incoming.state,
+			time: incoming.state.time ?? existing.state.time
+		}
+	};
+	return incoming;
+}
+function mapSeeds(messages) {
+	return {
+		messages: messages.map((message, index) => ({
+			id: message.id,
+			role: message.role,
+			_insertionIndex: index,
+			time: { created: toMillis(message.createdAt) ?? Date.now() }
+		})),
+		partMap: Object.fromEntries(messages.map((message) => [message.id, message.parts ?? textPartsFromContent(message.content ?? "", message.attachments)]))
+	};
+}
+function useSdkSession({ initialMessages = [] } = {}) {
+	const initialConversation = useMemo(() => mapSeeds(initialMessages), [initialMessages]);
+	const [conversation, setConversation] = useState(initialConversation);
+	const [isStreaming, setIsStreaming] = useState(false);
+	const activeAssistantIdRef = useRef(null);
+	const insertionIndexRef = useRef(initialConversation.messages.length);
+	const partIndexRef = useRef({});
+	const replaceHistory = useCallback((messages) => {
+		const next = mapSeeds(messages);
+		setConversation(next);
+		setIsStreaming(false);
+		activeAssistantIdRef.current = null;
+		insertionIndexRef.current = next.messages.length;
+		partIndexRef.current = {};
+	}, []);
+	const appendUserMessage = useCallback(({ id = uid(), role = "user", content, createdAt, attachments }) => {
+		setConversation((prev) => ({
+			messages: [...prev.messages, {
+				id,
+				role,
+				_insertionIndex: insertionIndexRef.current++,
+				time: { created: toMillis(createdAt) ?? Date.now() }
+			}],
+			partMap: {
+				...prev.partMap,
+				[id]: textPartsFromContent(content, attachments)
+			}
+		}));
+		return id;
+	}, []);
+	const beginAssistantMessage = useCallback(({ id = uid(), role = "assistant", createdAt } = {}) => {
+		setConversation((prev) => ({
+			messages: [...prev.messages, {
+				id,
+				role,
+				_insertionIndex: insertionIndexRef.current++,
+				time: { created: toMillis(createdAt) ?? Date.now() }
+			}],
+			partMap: {
+				...prev.partMap,
+				[id]: prev.partMap[id] ?? []
+			}
+		}));
+		activeAssistantIdRef.current = id;
+		partIndexRef.current[id] = partIndexRef.current[id] ?? {};
+		setIsStreaming(true);
+		return id;
+	}, []);
+	const completeAssistantMessage = useCallback(({ messageId, finalText } = {}) => {
+		const targetId = messageId ?? activeAssistantIdRef.current;
+		if (!targetId) {
+			setIsStreaming(false);
+			return;
+		}
+		if (finalText) setConversation((prev) => {
+			const nextParts = [...prev.partMap[targetId] ?? []];
+			const textIndex = nextParts.findIndex((part) => part.type === "text");
+			if (textIndex === -1) nextParts.push({
+				type: "text",
+				text: finalText
+			});
+			else nextParts[textIndex] = {
+				type: "text",
+				text: finalText
+			};
+			return {
+				...prev,
+				partMap: {
+					...prev.partMap,
+					[targetId]: nextParts
+				}
+			};
+		});
+		delete partIndexRef.current[targetId];
+		if (activeAssistantIdRef.current === targetId) activeAssistantIdRef.current = null;
+		setIsStreaming(false);
+	}, []);
+	const failAssistantMessage = useCallback((error, options) => {
+		const targetId = options?.messageId ?? activeAssistantIdRef.current;
+		if (!targetId) {
+			setIsStreaming(false);
+			return;
+		}
+		setConversation((prev) => ({
+			...prev,
+			partMap: {
+				...prev.partMap,
+				[targetId]: [{
+					type: "text",
+					text: `Error: ${error}`
+				}]
+			}
+		}));
+		delete partIndexRef.current[targetId];
+		if (activeAssistantIdRef.current === targetId) activeAssistantIdRef.current = null;
+		setIsStreaming(false);
+	}, []);
+	const applySdkEvent = useCallback((event, options) => {
+		const eventData = asRecord(event.data) ?? {};
+		if (event.type === "message.updated") {
+			const id = asString(eventData.id) ?? asString(eventData.messageId) ?? options?.messageId;
+			const role = asString(eventData.role) ?? "assistant";
+			if (!id) return;
+			setConversation((prev) => {
+				if (prev.messages.some((message) => message.id === id)) return prev;
+				return {
+					...prev,
+					messages: [...prev.messages, {
+						id,
+						role,
+						_insertionIndex: insertionIndexRef.current++,
+						time: { created: Date.now() }
+					}],
+					partMap: {
+						...prev.partMap,
+						[id]: prev.partMap[id] ?? []
+					}
+				};
+			});
+			if (role === "assistant" || role === "system") {
+				activeAssistantIdRef.current = id;
+				partIndexRef.current[id] = partIndexRef.current[id] ?? {};
+				setIsStreaming(true);
+			}
+			return;
+		}
+		if (event.type === "message.part.updated") {
+			const rawPart = asRecord(eventData.part) ?? eventData;
+			const targetId = options?.messageId ?? activeAssistantIdRef.current;
+			const delta = asString(eventData.delta);
+			if (!targetId || !rawPart) return;
+			const normalizedPart = normalizePart(rawPart);
+			if (!normalizedPart) return;
+			const key = getPartKey(rawPart);
+			setConversation((prev) => {
+				const nextParts = [...prev.partMap[targetId] ?? []];
+				const indexMap = partIndexRef.current[targetId] ?? (partIndexRef.current[targetId] = {});
+				const existingIndex = indexMap[key];
+				if (existingIndex == null) {
+					indexMap[key] = nextParts.length;
+					nextParts.push(mergePart(void 0, normalizedPart, delta));
+				} else nextParts[existingIndex] = mergePart(nextParts[existingIndex], normalizedPart, delta);
+				return {
+					...prev,
+					partMap: {
+						...prev.partMap,
+						[targetId]: nextParts
+					}
+				};
+			});
+			activeAssistantIdRef.current = targetId;
+			setIsStreaming(true);
+			return;
+		}
+		if (event.type === "result") {
+			completeAssistantMessage({
+				messageId: options?.messageId,
+				finalText: asString(eventData.finalText)
+			});
+			return;
+		}
+		if (event.type === "done") {
+			completeAssistantMessage({ messageId: options?.messageId });
+			return;
+		}
+		if (event.type === "error") failAssistantMessage(asString(eventData.message) ?? "Agent error", { messageId: options?.messageId });
+	}, [completeAssistantMessage, failAssistantMessage]);
+	const reset = useCallback(() => {
+		setConversation({
+			messages: [],
+			partMap: {}
+		});
+		setIsStreaming(false);
+		activeAssistantIdRef.current = null;
+		insertionIndexRef.current = 0;
+		partIndexRef.current = {};
+	}, []);
+	return {
+		messages: conversation.messages,
+		partMap: conversation.partMap,
+		isStreaming,
+		activeAssistantMessageId: activeAssistantIdRef.current,
+		replaceHistory,
+		appendUserMessage,
+		beginAssistantMessage,
+		applySdkEvent,
+		completeAssistantMessage,
+		failAssistantMessage,
+		setStreaming: setIsStreaming,
+		reset
+	};
+}
+//#endregion
+export { useSdkSession };

package/dist/hooks/use-sse-stream.d.ts

@@ -0,0 +1,124 @@
+//#region src/hooks/use-sse-stream.d.ts
+/**
+ * SSE Event data structure
+ */
+export interface SSEEvent<T = unknown> {
+  id?: string;
+  event: string;
+  data: T;
+  timestamp: number;
+}
+/**
+ * Connection state for SSE streams
+ */
+export type ConnectionState = "connecting" | "connected" | "reconnecting" | "disconnected" | "error";
+/**
+ * SSE stream options
+ */
+export interface UseSSEStreamOptions<T = unknown> {
+  /** URL to connect to */
+  url: string;
+  /** Authorization header value */
+  authToken?: string;
+  /** Enable automatic reconnection (default: true) */
+  autoReconnect?: boolean;
+  /** Max reconnection attempts (default: 5) */
+  maxRetries?: number;
+  /** Base delay between reconnects in ms (default: 1000) */
+  reconnectDelay?: number;
+  /** Event types to listen for (default: all) */
+  eventTypes?: string[];
+  /** Callback for each event */
+  onEvent?: (event: SSEEvent<T>) => void;
+  /** Callback on connection state change */
+  onStateChange?: (state: ConnectionState) => void;
+  /** Callback on error */
+  onError?: (error: Error) => void;
+  /** Custom headers */
+  headers?: Record<string, string>;
+  /** Whether to start connected (default: true) */
+  enabled?: boolean;
+}
+/**
+ * SSE stream result
+ */
+export interface UseSSEStreamResult<T = unknown> {
+  /** Current connection state */
+  state: ConnectionState;
+  /** All received events */
+  events: SSEEvent<T>[];
+  /** Most recent event */
+  lastEvent: SSEEvent<T> | null;
+  /** Error if any */
+  error: Error | null;
+  /** Manually connect */
+  connect: () => void;
+  /** Manually disconnect */
+  disconnect: () => void;
+  /** Clear events buffer */
+  clearEvents: () => void;
+  /** Retry count */
+  retryCount: number;
+  /** Time since last event (ms) */
+  timeSinceLastEvent: number;
+}
+/**
+ * React hook for consuming SSE streams with automatic reconnection,
+ * event buffering, and state management.
+ *
+ * @example
+ * ```tsx
+ * const { events, state, lastEvent } = useSSEStream({
+ *   url: '/api/v1/tasks/123/stream',
+ *   authToken: 'Bearer xxx',
+ *   onEvent: (e) => console.log('Event:', e),
+ * });
+ *
+ * return (
+ *   <div>
+ *     <p>Status: {state}</p>
+ *     {events.map((e, i) => (
+ *       <div key={i}>{e.event}: {JSON.stringify(e.data)}</div>
+ *     ))}
+ *   </div>
+ * );
+ * ```
+ */
+export declare function useSSEStream<T = unknown>(options: UseSSEStreamOptions<T>): UseSSEStreamResult<T>;
+/**
+ * Typed event types for common streaming scenarios
+ */
+export interface TaskStreamEvent {
+  task_id: string;
+  status?: string;
+  progress?: number;
+  message?: string;
+  result?: unknown;
+  error?: string;
+}
+export interface AgentStreamEvent {
+  type: "message.updated" | "tool_call" | "tool_result" | "llm_response" | "error" | "session.idle" | "execution.started" | "execution.result";
+  data: unknown;
+  timestamp?: number;
+}
+export interface TerminalStreamEvent {
+  type: "output" | "input" | "error" | "exit";
+  data: string;
+  timestamp: number;
+}
+export interface AutomationStreamEvent {
+  automation_id: string;
+  event_id?: string;
+  status?: string;
+  variant_id?: string;
+  output?: string;
+  action_result?: unknown;
+  error?: string;
+}
+export interface BotStreamEvent {
+  bot_id: string;
+  type: "balance" | "trade" | "decision" | "log" | "error";
+  data: unknown;
+  timestamp: number;
+}
+//#endregion

package/dist/hooks/use-sse-stream.js

@@ -0,0 +1,229 @@
+"use client";
+import * as React from "react";
+//#region src/hooks/use-sse-stream.ts
+/**
+* React hook for consuming SSE streams with automatic reconnection,
+* event buffering, and state management.
+*
+* @example
+* ```tsx
+* const { events, state, lastEvent } = useSSEStream({
+*   url: '/api/v1/tasks/123/stream',
+*   authToken: 'Bearer xxx',
+*   onEvent: (e) => console.log('Event:', e),
+* });
+*
+* return (
+*   <div>
+*     <p>Status: {state}</p>
+*     {events.map((e, i) => (
+*       <div key={i}>{e.event}: {JSON.stringify(e.data)}</div>
+*     ))}
+*   </div>
+* );
+* ```
+*/
+function useSSEStream(options) {
+	const { url, authToken, autoReconnect = true, maxRetries = 5, reconnectDelay = 1e3, eventTypes, onEvent, onStateChange, onError, headers, enabled = true } = options;
+	const [state, setState] = React.useState("disconnected");
+	const [events, setEvents] = React.useState([]);
+	const [lastEvent, setLastEvent] = React.useState(null);
+	const [error, setError] = React.useState(null);
+	const [lastEventTime, setLastEventTime] = React.useState(Date.now());
+	const [timeSinceLastEvent, setTimeSinceLastEvent] = React.useState(0);
+	const retryCountRef = React.useRef(0);
+	const eventSourceRef = React.useRef(null);
+	const abortControllerRef = React.useRef(null);
+	const reconnectTimeoutRef = React.useRef(null);
+	const lastEventIdRef = React.useRef(void 0);
+	React.useEffect(() => {
+		const interval = setInterval(() => {
+			setTimeSinceLastEvent(Date.now() - lastEventTime);
+		}, 1e3);
+		return () => clearInterval(interval);
+	}, [lastEventTime]);
+	React.useEffect(() => {
+		onStateChange?.(state);
+	}, [state, onStateChange]);
+	const handleEvent = React.useCallback((eventType, data, id) => {
+		const event = {
+			id,
+			event: eventType,
+			data,
+			timestamp: Date.now()
+		};
+		if (id) lastEventIdRef.current = id;
+		setLastEventTime(Date.now());
+		setLastEvent(event);
+		setEvents((prev) => {
+			const next = [...prev, event];
+			return next.length > 1e3 ? next.slice(-1e3) : next;
+		});
+		onEvent?.(event);
+	}, [onEvent]);
+	const disconnect = React.useCallback(() => {
+		if (reconnectTimeoutRef.current) {
+			clearTimeout(reconnectTimeoutRef.current);
+			reconnectTimeoutRef.current = null;
+		}
+		if (abortControllerRef.current) {
+			abortControllerRef.current.abort();
+			abortControllerRef.current = null;
+		}
+		if (eventSourceRef.current) {
+			eventSourceRef.current.close();
+			eventSourceRef.current = null;
+		}
+		setState("disconnected");
+	}, []);
+	const connect = React.useCallback(() => {
+		disconnect();
+		if (!url || !enabled) return;
+		setState("connecting");
+		setError(null);
+		const connectUrl = new URL(url, window.location.origin);
+		if (lastEventIdRef.current) connectUrl.searchParams.set("lastEventId", lastEventIdRef.current);
+		if (authToken || headers) {
+			abortControllerRef.current = new AbortController();
+			const fetchHeaders = {
+				Accept: "text/event-stream",
+				"Cache-Control": "no-cache",
+				...headers
+			};
+			if (authToken) fetchHeaders.Authorization = authToken.startsWith("Bearer ") ? authToken : `Bearer ${authToken}`;
+			if (lastEventIdRef.current) fetchHeaders["Last-Event-ID"] = lastEventIdRef.current;
+			fetch(connectUrl.toString(), {
+				headers: fetchHeaders,
+				signal: abortControllerRef.current.signal
+			}).then(async (response) => {
+				if (!response.ok) throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+				if (!response.body) throw new Error("Response body is null");
+				setState("connected");
+				retryCountRef.current = 0;
+				const reader = response.body.getReader();
+				const decoder = new TextDecoder();
+				let buffer = "";
+				while (true) {
+					const { done, value } = await reader.read();
+					if (done) break;
+					buffer += decoder.decode(value, { stream: true });
+					const lines = buffer.split("\n");
+					buffer = lines.pop() || "";
+					let currentEvent = "";
+					let currentData = "";
+					let currentId;
+					for (const line of lines) if (line.startsWith("event:")) currentEvent = line.slice(6).trim();
+					else if (line.startsWith("data:")) currentData += (currentData ? "\n" : "") + line.slice(5).trim();
+					else if (line.startsWith("id:")) currentId = line.slice(3).trim();
+					else if (line === "" && currentData) {
+						try {
+							const parsedData = JSON.parse(currentData);
+							const eventType = currentEvent || "message";
+							if (!eventTypes || eventTypes.includes(eventType)) handleEvent(eventType, parsedData, currentId);
+						} catch {
+							if (!eventTypes || eventTypes.includes(currentEvent || "message")) handleEvent(currentEvent || "message", currentData, currentId);
+						}
+						currentEvent = "";
+						currentData = "";
+						currentId = void 0;
+					}
+				}
+				if (autoReconnect && enabled) {
+					setState("reconnecting");
+					const delay = reconnectDelay * 2 ** retryCountRef.current;
+					reconnectTimeoutRef.current = setTimeout(() => {
+						retryCountRef.current += 1;
+						connect();
+					}, Math.min(delay, 3e4));
+				} else setState("disconnected");
+			}).catch((err) => {
+				if (err.name === "AbortError") return;
+				setError(err);
+				onError?.(err);
+				setState("error");
+				if (autoReconnect && enabled && retryCountRef.current < maxRetries) {
+					setState("reconnecting");
+					const delay = reconnectDelay * 2 ** retryCountRef.current;
+					reconnectTimeoutRef.current = setTimeout(() => {
+						retryCountRef.current += 1;
+						connect();
+					}, Math.min(delay, 3e4));
+				}
+			});
+		} else {
+			const es = new EventSource(connectUrl.toString());
+			eventSourceRef.current = es;
+			es.onopen = () => {
+				setState("connected");
+				retryCountRef.current = 0;
+			};
+			es.onerror = () => {
+				const err = /* @__PURE__ */ new Error("EventSource connection error");
+				setError(err);
+				onError?.(err);
+				if (autoReconnect && enabled && retryCountRef.current < maxRetries) {
+					setState("reconnecting");
+					es.close();
+					const delay = reconnectDelay * 2 ** retryCountRef.current;
+					reconnectTimeoutRef.current = setTimeout(() => {
+						retryCountRef.current += 1;
+						connect();
+					}, Math.min(delay, 3e4));
+				} else setState("error");
+			};
+			const types = eventTypes || ["message"];
+			for (const type of types) es.addEventListener(type, (e) => {
+				try {
+					const data = JSON.parse(e.data);
+					handleEvent(type, data, e.lastEventId);
+				} catch {
+					handleEvent(type, e.data, e.lastEventId);
+				}
+			});
+			if (!eventTypes) es.onmessage = (e) => {
+				try {
+					const data = JSON.parse(e.data);
+					handleEvent("message", data, e.lastEventId);
+				} catch {
+					handleEvent("message", e.data, e.lastEventId);
+				}
+			};
+		}
+	}, [
+		url,
+		authToken,
+		headers,
+		enabled,
+		autoReconnect,
+		maxRetries,
+		reconnectDelay,
+		eventTypes,
+		handleEvent,
+		onError,
+		disconnect
+	]);
+	React.useEffect(() => {
+		if (enabled) connect();
+		return () => disconnect();
+	}, [
+		enabled,
+		connect,
+		disconnect
+	]);
+	return {
+		state,
+		events,
+		lastEvent,
+		error,
+		connect,
+		disconnect,
+		clearEvents: React.useCallback(() => {
+			setEvents([]);
+			setLastEvent(null);
+		}, []),
+		retryCount: retryCountRef.current,
+		timeSinceLastEvent
+	};
+}
+//#endregion
+export { useSSEStream };

package/dist/hooks/use-tool-call-stream.d.ts

@@ -0,0 +1,23 @@
+import { FeedSegment } from "../run/tool-call-feed.js";
+//#region src/hooks/use-tool-call-stream.d.ts
+export interface UseToolCallStreamReturn {
+  /** Current feed segments (text + tool calls interleaved) */
+  segments: FeedSegment[];
+  /** Push a raw SSE event into the stream */
+  pushEvent: (event: {
+    type: string;
+    data: Record<string, unknown>;
+  }) => void;
+  /** Push a text delta (from message.part.updated) */
+  pushText: (delta: string) => void;
+  /** Mark a tool call as complete */
+  completeToolCall: (id: string, result: {
+    output?: string;
+    error?: string;
+    duration?: number;
+  }) => void;
+  /** Reset the stream */
+  reset: () => void;
+}
+export declare function useToolCallStream(): UseToolCallStreamReturn;
+//#endregion