@tangle-network/sandbox-ui 0.13.0 → 0.15.1

package/dist/chunk-DXMIEK4K.js

@@ -1,1426 +0,0 @@
-import {
-  parseToolEvent
-} from "./chunk-QID2OOMG.js";
-import {
-  bumpActiveSessionActivity,
-  registerActiveSession,
-  setActiveSessionAttention,
-  setActiveSessionConnection,
-  setActiveSessionError,
-  setActiveSessionRunning,
-  setForegroundActiveSession,
-  unregisterActiveSession,
-  updateActiveSessionMeta
-} from "./chunk-OEX7NZE3.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-sse-stream.ts
-import * as React 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] = 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 = 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]);
-  const clearEvents = React.useCallback(() => {
-    setEvents([]);
-    setLastEvent(null);
-  }, []);
-  return {
-    state,
-    events,
-    lastEvent,
-    error,
-    connect,
-    disconnect,
-    clearEvents,
-    retryCount: retryCountRef.current,
-    timeSinceLastEvent
-  };
-}
-
-// src/hooks/use-sdk-session.ts
-import { useCallback as useCallback3, useMemo, useRef as useRef3, useState as useState3 } from "react";
-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 attachmentText = attachments?.length ? `
-
-Attachments:
-${attachments.map((attachment) => `- ${attachment.name}`).join("\n")}` : "";
-  const text = `${content}${attachmentText}`.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 void 0;
-  }
-  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] = useState3(initialConversation);
-  const [isStreaming, setIsStreaming] = useState3(false);
-  const activeAssistantIdRef = useRef3(null);
-  const insertionIndexRef = useRef3(initialConversation.messages.length);
-  const partIndexRef = useRef3({});
-  const replaceHistory = useCallback3((messages) => {
-    const next = mapSeeds(messages);
-    setConversation(next);
-    setIsStreaming(false);
-    activeAssistantIdRef.current = null;
-    insertionIndexRef.current = next.messages.length;
-    partIndexRef.current = {};
-  }, []);
-  const appendUserMessage = useCallback3(
-    ({
-      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 = useCallback3(
-    ({
-      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 = useCallback3(
-    ({ messageId, finalText } = {}) => {
-      const targetId = messageId ?? activeAssistantIdRef.current;
-      if (!targetId) {
-        setIsStreaming(false);
-        return;
-      }
-      if (finalText) {
-        setConversation((prev) => {
-          const existingParts = prev.partMap[targetId] ?? [];
-          const nextParts = [...existingParts];
-          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 = useCallback3(
-    (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 = useCallback3(
-    (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 existingParts = prev.partMap[targetId] ?? [];
-          const nextParts = [...existingParts];
-          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 = useCallback3(() => {
-    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
-  };
-}
-
-// src/hooks/use-realtime-session.ts
-import { createElement, useEffect as useEffect2, useMemo as useMemo2, useRef as useRef4, useState as useState4 } from "react";
-function parseEvent(message) {
-  try {
-    const parsed = JSON.parse(message);
-    return typeof parsed?.type === "string" ? parsed : null;
-  } catch {
-    return null;
-  }
-}
-function eventTimestamp(event) {
-  const rootTimestamp = event.timestamp;
-  if (typeof rootTimestamp === "number" && Number.isFinite(rootTimestamp)) {
-    return rootTimestamp;
-  }
-  const raw = event.data?.timestamp ?? event.data?.ts ?? event.data?.time ?? event.data?.eventAt;
-  if (typeof raw === "number" && Number.isFinite(raw)) return raw;
-  return null;
-}
-function resolveErrorMessage(event) {
-  const message = event.data?.message;
-  return typeof message === "string" && message.length > 0 ? message : null;
-}
-function updateStoreFromEvent(sessionId, event) {
-  const lastEventAt = eventTimestamp(event) ?? Date.now();
-  bumpActiveSessionActivity(sessionId, { lastEventAt });
-  if (event.type === "session.run.started") {
-    setActiveSessionRunning(sessionId, true, { lastEventAt });
-    return;
-  }
-  if (event.type === "session.run.completed" || event.type === "done" || event.type === "result") {
-    setActiveSessionRunning(sessionId, false, { lastEventAt });
-    return;
-  }
-  if (event.type === "session.attention") {
-    setActiveSessionAttention(sessionId, true, { lastEventAt });
-    return;
-  }
-  if (event.type === "error" || event.type === "session.run.failed") {
-    setActiveSessionError(sessionId, resolveErrorMessage(event) ?? "Session error");
-    return;
-  }
-}
-function useRealtimeSession({
-  sessionId,
-  projectId = null,
-  projectLabel,
-  title,
-  href,
-  metadata,
-  connectUrl,
-  enabled = true,
-  foreground = true,
-  keepRegistered = true,
-  reconnect = true,
-  reconnectIntervalMs = 1500,
-  maxReconnectAttempts = Infinity,
-  transportMode = "websocket",
-  onEvent,
-  onOpen,
-  onClose,
-  onError
-}) {
-  const [connectionState, setConnectionState] = useState4("disconnected");
-  const [lastError, setLastError] = useState4(null);
-  const [reconnectAttempts, setReconnectAttempts] = useState4(0);
-  const socketRef = useRef4(null);
-  const timerRef = useRef4(null);
-  const reconnectAttemptsRef = useRef4(0);
-  const shouldReconnectRef = useRef4(true);
-  const registration = useMemo2(
-    () => ({
-      sessionId,
-      projectId,
-      projectLabel,
-      title,
-      href,
-      metadata
-    }),
-    [href, metadata, projectId, projectLabel, sessionId, title]
-  );
-  useEffect2(() => {
-    if (!sessionId || !keepRegistered) return void 0;
-    registerActiveSession(registration);
-    return () => {
-      unregisterActiveSession(sessionId);
-    };
-  }, [keepRegistered, registration, sessionId]);
-  useEffect2(() => {
-    if (!sessionId || !keepRegistered) return;
-    updateActiveSessionMeta(sessionId, {
-      projectId,
-      projectLabel,
-      title,
-      href,
-      metadata
-    });
-  }, [href, keepRegistered, metadata, projectId, projectLabel, sessionId, title]);
-  useEffect2(() => {
-    if (!sessionId || !foreground) return void 0;
-    setForegroundActiveSession(sessionId);
-    return () => {
-      setForegroundActiveSession(null);
-    };
-  }, [foreground, sessionId]);
-  useEffect2(() => {
-    if (!enabled || !sessionId || !connectUrl || typeof window === "undefined") {
-      setConnectionState("disconnected");
-      if (sessionId) {
-        setActiveSessionConnection(sessionId, {
-          connectionState: "disconnected",
-          reconnectState: "idle",
-          transportMode
-        });
-      }
-      return void 0;
-    }
-    shouldReconnectRef.current = true;
-    const clearReconnectTimer = () => {
-      if (timerRef.current != null) {
-        window.clearTimeout(timerRef.current);
-        timerRef.current = null;
-      }
-    };
-    const connect = () => {
-      clearReconnectTimer();
-      setConnectionState(reconnectAttemptsRef.current > 0 ? "reconnecting" : "connecting");
-      setActiveSessionConnection(sessionId, {
-        connectionState: reconnectAttemptsRef.current > 0 ? "reconnecting" : "connecting",
-        reconnectState: reconnectAttemptsRef.current > 0 ? "reconnecting" : "idle",
-        transportMode,
-        lastError: null
-      });
-      const socket = new window.WebSocket(connectUrl);
-      socketRef.current = socket;
-      socket.onopen = () => {
-        reconnectAttemptsRef.current = 0;
-        setReconnectAttempts(0);
-        setLastError(null);
-        setConnectionState("connected");
-        registerActiveSession(registration);
-        setActiveSessionConnection(sessionId, {
-          connectionState: "connected",
-          reconnectState: "idle",
-          transportMode,
-          lastError: null,
-          lastEventAt: Date.now()
-        });
-        onOpen?.();
-      };
-      socket.onmessage = (message) => {
-        const event = parseEvent(message.data);
-        if (!event) return;
-        registerActiveSession(registration);
-        updateStoreFromEvent(sessionId, event);
-        onEvent?.(event);
-      };
-      socket.onerror = () => {
-        const nextError = "Realtime session connection error";
-        setLastError(nextError);
-        setConnectionState("error");
-        setActiveSessionConnection(sessionId, {
-          connectionState: "error",
-          reconnectState: reconnect ? "reconnecting" : "failed",
-          transportMode,
-          lastError: nextError
-        });
-        onError?.(new Error(nextError));
-      };
-      socket.onclose = () => {
-        socketRef.current = null;
-        onClose?.();
-        if (!shouldReconnectRef.current || !reconnect) {
-          setConnectionState("disconnected");
-          setActiveSessionConnection(sessionId, {
-            connectionState: "disconnected",
-            reconnectState: "idle",
-            transportMode
-          });
-          return;
-        }
-        reconnectAttemptsRef.current += 1;
-        setReconnectAttempts(reconnectAttemptsRef.current);
-        if (reconnectAttemptsRef.current > maxReconnectAttempts) {
-          setConnectionState("error");
-          setActiveSessionConnection(sessionId, {
-            connectionState: "error",
-            reconnectState: "failed",
-            transportMode,
-            lastError: "Unable to reconnect to realtime session"
-          });
-          return;
-        }
-        setConnectionState("reconnecting");
-        timerRef.current = window.setTimeout(connect, reconnectIntervalMs);
-      };
-    };
-    connect();
-    return () => {
-      shouldReconnectRef.current = false;
-      clearReconnectTimer();
-      const socket = socketRef.current;
-      socketRef.current = null;
-      if (socket && socket.readyState < WebSocket.CLOSING) {
-        socket.close();
-      }
-    };
-  }, [
-    connectUrl,
-    enabled,
-    maxReconnectAttempts,
-    onClose,
-    onError,
-    onEvent,
-    onOpen,
-    reconnect,
-    reconnectIntervalMs,
-    registration,
-    sessionId,
-    transportMode
-  ]);
-  return {
-    connectionState,
-    lastError,
-    reconnectAttempts,
-    isConnected: connectionState === "connected"
-  };
-}
-function RealtimeSessionRegistryItem(props) {
-  useRealtimeSession({
-    ...props,
-    foreground: props.foreground ?? false
-  });
-  return null;
-}
-function RealtimeSessionRegistry({ sessions }) {
-  return sessions.map(
-    (session) => createElement(RealtimeSessionRegistryItem, {
-      key: session.key ?? session.sessionId,
-      ...session
-    })
-  );
-}
-
-// src/hooks/use-session-stream.ts
-import { useCallback as useCallback4, useEffect as useEffect3, useRef as useRef5, useState as useState5 } from "react";
-function mapApiMessage(msg, counterRef) {
-  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: counterRef.current++
-  };
-  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 }, credentials: "include" });
-  if (!res.ok) throw new Error(`HTTP ${res.status}: ${res.statusText}`);
-  return res.json();
-}
-function useSessionStream({
-  apiUrl,
-  token,
-  sessionId,
-  enabled = true
-}) {
-  const [messages, setMessages] = useState5([]);
-  const [partMap, setPartMap] = useState5({});
-  const [isStreaming, setIsStreaming] = useState5(false);
-  const [error, setError] = useState5(null);
-  const [connected, setConnected] = useState5(false);
-  const abortRef = useRef5(null);
-  const reconnectTimerRef = useRef5(null);
-  const streamingMsgIdRef = useRef5(null);
-  const insertionCounterRef = useRef5(0);
-  const handleSSEEventRef = useRef5(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, insertionCounterRef);
-        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;
-    if (reconnectTimerRef.current) {
-      clearTimeout(reconnectTimerRef.current);
-      reconnectTimerRef.current = null;
-    }
-    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,
-        credentials: "include"
-      });
-      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;
-          }
-          handleSSEEventRef.current?.(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) {
-        reconnectTimerRef.current = setTimeout(() => connectSSE(), 3e3);
-      }
-    }
-  }, [apiUrl, token, sessionId, enabled]);
-  const handleSSEEvent = useCallback4((type, raw) => {
-    const envelope = raw?.properties;
-    const props = envelope?.info ?? envelope?.part ?? envelope ?? raw;
-    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: insertionCounterRef.current++
-          }
-        ];
-      });
-      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]);
-  handleSSEEventRef.current = handleSSEEvent;
-  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();
-      if (reconnectTimerRef.current) clearTimeout(reconnectTimerRef.current);
-      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 useRef6, useState as useState6 } from "react";
-function useDropdownMenu(options) {
-  const closeOnEsc = options?.closeOnEsc ?? true;
-  const [open, setOpen] = useState6(false);
-  const ref = useRef6(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 useState7, useCallback as useCallback5, useEffect as useEffect5, useRef as useRef7 } 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] = useState7(cached?.token ?? null);
-  const [expiresAt, setExpiresAt] = useState7(cached?.expiresAt ?? 0);
-  const [isAuthenticating, setIsAuthenticating] = useState7(false);
-  const [error, setError] = useState7(null);
-  const refreshTimerRef = useRef7(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,
-  useSSEStream,
-  useSdkSession,
-  useRealtimeSession,
-  RealtimeSessionRegistry,
-  useSessionStream,
-  useDropdownMenu,
-  useSidecarAuth
-};