@agents24/chat-react 0.3.2 → 0.5.0

package/dist/index.js

@@ -6,1619 +6,15 @@ import {
   LatestThreadScrollerOutline,
   LatestThreadScrollerProvider,
   LatestThreadScrollerRoot,
-  LatestThreadScrollerViewport
-} from "./chunk-FFO6KEB4.js";
+  LatestThreadScrollerViewport,
+  validateMcpCallbackResult,
+  waitForMcpOauthComplete
+} from "./chunk-LI67M74F.js";
 import {
   getActiveStreamingTextPartId,
   isActiveStreamingTextPart,
   useStreamingText
-} from "./chunk-EWZO4QJI.js";
-
-// src/controller.ts
-import { useCallback as useCallback3, useEffect as useEffect2, useMemo as useMemo2, useRef as useRef2, useState as useState2 } from "react";
-
-// src/controller-actions.ts
-import { useCallback } from "react";
-function useControllerMessageActions(input) {
-  const handleCopy = useCallback((content, messageId) => {
-    navigator.clipboard?.writeText(content);
-    input.setCopiedMessageId(messageId);
-    setTimeout(() => input.setCopiedMessageId(null), 200);
-  }, [input]);
-  const handleLike = useCallback(async (msg) => {
-    const nextLiked = !input.liked[msg.id];
-    input.setLiked((prev) => ({ ...prev, [msg.id]: nextLiked }));
-    if (nextLiked) input.setDisliked((prev) => ({ ...prev, [msg.id]: false }));
-  }, [input]);
-  const handleDislike = useCallback(async (msg) => {
-    const nextDisliked = !input.disliked[msg.id];
-    input.setDisliked((prev) => ({ ...prev, [msg.id]: nextDisliked }));
-    if (nextDisliked) input.setLiked((prev) => ({ ...prev, [msg.id]: false }));
-  }, [input]);
-  const handleRetry = useCallback(async (msg) => {
-    const index = input.messagesRef.current.findIndex((message) => message.id === msg.id);
-    if (index <= 0) return;
-    const userMessage = input.messagesRef.current[index - 1];
-    if (userMessage.role !== "user") return;
-    const trimmed = input.messagesRef.current.slice(0, index);
-    input.setMessages(trimmed);
-    input.messagesRef.current = trimmed;
-    if (input.activeThreadIdRef.current) input.persistThread(input.activeThreadIdRef.current, trimmed);
-    await input.handleSubmit({ text: userMessage.content, files: userMessage.attachments || [] });
-  }, [input]);
-  const upsertLiveVoiceMessage = useCallback((payload) => {
-    const content = payload.content?.trim() ?? "";
-    if (!content && !payload.citations?.length && !payload.reasoningSteps?.length) return;
-    input.setMessages((prev) => {
-      const currentId = input.liveVoiceIdsRef.current[payload.role];
-      const index = currentId ? prev.findIndex((message) => message.id === currentId) : -1;
-      const nextMessage = {
-        id: currentId || input.createId(),
-        role: payload.role,
-        content,
-        createdAt: /* @__PURE__ */ new Date(),
-        isFinal: Boolean(payload.isFinal),
-        isVoice: payload.role === "user",
-        parts: content ? [{ id: input.createId(), type: "text", kind: "text", text: content }] : [],
-        citations: payload.citations,
-        reasoningSteps: payload.reasoningSteps
-      };
-      const next = index === -1 ? [...prev, nextMessage] : prev.map((message, itemIndex) => itemIndex === index ? { ...message, ...nextMessage } : message);
-      input.liveVoiceIdsRef.current[payload.role] = payload.isFinal ? void 0 : nextMessage.id;
-      input.messagesRef.current = next;
-      if (input.activeThreadIdRef.current) input.persistThread(input.activeThreadIdRef.current, next);
-      return next;
-    });
-  }, [input]);
-  const startNewThread = useCallback(() => {
-    input.detachActiveStream();
-    input.requestSeqRef.current += 1;
-    input.activeThreadIdRef.current = null;
-    input.loadedThreadIdRef.current = null;
-    input.nextBeforeTurnIndexRef.current = null;
-    input.hasOlderTurnsRef.current = false;
-    input.storage.setActiveThreadId?.(null);
-    input.onActiveThreadIdChange?.(null);
-    input.setMessages([]);
-    input.messagesRef.current = [];
-    input.setHasOlderTurns(false);
-    input.setIsLoadingOlder(false);
-    input.setContextStatus(null);
-    input.setLoadingHistory(false);
-  }, [input]);
-  return { handleCopy, handleDislike, handleLike, handleRetry, startNewThread, upsertLiveVoiceMessage };
-}
-
-// src/controller-hitl.ts
-import { useCallback as useCallback2, useMemo, useState } from "react";
-function useControllerHitl({
-  messages,
-  transport,
-  activeRunId,
-  activeRunIdRef,
-  activeThreadIdRef,
-  runStream
-}) {
-  const [isResolvingHitl, setIsResolvingHitl] = useState(false);
-  const pendingHitl = useMemo(() => {
-    for (let messageIndex = messages.length - 1; messageIndex >= 0; messageIndex -= 1) {
-      const parts = messages[messageIndex]?.parts || [];
-      for (let partIndex = parts.length - 1; partIndex >= 0; partIndex -= 1) {
-        const part = parts[partIndex];
-        if (part?.kind === "hitl" && part.status === "pending") return part;
-      }
-    }
-    return null;
-  }, [messages]);
-  const resumeHitl = useCallback2(async (input) => {
-    if (!transport.resumeHitl) throw new Error("HITL resume is not configured.");
-    const runId = input.runId || activeRunIdRef.current || activeRunId;
-    if (!runId) throw new Error("No paused run is available to resume.");
-    setIsResolvingHitl(true);
-    try {
-      const result = await transport.resumeHitl({ ...input, runId });
-      const threadId = result.thread_id || activeThreadIdRef.current;
-      if (threadId) await runStream({ mode: "attach", runId: result.run_id || runId, threadId });
-      return result;
-    } finally {
-      setIsResolvingHitl(false);
-    }
-  }, [activeRunId, activeRunIdRef, activeThreadIdRef, runStream, transport]);
-  return { pendingHitl, isResolvingHitl, resumeHitl };
-}
-
-// src/controller-thread-events.ts
-import { useEffect, useRef } from "react";
-
-// src/context-window.ts
-var SOURCE_PRIORITY = {
-  unknown: 0,
-  heuristic_estimate: 1,
-  tokenizer_estimate: 1,
-  text_estimate: 1,
-  estimated: 1,
-  multimodal_estimate: 2,
-  hf_tokenizer: 3,
-  runtime_tokenizer: 3,
-  provider_count_api: 4,
-  provider_usage: 5,
-  exact: 5
-};
-var STAGE_PRIORITY = {
-  preflight: 0,
-  sent_prompt: 1,
-  final_usage: 2
-};
-function numberOrNull(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : null;
-}
-function stagePriority(window2) {
-  return STAGE_PRIORITY[window2?.stage || "sent_prompt"] ?? STAGE_PRIORITY.sent_prompt;
-}
-function hasRenderableContextWindow(window2) {
-  const maxTokens = window2?.max_tokens;
-  return typeof maxTokens === "number" && Number.isFinite(maxTokens) && maxTokens > 0;
-}
-function windowWeight(window2) {
-  if (!window2) return [0, 0];
-  return [stagePriority(window2), SOURCE_PRIORITY[window2.source] || 0];
-}
-function normalizeContextCompression(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-  const payload = value;
-  return {
-    active: Boolean(payload.active),
-    reason: typeof payload.reason === "string" ? payload.reason : null,
-    input_tokens: numberOrNull(payload.input_tokens),
-    max_tokens: numberOrNull(payload.max_tokens),
-    usage_ratio: numberOrNull(payload.usage_ratio),
-    full_frame_count: numberOrNull(payload.full_frame_count),
-    compact_frame_count: numberOrNull(payload.compact_frame_count),
-    dropped_frame_count: numberOrNull(payload.dropped_frame_count),
-    artifact_ref_count: numberOrNull(payload.artifact_ref_count),
-    compression_trigger_budget: numberOrNull(payload.compression_trigger_budget),
-    compression_target_budget: numberOrNull(payload.compression_target_budget),
-    compression_target_ratio: numberOrNull(payload.compression_target_ratio),
-    threshold_used: numberOrNull(payload.threshold_used)
-  };
-}
-function normalizeContextWindow(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-  const payload = value;
-  const rawSource = String(payload.source || "").trim();
-  const source = rawSource === "exact" || rawSource === "estimated" || rawSource === "unknown" || rawSource === "provider_count_api" || rawSource === "provider_usage" || rawSource === "runtime_tokenizer" || rawSource === "hf_tokenizer" || rawSource === "multimodal_estimate" || rawSource === "text_estimate" || rawSource === "tokenizer_estimate" || rawSource === "heuristic_estimate" ? rawSource : rawSource ? "estimated" : "unknown";
-  const rawStage = String(payload.stage || "").trim();
-  const stage = rawStage === "preflight" || rawStage === "sent_prompt" || rawStage === "final_usage" ? rawStage : "sent_prompt";
-  const rawConfidence = String(payload.confidence || "").trim();
-  const confidence = rawConfidence === "exact" || rawConfidence === "high" || rawConfidence === "medium" || rawConfidence === "low" || rawConfidence === "unknown" ? rawConfidence : null;
-  return {
-    source,
-    run_id: typeof payload.run_id === "string" ? payload.run_id : null,
-    stage,
-    confidence,
-    counter: typeof payload.counter === "string" ? payload.counter : null,
-    model_id: typeof payload.model_id === "string" ? payload.model_id : null,
-    max_tokens: numberOrNull(payload.max_tokens),
-    max_tokens_source: typeof payload.max_tokens_source === "string" ? payload.max_tokens_source : null,
-    input_tokens: numberOrNull(payload.input_tokens),
-    remaining_tokens: numberOrNull(payload.remaining_tokens),
-    usage_ratio: numberOrNull(payload.usage_ratio),
-    assembly: payload.assembly && typeof payload.assembly === "object" && !Array.isArray(payload.assembly) ? payload.assembly : null,
-    context_compression: normalizeContextCompression(payload.context_compression)
-  };
-}
-function mergeContextWindow(current, incoming) {
-  if (!incoming) return current ?? null;
-  if (!current) return incoming;
-  if (hasRenderableContextWindow(current) && !hasRenderableContextWindow(incoming)) return current;
-  const currentRunId = current.run_id || null;
-  const incomingRunId = incoming.run_id || null;
-  if (incomingRunId && currentRunId && incomingRunId !== currentRunId) {
-    return stagePriority(incoming) >= STAGE_PRIORITY.sent_prompt ? incoming : current;
-  }
-  const currentWeight = windowWeight(current);
-  const incomingWeight = windowWeight(incoming);
-  return incomingWeight[0] > currentWeight[0] || incomingWeight[0] === currentWeight[0] && incomingWeight[1] >= currentWeight[1] ? incoming : current;
-}
-function mergeContextWindowUpdate(current, incoming) {
-  return mergeContextWindow(current, normalizeContextWindow(incoming));
-}
-function compressionFromContextWindow(contextWindow) {
-  if (!contextWindow) return null;
-  if (contextWindow.context_compression) return contextWindow.context_compression;
-  const assembly = contextWindow.assembly;
-  if (!assembly || typeof assembly !== "object" || Array.isArray(assembly)) return null;
-  const artifactRefs = Array.isArray(assembly.artifact_refs) ? assembly.artifact_refs : [];
-  const compactFrameCount = numberOrNull(assembly.compact_frame_count) ?? 0;
-  const droppedFrameCount = numberOrNull(assembly.dropped_frame_count) ?? 0;
-  const reason = typeof assembly.compaction_reason === "string" ? assembly.compaction_reason : "none";
-  return {
-    active: reason !== "none" || compactFrameCount > 0 || droppedFrameCount > 0,
-    reason,
-    input_tokens: contextWindow.input_tokens ?? null,
-    max_tokens: contextWindow.max_tokens ?? null,
-    usage_ratio: contextWindow.usage_ratio ?? null,
-    full_frame_count: numberOrNull(assembly.full_frame_count),
-    compact_frame_count: compactFrameCount,
-    dropped_frame_count: droppedFrameCount,
-    artifact_ref_count: artifactRefs.length,
-    compression_trigger_budget: numberOrNull(assembly.compression_trigger_budget),
-    compression_target_budget: numberOrNull(assembly.compression_target_budget),
-    compression_target_ratio: numberOrNull(assembly.compression_target_ratio),
-    threshold_used: numberOrNull(assembly.threshold_used)
-  };
-}
-
-// src/model.ts
-var DEFAULT_THREAD_PAGE_SIZE = 5;
-var isRunningThreadStatus = (status) => (/* @__PURE__ */ new Set(["queued", "running", "cancelling", "paused"])).has(String(status || "").toLowerCase());
-var isAutoAttachThreadStatus = (status) => (/* @__PURE__ */ new Set(["queued", "running", "cancelling"])).has(String(status || "").toLowerCase());
-var createChatId = () => {
-  if (typeof crypto !== "undefined" && "randomUUID" in crypto) return crypto.randomUUID();
-  return `chat-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
-};
-var titleFromMessage = (text, files = []) => {
-  const base = text.trim() || files[0]?.filename || "New chat";
-  return base.replace(/\s+/g, " ").slice(0, 48);
-};
-var threadActivityDate = (thread) => String(thread.updated_at || thread.last_activity_at || thread.created_at || (/* @__PURE__ */ new Date()).toISOString());
-var assistantTextFromResponseBlocks = (blocks) => (blocks || []).filter((block) => block.kind === "assistant_text" && typeof block.text === "string").map((block) => String(block.text)).join("\n\n").trim();
-var assistantTextFromParts = (parts) => (parts || []).filter((part) => part.kind === "text").map((part) => part.text).join("\n\n").trim();
-var displayTextWithoutInlineAttachments = (text, hasAttachments) => {
-  if (!hasAttachments) return text;
-  const marker = "Attached text file (";
-  const trimmed = text.trim();
-  if (trimmed.startsWith(marker)) return "";
-  const markerIndex = text.indexOf(`
-
-${marker}`);
-  if (markerIndex === -1) return text;
-  return text.slice(0, markerIndex).trim();
-};
-var attachmentsFromTurn = (turn) => (turn.attachments || []).map((attachment, index) => {
-  const record = attachment || {};
-  return {
-    ...record,
-    type: "file",
-    url: String(record.url || ""),
-    filename: String(record.filename || record.name || `attachment-${index + 1}`),
-    mediaType: String(record.mime_type || record.mediaType || record.type || "application/octet-stream")
-  };
-});
-var tokenUsageFromTurn = (turn) => {
-  const usage = turn.run_usage;
-  if (!usage || typeof usage !== "object") return void 0;
-  return {
-    inputTokens: usage.input_tokens ?? null,
-    outputTokens: usage.output_tokens ?? null,
-    totalTokens: usage.total_tokens ?? null,
-    usageSource: usage.source ?? null
-  };
-};
-var latestEventPayloadValue = (events, key) => {
-  for (let index = (events || []).length - 1; index >= 0; index -= 1) {
-    const payload = events?.[index]?.payload;
-    if (payload && payload[key] !== void 0 && payload[key] !== null) return payload[key];
-  }
-  return void 0;
-};
-var responseBlocksFromTurn = (turn) => {
-  if (Array.isArray(turn.response_blocks) && turn.response_blocks.length > 0) return turn.response_blocks;
-  const fromEvents = latestEventPayloadValue(turn.run_events, "response_blocks");
-  return Array.isArray(fromEvents) ? fromEvents : [];
-};
-var assistantTextFromEvents = (events) => {
-  const assistantText = latestEventPayloadValue(events, "assistant_output_text");
-  if (typeof assistantText === "string" && assistantText.trim()) return assistantText;
-  return "";
-};
-var asRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
-var optionalString = (value) => typeof value === "string" && value.trim() ? value.trim() : void 0;
-var HITL_ACTIONS_BY_KIND = {
-  tool_review: ["approve", "reject"],
-  mcp_auth: ["connect", "skip"],
-  user_approval: ["approve", "reject"],
-  app_data_permission: ["approve", "reject"]
-};
-var HITL_STATUSES = ["pending", "resolved", "expired", "cancelled", "invalidated"];
-function exactHitlActions(kind, value) {
-  if (!Array.isArray(value)) throw new Error("Invalid V2 HITL response block.");
-  const actions = value.map((item) => String(item));
-  const expected = HITL_ACTIONS_BY_KIND[kind];
-  if (actions.length !== expected.length || actions.some((action, index) => action !== expected[index])) {
-    throw new Error("Invalid V2 HITL response block.");
-  }
-  return actions;
-}
-var toolStateFromStatus = (status) => {
-  const normalized = String(status || "").trim().toLowerCase();
-  if (["failed", "error"].includes(normalized)) return "output-error";
-  if (["cancelled", "canceled"].includes(normalized)) return "cancelled";
-  if (["complete", "completed", "done", "success"].includes(normalized)) return "output-available";
-  if (["running", "active", "pending", "streaming"].includes(normalized)) return "input-available";
-  return "input-available";
-};
-var toolNameFromRecord = (tool) => String(tool.toolName || tool.tool_name || tool.name || tool.slug || tool.action || "tool").trim() || "tool";
-var toolCallIdFromRecords = (block, tool) => optionalString(tool.toolCallId) || optionalString(tool.tool_call_id) || optionalString(block.toolCallId) || optionalString(block.tool_call_id) || optionalString(block.id) || null;
-var presentationFromTool = (tool) => {
-  const presentation = asRecord(tool.presentation);
-  const outputView = asRecord(tool.outputView) || asRecord(tool.output_view);
-  const next = presentation ? { ...presentation } : {};
-  [
-    "title",
-    "activity",
-    "detail",
-    "category",
-    "groupKey",
-    "groupLabel",
-    "showOutput",
-    "outputView"
-  ].forEach((key) => {
-    if (tool[key] !== void 0) {
-      next[key] = tool[key];
-    }
-  });
-  if (tool.group_key !== void 0) next.group_key = tool.group_key;
-  if (tool.group_label !== void 0) next.group_label = tool.group_label;
-  if (tool.show_output !== void 0) next.show_output = tool.show_output;
-  if (outputView && next.outputView === void 0) next.outputView = outputView;
-  return Object.keys(next).length > 0 ? next : null;
-};
-var createToolPart = (block, index) => {
-  const tool = asRecord(block.tool) || {};
-  const toolName = toolNameFromRecord(tool);
-  const errorText = optionalString(tool.errorText) || optionalString(tool.error) || optionalString(block.error) || null;
-  return {
-    id: String(block.id || `${block.kind || "tool"}-${index}`),
-    type: `tool-${toolName}`,
-    kind: "tool",
-    toolName,
-    toolCallId: toolCallIdFromRecords(block, tool),
-    state: toolStateFromStatus(block.status),
-    input: tool.input ?? block.input,
-    output: tool.output ?? block.output,
-    errorText,
-    presentation: presentationFromTool(tool),
-    raw: block
-  };
-};
-var createDataPart = (block, index, name = String(block.kind || "data")) => ({
-  id: String(block.id || `${name}-${index}`),
-  type: "data",
-  kind: "data",
-  name,
-  data: block,
-  raw: block
-});
-var partsFromResponseBlocks = (blocks, fallbackText) => {
-  const parts = [];
-  (blocks || []).forEach((block, index) => {
-    const id = String(block.id || `${block.kind || "block"}-${index}`);
-    if (block.kind === "assistant_text" && typeof block.text === "string") {
-      parts.push({ id, type: "text", kind: "text", text: String(block.text), raw: block });
-      return;
-    }
-    if (block.kind === "tool_call") {
-      parts.push(createToolPart(block, index));
-      return;
-    }
-    if (block.kind === "ui_blocks") {
-      parts.push({
-        id,
-        type: "ui-blocks",
-        kind: "ui-blocks",
-        state: toolStateFromStatus(block.status),
-        toolCallId: optionalString(block.toolCallId) || optionalString(block.tool_call_id) || null,
-        contractVersion: optionalString(block.contractVersion) || optionalString(block.contract_version) || null,
-        bundle: asRecord(block.bundle),
-        errorText: optionalString(block.error) || null,
-        raw: block
-      });
-      return;
-    }
-    if (block.kind === "reasoning_note") {
-      parts.push({
-        id,
-        type: "reasoning",
-        kind: "reasoning",
-        label: optionalString(block.label) || null,
-        text: optionalString(block.text) || optionalString(block.summary) || null,
-        status: optionalString(block.status) || null,
-        raw: block
-      });
-      return;
-    }
-    if (block.kind === "hitl_request") {
-      const hitl = asRecord(block.hitl) || block;
-      if (hitl.schema_version !== "agents24.hitl.interrupt.v2") {
-        throw new Error("Invalid V2 HITL response block.");
-      }
-      const interruptId = optionalString(block.interruptId) || optionalString(hitl.interrupt_id);
-      const hitlKind = optionalString(block.hitlKind) || optionalString(hitl.kind);
-      const status = optionalString(block.status) || optionalString(hitl.status) || "pending";
-      if (!interruptId || !["tool_review", "mcp_auth", "user_approval", "app_data_permission"].includes(String(hitlKind)) || !HITL_STATUSES.includes(status)) {
-        throw new Error("Invalid V2 HITL response block.");
-      }
-      const kind = hitlKind;
-      const allowedActions = exactHitlActions(kind, hitl.allowed_actions);
-      const resolution = asRecord(block.resolution);
-      const resolver = asRecord(resolution?.resolver);
-      parts.push({
-        id,
-        type: "hitl",
-        kind: "hitl",
-        interruptId,
-        hitlKind: kind,
-        message: optionalString(hitl.message) || optionalString(block.text) || "Input is required to continue.",
-        allowedActions,
-        status,
-        presentation: asRecord(hitl.presentation) || {},
-        resolution: resolution ? {
-          action: ["approve", "reject", "connect", "skip"].includes(String(resolution.action)) ? String(resolution.action) : null,
-          outcome: optionalString(resolution.outcome),
-          reason: optionalString(resolution.reason),
-          resolvedAt: optionalString(resolution.resolved_at),
-          resolver: resolver ? {
-            principalType: optionalString(resolver.principal_type) || optionalString(resolver.principalType) || null,
-            principalId: optionalString(resolver.principal_id) || optionalString(resolver.principalId) || null
-          } : null
-        } : null,
-        raw: block
-      });
-      return;
-    }
-    if (block.kind === "error") {
-      parts.push({
-        id,
-        type: "error",
-        kind: "error",
-        errorText: optionalString(block.error) || optionalString(block.message) || "Error",
-        raw: block
-      });
-      return;
-    }
-    parts.push(createDataPart(block, index));
-  });
-  if (!parts.some((part) => part.kind === "text") && fallbackText?.trim()) {
-    parts.push({ id: "assistant-fallback-text", type: "text", kind: "text", text: fallbackText });
-  }
-  return parts;
-};
-var mergeReasoningSteps = (steps, options) => {
-  if (!steps?.length) return [];
-  const merged = [];
-  const indexMap = /* @__PURE__ */ new Map();
-  steps.forEach((step) => {
-    const key = String(step.label);
-    const status = options?.finalize ? "complete" : step.status || "complete";
-    if (indexMap.has(key)) {
-      const index = indexMap.get(key);
-      merged[index] = { ...merged[index], ...step, status };
-    } else {
-      indexMap.set(key, merged.push({ ...step, status }) - 1);
-    }
-  });
-  return merged;
-};
-var reasoningStepsFromParts = (parts) => (parts || []).map((block) => {
-  if (block.kind === "tool") {
-    const label = optionalString(block.presentation?.activity) || optionalString(block.presentation?.title) || block.toolName;
-    return {
-      label,
-      status: block.state === "input-available" || block.state === "input-streaming" ? "active" : "complete",
-      description: optionalString(block.presentation?.detail) || ""
-    };
-  }
-  if (block.kind === "reasoning") {
-    return {
-      label: block.label || "Reasoning",
-      status: block.status === "running" ? "active" : "complete",
-      description: block.text || ""
-    };
-  }
-  return null;
-}).filter(Boolean);
-var turnToMessages = (turn, activeRunId) => {
-  const messages = [];
-  const createdAt = turn.created_at ? new Date(turn.created_at) : /* @__PURE__ */ new Date();
-  const baseId = turn.id || turn.run_id || createChatId();
-  const responseBlocks = responseBlocksFromTurn(turn);
-  const isRunning = isRunningThreadStatus(turn.status) || Boolean(turn.run_id && activeRunId === turn.run_id);
-  const attachments = attachmentsFromTurn(turn);
-  const userContent = displayTextWithoutInlineAttachments(turn.user_input_text || "", attachments.length > 0);
-  if (userContent || attachments.length > 0) {
-    messages.push({
-      id: `${baseId}-user`,
-      role: "user",
-      content: userContent,
-      createdAt,
-      parts: userContent ? [{ id: `${baseId}-user-text`, type: "text", kind: "text", text: userContent }] : [],
-      attachments
-    });
-  }
-  const assistantText = turn.assistant_output_text || assistantTextFromResponseBlocks(responseBlocks) || assistantTextFromEvents(turn.run_events);
-  if (assistantText || responseBlocks.length > 0 || isRunning) {
-    const parts = partsFromResponseBlocks(responseBlocks, assistantText);
-    messages.push({
-      id: `${baseId}-assistant`,
-      role: "assistant",
-      runId: turn.run_id || null,
-      content: assistantText || assistantTextFromParts(parts),
-      createdAt: turn.completed_at ? new Date(turn.completed_at) : createdAt,
-      parts,
-      reasoningSteps: mergeReasoningSteps(reasoningStepsFromParts(parts), { finalize: !isRunning }),
-      isFinal: !isRunning,
-      tokenUsage: tokenUsageFromTurn(turn)
-    });
-  }
-  return messages;
-};
-var threadDetailToMessages = (thread) => {
-  const activeRun = activeRunIdFromThreadDetail(thread);
-  return (thread.turns || []).flatMap((turn) => turnToMessages(turn, activeRun));
-};
-var threadPaging = (thread) => {
-  const nextBeforeTurnIndex = thread.paging?.next_before_turn_index ?? null;
-  return {
-    hasOlderTurns: Boolean(thread.paging?.has_more || nextBeforeTurnIndex !== null),
-    nextBeforeTurnIndex
-  };
-};
-var latestContextWindowFromThread = (thread) => {
-  const threadContextWindow = normalizeContextWindow(thread.context_window);
-  if (threadContextWindow) return threadContextWindow;
-  for (let index = (thread.turns || []).length - 1; index >= 0; index -= 1) {
-    const contextWindow = normalizeContextWindow(thread.turns?.[index]?.context_window);
-    if (contextWindow) return contextWindow;
-  }
-  return null;
-};
-var activeRunIdFromThread = (thread) => {
-  const hasCamelActiveRun = Boolean(
-    thread && Object.prototype.hasOwnProperty.call(thread, "activeRun")
-  );
-  const hasCamelLastRunStatus = Boolean(
-    thread && Object.prototype.hasOwnProperty.call(thread, "lastRunStatus")
-  );
-  const hasCamelLastRunId = Boolean(
-    thread && Object.prototype.hasOwnProperty.call(thread, "lastRunId")
-  );
-  const activeRun = hasCamelActiveRun ? thread?.activeRun || null : thread?.active_run || null;
-  const lastRunStatus = hasCamelLastRunStatus ? thread?.lastRunStatus || null : thread?.last_run_status || thread?.lastRunStatus || null;
-  const activeRunId = activeRun?.run_id ? String(activeRun.run_id) : "";
-  if (activeRunId && isRunningThreadStatus(activeRun?.status || lastRunStatus)) return activeRunId;
-  const lastRunId = hasCamelLastRunId ? thread?.lastRunId : thread?.last_run_id || thread?.lastRunId;
-  return lastRunId && isRunningThreadStatus(lastRunStatus) ? String(lastRunId) : null;
-};
-var autoAttachRunIdFromThread = (thread) => {
-  const hasCamelActiveRun = Boolean(
-    thread && Object.prototype.hasOwnProperty.call(thread, "activeRun")
-  );
-  const hasCamelLastRunStatus = Boolean(
-    thread && Object.prototype.hasOwnProperty.call(thread, "lastRunStatus")
-  );
-  const hasCamelLastRunId = Boolean(
-    thread && Object.prototype.hasOwnProperty.call(thread, "lastRunId")
-  );
-  const activeRun = hasCamelActiveRun ? thread?.activeRun || null : thread?.active_run || null;
-  const lastRunStatus = hasCamelLastRunStatus ? thread?.lastRunStatus || null : thread?.last_run_status || thread?.lastRunStatus || null;
-  const activeRunId = activeRun?.run_id ? String(activeRun.run_id) : "";
-  if (activeRunId && isAutoAttachThreadStatus(activeRun?.status || lastRunStatus)) return activeRunId;
-  const lastRunId = hasCamelLastRunId ? thread?.lastRunId : thread?.last_run_id || thread?.lastRunId;
-  return lastRunId && isAutoAttachThreadStatus(lastRunStatus) ? String(lastRunId) : null;
-};
-var hasUnfinishedAssistantMessage = (messages) => Boolean(messages?.some((message) => message.role === "assistant" && message.isFinal === false));
-var hasStaleUnfinishedAssistantCache = (thread) => hasUnfinishedAssistantMessage(thread?.messages) && !activeRunIdFromThread(thread);
-var activeRunIdFromThreadDetail = (thread) => {
-  const summaryRunId = activeRunIdFromThread(thread);
-  if (summaryRunId) return summaryRunId;
-  const runningTurn = [...thread?.turns || []].reverse().find((turn) => turn.run_id && isRunningThreadStatus(turn.status));
-  return runningTurn?.run_id ? String(runningTurn.run_id) : null;
-};
-
-// src/controller-helpers.ts
-var threadSummaryToStored = (thread) => ({
-  ...thread,
-  id: String(thread.id),
-  title: String(thread.title || "New chat"),
-  updated_at: String(thread.updated_at || thread.last_activity_at || thread.created_at || (/* @__PURE__ */ new Date()).toISOString()),
-  messages: [],
-  isHydrated: false
-});
-var isThreadNotFoundError = (error) => {
-  if (!error || typeof error !== "object" || !("status" in error)) return false;
-  return Number(error.status) === 404;
-};
-var isAbortError = (error) => {
-  if (!error || typeof error !== "object") return false;
-  const maybe = error;
-  return maybe.name === "AbortError" || String(maybe.message || "").toLowerCase().includes("aborted");
-};
-var abortDetachedStream = (controller) => {
-  if (!controller || controller.signal.aborted) return;
-  try {
-    const reason = typeof DOMException !== "undefined" ? new DOMException("Chat stream detached.", "AbortError") : new Error("Chat stream detached.");
-    controller.abort(reason);
-  } catch {
-  }
-};
-var hasRunState = (thread) => Boolean(
-  thread.active_run || thread.activeRun || thread.last_run_id || thread.lastRunId || thread.last_run_status || thread.lastRunStatus || thread.isRunning
-);
-var mergeStoredThreadsForRefresh = (currentThreads, serverThreads) => {
-  const currentById = new Map(currentThreads.map((thread) => [thread.id, thread]));
-  const serverIds = new Set(serverThreads.map((thread) => thread.id));
-  const mergedServerThreads = serverThreads.map((serverThread) => {
-    const current = currentById.get(serverThread.id);
-    if (!current) return serverThread;
-    const incomingHasRunState = hasRunState(serverThread);
-    return {
-      ...current,
-      ...serverThread,
-      messages: current.messages || [],
-      isHydrated: current.isHydrated,
-      hasOlderTurns: current.hasOlderTurns,
-      nextBeforeTurnIndex: current.nextBeforeTurnIndex,
-      active_run: incomingHasRunState ? serverThread.active_run : current.active_run,
-      activeRun: incomingHasRunState ? serverThread.activeRun : current.activeRun,
-      last_run_id: incomingHasRunState ? serverThread.last_run_id : current.last_run_id,
-      lastRunId: incomingHasRunState ? serverThread.lastRunId : current.lastRunId,
-      last_run_status: incomingHasRunState ? serverThread.last_run_status : current.last_run_status,
-      lastRunStatus: incomingHasRunState ? serverThread.lastRunStatus : current.lastRunStatus,
-      lastEventSeq: incomingHasRunState ? serverThread.lastEventSeq : current.lastEventSeq,
-      isRunning: incomingHasRunState ? serverThread.isRunning : current.isRunning
-    };
-  });
-  const localOnlyThreads = currentThreads.filter((thread) => {
-    if (serverIds.has(thread.id)) return false;
-    return Boolean(thread.isHydrated || thread.messages?.length || thread.isRunning || thread.activeRun || thread.active_run);
-  });
-  return [...mergedServerThreads, ...localOnlyThreads];
-};
-var stableStringify = (value) => JSON.stringify(value ?? null);
-var sameStoredThread = (left, right) => {
-  if (left === right) return true;
-  if (!left || !right) return false;
-  return stableStringify(left) === stableStringify(right);
-};
-var applyThreadSummaryEvent = (currentThreads, event) => {
-  if (event.event === "snapshot_required") return currentThreads;
-  if (event.event === "thread.deleted") {
-    const next2 = currentThreads.filter((thread) => thread.id !== event.thread_id);
-    return next2.length === currentThreads.length ? currentThreads : next2;
-  }
-  const incoming = threadSummaryToStored(event.thread);
-  const index = currentThreads.findIndex((thread) => thread.id === incoming.id);
-  const sortByActivity = (threads) => [...threads].sort((a, b) => {
-    const left = Date.parse(String(a.updated_at || a.last_activity_at || a.created_at || ""));
-    const right = Date.parse(String(b.updated_at || b.last_activity_at || b.created_at || ""));
-    return (Number.isFinite(right) ? right : 0) - (Number.isFinite(left) ? left : 0);
-  });
-  if (index === -1) return sortByActivity([...currentThreads, incoming]);
-  const [merged] = mergeStoredThreadsForRefresh([currentThreads[index]], [incoming]);
-  if (sameStoredThread(currentThreads[index], merged)) return currentThreads;
-  const next = [...currentThreads];
-  next[index] = merged;
-  return sortByActivity(next);
-};
-
-// src/controller-thread-events.ts
-function useControllerThreadEvents({
-  transport,
-  storage,
-  refresh,
-  setThreads
-}) {
-  const cursorRef = useRef(null);
-  useEffect(() => {
-    if (!transport.subscribeThreadEvents) return;
-    let cancelled = false;
-    let retryTimeout = null;
-    let controller = null;
-    const connect = () => {
-      if (cancelled) return;
-      controller = new AbortController();
-      transport.subscribeThreadEvents?.(
-        { cursor: cursorRef.current, signal: controller.signal },
-        async (event) => {
-          if (typeof event.cursor === "number") cursorRef.current = event.cursor;
-          if (event.event === "snapshot_required") {
-            await refresh().catch(() => void 0);
-            return;
-          }
-          storage.setThreads(applyThreadSummaryEvent(storage.listThreads(), event));
-          setThreads(storage.listThreads());
-        }
-      ).catch((error) => {
-        if (cancelled || isAbortError(error)) return;
-        retryTimeout = setTimeout(connect, 1500);
-      });
-    };
-    connect();
-    return () => {
-      cancelled = true;
-      if (retryTimeout) clearTimeout(retryTimeout);
-      controller?.abort();
-    };
-  }, [refresh, setThreads, storage, transport]);
-}
-
-// src/message-lifecycle.ts
-function findStableAssistantMessageIndex(messages, input) {
-  return messages.findIndex(
-    (message) => message.role === "assistant" && (input.messageId && message.id === input.messageId || Boolean(input.runId && message.runId === input.runId))
-  );
-}
-function appendStableStreamingTurn(messages, userMessage, assistantMessage) {
-  const next = [...messages];
-  if (!next.some((message) => message.id === userMessage.id)) {
-    next.push(userMessage);
-  }
-  if (!next.some(
-    (message) => message.id === assistantMessage.id || Boolean(
-      assistantMessage.runId && message.role === "assistant" && message.runId === assistantMessage.runId
-    )
-  )) {
-    next.push(assistantMessage);
-  }
-  return next;
-}
-function upsertStableAssistantMessage(messages, input) {
-  const next = [...messages];
-  for (const baseMessage of input.baseMessages || []) {
-    const matchesTarget = baseMessage.role === "assistant" && (input.messageId && baseMessage.id === input.messageId || Boolean(input.runId && baseMessage.runId === input.runId));
-    if (!matchesTarget && !next.some((message) => message.id === baseMessage.id)) {
-      next.push(baseMessage);
-    }
-  }
-  const index = findStableAssistantMessageIndex(next, input);
-  if (index === -1) {
-    next.push(input.create());
-    return next;
-  }
-  next[index] = input.update(next[index]);
-  return next;
-}
-
-// src/controller.ts
-function useAgents24ChatController(options) {
-  const {
-    transport,
-    storage,
-    activeThreadId: controlledActiveThreadId,
-    pageSize = DEFAULT_THREAD_PAGE_SIZE,
-    storageKey,
-    createId = createChatId,
-    onActiveThreadIdChange,
-    onSourceClick,
-    onStreamErrorMessage,
-    onRuntimeEvent,
-    onThreadDetailLoaded
-  } = options;
-  const activeThreadId = controlledActiveThreadId ?? storage.getActiveThreadId?.() ?? null;
-  const initialCached = activeThreadId ? storage.getThread(activeThreadId) : void 0;
-  const [messages, setMessages] = useState2(() => initialCached?.messages || []);
-  const [isLoading, setIsLoading] = useState2(false);
-  const [isLoadingHistory, setIsLoadingHistory] = useState2(() => Boolean(activeThreadId) && !initialCached?.messages?.length);
-  const [isLoadingOlder, setIsLoadingOlder] = useState2(false);
-  const [hasOlderTurns, setHasOlderTurns] = useState2(Boolean(initialCached?.hasOlderTurns));
-  const [streamingContent, setStreamingContent] = useState2("");
-  const [streamingMessageId, setStreamingMessageId] = useState2(null);
-  const [contextStatus, setContextStatus] = useState2(null);
-  const [currentReasoning, setCurrentReasoning] = useState2([]);
-  const [liked, setLiked] = useState2({});
-  const [disliked, setDisliked] = useState2({});
-  const [copiedMessageId, setCopiedMessageId] = useState2(null);
-  const [lastThinkingDurationMs, setLastThinkingDurationMs] = useState2(null);
-  const [threads, setThreads] = useState2(() => storage.listThreads());
-  const [isRefreshingThreads, setIsRefreshingThreads] = useState2(false);
-  const [isSelectingThread, setIsSelectingThread] = useState2(false);
-  const [activeRunId, setActiveRunId] = useState2(null);
-  const textareaRef = useRef2(null);
-  const activeThreadIdRef = useRef2(activeThreadId);
-  const messagesRef = useRef2(messages);
-  const nextBeforeTurnIndexRef = useRef2(initialCached?.nextBeforeTurnIndex ?? null);
-  const hasOlderTurnsRef = useRef2(Boolean(initialCached?.hasOlderTurns));
-  const isLoadingOlderRef = useRef2(false);
-  const loadedThreadIdRef = useRef2(initialCached?.messages?.length ? activeThreadId : null);
-  const requestSeqRef = useRef2(0);
-  const isLoadingHistoryRef = useRef2(isLoadingHistory);
-  const activeRunIdRef = useRef2(null);
-  const reattachedRunIdRef = useRef2(null);
-  const abortControllerRef = useRef2(null);
-  const [lifecycleAbortController] = useState2(() => new AbortController());
-  const streamingContentRef = useRef2("");
-  const streamingMessageIdRef = useRef2(null);
-  const reasoningRef = useRef2([]);
-  const liveVoiceIdsRef = useRef2({});
-  const refreshSeqRef = useRef2(0);
-  const setActiveRunIdValue = useCallback3((runId) => {
-    activeRunIdRef.current = runId;
-    setActiveRunId(runId);
-  }, []);
-  const syncThreadsFromStorage = useCallback3(() => {
-    setThreads(storage.listThreads());
-  }, [storage]);
-  const upsertStoredThread = useCallback3(
-    (thread) => {
-      storage.upsertThread(thread);
-      syncThreadsFromStorage();
-    },
-    [storage, syncThreadsFromStorage]
-  );
-  useEffect2(() => {
-    messagesRef.current = messages;
-  }, [messages]);
-  const persistThread = useCallback3(
-    (threadId, nextMessages, paging, options2) => {
-      const existing = storage.getThread(threadId);
-      const firstUser = nextMessages.find((message) => message.role === "user");
-      upsertStoredThread({
-        ...existing || {},
-        id: threadId,
-        title: existing?.title || (firstUser ? titleFromMessage(firstUser.content, firstUser.attachments || []) : "New chat"),
-        updated_at: options2?.updatedAt || (options2?.touch ? (/* @__PURE__ */ new Date()).toISOString() : existing?.updated_at) || (/* @__PURE__ */ new Date()).toISOString(),
-        messages: nextMessages,
-        isHydrated: true,
-        hasOlderTurns: paging?.hasOlderTurns ?? hasOlderTurnsRef.current,
-        nextBeforeTurnIndex: paging?.nextBeforeTurnIndex ?? nextBeforeTurnIndexRef.current
-      });
-    },
-    [storage, upsertStoredThread]
-  );
-  const markThreadRunStatus = useCallback3(
-    (threadId, runId, status, lastEventSeq) => {
-      const existing = storage.getThread(threadId);
-      if (!existing || !runId) return;
-      upsertStoredThread({
-        ...existing,
-        last_run_id: runId,
-        last_run_status: status,
-        active_run: {
-          run_id: runId,
-          status,
-          created_at: existing.activeRun?.created_at ?? existing.active_run?.created_at ?? (/* @__PURE__ */ new Date()).toISOString()
-        },
-        lastRunId: runId,
-        lastRunStatus: status,
-        activeRun: {
-          run_id: runId,
-          status,
-          created_at: existing.activeRun?.created_at ?? existing.active_run?.created_at ?? (/* @__PURE__ */ new Date()).toISOString()
-        },
-        lastEventSeq: typeof lastEventSeq === "number" ? lastEventSeq : existing.lastEventSeq ?? null,
-        isRunning: activeRunIdFromThread({
-          lastRunId: runId,
-          lastRunStatus: status,
-          activeRun: { run_id: runId, status }
-        }) !== null
-      });
-    },
-    [storage, upsertStoredThread]
-  );
-  const refresh = useCallback3(async () => {
-    const seq = ++refreshSeqRef.current;
-    setIsRefreshingThreads(true);
-    try {
-      const data = await transport.listThreads({ signal: lifecycleAbortController.signal });
-      if (lifecycleAbortController.signal.aborted) return;
-      if (seq !== refreshSeqRef.current) return;
-      const nextThreads = (data.items || []).map((item) => threadSummaryToStored(item));
-      storage.setThreads(mergeStoredThreadsForRefresh(storage.listThreads(), nextThreads));
-      setThreads(storage.listThreads());
-    } finally {
-      if (!lifecycleAbortController.signal.aborted && seq === refreshSeqRef.current) setIsRefreshingThreads(false);
-    }
-  }, [lifecycleAbortController, storage, transport]);
-  const applyThreadId = useCallback3(
-    (threadId, baseMessages) => {
-      if (!threadId || activeThreadIdRef.current === threadId) return;
-      activeThreadIdRef.current = threadId;
-      persistThread(threadId, messagesRef.current.length > 0 ? messagesRef.current : baseMessages, void 0, { touch: true });
-      storage.setActiveThreadId?.(threadId);
-      onActiveThreadIdChange?.(threadId);
-    },
-    [onActiveThreadIdChange, persistThread, storage]
-  );
-  const setStreamingText = (value) => {
-    streamingContentRef.current = value;
-    setStreamingContent(value);
-  };
-  const setLoadingHistory = useCallback3((value) => {
-    isLoadingHistoryRef.current = value;
-    setIsLoadingHistory(value);
-  }, []);
-  const setReasoningSteps = useCallback3((value) => {
-    reasoningRef.current = value || [];
-    setCurrentReasoning(value || []);
-  }, []);
-  const detachActiveStream = useCallback3(() => {
-    const controller = abortControllerRef.current;
-    abortControllerRef.current = null;
-    abortDetachedStream(controller);
-    setActiveRunIdValue(null);
-    reattachedRunIdRef.current = null;
-    streamingMessageIdRef.current = null;
-    streamingContentRef.current = "";
-    reasoningRef.current = [];
-    setStreamingMessageId(null);
-    setIsLoading(false);
-    setStreamingContent("");
-    setCurrentReasoning([]);
-  }, [setActiveRunIdValue]);
-  const clearMissingThread = useCallback3(
-    (threadId) => {
-      storage.deleteThread?.(threadId);
-      syncThreadsFromStorage();
-      if (activeThreadIdRef.current !== threadId) return;
-      requestSeqRef.current += 1;
-      detachActiveStream();
-      activeThreadIdRef.current = null;
-      loadedThreadIdRef.current = null;
-      nextBeforeTurnIndexRef.current = null;
-      hasOlderTurnsRef.current = false;
-      storage.setActiveThreadId?.(null);
-      onActiveThreadIdChange?.(null);
-      setMessages([]);
-      messagesRef.current = [];
-      setHasOlderTurns(false);
-      setIsLoadingOlder(false);
-      setContextStatus(null);
-      setLoadingHistory(false);
-    },
-    [detachActiveStream, onActiveThreadIdChange, setLoadingHistory, storage, syncThreadsFromStorage]
-  );
-  const setLiveAssistantMessage = useCallback3(
-    (input) => {
-      setMessages((prev) => {
-        const next = upsertStableAssistantMessage(prev, {
-          baseMessages: input.baseMessages,
-          messageId: input.messageId,
-          runId: input.runId,
-          create: () => ({
-            id: input.messageId,
-            role: "assistant",
-            runId: input.runId ?? null,
-            content: input.content,
-            createdAt: /* @__PURE__ */ new Date(),
-            reasoningSteps: input.reasoning,
-            isFinal: false,
-            parts: input.parts || []
-          }),
-          update: (message) => ({
-            ...message,
-            runId: input.runId ?? message.runId ?? null,
-            content: input.content,
-            reasoningSteps: input.reasoning,
-            isFinal: false,
-            parts: input.parts ?? message.parts
-          })
-        });
-        messagesRef.current = next;
-        return next;
-      });
-    },
-    []
-  );
-  const finalizeAssistantMessage = useCallback3(
-    (input) => {
-      const content = input.error || input.assistantText.trim();
-      if (!content) return input.baseMessages;
-      const existingIndex = input.baseMessages.findIndex(
-        (message) => input.messageId && message.id === input.messageId || input.runId && message.role === "assistant" && message.runId === input.runId
-      );
-      const existing = existingIndex >= 0 ? input.baseMessages[existingIndex] : void 0;
-      const parts = input.parts || existing?.parts || partsFromResponseBlocks(void 0, content);
-      const assistant = {
-        id: existing?.id || input.messageId || createId(),
-        role: "assistant",
-        runId: input.runId ?? existing?.runId ?? null,
-        content,
-        createdAt: /* @__PURE__ */ new Date(),
-        isFinal: true,
-        parts,
-        reasoningSteps: mergeReasoningSteps(input.reasoning, { finalize: true }),
-        thinkingDurationMs: input.thinkingDurationMs
-      };
-      const completed = upsertStableAssistantMessage(input.baseMessages, {
-        messageId: input.messageId,
-        runId: input.runId,
-        create: () => assistant,
-        update: (message) => ({
-          ...message,
-          ...assistant,
-          id: message.id,
-          createdAt: message.createdAt
-        })
-      });
-      setMessages(completed);
-      messagesRef.current = completed;
-      if (input.threadId) {
-        persistThread(input.threadId, completed);
-        const existingThread = storage.getThread(input.threadId);
-        if (existingThread && input.runId) {
-          upsertStoredThread({
-            ...existingThread,
-            messages: completed,
-            last_run_id: input.runId,
-            last_run_status: input.error ? "failed" : "completed",
-            active_run: null,
-            lastRunId: input.runId,
-            lastRunStatus: input.error ? "failed" : "completed",
-            activeRun: null,
-            isRunning: false
-          });
-        }
-      }
-      return completed;
-    },
-    [createId, persistThread, storage, upsertStoredThread]
-  );
-  const loadThread = useCallback3(
-    async (threadId) => {
-      const seq = ++requestSeqRef.current;
-      setLoadingHistory(true);
-      setIsLoadingOlder(false);
-      isLoadingOlderRef.current = false;
-      try {
-        const detail = await transport.getThread({
-          threadId,
-          limit: pageSize,
-          includeRunEvents: false,
-          signal: lifecycleAbortController.signal
-        });
-        if (activeThreadIdRef.current !== threadId || seq !== requestSeqRef.current) return;
-        void onThreadDetailLoaded?.(detail);
-        const nextMessages = threadDetailToMessages(detail);
-        const paging = threadPaging(detail);
-        setContextStatus(latestContextWindowFromThread(detail));
-        setMessages(nextMessages);
-        messagesRef.current = nextMessages;
-        setHasOlderTurns(paging.hasOlderTurns);
-        hasOlderTurnsRef.current = paging.hasOlderTurns;
-        nextBeforeTurnIndexRef.current = paging.nextBeforeTurnIndex;
-        loadedThreadIdRef.current = threadId;
-        upsertStoredThread({
-          ...threadSummaryToStored(detail),
-          messages: nextMessages,
-          isHydrated: true,
-          hasOlderTurns: paging.hasOlderTurns,
-          nextBeforeTurnIndex: paging.nextBeforeTurnIndex,
-          updated_at: threadActivityDate(detail)
-        });
-      } catch (error) {
-        if (isAbortError(error)) return;
-        if (isThreadNotFoundError(error)) {
-          clearMissingThread(threadId);
-          return;
-        }
-        throw error;
-      } finally {
-        if (!lifecycleAbortController.signal.aborted && activeThreadIdRef.current === threadId && seq === requestSeqRef.current) setLoadingHistory(false);
-      }
-    },
-    [clearMissingThread, lifecycleAbortController, onThreadDetailLoaded, pageSize, setLoadingHistory, transport, upsertStoredThread]
-  );
-  const loadOlderTurns = useCallback3(async () => {
-    const threadId = activeThreadIdRef.current;
-    const beforeTurnIndex = nextBeforeTurnIndexRef.current;
-    if (!threadId || beforeTurnIndex === null || isLoadingOlderRef.current) return;
-    isLoadingOlderRef.current = true;
-    setIsLoadingOlder(true);
-    try {
-      const detail = await transport.getThread({
-        threadId,
-        limit: pageSize,
-        beforeTurnIndex,
-        includeRunEvents: false,
-        signal: lifecycleAbortController.signal
-      });
-      if (activeThreadIdRef.current !== threadId) return;
-      const older = threadDetailToMessages(detail);
-      const paging = threadPaging(detail);
-      const next = [...older, ...messagesRef.current];
-      setMessages(next);
-      messagesRef.current = next;
-      setHasOlderTurns(paging.hasOlderTurns);
-      hasOlderTurnsRef.current = paging.hasOlderTurns;
-      nextBeforeTurnIndexRef.current = paging.nextBeforeTurnIndex;
-      persistThread(threadId, next, paging);
-    } catch (error) {
-      if (isAbortError(error)) return;
-      if (isThreadNotFoundError(error)) {
-        clearMissingThread(threadId);
-        return;
-      }
-      throw error;
-    } finally {
-      if (!lifecycleAbortController.signal.aborted && activeThreadIdRef.current === threadId) setIsLoadingOlder(false);
-      isLoadingOlderRef.current = false;
-    }
-  }, [clearMissingThread, lifecycleAbortController, pageSize, persistThread, transport]);
-  const handleStreamEvent = useCallback3(
-    (input) => {
-      const { mode, event, assistantMessageId, startedAt, streamThreadIdRef, baseMessages } = input;
-      const payload = event.payload || {};
-      const responseBlocks = Array.isArray(payload.response_blocks) ? payload.response_blocks : null;
-      if (event.run_id) setActiveRunIdValue(event.run_id);
-      void onRuntimeEvent?.(event, {
-        mode,
-        assistantMessageId,
-        threadId: streamThreadIdRef.current,
-        runId: event.run_id || activeRunIdRef.current,
-        startedAt
-      });
-      setContextStatus((current) => mergeContextWindowUpdate(current, payload.context_window));
-      if (responseBlocks) {
-        const blockText = String(payload.assistant_output_text || "") || assistantTextFromResponseBlocks(responseBlocks) || streamingContentRef.current;
-        if (blockText) setStreamingText(blockText);
-        const parts = partsFromResponseBlocks(responseBlocks, blockText);
-        const reasoning = mergeReasoningSteps([...reasoningRef.current, ...reasoningStepsFromParts(parts)]);
-        setReasoningSteps(reasoning);
-        setLiveAssistantMessage({
-          messageId: assistantMessageId,
-          runId: event.run_id || activeRunIdRef.current,
-          content: blockText,
-          reasoning,
-          parts,
-          baseMessages
-        });
-      }
-      if (event.event === "run.accepted" || event.event === "run.snapshot") {
-        const nextThreadId = String(payload.thread_id || streamThreadIdRef.current || "");
-        if (nextThreadId) {
-          streamThreadIdRef.current = nextThreadId;
-          applyThreadId(nextThreadId, baseMessages);
-          markThreadRunStatus(nextThreadId, event.run_id || activeRunIdRef.current || "", String(payload.status || "running"), typeof payload.last_event_seq === "number" ? payload.last_event_seq : null);
-        }
-        return;
-      }
-      const isTerminal = event.event === "run.completed" || event.event === "run.cancelled" || event.event === "reshet.stream.result";
-      const isFailed = event.event === "run.failed" || event.event.endsWith(".stream.error");
-      if (!isTerminal && !isFailed) return;
-      const terminalThreadId = String(payload.thread_id || "");
-      if (terminalThreadId && !streamThreadIdRef.current) {
-        streamThreadIdRef.current = terminalThreadId;
-        applyThreadId(terminalThreadId, baseMessages);
-      }
-      const finalText = String(payload.assistant_output_text || assistantTextFromResponseBlocks(responseBlocks || []) || streamingContentRef.current || "");
-      finalizeAssistantMessage({
-        threadId: streamThreadIdRef.current || activeThreadIdRef.current,
-        baseMessages: messagesRef.current,
-        assistantText: finalText,
-        reasoning: reasoningRef.current,
-        thinkingDurationMs: Date.now() - startedAt,
-        messageId: assistantMessageId,
-        runId: event.run_id || activeRunIdRef.current,
-        parts: responseBlocks ? partsFromResponseBlocks(responseBlocks, finalText) : void 0,
-        error: isFailed ? String(payload.message || payload.error || event.diagnostics?.[0]?.message || onStreamErrorMessage?.(event) || "The chat run failed.") : void 0
-      });
-    },
-    [applyThreadId, finalizeAssistantMessage, markThreadRunStatus, onRuntimeEvent, onStreamErrorMessage, setActiveRunIdValue, setLiveAssistantMessage, setReasoningSteps]
-  );
-  const runStream = useCallback3(
-    async (input) => {
-      const startedAt = Date.now();
-      const controller = new AbortController();
-      requestSeqRef.current += 1;
-      abortControllerRef.current = controller;
-      setIsLoading(true);
-      setStreamingText("");
-      setReasoningSteps([{ label: input.mode === "attach" ? "Reconnecting" : "Connecting", status: "active" }]);
-      const streamThreadIdRef = { current: input.mode === "attach" ? input.threadId : activeThreadIdRef.current };
-      const attachAssistantMessage = input.mode === "attach" ? [...messagesRef.current].reverse().find(
-        (message) => message.role === "assistant" && (message.runId === input.runId || message.isFinal === false)
-      ) : void 0;
-      let assistantMessageId = input.mode === "attach" ? attachAssistantMessage?.id || `${input.runId}-assistant` : createId();
-      let baseMessages = messagesRef.current;
-      if (input.mode === "submit") {
-        const userMessage = {
-          id: createId(),
-          role: "user",
-          content: input.message.text,
-          createdAt: /* @__PURE__ */ new Date(),
-          parts: input.message.text ? [{ id: createId(), type: "text", kind: "text", text: input.message.text }] : [],
-          attachments: input.message.files
-        };
-        baseMessages = [...messagesRef.current, userMessage];
-      }
-      if (!messagesRef.current.some((message) => message.id === assistantMessageId)) {
-        const assistantMessage = {
-          id: assistantMessageId,
-          role: "assistant",
-          content: "",
-          createdAt: /* @__PURE__ */ new Date(),
-          isFinal: false,
-          parts: [],
-          reasoningSteps: []
-        };
-        const liveMessages = [...baseMessages, assistantMessage];
-        setMessages(liveMessages);
-        messagesRef.current = liveMessages;
-      } else if (input.mode === "attach" && attachAssistantMessage) {
-        const nextMessages = messagesRef.current.map(
-          (message) => message.id === attachAssistantMessage.id ? { ...message, runId: message.runId || input.runId, isFinal: false } : message
-        );
-        setMessages(nextMessages);
-        messagesRef.current = nextMessages;
-        baseMessages = nextMessages;
-        if (streamThreadIdRef.current) persistThread(streamThreadIdRef.current, nextMessages);
-      }
-      streamingMessageIdRef.current = assistantMessageId;
-      setStreamingMessageId(assistantMessageId);
-      if (streamThreadIdRef.current) {
-        persistThread(
-          streamThreadIdRef.current,
-          messagesRef.current.length > 0 ? messagesRef.current : baseMessages,
-          void 0,
-          { touch: input.mode === "submit" }
-        );
-      }
-      try {
-        let streamResult = null;
-        if (input.mode === "attach") {
-          setActiveRunIdValue(input.runId);
-          reattachedRunIdRef.current = input.runId;
-          streamResult = await transport.attachRun(
-            { runId: input.runId, signal: controller.signal },
-            (event) => handleStreamEvent({ mode: "attach", event, assistantMessageId, startedAt, streamThreadIdRef, baseMessages })
-          );
-        } else {
-          streamResult = await transport.streamMessage(
-            { ...input.message, files: input.message.files || [], threadId: activeThreadIdRef.current, signal: controller.signal },
-            (event) => handleStreamEvent({ mode: "submit", event, assistantMessageId, startedAt, streamThreadIdRef, baseMessages })
-          );
-        }
-        if (streamResult?.runId) setActiveRunIdValue(streamResult.runId);
-        if (streamResult?.threadId) {
-          streamThreadIdRef.current = streamResult.threadId;
-          applyThreadId(streamResult.threadId, baseMessages);
-          if (streamResult.runId) {
-            markThreadRunStatus(streamResult.threadId, streamResult.runId, "running");
-          }
-        }
-        if (streamingContentRef.current.trim() && streamingMessageIdRef.current) {
-          finalizeAssistantMessage({
-            threadId: streamThreadIdRef.current,
-            baseMessages: messagesRef.current,
-            assistantText: streamingContentRef.current,
-            reasoning: reasoningRef.current,
-            thinkingDurationMs: Date.now() - startedAt,
-            messageId: assistantMessageId,
-            runId: activeRunIdRef.current
-          });
-        }
-        await refresh().catch(() => void 0);
-      } catch (error) {
-        if (!isAbortError(error)) {
-          finalizeAssistantMessage({
-            threadId: streamThreadIdRef.current,
-            baseMessages: messagesRef.current,
-            assistantText: streamingContentRef.current,
-            reasoning: reasoningRef.current,
-            thinkingDurationMs: Date.now() - startedAt,
-            messageId: assistantMessageId,
-            runId: activeRunIdRef.current,
-            error: onStreamErrorMessage?.(error) || error.message || "Failed to reach the chat agent."
-          });
-        }
-      } finally {
-        const isCurrentStream = abortControllerRef.current === controller || streamingMessageIdRef.current === assistantMessageId;
-        if (abortControllerRef.current === controller) abortControllerRef.current = null;
-        if (isCurrentStream) {
-          setActiveRunIdValue(null);
-          streamingMessageIdRef.current = null;
-          reattachedRunIdRef.current = null;
-          setStreamingMessageId(null);
-          setIsLoading(false);
-          setStreamingText("");
-          setReasoningSteps([]);
-          setLastThinkingDurationMs(Date.now() - startedAt);
-        }
-      }
-    },
-    [createId, finalizeAssistantMessage, handleStreamEvent, onStreamErrorMessage, persistThread, refresh, setActiveRunIdValue, setReasoningSteps, transport]
-  );
-  const handleSubmit = useCallback3(
-    async (message) => {
-      if (!message.text.trim() && !(message.files || []).length) return;
-      await runStream({ mode: "submit", message });
-    },
-    [runStream]
-  );
-  const attachRun = useCallback3(async (runId, threadId) => {
-    const resolvedThreadId = threadId ?? activeThreadIdRef.current;
-    if (runId && resolvedThreadId) await runStream({ mode: "attach", runId, threadId: resolvedThreadId });
-  }, [runStream]);
-  const { pendingHitl, isResolvingHitl, resumeHitl } = useControllerHitl({
-    messages,
-    transport,
-    activeRunId,
-    activeRunIdRef,
-    activeThreadIdRef,
-    runStream
-  });
-  const handleStop = useCallback3(() => {
-    const runId = activeRunIdRef.current;
-    const partial = streamingContentRef.current;
-    const liveMessageId = streamingMessageIdRef.current;
-    abortDetachedStream(abortControllerRef.current);
-    abortControllerRef.current = null;
-    setActiveRunIdValue(null);
-    streamingMessageIdRef.current = null;
-    setStreamingMessageId(null);
-    setIsLoading(false);
-    setStreamingText("");
-    setReasoningSteps([]);
-    if (runId) transport.cancelRun({ runId, assistantOutputText: partial }).catch(() => void 0);
-    if (partial.trim()) {
-      finalizeAssistantMessage({
-        threadId: activeThreadIdRef.current,
-        baseMessages: messagesRef.current,
-        assistantText: partial,
-        reasoning: reasoningRef.current,
-        thinkingDurationMs: lastThinkingDurationMs || 0,
-        messageId: liveMessageId
-      });
-    }
-  }, [finalizeAssistantMessage, lastThinkingDurationMs, setActiveRunIdValue, setReasoningSteps, transport]);
-  useEffect2(() => {
-    refresh().catch((error) => {
-      if (!isAbortError(error) && !lifecycleAbortController.signal.aborted) {
-        setThreads(storage.listThreads());
-      }
-    });
-  }, [lifecycleAbortController, refresh, storage]);
-  useEffect2(() => {
-    return () => {
-      lifecycleAbortController.abort();
-      abortDetachedStream(abortControllerRef.current);
-      abortControllerRef.current = null;
-    };
-  }, [lifecycleAbortController]);
-  useControllerThreadEvents({ transport, storage, refresh, setThreads });
-  useEffect2(() => {
-    syncThreadsFromStorage();
-  }, [storageKey, syncThreadsFromStorage]);
-  useEffect2(() => {
-    const previous = activeThreadIdRef.current;
-    activeThreadIdRef.current = activeThreadId;
-    if (activeThreadId && previous === activeThreadId && (activeRunIdRef.current || streamingMessageIdRef.current)) {
-      return;
-    }
-    if (previous && previous !== activeThreadId && abortControllerRef.current) {
-      detachActiveStream();
-    }
-    if (!activeThreadId) {
-      if (previous === null && loadedThreadIdRef.current === null && messagesRef.current.length === 0 && !hasOlderTurnsRef.current && !isLoadingHistoryRef.current && !isLoadingOlderRef.current && nextBeforeTurnIndexRef.current === null) {
-        return;
-      }
-      requestSeqRef.current += 1;
-      loadedThreadIdRef.current = null;
-      setMessages([]);
-      messagesRef.current = [];
-      setHasOlderTurns(false);
-      setIsLoadingOlder(false);
-      setContextStatus(null);
-      nextBeforeTurnIndexRef.current = null;
-      setLoadingHistory(false);
-      return;
-    }
-    const cached = storage.getThread(activeThreadId);
-    const cachedMessages = cached?.isHydrated && cached.messages?.length ? cached.messages : null;
-    const hasCachedMessages = Boolean(cachedMessages);
-    const shouldRefreshStaleCache = hasCachedMessages && hasStaleUnfinishedAssistantCache(cached);
-    if (cached && cachedMessages) {
-      setMessages(cachedMessages);
-      messagesRef.current = cachedMessages;
-      setHasOlderTurns(Boolean(cached.hasOlderTurns));
-      hasOlderTurnsRef.current = Boolean(cached.hasOlderTurns);
-      nextBeforeTurnIndexRef.current = cached.nextBeforeTurnIndex ?? null;
-      loadedThreadIdRef.current = activeThreadId;
-      setLoadingHistory(false);
-      if (!shouldRefreshStaleCache) return;
-    }
-    if (!hasCachedMessages) {
-      setMessages([]);
-      messagesRef.current = [];
-    }
-    void loadThread(activeThreadId).catch(() => setLoadingHistory(false));
-  }, [activeThreadId, detachActiveStream, loadThread, setLoadingHistory, storage]);
-  useEffect2(() => {
-    const threadId = activeThreadId;
-    if (!threadId || isLoadingHistory || loadedThreadIdRef.current !== threadId || activeRunIdRef.current) return;
-    const runId = autoAttachRunIdFromThread(storage.getThread(threadId));
-    if (!runId || reattachedRunIdRef.current === runId) return;
-    void runStream({ mode: "attach", threadId, runId });
-  }, [activeThreadId, isLoadingHistory, runStream, storage, storageKey]);
-  useEffect2(() => {
-    const threadId = activeThreadId;
-    if (!threadId || isLoadingHistoryRef.current || activeRunIdRef.current || streamingMessageIdRef.current) {
-      return;
-    }
-    const cached = storage.getThread(threadId);
-    if (!hasStaleUnfinishedAssistantCache(cached)) return;
-    void loadThread(threadId).catch(() => setLoadingHistory(false));
-  }, [activeThreadId, loadThread, setLoadingHistory, storage, storageKey]);
-  const {
-    handleCopy,
-    handleDislike,
-    handleLike,
-    handleRetry,
-    startNewThread,
-    upsertLiveVoiceMessage
-  } = useControllerMessageActions({
-    activeThreadIdRef,
-    createId,
-    detachActiveStream,
-    disliked,
-    handleSubmit,
-    hasOlderTurnsRef,
-    liked,
-    liveVoiceIdsRef,
-    loadedThreadIdRef,
-    messagesRef,
-    nextBeforeTurnIndexRef,
-    onActiveThreadIdChange,
-    persistThread,
-    requestSeqRef,
-    setContextStatus,
-    setCopiedMessageId,
-    setDisliked,
-    setHasOlderTurns,
-    setIsLoadingOlder,
-    setLiked,
-    setLoadingHistory,
-    setMessages,
-    storage
-  });
-  const loadThreadById = useCallback3(
-    async (threadId) => {
-      if (!threadId) return;
-      setIsSelectingThread(true);
-      if (activeThreadIdRef.current !== threadId) {
-        if (abortControllerRef.current) detachActiveStream();
-        activeThreadIdRef.current = threadId;
-        storage.setActiveThreadId?.(threadId);
-        onActiveThreadIdChange?.(threadId);
-      }
-      try {
-        await loadThread(threadId);
-      } finally {
-        if (activeThreadIdRef.current === threadId) setIsSelectingThread(false);
-      }
-    },
-    [detachActiveStream, loadThread, onActiveThreadIdChange, storage]
-  );
-  const activeThread = activeThreadId ? storage.getThread(activeThreadId) || threads.find((thread) => thread.id === activeThreadId) || null : null;
-  return useMemo2(() => ({
-    threads,
-    activeThreadId,
-    activeThread,
-    messages,
-    streamingContent,
-    streamingMessageId,
-    contextStatus,
-    currentReasoning,
-    isLoading,
-    isLoadingHistory,
-    isLoadingOlder,
-    isRefreshingThreads,
-    isSelectingThread,
-    hasOlderTurns,
-    liked,
-    disliked,
-    copiedMessageId,
-    lastThinkingDurationMs,
-    activeRunId,
-    pendingHitl,
-    isResolvingHitl,
-    handleSubmit,
-    attachRun,
-    resumeHitl,
-    handleStop,
-    handleCopy,
-    handleLike,
-    handleDislike,
-    handleRetry,
-    handleSourceClick: (citations) => onSourceClick?.(citations),
-    upsertLiveVoiceMessage,
-    startNewThread,
-    loadThreadById,
-    loadOlderTurns,
-    refresh,
-    textareaRef
-  }), [
-    copiedMessageId,
-    activeRunId,
-    activeThread,
-    activeThreadId,
-    attachRun,
-    contextStatus,
-    currentReasoning,
-    disliked,
-    handleCopy,
-    handleDislike,
-    handleLike,
-    handleRetry,
-    handleStop,
-    handleSubmit,
-    hasOlderTurns,
-    isLoading,
-    isLoadingHistory,
-    isLoadingOlder,
-    isRefreshingThreads,
-    isSelectingThread,
-    lastThinkingDurationMs,
-    liked,
-    loadThreadById,
-    loadOlderTurns,
-    messages,
-    isResolvingHitl,
-    onSourceClick,
-    pendingHitl,
-    refresh,
-    resumeHitl,
-    streamingContent,
-    streamingMessageId,
-    startNewThread,
-    threads,
-    upsertLiveVoiceMessage
-  ]);
-}
-
-// src/mcp-oauth.ts
-var CONNECTION_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-function normalizedOrigin(value) {
-  try {
-    return new URL(value).origin;
-  } catch {
-    throw new Error("MCP authorization returned an invalid callback origin.");
-  }
-}
-function waitForMcpOauthComplete({
-  popup,
-  callbackOrigin,
-  serverId,
-  timeoutMs = 12e4
-}) {
-  if (!popup) return Promise.reject(new Error("Could not open the MCP authorization popup."));
-  const expectedOrigin = normalizedOrigin(callbackOrigin);
-  const expectedServerId = String(serverId || "").trim();
-  if (!expectedServerId) return Promise.reject(new Error("MCP authorization is missing its server identity."));
-  return new Promise((resolve, reject) => {
-    let settled = false;
-    const finish = (result) => {
-      if (settled) return;
-      settled = true;
-      window.clearTimeout(timeout);
-      window.clearInterval(closeTimer);
-      window.removeEventListener("message", onMessage);
-      if (result instanceof Error) reject(result);
-      else resolve(result);
-    };
-    const onMessage = (event) => {
-      if (event.source !== popup || event.origin !== expectedOrigin) return;
-      const data = event.data;
-      if (data?.type !== "mcp-oauth-complete" || data.server_id !== expectedServerId) return;
-      if (!data.success) {
-        finish(new Error("MCP authorization failed."));
-        return;
-      }
-      const connectionId = String(data.connection_id || "").trim();
-      if (!CONNECTION_ID_PATTERN.test(connectionId)) return;
-      finish({ connectionId });
-    };
-    const timeout = window.setTimeout(
-      () => finish(new Error("MCP authorization timed out.")),
-      Math.max(1, timeoutMs)
-    );
-    const closeTimer = window.setInterval(() => {
-      if (popup.closed) finish(new Error("MCP authorization window was closed before connecting."));
-    }, 500);
-    window.addEventListener("message", onMessage);
-  });
-}
+} from "./chunk-CHAU7FNW.js";
 
 // src/renderers.tsx
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
@@ -1670,204 +66,6 @@ var renderChatPart = (part, message, renderOptions) => /* @__PURE__ */ jsx(
   part.id
 );
 
-// src/sse.ts
-var isAbortError2 = (error) => {
-  if (!error || typeof error !== "object") return false;
-  const maybe = error;
-  return maybe.name === "AbortError" || String(maybe.message || "").toLowerCase().includes("aborted");
-};
-var parseSseBlock = (block) => {
-  const data = block.split("\n").filter((line) => line.startsWith("data:")).map((line) => line.replace(/^data:\s?/, "")).join("\n").trim();
-  if (!data) return null;
-  return JSON.parse(data);
-};
-var consumeSseResponse = async (response, onEvent, options = {}) => {
-  if (!response.ok) {
-    let message = response.statusText || "Failed to open chat stream.";
-    try {
-      const errorData = await response.json();
-      message = String(errorData.detail || errorData.message || message);
-    } catch {
-    }
-    throw new Error(message);
-  }
-  const reader = response.body?.getReader();
-  if (!reader) throw new Error("The chat stream did not return a readable body.");
-  const decoder = new TextDecoder();
-  let buffer = "";
-  let threadId = response.headers.get("X-Thread-ID") || null;
-  let runId = response.headers.get("X-Run-ID") || null;
-  let closed = false;
-  const closeReader = () => {
-    closed = true;
-    queueMicrotask(() => {
-      void reader.cancel().catch(() => {
-      });
-    });
-  };
-  if (options.signal?.aborted) {
-    closeReader();
-    return { threadId, runId };
-  }
-  options.signal?.addEventListener("abort", closeReader, { once: true });
-  try {
-    while (!closed) {
-      const { value, done } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      let boundary = buffer.indexOf("\n\n");
-      while (boundary !== -1) {
-        const block = buffer.slice(0, boundary);
-        buffer = buffer.slice(boundary + 2);
-        boundary = buffer.indexOf("\n\n");
-        const event = parseSseBlock(block);
-        if (!event) continue;
-        if (event.run_id) runId = event.run_id;
-        const payloadThreadId = event.payload?.thread_id;
-        if (payloadThreadId) threadId = String(payloadThreadId);
-        await onEvent(event);
-      }
-    }
-  } catch (error) {
-    if (!isAbortError2(error)) throw error;
-  } finally {
-    options.signal?.removeEventListener("abort", closeReader);
-  }
-  return { threadId, runId };
-};
-
-// src/transport.ts
-var jsonHeaders = (headers) => ({
-  ...headers || {},
-  Accept: "application/json",
-  "Content-Type": "application/json"
-});
-var streamHeaders = (headers) => ({
-  ...headers || {},
-  Accept: "text/event-stream",
-  "Content-Type": "application/json"
-});
-var ChatTransportError = class extends Error {
-  constructor(message, status) {
-    super(message);
-    this.name = "ChatTransportError";
-    this.status = status;
-  }
-};
-var transportError = (response, fallback) => new ChatTransportError(response.statusText || fallback, response.status);
-var createFetchChatTransport = ({
-  routes,
-  fetchImpl = fetch,
-  headers,
-  streamBody
-}) => {
-  const loadHeaders = async () => headers?.() ?? {};
-  return {
-    async listThreads(input) {
-      const response = await fetchImpl(routes.listThreads(), {
-        signal: input?.signal,
-        headers: jsonHeaders(await loadHeaders())
-      });
-      if (!response.ok) throw transportError(response, "Failed to list chat threads.");
-      return response.json();
-    },
-    async getThread(input) {
-      const response = await fetchImpl(routes.getThread(input), {
-        signal: input.signal,
-        headers: jsonHeaders(await loadHeaders())
-      });
-      if (!response.ok) throw transportError(response, "Failed to load chat thread.");
-      return response.json();
-    },
-    async streamMessage(input, onEvent) {
-      const response = await fetchImpl(routes.streamMessage(), {
-        method: "POST",
-        signal: input.signal,
-        headers: streamHeaders(await loadHeaders()),
-        body: JSON.stringify(
-          streamBody?.(input) ?? {
-            input: input.text,
-            thread_id: input.threadId || void 0,
-            files: input.files || []
-          }
-        )
-      });
-      return consumeSseResponse(response, onEvent, { signal: input.signal });
-    },
-    async attachRun(input, onEvent) {
-      const response = await fetchImpl(routes.attachRun(input), {
-        method: "POST",
-        signal: input.signal,
-        headers: streamHeaders(await loadHeaders()),
-        body: JSON.stringify({})
-      });
-      return consumeSseResponse(response, onEvent, { signal: input.signal });
-    },
-    async cancelRun(input) {
-      const response = await fetchImpl(routes.cancelRun(input), {
-        method: "POST",
-        headers: jsonHeaders(await loadHeaders()),
-        body: JSON.stringify({ assistant_output_text: input.assistantOutputText || void 0 })
-      });
-      if (!response.ok) throw transportError(response, "Failed to cancel chat run.");
-      return response.json();
-    },
-    async deleteThread(input) {
-      if (!routes.deleteThread) return { deleted: false };
-      const response = await fetchImpl(routes.deleteThread(input), {
-        method: "DELETE",
-        headers: jsonHeaders(await loadHeaders())
-      });
-      if (!response.ok) throw transportError(response, "Failed to delete chat thread.");
-      return response.json();
-    },
-    async subscribeThreadEvents(input, onEvent) {
-      if (!routes.threadEvents) return;
-      const response = await fetchImpl(routes.threadEvents({ cursor: input.cursor }), {
-        method: "GET",
-        signal: input.signal,
-        headers: streamHeaders(await loadHeaders())
-      });
-      await consumeSseResponse(
-        response,
-        (event) => onEvent(event),
-        { signal: input.signal }
-      );
-    },
-    async resumeHitl(input) {
-      if (!routes.resumeRun) throw new ChatTransportError("HITL resume is not configured.", 501);
-      const response = await fetchImpl(routes.resumeRun({ runId: input.runId }), {
-        method: "POST",
-        headers: jsonHeaders(await loadHeaders()),
-        body: JSON.stringify({
-          schema_version: "agents24.hitl.resume.v2",
-          interrupt_id: input.interruptId,
-          action: input.action,
-          comment: input.comment,
-          client: input.client
-        })
-      });
-      if (!response.ok) throw transportError(response, "Failed to resume chat run.");
-      return response.json();
-    },
-    async startMcpAuth(input) {
-      if (!routes.startMcpAuth) throw new ChatTransportError("MCP auth is not configured.", 501);
-      const response = await fetchImpl(routes.startMcpAuth({ runId: input.runId, serverId: input.serverId }), {
-        method: "POST",
-        headers: jsonHeaders(await loadHeaders()),
-        body: JSON.stringify({
-          interrupt_id: input.interruptId || void 0,
-          principal_type: input.principalType || void 0,
-          principal_id: input.principalId || void 0,
-          client: input.client
-        })
-      });
-      if (!response.ok) throw transportError(response, "Failed to start MCP authorization.");
-      return response.json();
-    }
-  };
-};
-
 // src/viewport.ts
 import {
   MessageScroller,
@@ -1876,8 +74,6 @@ import {
   useMessageScrollerVisibility
 } from "@shadcn/react/message-scroller";
 export {
-  ChatTransportError,
-  DEFAULT_THREAD_PAGE_SIZE,
   DefaultChatPart,
   DefaultToolPart,
   LatestThreadScroller,
@@ -1889,45 +85,14 @@ export {
   LatestThreadScrollerRoot,
   LatestThreadScrollerViewport,
   MessageScroller,
-  activeRunIdFromThread,
-  activeRunIdFromThreadDetail,
-  appendStableStreamingTurn,
-  assistantTextFromParts,
-  assistantTextFromResponseBlocks,
-  autoAttachRunIdFromThread,
-  compressionFromContextWindow,
-  consumeSseResponse,
-  createChatId,
-  createFetchChatTransport,
-  findStableAssistantMessageIndex,
   getActiveStreamingTextPartId,
-  hasStaleUnfinishedAssistantCache,
-  hasUnfinishedAssistantMessage,
   isActiveStreamingTextPart,
-  isAutoAttachThreadStatus,
-  isRunningThreadStatus,
-  latestContextWindowFromThread,
-  mergeContextWindow,
-  mergeContextWindowUpdate,
-  mergeReasoningSteps,
-  mergeStoredThreadsForRefresh,
-  normalizeContextCompression,
-  normalizeContextWindow,
-  parseSseBlock,
-  partsFromResponseBlocks,
-  reasoningStepsFromParts,
   renderChatPart,
-  threadActivityDate,
-  threadDetailToMessages,
-  threadPaging,
-  titleFromMessage,
-  toolStateFromStatus,
-  upsertStableAssistantMessage,
-  useAgents24ChatController,
   useMessageScroller,
   useMessageScrollerScrollable,
   useMessageScrollerVisibility,
   useStreamingText,
+  validateMcpCallbackResult,
   waitForMcpOauthComplete
 };
 //# sourceMappingURL=index.js.map