@tangle-network/sandbox-ui 0.2.0

package/dist/terminal.js

@@ -0,0 +1,160 @@
+import {
+  usePtySession
+} from "./chunk-GRYHFH5O.js";
+
+// src/terminal/terminal-view.tsx
+import "@xterm/xterm/css/xterm.css";
+import { useEffect, useRef, useCallback } from "react";
+import { Terminal } from "@xterm/xterm";
+import { FitAddon } from "@xterm/addon-fit";
+import { WebLinksAddon } from "@xterm/addon-web-links";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var DEFAULT_TERMINAL_THEME = {
+  background: "#0c0c0e",
+  foreground: "#d4d4d8",
+  cursor: "#34d399",
+  cursorAccent: "#0c0c0e",
+  selectionBackground: "#7c3aed33",
+  selectionForeground: "#d4d4d8",
+  black: "#18181b",
+  red: "#ef4444",
+  green: "#34d399",
+  yellow: "#fbbf24",
+  blue: "#60a5fa",
+  magenta: "#a78bfa",
+  cyan: "#22d3ee",
+  white: "#d4d4d8",
+  brightBlack: "#52525b",
+  brightRed: "#f87171",
+  brightGreen: "#6ee7b7",
+  brightYellow: "#fde68a",
+  brightBlue: "#93c5fd",
+  brightMagenta: "#c4b5fd",
+  brightCyan: "#67e8f9",
+  brightWhite: "#fafafa"
+};
+var DEFAULT_PROMPT = "\x1B[38;5;48m$\x1B[0m ";
+function TerminalView({
+  apiUrl,
+  token,
+  theme,
+  title = "Terminal",
+  subtitle = "Connected to PTY session",
+  prompt = DEFAULT_PROMPT
+}) {
+  const resolvedTheme = { ...DEFAULT_TERMINAL_THEME, ...theme };
+  const containerRef = useRef(null);
+  const termRef = useRef(null);
+  const fitAddonRef = useRef(null);
+  const lineBufferRef = useRef("");
+  const writePrompt = useCallback(() => {
+    termRef.current?.write("\r\n" + prompt);
+  }, [prompt]);
+  const onData = useCallback((data) => {
+    termRef.current?.write(data);
+  }, []);
+  const { isConnected, error, sendCommand, reconnect } = usePtySession({
+    apiUrl,
+    token,
+    onData
+  });
+  useEffect(() => {
+    if (!containerRef.current) return;
+    const term = new Terminal({
+      theme: resolvedTheme,
+      fontFamily: '"JetBrains Mono", "Fira Code", "Cascadia Code", Menlo, monospace',
+      fontSize: 13,
+      lineHeight: 1.4,
+      cursorBlink: true,
+      cursorStyle: "bar",
+      scrollback: 5e3,
+      convertEol: true,
+      allowProposedApi: true
+    });
+    const fitAddon = new FitAddon();
+    const webLinksAddon = new WebLinksAddon();
+    term.loadAddon(fitAddon);
+    term.loadAddon(webLinksAddon);
+    term.open(containerRef.current);
+    requestAnimationFrame(() => {
+      fitAddon.fit();
+    });
+    termRef.current = term;
+    fitAddonRef.current = fitAddon;
+    const padTitle = title.padEnd(37);
+    const padSubtitle = subtitle.padEnd(37);
+    term.writeln(`\x1B[38;5;48m\u256D${"\u2500".repeat(41)}\u256E\x1B[0m`);
+    term.writeln(`\x1B[38;5;48m\u2502\x1B[0m  \x1B[1m${padTitle}\x1B[0m\x1B[38;5;48m\u2502\x1B[0m`);
+    term.writeln(`\x1B[38;5;48m\u2502\x1B[0m  ${padSubtitle}\x1B[38;5;48m\u2502\x1B[0m`);
+    term.writeln(`\x1B[38;5;48m\u2570${"\u2500".repeat(41)}\u256F\x1B[0m`);
+    term.write(prompt);
+    term.onData((data) => {
+      const code = data.charCodeAt(0);
+      if (data === "\r") {
+        const cmd = lineBufferRef.current;
+        lineBufferRef.current = "";
+        term.write("\r\n");
+        if (cmd.trim()) {
+          sendCommand(cmd).catch((err) => {
+            term.writeln(`\x1B[31mError: ${err instanceof Error ? err.message : String(err)}\x1B[0m`);
+            writePrompt();
+          });
+        } else {
+          term.write(prompt);
+        }
+      } else if (data === "\x7F" || data === "\b") {
+        if (lineBufferRef.current.length > 0) {
+          lineBufferRef.current = lineBufferRef.current.slice(0, -1);
+          term.write("\b \b");
+        }
+      } else if (data === "") {
+        lineBufferRef.current = "";
+        term.write("^C");
+        writePrompt();
+      } else if (data === "\f") {
+        term.clear();
+        term.write(prompt);
+      } else if (code >= 32) {
+        lineBufferRef.current += data;
+        term.write(data);
+      }
+    });
+    const ro = new ResizeObserver(() => {
+      requestAnimationFrame(() => {
+        fitAddon.fit();
+      });
+    });
+    ro.observe(containerRef.current);
+    return () => {
+      ro.disconnect();
+      term.dispose();
+      termRef.current = null;
+      fitAddonRef.current = null;
+    };
+  }, [sendCommand, writePrompt, prompt, resolvedTheme, title, subtitle]);
+  return /* @__PURE__ */ jsxs("div", { className: "relative h-full w-full", children: [
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref: containerRef,
+        className: "h-full w-full rounded-lg overflow-hidden",
+        style: { backgroundColor: resolvedTheme.background }
+      }
+    ),
+    (!isConnected || error) && /* @__PURE__ */ jsx("div", { className: "absolute inset-0 flex items-center justify-center bg-black/60 rounded-lg", children: /* @__PURE__ */ jsx("div", { className: "text-center", children: error ? /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx("p", { className: "text-sm text-red-400 mb-3", children: error }),
+      /* @__PURE__ */ jsx(
+        "button",
+        {
+          onClick: reconnect,
+          className: "text-sm text-emerald-400 hover:text-emerald-300 underline cursor-pointer",
+          children: "Retry connection"
+        }
+      )
+    ] }) : /* @__PURE__ */ jsx("p", { className: "text-sm text-neutral-400", children: "Connecting to terminal..." }) }) })
+  ] });
+}
+export {
+  DEFAULT_TERMINAL_THEME,
+  TerminalView
+};

