@tangle-network/sandbox-ui 0.2.0

package/dist/chunk-HYEAX3DC.js

@@ -0,0 +1,822 @@
+import {
+  parseToolEvent
+} from "./chunk-M6VLC32S.js";
+
+// src/hooks/use-tool-call-stream.ts
+import { useState, useCallback, useRef } from "react";
+function useToolCallStream() {
+  const [segments, setSegments] = useState([]);
+  const pendingToolsRef = useRef(/* @__PURE__ */ new Map());
+  const lastSegmentKindRef = useRef(null);
+  const pushText = useCallback((delta) => {
+    setSegments((prev) => {
+      const last = prev[prev.length - 1];
+      if (last && last.kind === "text") {
+        return [...prev.slice(0, -1), { kind: "text", content: last.content + delta }];
+      }
+      return [...prev, { kind: "text", content: delta }];
+    });
+    lastSegmentKindRef.current = "text";
+  }, []);
+  const pushEvent = useCallback((event) => {
+    const toolCall = parseToolEvent(event);
+    if (!toolCall) return;
+    if (event.type === "tool.invocation" || event.type === "tool_use") {
+      pendingToolsRef.current.set(toolCall.id, toolCall);
+      setSegments((prev) => [
+        ...prev,
+        { kind: "tool_call", call: { ...toolCall, status: "running" } }
+      ]);
+      lastSegmentKindRef.current = "tool";
+    }
+  }, []);
+  const completeToolCall = useCallback(
+    (id, result) => {
+      const pending = pendingToolsRef.current.get(id);
+      if (pending) {
+        pending.status = result.error ? "error" : "success";
+        pending.output = result.output || result.error;
+        pending.duration = result.duration;
+        pendingToolsRef.current.delete(id);
+      }
+      setSegments(
+        (prev) => prev.map((seg) => {
+          if (seg.kind === "tool_call" && seg.call.id === id) {
+            return {
+              kind: "tool_call",
+              call: {
+                ...seg.call,
+                status: result.error ? "error" : "success",
+                output: result.output || result.error,
+                duration: result.duration
+              }
+            };
+          }
+          return seg;
+        })
+      );
+    },
+    []
+  );
+  const reset = useCallback(() => {
+    setSegments([]);
+    pendingToolsRef.current.clear();
+    lastSegmentKindRef.current = null;
+  }, []);
+  return { segments, pushEvent, pushText, completeToolCall, reset };
+}
+
+// src/hooks/use-auth.ts
+import * as React from "react";
+function useAuth({
+  apiBaseUrl,
+  revalidateOnFocus = false,
+  shouldRetryOnError = false
+}) {
+  const [user, setUser] = React.useState(null);
+  const [isLoading, setIsLoading] = React.useState(true);
+  const [error, setError] = React.useState(null);
+  const fetchSession = React.useCallback(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const res = await fetch(`${apiBaseUrl}/auth/session`, {
+        credentials: "include"
+      });
+      if (!res.ok) {
+        throw new Error("Not authenticated");
+      }
+      const data = await res.json();
+      if (data.success && data.data) {
+        setUser(data.data);
+      } else {
+        setUser(null);
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Unknown error"));
+      setUser(null);
+      if (shouldRetryOnError) {
+        setTimeout(fetchSession, 5e3);
+      }
+    } finally {
+      setIsLoading(false);
+    }
+  }, [apiBaseUrl, shouldRetryOnError]);
+  React.useEffect(() => {
+    fetchSession();
+  }, [fetchSession]);
+  React.useEffect(() => {
+    if (!revalidateOnFocus) return;
+    const handleFocus = () => {
+      fetchSession();
+    };
+    window.addEventListener("focus", handleFocus);
+    return () => window.removeEventListener("focus", handleFocus);
+  }, [revalidateOnFocus, fetchSession]);
+  return {
+    user,
+    isLoading,
+    isError: !!error,
+    error,
+    mutate: fetchSession
+  };
+}
+function createAuthFetcher(_apiBaseUrl) {
+  return async function authFetcher(url, options) {
+    const res = await fetch(url, {
+      ...options,
+      credentials: "include",
+      headers: {
+        ...options?.headers
+      }
+    });
+    if (!res.ok) {
+      throw new Error(`Request failed with status ${res.status}`);
+    }
+    return res.json();
+  };
+}
+function useApiKey() {
+  const [apiKey, setApiKey] = React.useState(null);
+  React.useEffect(() => {
+    if (typeof window !== "undefined") {
+      setApiKey(localStorage.getItem("apiKey"));
+    }
+  }, []);
+  return apiKey;
+}
+
+// src/hooks/use-sse-stream.ts
+import * as React2 from "react";
+function useSSEStream(options) {
+  const {
+    url,
+    authToken,
+    autoReconnect = true,
+    maxRetries = 5,
+    reconnectDelay = 1e3,
+    eventTypes,
+    onEvent,
+    onStateChange,
+    onError,
+    headers,
+    enabled = true
+  } = options;
+  const [state, setState] = React2.useState("disconnected");
+  const [events, setEvents] = React2.useState([]);
+  const [lastEvent, setLastEvent] = React2.useState(null);
+  const [error, setError] = React2.useState(null);
+  const [retryCount, setRetryCount] = React2.useState(0);
+  const [lastEventTime, setLastEventTime] = React2.useState(Date.now());
+  const [timeSinceLastEvent, setTimeSinceLastEvent] = React2.useState(0);
+  const eventSourceRef = React2.useRef(null);
+  const abortControllerRef = React2.useRef(null);
+  const reconnectTimeoutRef = React2.useRef(null);
+  const lastEventIdRef = React2.useRef(void 0);
+  React2.useEffect(() => {
+    const interval = setInterval(() => {
+      setTimeSinceLastEvent(Date.now() - lastEventTime);
+    }, 1e3);
+    return () => clearInterval(interval);
+  }, [lastEventTime]);
+  React2.useEffect(() => {
+    onStateChange?.(state);
+  }, [state, onStateChange]);
+  const handleEvent = React2.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) => [...prev, event]);
+      onEvent?.(event);
+    },
+    [onEvent]
+  );
+  const disconnect = React2.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 = React2.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");
+        setRetryCount(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 ** retryCount;
+          reconnectTimeoutRef.current = setTimeout(
+            () => {
+              setRetryCount((c) => c + 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 && retryCount < maxRetries) {
+          setState("reconnecting");
+          const delay = reconnectDelay * 2 ** retryCount;
+          reconnectTimeoutRef.current = setTimeout(
+            () => {
+              setRetryCount((c) => c + 1);
+              connect();
+            },
+            Math.min(delay, 3e4)
+          );
+        }
+      });
+    } else {
+      const es = new EventSource(connectUrl.toString());
+      eventSourceRef.current = es;
+      es.onopen = () => {
+        setState("connected");
+        setRetryCount(0);
+      };
+      es.onerror = () => {
+        const err = new Error("EventSource connection error");
+        setError(err);
+        onError?.(err);
+        if (autoReconnect && enabled && retryCount < maxRetries) {
+          setState("reconnecting");
+          es.close();
+          const delay = reconnectDelay * 2 ** retryCount;
+          reconnectTimeoutRef.current = setTimeout(
+            () => {
+              setRetryCount((c) => c + 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,
+    retryCount,
+    eventTypes,
+    handleEvent,
+    onError,
+    disconnect
+  ]);
+  React2.useEffect(() => {
+    if (enabled) {
+      connect();
+    }
+    return () => disconnect();
+  }, [enabled, connect, disconnect]);
+  const clearEvents = React2.useCallback(() => {
+    setEvents([]);
+    setLastEvent(null);
+  }, []);
+  return {
+    state,
+    events,
+    lastEvent,
+    error,
+    connect,
+    disconnect,
+    clearEvents,
+    retryCount,
+    timeSinceLastEvent
+  };
+}
+
+// src/hooks/use-session-stream.ts
+import { useCallback as useCallback4, useEffect as useEffect3, useRef as useRef3, useState as useState4 } from "react";
+var _insertionCounter = 0;
+function mapApiMessage(msg) {
+  const created = msg.info.timestamp ? new Date(msg.info.timestamp).getTime() : Date.now();
+  const message = {
+    id: msg.info.id,
+    role: msg.info.role,
+    time: { created },
+    _insertionIndex: _insertionCounter++
+  };
+  const parts = (msg.parts ?? []).map((p, i) => {
+    if (p.type === "tool" && p.tool) {
+      return {
+        type: "tool",
+        id: p.id ?? `${msg.info.id}-tool-${i}`,
+        tool: p.tool,
+        state: {
+          status: p.state?.status ?? "completed",
+          input: p.state?.input,
+          output: p.state?.output,
+          error: p.state?.error,
+          metadata: p.state?.metadata,
+          time: p.time
+        }
+      };
+    }
+    if (p.type === "reasoning") {
+      return {
+        type: "reasoning",
+        text: p.text ?? "",
+        time: p.time
+      };
+    }
+    return { type: "text", text: p.text ?? "" };
+  });
+  return { message, parts };
+}
+async function fetchJson(url, token, init) {
+  const headers = { Authorization: `Bearer ${token}` };
+  if (init?.body) headers["Content-Type"] = "application/json";
+  const res = await fetch(url, { ...init, headers: { ...headers, ...init?.headers } });
+  if (!res.ok) throw new Error(`HTTP ${res.status}: ${res.statusText}`);
+  return res.json();
+}
+function useSessionStream({
+  apiUrl,
+  token,
+  sessionId,
+  enabled = true
+}) {
+  const [messages, setMessages] = useState4([]);
+  const [partMap, setPartMap] = useState4({});
+  const [isStreaming, setIsStreaming] = useState4(false);
+  const [error, setError] = useState4(null);
+  const [connected, setConnected] = useState4(false);
+  const abortRef = useRef3(null);
+  const streamingMsgIdRef = useRef3(null);
+  const refetch = useCallback4(async () => {
+    if (!token || !sessionId || !apiUrl) return;
+    try {
+      const url = `${apiUrl}/session/sessions/${encodeURIComponent(sessionId)}/messages?limit=200`;
+      const data = await fetchJson(url, token);
+      const apiMessages = Array.isArray(data) ? data : data.messages ?? [];
+      const newMessages = [];
+      const newPartMap = {};
+      for (const apiMsg of apiMessages) {
+        const { message, parts } = mapApiMessage(apiMsg);
+        newMessages.push(message);
+        newPartMap[message.id] = parts;
+      }
+      setMessages(newMessages);
+      setPartMap(newPartMap);
+      streamingMsgIdRef.current = null;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : "Failed to fetch messages";
+      setError(msg);
+    }
+  }, [apiUrl, token, sessionId]);
+  const connectSSE = useCallback4(async () => {
+    if (!token || !sessionId || !apiUrl || !enabled) return;
+    abortRef.current?.abort();
+    const controller = new AbortController();
+    abortRef.current = controller;
+    try {
+      const url = `${apiUrl}/session/events?sessionId=${encodeURIComponent(sessionId)}`;
+      const res = await fetch(url, {
+        headers: { Authorization: `Bearer ${token}` },
+        signal: controller.signal
+      });
+      if (!res.ok) throw new Error(`SSE connection failed: ${res.status}`);
+      setConnected(true);
+      setError(null);
+      const reader = res.body?.getReader();
+      if (!reader) throw new Error("No response body");
+      const decoder = new TextDecoder();
+      let buffer = "";
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const frames = buffer.split("\n\n");
+        buffer = frames.pop() ?? "";
+        for (const frame of frames) {
+          if (!frame.trim()) continue;
+          let eventType = "message";
+          const dataLines = [];
+          for (const line of frame.split("\n")) {
+            if (line.startsWith("event:")) {
+              eventType = line.slice(6).trim();
+            } else if (line.startsWith("data:")) {
+              dataLines.push(line.slice(5).trim());
+            }
+          }
+          if (dataLines.length === 0) continue;
+          let parsed;
+          try {
+            parsed = JSON.parse(dataLines.join("\n"));
+          } catch {
+            continue;
+          }
+          handleSSEEvent(eventType, parsed);
+        }
+      }
+    } catch (err) {
+      if (err.name === "AbortError") return;
+      const msg = err instanceof Error ? err.message : "SSE connection error";
+      setError(msg);
+      setConnected(false);
+      if (!controller.signal.aborted) {
+        setTimeout(() => connectSSE(), 3e3);
+      }
+    }
+  }, [apiUrl, token, sessionId, enabled]);
+  const handleSSEEvent = useCallback4((type, props) => {
+    if (type === "message.updated") {
+      const id = props.id ?? props.messageId ?? "";
+      const role = props.role ?? "assistant";
+      if (!id) return;
+      setMessages((prev) => {
+        const exists = prev.some((m) => m.id === id);
+        if (exists) return prev;
+        return [
+          ...prev,
+          {
+            id,
+            role,
+            time: { created: Date.now() },
+            _insertionIndex: _insertionCounter++
+          }
+        ];
+      });
+      if (role === "assistant") {
+        streamingMsgIdRef.current = id;
+        setIsStreaming(true);
+      }
+    } else if (type === "message.part.updated") {
+      const msgId = streamingMsgIdRef.current;
+      if (!msgId) return;
+      const partType = props.type ?? "text";
+      setIsStreaming(true);
+      setPartMap((prev) => {
+        const existing = prev[msgId] ?? [];
+        const updated = [...existing];
+        if (partType === "text") {
+          const text = props.text ?? props.content ?? "";
+          const idx = updated.findIndex((p) => p.type === "text");
+          const textPart = { type: "text", text };
+          if (idx >= 0) {
+            updated[idx] = textPart;
+          } else {
+            updated.push(textPart);
+          }
+        } else if (partType === "tool") {
+          const toolId = props.id ?? props.toolId ?? `tool-${Date.now()}`;
+          const toolName = props.tool ?? props.name ?? "unknown";
+          const state = props.state ?? { status: "running" };
+          const toolPart = {
+            type: "tool",
+            id: toolId,
+            tool: toolName,
+            state: {
+              status: state.status ?? "running",
+              input: state.input,
+              output: state.output,
+              error: state.error,
+              metadata: state.metadata,
+              time: state.time
+            }
+          };
+          const idx = updated.findIndex((p) => p.type === "tool" && p.id === toolId);
+          if (idx >= 0) {
+            updated[idx] = toolPart;
+          } else {
+            updated.push(toolPart);
+          }
+        } else if (partType === "reasoning") {
+          const text = props.text ?? "";
+          const idx = updated.findIndex((p) => p.type === "reasoning");
+          const reasoningPart = { type: "reasoning", text };
+          if (idx >= 0) {
+            updated[idx] = reasoningPart;
+          } else {
+            updated.push(reasoningPart);
+          }
+        }
+        return { ...prev, [msgId]: updated };
+      });
+    } else if (type === "session.idle") {
+      setIsStreaming(false);
+      streamingMsgIdRef.current = null;
+      refetch();
+    } else if (type === "session.error") {
+      setIsStreaming(false);
+      streamingMsgIdRef.current = null;
+      const errorMsg = props.error ?? props.message ?? "Agent error";
+      setError(errorMsg);
+      refetch();
+    }
+  }, [refetch]);
+  const send = useCallback4(async (text) => {
+    if (!token || !sessionId || !apiUrl) return;
+    try {
+      const url = `${apiUrl}/session/sessions/${encodeURIComponent(sessionId)}/messages`;
+      await fetchJson(url, token, {
+        method: "POST",
+        body: JSON.stringify({ parts: [{ type: "text", text }] })
+      });
+      setIsStreaming(true);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : "Failed to send message";
+      setError(msg);
+    }
+  }, [apiUrl, token, sessionId]);
+  const abort = useCallback4(async () => {
+    if (!token || !sessionId || !apiUrl) return;
+    try {
+      const url = `${apiUrl}/session/sessions/${encodeURIComponent(sessionId)}/abort`;
+      await fetchJson(url, token, { method: "POST" });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : "Failed to abort";
+      setError(msg);
+    }
+  }, [apiUrl, token, sessionId]);
+  useEffect3(() => {
+    if (!enabled || !token || !sessionId) return;
+    refetch();
+    connectSSE();
+    return () => {
+      abortRef.current?.abort();
+      setConnected(false);
+    };
+  }, [enabled, token, sessionId, refetch, connectSSE]);
+  return { messages, partMap, isStreaming, send, abort, refetch, error, connected };
+}
+
+// src/hooks/use-dropdown-menu.ts
+import { useEffect as useEffect4, useRef as useRef4, useState as useState5 } from "react";
+function useDropdownMenu(options) {
+  const closeOnEsc = options?.closeOnEsc ?? true;
+  const [open, setOpen] = useState5(false);
+  const ref = useRef4(null);
+  useEffect4(() => {
+    function handleClick(e) {
+      if (ref.current && !ref.current.contains(e.target)) {
+        setOpen(false);
+      }
+    }
+    if (open) {
+      document.addEventListener("mousedown", handleClick);
+    }
+    return () => document.removeEventListener("mousedown", handleClick);
+  }, [open]);
+  useEffect4(() => {
+    if (!open || !closeOnEsc) return;
+    function handleKey(e) {
+      if (e.key === "Escape") setOpen(false);
+    }
+    document.addEventListener("keydown", handleKey);
+    return () => document.removeEventListener("keydown", handleKey);
+  }, [open, closeOnEsc]);
+  return {
+    open,
+    setOpen,
+    ref,
+    toggle: () => setOpen((prev) => !prev),
+    close: () => setOpen(false)
+  };
+}
+
+// src/hooks/use-sidecar-auth.ts
+import { useState as useState6, useCallback as useCallback5, useEffect as useEffect5, useRef as useRef5 } from "react";
+function storageKey(resourceId, apiUrl) {
+  return `sidecar_session_${resourceId}__${apiUrl}`;
+}
+function loadSession(resourceId, apiUrl) {
+  if (typeof window === "undefined") return null;
+  try {
+    const raw = localStorage.getItem(storageKey(resourceId, apiUrl));
+    if (!raw) return null;
+    const data = JSON.parse(raw);
+    if (data.expiresAt * 1e3 - Date.now() < 6e4) {
+      localStorage.removeItem(storageKey(resourceId, apiUrl));
+      return null;
+    }
+    return data;
+  } catch {
+    return null;
+  }
+}
+function saveSession(resourceId, apiUrl, token, expiresAt) {
+  if (typeof window === "undefined") return;
+  try {
+    localStorage.setItem(storageKey(resourceId, apiUrl), JSON.stringify({ token, expiresAt }));
+  } catch {
+  }
+}
+function clearSession(resourceId, apiUrl) {
+  if (typeof window === "undefined") return;
+  localStorage.removeItem(storageKey(resourceId, apiUrl));
+}
+function useSidecarAuth({ resourceId, apiUrl, signMessage }) {
+  const cached = loadSession(resourceId, apiUrl);
+  const [token, setToken] = useState6(cached?.token ?? null);
+  const [expiresAt, setExpiresAt] = useState6(cached?.expiresAt ?? 0);
+  const [isAuthenticating, setIsAuthenticating] = useState6(false);
+  const [error, setError] = useState6(null);
+  const refreshTimerRef = useRef5(void 0);
+  const clearCachedToken = useCallback5(() => {
+    setToken(null);
+    setExpiresAt(0);
+    clearSession(resourceId, apiUrl);
+  }, [resourceId, apiUrl]);
+  const authenticate = useCallback5(async () => {
+    if (!apiUrl) return null;
+    setIsAuthenticating(true);
+    setError(null);
+    try {
+      const challengeRes = await fetch(`${apiUrl}/api/auth/challenge`, {
+        method: "POST"
+      });
+      if (!challengeRes.ok) {
+        throw new Error(`Challenge failed: ${challengeRes.status}`);
+      }
+      const { nonce, message } = await challengeRes.json();
+      const signature = await signMessage(message);
+      const sessionRes = await fetch(`${apiUrl}/api/auth/session`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ nonce, signature })
+      });
+      if (!sessionRes.ok) {
+        const text = await sessionRes.text();
+        throw new Error(text || `Session exchange failed: ${sessionRes.status}`);
+      }
+      const { token: newToken, expires_at } = await sessionRes.json();
+      setToken(newToken);
+      setExpiresAt(expires_at);
+      saveSession(resourceId, apiUrl, newToken, expires_at);
+      return newToken;
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Authentication failed");
+      clearCachedToken();
+      return null;
+    } finally {
+      setIsAuthenticating(false);
+    }
+  }, [resourceId, apiUrl, signMessage, clearCachedToken]);
+  useEffect5(() => {
+    if (refreshTimerRef.current) {
+      clearTimeout(refreshTimerRef.current);
+    }
+    if (!token || !expiresAt) return;
+    const msUntilRefresh = (expiresAt - 300) * 1e3 - Date.now();
+    if (msUntilRefresh <= 0) {
+      clearCachedToken();
+      return;
+    }
+    refreshTimerRef.current = setTimeout(() => {
+      authenticate().catch(() => {
+        clearCachedToken();
+      });
+    }, msUntilRefresh);
+    return () => {
+      if (refreshTimerRef.current) {
+        clearTimeout(refreshTimerRef.current);
+      }
+    };
+  }, [token, expiresAt, authenticate, clearCachedToken]);
+  return {
+    token,
+    isAuthenticated: token !== null,
+    isAuthenticating,
+    authenticate,
+    clearCachedToken,
+    error
+  };
+}
+
+export {
+  useToolCallStream,
+  useAuth,
+  createAuthFetcher,
+  useApiKey,
+  useSSEStream,
+  useSessionStream,
+  useDropdownMenu,
+  useSidecarAuth
+};