@tangle-network/ui 1.0.0

package/dist/sdk-hooks.d.ts

@@ -0,0 +1,285 @@
+import * as React from 'react';
+import { RefObject } from 'react';
+import { R as Run, G as GroupedMessage } from './run-PfLmDAox.js';
+import { S as SessionMessage } from './message-BHWbxBtT.js';
+import { S as SessionPart } from './parts-dj7AcUg0.js';
+import { R as RegisterActiveSessionOptions, g as ActiveSessionTransportMode, c as ActiveSessionConnectionState } from './active-sessions-store-CeOmXgv5.js';
+import { F as FeedSegment } from './tool-call-feed-Bs3MyQMT.js';
+import 'nanostores';
+import 'react/jsx-runtime';
+
+/**
+ * Scroll-to-bottom behaviour: sticks to the bottom while streaming,
+ * pauses when user scrolls up, resumes when user scrolls back down.
+ */
+declare function useAutoScroll(containerRef: RefObject<HTMLElement | null>, deps?: unknown[]): {
+    isAtBottom: boolean;
+    scrollToBottom: () => void;
+};
+
+interface UseDropdownMenuOptions {
+    closeOnEsc?: boolean;
+}
+declare function useDropdownMenu(options?: UseDropdownMenuOptions): {
+    open: boolean;
+    setOpen: React.Dispatch<React.SetStateAction<boolean>>;
+    ref: React.RefObject<HTMLDivElement | null>;
+    toggle: () => void;
+    close: () => void;
+};
+
+/**
+ * Manages per-run collapse state with auto-collapse after run completion.
+ *
+ * - Runs stay expanded by default
+ * - Collapse is manual only
+ */
+declare function useRunCollapseState(runs: Run[]): {
+    isCollapsed: (runId: string) => boolean;
+    toggleCollapse: (runId: string) => void;
+};
+
+interface UseRunGroupsOptions {
+    messages: SessionMessage[];
+    partMap: Record<string, SessionPart[]>;
+    isStreaming: boolean;
+}
+declare function useRunGroups({ messages, partMap, isStreaming, }: UseRunGroupsOptions): GroupedMessage[];
+
+/**
+ * useToolCallStream — parses SSE events into ToolCallFeed segments.
+ *
+ * Takes raw SSE event data from the orchestrator stream and produces
+ * structured FeedSegments that ToolCallFeed can render.
+ */
+
+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;
+}
+declare function useToolCallStream(): UseToolCallStreamReturn;
+
+interface SdkSessionAttachment {
+    name: string;
+    size?: number;
+}
+interface SdkSessionSeed {
+    id: string;
+    role: SessionMessage["role"];
+    createdAt?: number | string | Date;
+    content?: string;
+    attachments?: SdkSessionAttachment[];
+    parts?: SessionPart[];
+}
+interface SdkSessionEvent {
+    type: string;
+    data?: Record<string, unknown>;
+}
+interface BeginAssistantMessageOptions {
+    id?: string;
+    role?: Extract<SessionMessage["role"], "assistant" | "system">;
+    createdAt?: number | string | Date;
+}
+interface AppendUserMessageOptions {
+    id?: string;
+    role?: Extract<SessionMessage["role"], "user" | "system">;
+    content: string;
+    createdAt?: number | string | Date;
+    attachments?: SdkSessionAttachment[];
+}
+interface CompleteAssistantMessageOptions {
+    messageId?: string;
+    finalText?: string;
+}
+interface ApplySdkEventOptions {
+    messageId?: string;
+}
+interface UseSdkSessionOptions {
+    initialMessages?: SdkSessionSeed[];
+}
+interface UseSdkSessionReturn {
+    messages: SessionMessage[];
+    partMap: Record<string, SessionPart[]>;
+    isStreaming: boolean;
+    activeAssistantMessageId: string | null;
+    replaceHistory: (messages: SdkSessionSeed[]) => void;
+    appendUserMessage: (message: AppendUserMessageOptions) => string;
+    beginAssistantMessage: (options?: BeginAssistantMessageOptions) => string;
+    applySdkEvent: (event: SdkSessionEvent, options?: ApplySdkEventOptions) => void;
+    completeAssistantMessage: (options?: CompleteAssistantMessageOptions) => void;
+    failAssistantMessage: (error: string, options?: {
+        messageId?: string;
+    }) => void;
+    setStreaming: (value: boolean) => void;
+    reset: () => void;
+}
+declare function useSdkSession({ initialMessages, }?: UseSdkSessionOptions): UseSdkSessionReturn;
+
+interface RealtimeSessionOptions extends RegisterActiveSessionOptions {
+    connectUrl?: string | null;
+    enabled?: boolean;
+    foreground?: boolean;
+    keepRegistered?: boolean;
+    reconnect?: boolean;
+    reconnectIntervalMs?: number;
+    maxReconnectAttempts?: number;
+    transportMode?: ActiveSessionTransportMode;
+    onEvent?: (event: SdkSessionEvent) => void;
+    onOpen?: () => void;
+    onClose?: () => void;
+    onError?: (error: Error) => void;
+}
+interface RealtimeSessionState {
+    connectionState: ActiveSessionConnectionState;
+    lastError: string | null;
+    reconnectAttempts: number;
+    isConnected: boolean;
+}
+interface RealtimeSessionTarget extends RealtimeSessionOptions {
+    key?: string;
+}
+interface RealtimeSessionRegistryProps {
+    sessions: RealtimeSessionTarget[];
+}
+declare function useRealtimeSession({ sessionId, projectId, projectLabel, title, href, metadata, connectUrl, enabled, foreground, keepRegistered, reconnect, reconnectIntervalMs, maxReconnectAttempts, transportMode, onEvent, onOpen, onClose, onError, }: RealtimeSessionOptions): RealtimeSessionState;
+declare function RealtimeSessionRegistry({ sessions }: RealtimeSessionRegistryProps): React.FunctionComponentElement<RealtimeSessionTarget>[];
+
+/**
+ * SSE Event data structure
+ */
+interface SSEEvent<T = unknown> {
+    id?: string;
+    event: string;
+    data: T;
+    timestamp: number;
+}
+/**
+ * Connection state for SSE streams
+ */
+type ConnectionState = "connecting" | "connected" | "reconnecting" | "disconnected" | "error";
+/**
+ * SSE stream options
+ */
+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
+ */
+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>
+ * );
+ * ```
+ */
+declare function useSSEStream<T = unknown>(options: UseSSEStreamOptions<T>): UseSSEStreamResult<T>;
+/**
+ * Typed event types for common streaming scenarios
+ */
+interface TaskStreamEvent {
+    task_id: string;
+    status?: string;
+    progress?: number;
+    message?: string;
+    result?: unknown;
+    error?: string;
+}
+interface AgentStreamEvent {
+    type: "message.updated" | "tool_call" | "tool_result" | "llm_response" | "error" | "session.idle" | "execution.started" | "execution.result";
+    data: unknown;
+    timestamp?: number;
+}
+interface TerminalStreamEvent {
+    type: "output" | "input" | "error" | "exit";
+    data: string;
+    timestamp: number;
+}
+interface AutomationStreamEvent {
+    automation_id: string;
+    event_id?: string;
+    status?: string;
+    variant_id?: string;
+    output?: string;
+    action_result?: unknown;
+    error?: string;
+}
+interface BotStreamEvent {
+    bot_id: string;
+    type: "balance" | "trade" | "decision" | "log" | "error";
+    data: unknown;
+    timestamp: number;
+}
+
+export { type AgentStreamEvent, type AppendUserMessageOptions, type ApplySdkEventOptions, type AutomationStreamEvent, type BeginAssistantMessageOptions, type BotStreamEvent, type CompleteAssistantMessageOptions, type ConnectionState, type RealtimeSessionOptions, RealtimeSessionRegistry, type RealtimeSessionRegistryProps, type RealtimeSessionState, type RealtimeSessionTarget, type SSEEvent, type SdkSessionAttachment, type SdkSessionEvent, type SdkSessionSeed, type TaskStreamEvent, type TerminalStreamEvent, type UseRunGroupsOptions, type UseSSEStreamOptions, type UseSSEStreamResult, type UseSdkSessionOptions, type UseSdkSessionReturn, type UseToolCallStreamReturn, useAutoScroll, useDropdownMenu, useRealtimeSession, useRunCollapseState, useRunGroups, useSSEStream, useSdkSession, useToolCallStream };

package/dist/sdk-hooks.js

@@ -0,0 +1,31 @@
+import {
+  RealtimeSessionRegistry,
+  useDropdownMenu,
+  useRealtimeSession,
+  useSSEStream,
+  useSdkSession,
+  useToolCallStream
+} from "./chunk-YJ2G3XO5.js";
+import "./chunk-OEX7NZE3.js";
+import {
+  useAutoScroll,
+  useRunCollapseState,
+  useRunGroups
+} from "./chunk-54SQQMMM.js";
+import "./chunk-7UO2ZMRQ.js";
+import "./chunk-2VH6PUXD.js";
+import "./chunk-BX6AQMUS.js";
+import "./chunk-CD53GZOM.js";
+import "./chunk-66BNMOVT.js";
+import "./chunk-RQHJBTEU.js";
+export {
+  RealtimeSessionRegistry,
+  useAutoScroll,
+  useDropdownMenu,
+  useRealtimeSession,
+  useRunCollapseState,
+  useRunGroups,
+  useSSEStream,
+  useSdkSession,
+  useToolCallStream
+};

package/dist/stores.d.ts

@@ -0,0 +1,17 @@
+export { A as ActiveProjectActivity, a as ActiveSessionActivityOptions, b as ActiveSessionConnectionOptions, c as ActiveSessionConnectionState, d as ActiveSessionReconnectState, e as ActiveSessionRecord, f as ActiveSessionStatus, g as ActiveSessionTransportMode, h as ActiveSessionsState, R as RegisterActiveSessionOptions, S as SessionProjectKey, i as activeSessionsAtom, j as bumpActiveSessionActivity, k as getActiveSession, l as getAllActiveSessions, m as getAllProjectActivity, n as getSessionsByActivity, o as getSessionsForNavbar, p as getSessionsForProject, q as getTotalRunningSessionCount, r as hasBackgroundRunningSessions, s as registerActiveSession, t as resetActiveSessions, u as setActiveSessionAttention, v as setActiveSessionConnection, w as setActiveSessionError, x as setActiveSessionRunning, y as setForegroundActiveSession, z as unregisterActiveSession, B as updateActiveSessionMeta, C as useActiveSession, D as useActiveSessions, E as useActiveSessionsState, F as useHasBackgroundRunningSessions, G as useNavbarSessions, H as useProjectActivity, I as useProjectSessions, J as useSessionsByActivity, K as useTotalRunningSessions } from './active-sessions-store-CeOmXgv5.js';
+import * as nanostores from 'nanostores';
+import { S as SessionMessage } from './message-BHWbxBtT.js';
+import { S as SessionPart } from './parts-dj7AcUg0.js';
+
+/** Ordered list of messages in the current chat session. */
+declare const messagesAtom: nanostores.PreinitializedWritableAtom<SessionMessage[]> & object;
+/** Map of message ID → parts for that message. */
+declare const partMapAtom: nanostores.PreinitializedMapStore<Record<string, SessionPart[]>> & object;
+/** Whether the assistant is currently streaming a response. */
+declare const isStreamingAtom: nanostores.PreinitializedWritableAtom<boolean> & object;
+declare function addMessage(msg: SessionMessage): void;
+declare function addParts(messageId: string, parts: SessionPart[]): void;
+declare function updatePart(messageId: string, partIndex: number, part: SessionPart): void;
+declare function clearChat(): void;
+
+export { addMessage, addParts, clearChat, isStreamingAtom, messagesAtom, partMapAtom, updatePart };

package/dist/stores.js

@@ -0,0 +1,76 @@
+import {
+  addMessage,
+  addParts,
+  clearChat,
+  isStreamingAtom,
+  messagesAtom,
+  partMapAtom,
+  updatePart
+} from "./chunk-HFL6R6IF.js";
+import {
+  activeSessionsAtom,
+  bumpActiveSessionActivity,
+  getActiveSession,
+  getAllActiveSessions,
+  getAllProjectActivity,
+  getSessionsByActivity,
+  getSessionsForNavbar,
+  getSessionsForProject,
+  getTotalRunningSessionCount,
+  hasBackgroundRunningSessions,
+  registerActiveSession,
+  resetActiveSessions,
+  setActiveSessionAttention,
+  setActiveSessionConnection,
+  setActiveSessionError,
+  setActiveSessionRunning,
+  setForegroundActiveSession,
+  unregisterActiveSession,
+  updateActiveSessionMeta,
+  useActiveSession,
+  useActiveSessions,
+  useActiveSessionsState,
+  useHasBackgroundRunningSessions,
+  useNavbarSessions,
+  useProjectActivity,
+  useProjectSessions,
+  useSessionsByActivity,
+  useTotalRunningSessions
+} from "./chunk-OEX7NZE3.js";
+export {
+  activeSessionsAtom,
+  addMessage,
+  addParts,
+  bumpActiveSessionActivity,
+  clearChat,
+  getActiveSession,
+  getAllActiveSessions,
+  getAllProjectActivity,
+  getSessionsByActivity,
+  getSessionsForNavbar,
+  getSessionsForProject,
+  getTotalRunningSessionCount,
+  hasBackgroundRunningSessions,
+  isStreamingAtom,
+  messagesAtom,
+  partMapAtom,
+  registerActiveSession,
+  resetActiveSessions,
+  setActiveSessionAttention,
+  setActiveSessionConnection,
+  setActiveSessionError,
+  setActiveSessionRunning,
+  setForegroundActiveSession,
+  unregisterActiveSession,
+  updateActiveSessionMeta,
+  updatePart,
+  useActiveSession,
+  useActiveSessions,
+  useActiveSessionsState,
+  useHasBackgroundRunningSessions,
+  useNavbarSessions,
+  useProjectActivity,
+  useProjectSessions,
+  useSessionsByActivity,
+  useTotalRunningSessions
+};

package/dist/tool-call-feed-Bs3MyQMT.d.ts

@@ -0,0 +1,68 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+
+type ToolCallType = "bash" | "read" | "write" | "edit" | "glob" | "grep" | "list" | "download" | "inspect" | "audit" | "unknown";
+type ToolCallStatus = "running" | "success" | "error";
+interface ToolCallStepProps {
+    type: ToolCallType;
+    label: string;
+    status: ToolCallStatus;
+    detail?: string;
+    output?: string;
+    /** Override syntax highlighting language; inferred from detail path if omitted */
+    language?: string;
+    duration?: number;
+    className?: string;
+}
+declare function ToolCallStep({ type, label, status, detail, output, language, duration, className, }: ToolCallStepProps): react_jsx_runtime.JSX.Element;
+/**
+ * ToolCallGroup — groups multiple tool calls under a heading.
+ */
+interface ToolCallGroupProps {
+    title?: string;
+    children: ReactNode;
+    className?: string;
+}
+declare function ToolCallGroup({ title, children, className }: ToolCallGroupProps): react_jsx_runtime.JSX.Element;
+
+interface ToolCallData {
+    id: string;
+    type: ToolCallType;
+    label: string;
+    status: ToolCallStatus;
+    detail?: string;
+    output?: string;
+    duration?: number;
+}
+type FeedSegment = {
+    kind: "text";
+    content: string;
+} | {
+    kind: "tool_call";
+    call: ToolCallData;
+} | {
+    kind: "tool_group";
+    title?: string;
+    calls: ToolCallData[];
+};
+interface ToolCallFeedProps {
+    segments: FeedSegment[];
+    className?: string;
+}
+/**
+ * Renders a feed of interleaved text and tool calls.
+ */
+declare function ToolCallFeed({ segments, className }: ToolCallFeedProps): react_jsx_runtime.JSX.Element | null;
+/**
+ * Parse raw SSE tool events into FeedSegments.
+ *
+ * This is the bridge between the orchestrator's SSE stream format
+ * and the ToolCallFeed component. Consumers call this in their
+ * useToolCallStream hook.
+ */
+declare function parseToolEvent(event: {
+    type: string;
+    data: Record<string, unknown>;
+}): ToolCallData | null;
+
+export { type FeedSegment as F, type ToolCallData as T, ToolCallFeed as a, type ToolCallFeedProps as b, ToolCallGroup as c, type ToolCallGroupProps as d, type ToolCallStatus as e, ToolCallStep as f, type ToolCallStepProps as g, type ToolCallType as h, parseToolEvent as p };

package/dist/tool-display-z4JcDmMQ.d.ts

@@ -0,0 +1,32 @@
+import { a as ToolPart } from './parts-dj7AcUg0.js';
+import { ReactNode } from 'react';
+
+/**
+ * Variant-specific rendering instructions for tool output.
+ * Maps directly to specialised preview components.
+ */
+type DisplayVariant = "command" | "write-file" | "read-file" | "diff" | "question" | "web-search" | "grep" | "glob" | "default";
+/**
+ * Custom renderer for tool details. Return a ReactNode to override the
+ * default ExpandedToolDetail, or null to fall back to the built-in renderer.
+ */
+type CustomToolRenderer = (part: ToolPart) => ReactNode | null;
+/**
+ * Visual metadata for a tool invocation — computed from the tool name,
+ * input, and output by `getToolDisplayMetadata()`.
+ */
+interface ToolDisplayMetadata {
+    title: string;
+    description?: string;
+    inputTitle?: string;
+    outputTitle?: string;
+    inputLanguage?: string;
+    outputLanguage?: string;
+    hasDiffOutput?: boolean;
+    diffFilePath?: string;
+    displayVariant?: DisplayVariant;
+    commandSnippet?: string;
+    targetPath?: string;
+}
+
+export type { CustomToolRenderer as C, DisplayVariant as D, ToolDisplayMetadata as T };

package/dist/tool-previews.d.ts

@@ -0,0 +1,48 @@
+import * as React from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { a as ToolPart } from './parts-dj7AcUg0.js';
+
+interface CommandPreviewProps {
+    part: ToolPart;
+}
+/**
+ * Terminal-style command output preview.
+ * Shows the command, exit code, and stdout/stderr with expand/collapse.
+ */
+declare const CommandPreview: React.MemoExoticComponent<({ part }: CommandPreviewProps) => react_jsx_runtime.JSX.Element>;
+
+interface WriteFilePreviewProps {
+    part: ToolPart;
+}
+/**
+ * Preview for file write/create operations.
+ * Shows file path, line count, and the written content.
+ */
+declare const WriteFilePreview: React.MemoExoticComponent<({ part }: WriteFilePreviewProps) => react_jsx_runtime.JSX.Element | null>;
+
+interface GrepResultsPreviewProps {
+    part: ToolPart;
+}
+declare const GrepResultsPreview: React.MemoExoticComponent<({ part }: GrepResultsPreviewProps) => react_jsx_runtime.JSX.Element>;
+
+interface GlobResultsPreviewProps {
+    part: ToolPart;
+}
+declare const GlobResultsPreview: React.MemoExoticComponent<({ part }: GlobResultsPreviewProps) => react_jsx_runtime.JSX.Element>;
+
+interface WebSearchPreviewProps {
+    part: ToolPart;
+}
+declare const WebSearchPreview: React.MemoExoticComponent<({ part }: WebSearchPreviewProps) => react_jsx_runtime.JSX.Element>;
+
+interface QuestionPreviewProps {
+    part: ToolPart;
+}
+declare const QuestionPreview: React.MemoExoticComponent<({ part }: QuestionPreviewProps) => react_jsx_runtime.JSX.Element>;
+
+interface DiffPreviewProps {
+    part: ToolPart;
+}
+declare const DiffPreview: React.MemoExoticComponent<({ part }: DiffPreviewProps) => react_jsx_runtime.JSX.Element>;
+
+export { CommandPreview, type CommandPreviewProps, DiffPreview, type DiffPreviewProps, GlobResultsPreview, type GlobResultsPreviewProps, GrepResultsPreview, type GrepResultsPreviewProps, QuestionPreview, type QuestionPreviewProps, WebSearchPreview, type WebSearchPreviewProps, WriteFilePreview, type WriteFilePreviewProps };

package/dist/tool-previews.js

@@ -0,0 +1,21 @@
+import "./chunk-3OI2QKFD.js";
+import {
+  CommandPreview,
+  DiffPreview,
+  GlobResultsPreview,
+  GrepResultsPreview,
+  QuestionPreview,
+  WebSearchPreview,
+  WriteFilePreview
+} from "./chunk-XIHMJ7ZQ.js";
+import "./chunk-66BNMOVT.js";
+import "./chunk-RQHJBTEU.js";
+export {
+  CommandPreview,
+  DiffPreview,
+  GlobResultsPreview,
+  GrepResultsPreview,
+  QuestionPreview,
+  WebSearchPreview,
+  WriteFilePreview
+};

package/dist/types.d.ts

@@ -0,0 +1,19 @@
+export { S as SessionMessage } from './message-BHWbxBtT.js';
+export { R as ReasoningPart, S as SessionPart, T as TextPart, a as ToolPart, b as ToolState, c as ToolStatus, d as ToolTime } from './parts-dj7AcUg0.js';
+export { F as FinalTextPart, G as GroupedMessage, M as MessageRun, a as MessageUser, R as Run, b as RunStats, T as ToolCategory } from './run-PfLmDAox.js';
+export { C as CustomToolRenderer, D as DisplayVariant, T as ToolDisplayMetadata } from './tool-display-z4JcDmMQ.js';
+import 'react';
+
+/** Visual branding for a run group header — injected by consuming app. */
+interface AgentBranding {
+    label: string;
+    accentClass: string;
+    bgClass: string;
+    containerBgClass: string;
+    borderClass: string;
+    /** CSS class for the agent icon (legacy). Ignored when using lucide-react icons. */
+    iconClass: string;
+    textClass: string;
+}
+
+export type { AgentBranding };

package/dist/types.js

@@ -0,0 +1 @@
+import "./chunk-6BGQA4BQ.js";

package/dist/utils.d.ts

@@ -0,0 +1,45 @@
+import { a as ToolPart } from './parts-dj7AcUg0.js';
+import { T as ToolDisplayMetadata } from './tool-display-z4JcDmMQ.js';
+import { T as ToolCategory } from './run-PfLmDAox.js';
+import { ClassValue } from 'clsx';
+import 'react';
+import './message-BHWbxBtT.js';
+
+/**
+ * Copy text to clipboard with a non-secure-context fallback.
+ * Returns true if a copy strategy likely succeeded.
+ */
+declare function copyText(text: string): Promise<boolean>;
+
+/** Format a duration in milliseconds to a human-readable string. */
+declare function formatDuration(ms: number): string;
+/** Truncate text to `max` characters, appending "..." if truncated. */
+declare function truncateText(text: string, max: number): string;
+/**
+ * Format an uptime duration in milliseconds with progressive
+ * granularity, so short-lived sandboxes don't render as "0d 0h".
+ *  - < 60s        → "Ns"
+ *  - < 60m        → "Nm Ss"
+ *  - < 24h        → "Nh Mm"
+ *  - otherwise    → "Nd Hh"
+ */
+declare function formatUptime(ms: number): string;
+/**
+ * Format a byte count using binary units (KiB/MiB/GiB, surfaced as
+ * "KB/MB/GB" for readability). KB and MB use one decimal below 10 and
+ * round above; GB keeps two decimals below 10 so half-GB changes stay
+ * visible on memory dashboards, and drops to one decimal above.
+ */
+declare function formatBytes(bytes: number): string;
+
+declare function timeAgo(ts: number): string;
+
+declare const TOOL_CATEGORY_ICONS: Record<ToolCategory, string>;
+declare function getToolCategory(toolName: string): ToolCategory;
+declare function getToolDisplayMetadata(part: ToolPart): ToolDisplayMetadata;
+/** Extract error text from a tool part, if any. */
+declare function getToolErrorText(part: ToolPart, fallback?: string): string | undefined;
+
+declare function cn(...inputs: ClassValue[]): string;
+
+export { TOOL_CATEGORY_ICONS, cn, copyText, formatBytes, formatDuration, formatUptime, getToolCategory, getToolDisplayMetadata, getToolErrorText, timeAgo, truncateText };

package/dist/utils.js

@@ -0,0 +1,32 @@
+import {
+  copyText,
+  timeAgo
+} from "./chunk-XGKULLYE.js";
+import {
+  formatBytes,
+  formatDuration,
+  formatUptime,
+  truncateText
+} from "./chunk-4CLN43XT.js";
+import {
+  TOOL_CATEGORY_ICONS,
+  getToolCategory,
+  getToolDisplayMetadata,
+  getToolErrorText
+} from "./chunk-BX6AQMUS.js";
+import {
+  cn
+} from "./chunk-RQHJBTEU.js";
+export {
+  TOOL_CATEGORY_ICONS,
+  cn,
+  copyText,
+  formatBytes,
+  formatDuration,
+  formatUptime,
+  getToolCategory,
+  getToolDisplayMetadata,
+  getToolErrorText,
+  timeAgo,
+  truncateText
+};