package/dist/tool-call-feed-D5Ume-Pt.d.ts

@@ -0,0 +1,66 @@
+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;
+    duration?: number;
+    className?: string;
+}
+declare function ToolCallStep({ type, label, status, detail, output, 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-BvsVW_Ur.d.ts

@@ -0,0 +1,32 @@
+import { b as ToolPart } from './parts-CyGkM6Fp.js';
+import { ReactNode } from 'react';
+
+/**
+ * Variant-specific rendering instructions for tool output.
+ * Maps directly to specialised preview components.
+ */
+type DisplayVariant = "command" | "write-file" | "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/types.d.ts

@@ -0,0 +1,6 @@
+export { R as ReasoningPart, S as SessionMessage, a as SessionPart, T as TextPart, b as ToolPart, c as ToolState, d as ToolStatus, e as ToolTime } from './parts-CyGkM6Fp.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-CtFZ6s-D.js';
+export { S as Session } from './sidecar-CFU2W9j1.js';
+export { C as CustomToolRenderer, D as DisplayVariant, T as ToolDisplayMetadata } from './tool-display-BvsVW_Ur.js';
+export { A as AgentBranding } from './branding-DCi5VEik.js';
+import 'react';

package/dist/usage-chart-DINgSVL5.d.ts

@@ -0,0 +1,60 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+
+interface BillingSubscription {
+    status: string;
+    tierName: string;
+    renewsAt: string;
+}
+interface BillingBalance {
+    available: number;
+    used: number;
+}
+interface BillingUsage {
+    period: string;
+    total: number;
+    byModel: Record<string, number>;
+}
+interface BillingDashboardProps {
+    subscription: BillingSubscription | null;
+    balance: BillingBalance;
+    usage: BillingUsage;
+    onManageSubscription: () => void;
+    onAddCredits: () => void;
+    variant?: "sandbox";
+}
+declare function BillingDashboard({ subscription, balance, usage, onManageSubscription, onAddCredits, variant, }: BillingDashboardProps): react_jsx_runtime.JSX.Element;
+
+interface PricingTier {
+    id: string;
+    name: string;
+    description: string;
+    monthlyPriceCents: number;
+    yearlyPriceCents?: number;
+    features: string[];
+    recommended?: boolean;
+    creditsPerMonth?: number;
+}
+interface PricingPageProps {
+    tiers: PricingTier[];
+    currentTierId?: string;
+    billingPeriod: "monthly" | "yearly";
+    onBillingPeriodChange: (period: "monthly" | "yearly") => void;
+    onSelectTier: (tierId: string) => void;
+    variant?: "sandbox";
+    loading?: boolean;
+}
+declare function PricingPage({ tiers, currentTierId, billingPeriod, onBillingPeriodChange, onSelectTier, variant, loading, }: PricingPageProps): react_jsx_runtime.JSX.Element;
+
+interface UsageDataPoint {
+    date: string;
+    value: number;
+}
+interface UsageChartProps {
+    data: UsageDataPoint[];
+    title: string;
+    unit: string;
+    variant?: "agentrun" | "automateai" | "tradingbots" | "sandbox";
+}
+declare function UsageChart({ data, title, unit, variant, }: UsageChartProps): react_jsx_runtime.JSX.Element;
+
+export { type BillingSubscription as B, type PricingTier as P, type UsageDataPoint as U, type BillingBalance as a, type BillingUsage as b, BillingDashboard as c, type BillingDashboardProps as d, PricingPage as e, type PricingPageProps as f, UsageChart as g, type UsageChartProps as h };

package/dist/use-sidecar-auth-Bb0-w3lX.d.ts

@@ -0,0 +1,339 @@
+import { F as FeedSegment } from './tool-call-feed-D5Ume-Pt.js';
+import { S as SessionMessage, a as SessionPart } from './parts-CyGkM6Fp.js';
+import { G as GroupedMessage, R as Run } from './run-CtFZ6s-D.js';
+import * as React from 'react';
+import { RefObject } from 'react';
+
+/**
+ * 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 AuthUser {
+    customer_id: string;
+    email: string;
+    name?: string;
+    tier: string;
+    github?: {
+        login: string;
+        connected: boolean;
+    } | null;
+    session_expires_at?: string;
+}
+interface UseAuthOptions {
+    apiBaseUrl: string;
+    revalidateOnFocus?: boolean;
+    shouldRetryOnError?: boolean;
+}
+interface UseAuthResult {
+    user: AuthUser | null;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    mutate: () => Promise<void>;
+}
+/**
+ * Hook for managing authentication state.
+ * Fetches user session from the API and provides loading/error states.
+ */
+declare function useAuth({ apiBaseUrl, revalidateOnFocus, shouldRetryOnError, }: UseAuthOptions): UseAuthResult;
+/**
+ * Creates a fetcher function that includes auth credentials.
+ * Uses both cookie-based session and localStorage API key for backwards compatibility.
+ */
+declare function createAuthFetcher(_apiBaseUrl: string): <T = unknown>(url: string, options?: RequestInit) => Promise<T>;
+/**
+ * Hook to get the API key from localStorage.
+ * For backwards compatibility with API key-based auth.
+ */
+declare function useApiKey(): string | null;
+
+/**
+ * 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;
+}
+
+interface UseRunGroupsOptions {
+    messages: SessionMessage[];
+    partMap: Record<string, SessionPart[]>;
+    isStreaming: boolean;
+}
+declare function useRunGroups({ messages, partMap, isStreaming, }: UseRunGroupsOptions): GroupedMessage[];
+
+/**
+ * Manages per-run collapse state with auto-collapse after run completion.
+ *
+ * - Runs start expanded while streaming
+ * - Auto-collapse 1s after the run completes
+ * - Manual toggle is preserved (user override sticks)
+ */
+declare function useRunCollapseState(runs: Run[]): {
+    isCollapsed: (runId: string) => boolean;
+    toggleCollapse: (runId: string) => void;
+};
+
+/**
+ * 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;
+};
+
+/** Minimal session info returned by the listing API. */
+interface SessionInfo {
+    id: string;
+    title: string;
+    parentID?: string;
+}
+interface UseSessionStreamOptions {
+    /** Base URL of the session proxy (e.g. "http://localhost:9100"). */
+    apiUrl: string;
+    /** Bearer token for authentication. */
+    token: string | null;
+    /** Session ID to stream events for. */
+    sessionId: string;
+    /** Only connect when true. Defaults to true. */
+    enabled?: boolean;
+}
+interface UseSessionStreamResult {
+    /** All messages in the session (fetched + streaming). */
+    messages: SessionMessage[];
+    /** Part map: messageId → SessionPart[]. */
+    partMap: Record<string, SessionPart[]>;
+    /** Whether the agent is currently streaming a response. */
+    isStreaming: boolean;
+    /** Send a text message to the agent. */
+    send: (text: string) => Promise<void>;
+    /** Abort the current agent execution. */
+    abort: () => Promise<void>;
+    /** Refetch full message history from the API. */
+    refetch: () => Promise<void>;
+    /** Connection or stream error, if any. */
+    error: string | null;
+    /** Whether the SSE connection is active. */
+    connected: boolean;
+}
+/**
+ * Streams chat messages from a sidecar session gateway via SSE.
+ *
+ * Fetches existing message history on mount, then subscribes to SSE for
+ * real-time updates. Maps the sidecar's message format to agent-ui's
+ * SessionMessage + partMap format.
+ */
+declare function useSessionStream({ apiUrl, token, sessionId, enabled, }: UseSessionStreamOptions): UseSessionStreamResult;
+
+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;
+};
+
+interface UsePtySessionOptions {
+    /** Base URL of the sidecar (e.g. "http://localhost:9100"). */
+    apiUrl: string;
+    /** Bearer token for authentication. */
+    token: string;
+    /** Called with raw PTY output (may contain ANSI escape codes). */
+    onData: (data: string) => void;
+}
+interface UsePtySessionReturn {
+    /** Whether the SSE stream is connected and receiving data. */
+    isConnected: boolean;
+    /** Connection or API error, if any. */
+    error: string | null;
+    /** Send a command to the PTY session. */
+    sendCommand: (command: string) => Promise<void>;
+    /** Tear down and reconnect. */
+    reconnect: () => void;
+}
+/**
+ * Manages a PTY session against the sidecar terminal API.
+ *
+ * Protocol:
+ * - POST /terminals              → create session → { data: { sessionId } }
+ * - GET  /terminals/{id}/stream  → SSE output (raw PTY with ANSI codes)
+ * - POST /terminals/{id}/execute → send command   { command: "..." }
+ * - DELETE /terminals/{id}       → close session
+ */
+declare function usePtySession({ apiUrl, token, onData }: UsePtySessionOptions): UsePtySessionReturn;
+
+interface UseSidecarAuthOptions {
+    /** Scoping key for token storage (e.g. botId, sandboxId). */
+    resourceId: string;
+    /** Base URL of the sidecar or operator API. */
+    apiUrl: string;
+    /**
+     * Sign a plaintext message and return the hex signature.
+     * Consuming apps wire this to their wallet library (e.g. wagmi's signMessageAsync).
+     */
+    signMessage: (message: string) => Promise<string>;
+}
+interface SidecarAuth {
+    token: string | null;
+    isAuthenticated: boolean;
+    isAuthenticating: boolean;
+    authenticate: () => Promise<string | null>;
+    clearCachedToken: () => void;
+    error: string | null;
+}
+/**
+ * Generic sidecar PASETO challenge/response auth.
+ *
+ * Flow:
+ * 1. POST /api/auth/challenge  → { nonce, message, expires_at }
+ * 2. signMessage(message)       → signature (provided by consuming app)
+ * 3. POST /api/auth/session     → { token, address, expires_at }
+ *
+ * Tokens are cached in localStorage and auto-refreshed 5 minutes before expiry.
+ */
+declare function useSidecarAuth({ resourceId, apiUrl, signMessage }: UseSidecarAuthOptions): SidecarAuth;
+
+export { type AgentStreamEvent as A, type BotStreamEvent as B, type ConnectionState as C, useToolCallStream as D, type SSEEvent as S, type TaskStreamEvent as T, type UseAuthOptions as U, type AuthUser as a, type AutomationStreamEvent as b, type SessionInfo as c, type SidecarAuth as d, type TerminalStreamEvent as e, type UseAuthResult as f, type UsePtySessionOptions as g, type UsePtySessionReturn as h, type UseRunGroupsOptions as i, type UseSSEStreamOptions as j, type UseSSEStreamResult as k, type UseSessionStreamOptions as l, type UseSessionStreamResult as m, type UseSidecarAuthOptions as n, type UseToolCallStreamReturn as o, createAuthFetcher as p, useAuth as q, useAutoScroll as r, useDropdownMenu as s, usePtySession as t, useApiKey as u, useRunCollapseState as v, useRunGroups as w, useSSEStream as x, useSessionStream as y, useSidecarAuth as z };

package/dist/utils.d.ts

@@ -0,0 +1,28 @@
+import { b as ToolPart } from './parts-CyGkM6Fp.js';
+import { T as ToolDisplayMetadata } from './tool-display-BvsVW_Ur.js';
+import { T as ToolCategory } from './run-CtFZ6s-D.js';
+import { ClassValue } from 'clsx';
+import 'react';
+
+declare function cn(...inputs: ClassValue[]): string;
+
+/**
+ * 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;
+
+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;
+
+export { TOOL_CATEGORY_ICONS, cn, copyText, formatDuration, getToolCategory, getToolDisplayMetadata, getToolErrorText, timeAgo, truncateText };