@athenaintel/react 0.12.2 → 0.12.4

package/dist/index.cjs

@@ -45,7 +45,6 @@ const jsxRuntime = require("react/jsx-runtime");
 const React = require("react");
 const react$1 = require("@assistant-ui/react");
 const AthenaAuthContext = require("./AthenaAuthContext-B3AwLA5Z.cjs");
-const localStorage$1 = require("@assistant-ui/react-statewire/local-storage");
 const tap = require("@assistant-ui/tap");
 const statewire = require("statewire");
 require("@assistant-ui/core");
@@ -73,11 +72,64 @@ function _interopNamespaceDefault(e) {
 }
 const React__namespace = /* @__PURE__ */ _interopNamespaceDefault(React);
 const ReactDOM__namespace = /* @__PURE__ */ _interopNamespaceDefault(ReactDOM);
-const version$1 = "0.12.2";
+const version$1 = "0.12.4";
 const packageJson = {
   version: version$1
 };
 const ATHENA_REACT_SDK_VERSION = packageJson.version;
+const BENIGN_BROWSER_EXCEPTION_SIGNATURES = /* @__PURE__ */ new Set([
+  "TypeError: Failed to fetch",
+  // fetch — Chromium
+  "TypeError: Load failed",
+  // fetch — Safari / WebKit
+  "TypeError: NetworkError when attempting to fetch resource.",
+  // fetch — Firefox
+  "AxiosError: Network Error",
+  // axios — no response received
+  "Error: ResizeObserver loop limit exceeded",
+  // Chromium
+  "Error: ResizeObserver loop completed with undelivered notifications.",
+  // Safari / Firefox
+  "TimeoutError: signal timed out",
+  // AbortSignal.timeout() on handled requests
+  "NegotiationError: negotiation timed out"
+  // WebRTC negotiation on flaky networks
+]);
+const BENIGN_MESSAGE_PATTERNS = [
+  // assistant-ui useClientLookup recoverable races — the library retries.
+  /\(ignore if recovered\)$/,
+  // Drift-proof ResizeObserver loop diagnostics across engines.
+  /^ResizeObserver loop /
+];
+const FORMULA_ERROR_CODE_TYPE_PATTERN = /^#[A-Z0-9/_]{1,14}[!?]?$/;
+function isBenignBrowserExceptionEntry(exception) {
+  var _a3, _b2;
+  const type = (_a3 = exception.type) == null ? void 0 : _a3.trim();
+  const value = (_b2 = exception.value) == null ? void 0 : _b2.trim();
+  if (type === "AggregateError" && !value) return true;
+  if (type !== void 0 && FORMULA_ERROR_CODE_TYPE_PATTERN.test(type)) return true;
+  if (type === void 0 || value === void 0) return false;
+  if (BENIGN_BROWSER_EXCEPTION_SIGNATURES.has(`${type}: ${value}`)) return true;
+  return BENIGN_MESSAGE_PATTERNS.some((pattern) => pattern.test(value));
+}
+function isBenignBrowserException(captureResult) {
+  var _a3, _b2, _c2;
+  if (captureResult.event !== "$exception") return false;
+  const exceptionList = (_a3 = captureResult.properties) == null ? void 0 : _a3.$exception_list;
+  if (Array.isArray(exceptionList) && exceptionList.length > 0) {
+    return exceptionList.every(isBenignBrowserExceptionEntry);
+  }
+  return isBenignBrowserExceptionEntry({
+    type: (_b2 = captureResult.properties) == null ? void 0 : _b2.$exception_type,
+    value: (_c2 = captureResult.properties) == null ? void 0 : _c2.$exception_message
+  });
+}
+const dropBenignBrowserExceptions = (captureResult) => {
+  if (captureResult && isBenignBrowserException(captureResult)) {
+    return null;
+  }
+  return captureResult;
+};
 const DEFAULT_CAPTURE_GATE_CONFIG = {
   globalMaxPerWindow: 50,
   globalWindowMs: 1e4,
@@ -486,6 +538,7 @@ async function initializePostHog(apiKey, host, debug) {
     posthog.init(apiKey, {
       api_host: host,
       autocapture: true,
+      before_send: dropBenignBrowserExceptions,
       capture_pageview: false,
       session_recording: {
         recordCrossOriginIframes: true,
@@ -549,6 +602,8 @@ const ATHENA_SDK_ERROR_CODES = {
   stream_failed: "stream_failed",
   /** The selected collab agent / channel was refused by the backend. */
   collab_agent_rejected: "collab_agent_rejected",
+  /** A React render error crashed the chat surface (caught by the SDK's error boundary). */
+  chat_render_crash: "chat_render_crash",
   /** Anything else. */
   unknown: "unknown"
 };
@@ -5931,7 +5986,7 @@ const cn = function() {
   }
   return twMerge.mergeString(result);
 };
-function isRecord$2(value) {
+function isRecord$3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 var _a$2;
@@ -10607,10 +10662,10 @@ const autoCloseInFlightSubgraphMessages = (msgs) => {
   const beginIds = /* @__PURE__ */ new Set();
   const endIds = /* @__PURE__ */ new Set();
   for (const message of msgs) {
-    if (!isRecord$2(message)) continue;
+    if (!isRecord$3(message)) continue;
     if (message.type === "ai" && Array.isArray(message.tool_calls)) {
       for (const toolCall of message.tool_calls) {
-        if (!isRecord$2(toolCall)) continue;
+        if (!isRecord$3(toolCall)) continue;
         const id = toolCall.id;
         if (typeof id === "string") beginIds.add(id);
       }
@@ -10672,7 +10727,7 @@ const contentToParts = (content) => {
 const getNumberAtPath = (value, path) => {
   let current = value;
   for (const segment of path) {
-    if (!isRecord$2(current)) {
+    if (!isRecord$3(current)) {
       return void 0;
     }
     current = current[segment];
@@ -10693,7 +10748,7 @@ const buildCustomMetadata = ({
 }) => {
   const customMetadata = additionalKwargs ? { ...additionalKwargs } : {};
   const reasoningTokens = extractReasoningTokens({ usageMetadata, responseMetadata });
-  const existingAthenaMetadata = isRecord$2(customMetadata._athena) ? customMetadata._athena : void 0;
+  const existingAthenaMetadata = isRecord$3(customMetadata._athena) ? customMetadata._athena : void 0;
   const athenaMetadata = {
     ...existingAthenaMetadata ?? {}
   };
@@ -10712,9 +10767,9 @@ const buildCustomMetadata = ({
   return Object.keys(customMetadata).length > 0 ? customMetadata : void 0;
 };
 const getSubgraphMessages = (artifact) => {
-  if (!isRecord$2(artifact)) return void 0;
+  if (!isRecord$3(artifact)) return void 0;
   const subgraphState = artifact.subgraph_state;
-  if (!isRecord$2(subgraphState)) return void 0;
+  if (!isRecord$3(subgraphState)) return void 0;
   const messages = subgraphState.messages;
   return Array.isArray(messages) && messages.length > 0 ? messages : void 0;
 };
@@ -11466,7 +11521,104 @@ const useAthenaRuntime = (config2) => {
   }, [isExistingThread, runtime, threadId, backendUrl, resolvedStatusApiUrl]);
   return runtime;
 };
+const RUN_CONFIG_CUSTOM_KEYS = [
+  "agent",
+  "agent_catalog_asset_ids",
+  "allowed_tab_ids",
+  "app_id",
+  "async_subagents",
+  "catalog_asset_ids",
+  "channel",
+  "client_tools",
+  "collab_agent_id",
+  "collab_channel_id",
+  "compiled_subagents",
+  "declined_toolkit_ids",
+  "deterministic",
+  "device_id",
+  "drive_mounts",
+  "dry_run",
+  "enable_interpreter",
+  "enable_persistent_fs",
+  "enable_sandbox",
+  "enable_skills",
+  "enabled_toolkits",
+  "enabled_tools",
+  "environment",
+  "environment_asset_id",
+  "environment_id",
+  "environment_name",
+  "excluded_middleware",
+  "excluded_tools",
+  "extra_middleware",
+  "frontend_available",
+  "github_identity",
+  "interpreter_max_ptc_calls",
+  "interpreter_mode",
+  "interpreter_ptc",
+  "interpreter_ptc_exclusive",
+  "interpreter_runtime",
+  "interpreter_subagents",
+  "interpreter_timeout_seconds",
+  "interrupt_on",
+  "knowledge_base",
+  "max_tokens",
+  "mcp_server_configs",
+  "mcp_servers",
+  "memory",
+  "middleware",
+  "model",
+  "office_context",
+  "panel_config",
+  "permissions",
+  "recursion_limit",
+  "run_label",
+  "runtime",
+  "sandbox_runtime",
+  "secret_asset_ids",
+  "session_id",
+  "session_tab_id",
+  "session_vm_retention",
+  "skill_asset_ids",
+  "skills",
+  "skip_title_generation",
+  "source_aop_id",
+  "start_channel",
+  "structured_output",
+  "subagents",
+  "system_prompt",
+  "temperature",
+  "tool_description_overrides",
+  "tool_limit_override",
+  "trigger_type",
+  "voice_update_handle",
+  "workbench",
+  "workspace_id"
+];
+new Set(
+  RUN_CONFIG_CUSTOM_KEYS
+);
+const KNOWN_START_CHANNELS = [
+  "api",
+  "chrome_extension",
+  "default_voice",
+  "email",
+  "mobile_app",
+  "orchestration",
+  "programmatic",
+  "slack",
+  "sms",
+  "task",
+  "teams",
+  "voice",
+  "web"
+];
+new Set(
+  KNOWN_START_CHANNELS
+);
 const CLIENT_TOOL_INTERRUPT_SOURCE = "client_tool";
+const CLIENT_TOOL_RESULT_STATUS_SUCCESS = "success";
+const CLIENT_TOOL_RESULT_STATUS_ERROR = "error";
 function isClientToolCallRequest(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return false;
   const candidate = value;
@@ -11490,11 +11642,14 @@ function clientToolResultsResumeValue(results) {
   return { client_tool_results: results };
 }
 function clientToolSuccessEnvelope(result) {
-  return { status: "success", result: result === void 0 ? null : result };
+  return {
+    status: CLIENT_TOOL_RESULT_STATUS_SUCCESS,
+    result: result === void 0 ? null : result
+  };
 }
 function clientToolErrorEnvelope(error2) {
   const message = error2 instanceof Error ? error2.message : typeof error2 === "string" ? error2 : "Client tool execution failed.";
-  return { status: "error", error: message };
+  return { status: CLIENT_TOOL_RESULT_STATUS_ERROR, error: message };
 }
 function createClientToolRequestTracker() {
   const handled = /* @__PURE__ */ new Set();
@@ -11512,6 +11667,170 @@ function createClientToolRequestTracker() {
     }
   };
 }
+const CLIENT_TOOL_WRITE_DECLINED_MESSAGE = "The user declined this edit. Do not retry it; ask the user how to proceed.";
+function defaultMissingClientToolMessage(toolName) {
+  return `This surface has no tool named '${toolName}'.`;
+}
+function clientToolClaimKey(threadId, requestId) {
+  return `${threadId}:${requestId}`;
+}
+function jsonSafeClientToolResult(value) {
+  const serialized = JSON.stringify(value);
+  return serialized === void 0 ? null : JSON.parse(serialized);
+}
+function isPendingClientToolRequest(request) {
+  if (request.type !== "interrupt" || "response" in request) return false;
+  return isClientToolInterrupt(request.payload);
+}
+async function executeClientToolBatch(options) {
+  const {
+    calls,
+    tools,
+    isLive,
+    confirmWrites,
+    writeDeclinedMessage = CLIENT_TOOL_WRITE_DECLINED_MESSAGE,
+    missingToolMessage = defaultMissingClientToolMessage,
+    onCallSettled,
+    onExecutionStart
+  } = options;
+  const registry2 = new Map(tools.map((tool) => [tool.name, tool]));
+  let writesDeclined = false;
+  const writeToolNames = calls.filter((call) => {
+    var _a3;
+    return ((_a3 = registry2.get(call.tool_name)) == null ? void 0 : _a3.requiresWrite) === true;
+  }).map((call) => call.tool_name);
+  if (writeToolNames.length > 0 && confirmWrites) {
+    const decision = await confirmWrites({ writeToolNames });
+    if (decision === "abandoned" || !isLive()) {
+      return null;
+    }
+    writesDeclined = decision === "declined";
+  }
+  onExecutionStart == null ? void 0 : onExecutionStart();
+  const results = {};
+  for (const call of calls) {
+    if (!isLive()) return null;
+    const tool = registry2.get(call.tool_name);
+    let envelope;
+    let status = "success";
+    let errorType;
+    if (!tool) {
+      envelope = clientToolErrorEnvelope(missingToolMessage(call.tool_name));
+      status = "error";
+      errorType = "UnknownClientTool";
+    } else if (tool.requiresWrite === true && writesDeclined) {
+      envelope = clientToolErrorEnvelope(writeDeclinedMessage);
+      status = "declined";
+    } else {
+      try {
+        envelope = clientToolSuccessEnvelope(
+          jsonSafeClientToolResult(
+            await tool.run(clientToolCallArgs(call), {
+              toolCallId: call.interrupt_id
+            })
+          )
+        );
+      } catch (error2) {
+        envelope = clientToolErrorEnvelope(error2);
+        status = "error";
+        errorType = error2 instanceof Error ? error2.name : typeof error2;
+      }
+    }
+    results[call.interrupt_id] = envelope;
+    onCallSettled == null ? void 0 : onCallSettled({
+      toolName: call.tool_name,
+      status,
+      ...errorType !== void 0 ? { errorType } : {}
+    });
+  }
+  return isLive() ? results : null;
+}
+function useStatewireClientToolBridge(options) {
+  const { threadId, tracker, inputRequests, logLabel = "[AthenaSDK]" } = options;
+  const optionsRef = React.useRef(options);
+  optionsRef.current = options;
+  const pendingRequest = inputRequests == null ? void 0 : inputRequests.find(isPendingClientToolRequest);
+  const ownedClaimsRef = React.useRef(/* @__PURE__ */ new Set());
+  const startedClaimsRef = React.useRef(/* @__PURE__ */ new Set());
+  const activeRef = React.useRef(true);
+  const releaseClaim = React.useCallback(
+    (claim) => {
+      const owned = ownedClaimsRef.current.delete(claim);
+      startedClaimsRef.current.delete(claim);
+      if (owned) tracker.release(claim);
+    },
+    [tracker]
+  );
+  React.useEffect(() => {
+    activeRef.current = true;
+    const ownedClaims = ownedClaimsRef.current;
+    const startedClaims = startedClaimsRef.current;
+    return () => {
+      activeRef.current = false;
+      for (const claim of ownedClaims) {
+        if (startedClaims.has(claim)) continue;
+        ownedClaims.delete(claim);
+        tracker.release(claim);
+      }
+    };
+  }, [tracker]);
+  const liveRequestIdsRef = React.useRef(/* @__PURE__ */ new Set());
+  liveRequestIdsRef.current = new Set((inputRequests ?? []).map((request) => request.id));
+  const executeRequest = React.useCallback(
+    async (request) => {
+      const payload = request.payload;
+      if (!isClientToolInterrupt(payload)) return;
+      const claim = clientToolClaimKey(threadId, request.id);
+      const {
+        tools,
+        confirmWrites,
+        writeDeclinedMessage,
+        missingToolMessage,
+        onCallSettled,
+        sendResume
+      } = optionsRef.current;
+      const results = await executeClientToolBatch({
+        calls: payload.context.requests,
+        tools,
+        // Live while the request still exists AND this surface may answer it:
+        // mounted, or already past the point of no return (handlers started —
+        // the detached execution must finish and settle, never re-execute).
+        // After unmount the request-id snapshot freezes at its last observed
+        // state, which keeps a started batch's own request visible to it.
+        isLive: () => liveRequestIdsRef.current.has(request.id) && (activeRef.current || startedClaimsRef.current.has(claim)),
+        onExecutionStart: () => {
+          startedClaimsRef.current.add(claim);
+        },
+        ...confirmWrites ? {
+          confirmWrites: ({ writeToolNames }) => confirmWrites({ requestId: request.id, writeToolNames })
+        } : {},
+        ...writeDeclinedMessage !== void 0 ? { writeDeclinedMessage } : {},
+        ...missingToolMessage ? { missingToolMessage } : {},
+        ...onCallSettled ? { onCallSettled } : {}
+      });
+      if (results === null) {
+        releaseClaim(claim);
+        return;
+      }
+      try {
+        sendResume(request.id, clientToolResultsResumeValue(results));
+        ownedClaimsRef.current.delete(claim);
+        startedClaimsRef.current.delete(claim);
+      } catch (error2) {
+        releaseClaim(claim);
+        console.error(`${logLabel} failed to resume client tool results:`, error2);
+      }
+    },
+    [logLabel, releaseClaim, threadId]
+  );
+  React.useEffect(() => {
+    if (!pendingRequest) return;
+    const claim = clientToolClaimKey(threadId, pendingRequest.id);
+    if (!tracker.claim(claim)) return;
+    ownedClaimsRef.current.add(claim);
+    void executeRequest(pendingRequest);
+  }, [executeRequest, pendingRequest, threadId, tracker]);
+}
 const AUTH_DENIAL_PARK_THRESHOLD = 8;
 const initialAuthDenialTrackerState = () => ({
   lastAttempt: null,
@@ -11609,6 +11928,125 @@ function projectDeepAgentConnection(connection, { awaitingFirstSend = false } =
   if (connection.status === "connecting" && awaitingFirstSend) return { status: "ready" };
   return { status: connection.status };
 }
+const preStreamState = { messages: [], todos: [] };
+Object.freeze(preStreamState.messages);
+Object.freeze(preStreamState.todos);
+const DEEP_AGENT_PRE_STREAM_STATE = Object.freeze(preStreamState);
+function readDeepAgentStreamValues(state) {
+  return typeof state === "object" && state !== null ? state : DEEP_AGENT_PRE_STREAM_STATE;
+}
+function isRecord$2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isPendingInterrupt(request) {
+  return request.type === "interrupt" && !("response" in request);
+}
+function isApprovalCardInterrupt(request) {
+  if (!isPendingInterrupt(request)) return false;
+  return !hasClientToolInterruptSource(request.payload);
+}
+function asHitlApproval(value) {
+  if (!isRecord$2(value)) return null;
+  return value.type === "hitl" && value.source === "hitl_approval" && typeof value.message === "string" ? value : null;
+}
+const DEFAULT_INTERRUPT_PAUSED_MESSAGE = "The agent is paused and waiting for input.";
+function readInterruptMessage(value, fallback = DEFAULT_INTERRUPT_PAUSED_MESSAGE) {
+  if (isRecord$2(value) && typeof value.message === "string" && value.message.length > 0) {
+    return value.message;
+  }
+  return fallback;
+}
+function readAbandonedInputRequests(state) {
+  const abandoned = readDeepAgentStreamValues(state).abandonedInputRequests;
+  return Array.isArray(abandoned) ? abandoned : void 0;
+}
+function findAbandonedInterrupt(abandoned) {
+  return abandoned == null ? void 0 : abandoned.find(
+    (request) => isRecord$2(request) && request.type === "interrupt" && typeof request.id === "string"
+  );
+}
+const HITL_REJECT_REASON = "User rejected the action.";
+function hitlResumeApprove() {
+  return { action: "approve" };
+}
+function hitlResumeReject(reason = HITL_REJECT_REASON) {
+  return { action: "reject", reason };
+}
+function hitlResumeContinue() {
+  return { action: "continue" };
+}
+function useApprovalResumeLock(options) {
+  const { requestId, isRunning, sendResume, pendingResumeGraceMs } = options;
+  const [pending, setPending] = React.useState(false);
+  const prevRequestIdRef = React.useRef(requestId);
+  if (prevRequestIdRef.current !== requestId) {
+    prevRequestIdRef.current = requestId;
+    if (pending) setPending(false);
+  }
+  const sawResumeRunRef = React.useRef(false);
+  React.useEffect(() => {
+    if (!pending) {
+      sawResumeRunRef.current = false;
+      return;
+    }
+    if (isRunning) {
+      sawResumeRunRef.current = true;
+      return;
+    }
+    if (sawResumeRunRef.current) {
+      sawResumeRunRef.current = false;
+      setPending(false);
+    }
+  }, [pending, isRunning]);
+  React.useEffect(() => {
+    if (!pending || pendingResumeGraceMs === void 0) return;
+    const timer = setTimeout(() => {
+      if (!sawResumeRunRef.current) setPending(false);
+    }, pendingResumeGraceMs);
+    return () => clearTimeout(timer);
+  }, [pending, requestId, pendingResumeGraceMs]);
+  const sendResumeRef = React.useRef(sendResume);
+  sendResumeRef.current = sendResume;
+  const pendingRef = React.useRef(pending);
+  pendingRef.current = pending;
+  const resume = React.useCallback(
+    (value) => {
+      if (requestId === void 0 || pendingRef.current) return;
+      setPending(true);
+      pendingRef.current = true;
+      sendResumeRef.current(requestId, value);
+    },
+    [requestId]
+  );
+  return { pending, resume };
+}
+function queueEntryText(parts) {
+  return parts.flatMap(
+    (part) => part.type === "text" && typeof part.text === "string" ? [part.text] : []
+  ).join("\n\n");
+}
+function queueLaneFlags(status) {
+  return {
+    isRunning: status === "running",
+    isContinuable: status === "stopped" || status === "error"
+  };
+}
+function buildStatewireQueueRows(options) {
+  const { queue, steerQueue, isContinuable } = options;
+  return [
+    ...isContinuable ? steerQueue.map((item) => ({ item, lane: "steer" })) : [],
+    ...queue.map((item) => ({ item, lane: "queue" }))
+  ];
+}
+function showQueueRowSendNow(options) {
+  const { lane, index: index2, isRunning, isContinuable } = options;
+  return lane === "queue" && (isContinuable || isRunning && index2 === 0);
+}
+function hasStatewireThreadExtras(extras) {
+  if (!extras || typeof extras !== "object") return false;
+  const candidate = extras;
+  return typeof candidate.sendCommand === "function" && Array.isArray(candidate.inputRequests) && typeof candidate.runs === "object" && candidate.runs !== null;
+}
 const buildOptimisticHumanContent = (parts) => {
   const imageParts = parts.filter(
     (part) => part.type === "image"
@@ -11858,10 +12296,11 @@ function isLangGraphState(value) {
 }
 function convertDeepAgentState(state, { laneProjection = "both" } = {}) {
   var _a3, _b2;
-  const status = (_b2 = (_a3 = state == null ? void 0 : state.runs) == null ? void 0 : _a3[0]) == null ? void 0 : _b2.status;
+  const values = readDeepAgentStreamValues(state);
+  const status = (_b2 = (_a3 = values.runs) == null ? void 0 : _a3[0]) == null ? void 0 : _b2.status;
   const isRunning = status === "running";
-  const laneTail = status === "stopped" || status === "error" ? [] : laneTailMessages(state, laneProjection);
-  const stateMessages = isLangGraphState(state) ? sanitizeLangChainMessages(state.messages) : [];
+  const laneTail = status === "stopped" || status === "error" ? [] : laneTailMessages(values, laneProjection);
+  const stateMessages = isLangGraphState(values) ? sanitizeLangChainMessages(values.messages) : [];
   return {
     messages: messageConverter.toThreadMessages(
       [...withPendingAssistantMessage(stateMessages, isRunning), ...laneTail],
@@ -11879,6 +12318,132 @@ function registerDeepAgentRunConfig(aui, getRunConfig) {
     })
   });
 }
+const browserGlobals = globalThis;
+function requireLocalStorage() {
+  const storage = browserGlobals.localStorage;
+  if (!storage) {
+    throw new Error("statewire: QuotaSafeLocalStorageSession requires localStorage");
+  }
+  return storage;
+}
+const SESSION_PREFIX = "aui:statewire-session:";
+const SESSION_LOCK_PREFIX = "aui:statewire-session-lock:";
+function isStorageQuotaError(error2) {
+  if (typeof DOMException !== "undefined" && error2 instanceof DOMException) {
+    return error2.name === "QuotaExceededError" || error2.name === "NS_ERROR_DOM_QUOTA_REACHED" || error2.code === 22 || error2.code === 1014;
+  }
+  if (error2 instanceof Error) {
+    return /exceeded the quota|quotaexceedederror|ns_error_dom_quota_reached/i.test(error2.message);
+  }
+  return false;
+}
+function readEvictionMeta(raw) {
+  if (!raw) return { savedAt: 0, hasPendingCommands: false };
+  try {
+    const parsed = JSON.parse(raw);
+    return {
+      savedAt: typeof (parsed == null ? void 0 : parsed.savedAt) === "number" ? parsed.savedAt : 0,
+      hasPendingCommands: Array.isArray(parsed == null ? void 0 : parsed.commands) && parsed.commands.length > 0
+    };
+  } catch {
+    return { savedAt: 0, hasPendingCommands: false };
+  }
+}
+function evictOldestStatewireSessions(currentKey) {
+  const storage = requireLocalStorage();
+  const candidates = [];
+  for (let i = 0; i < storage.length; i++) {
+    const key = storage.key(i);
+    if (!key || !key.startsWith(SESSION_PREFIX) || key === currentKey) continue;
+    candidates.push({ key, ...readEvictionMeta(storage.getItem(key)) });
+  }
+  candidates.sort(
+    (a, b) => Number(a.hasPendingCommands) - Number(b.hasPendingCommands) || a.savedAt - b.savedAt
+  );
+  const evictCount = Math.min(candidates.length, Math.max(1, Math.ceil(candidates.length / 2)));
+  let removed = 0;
+  for (const { key } of candidates.slice(0, evictCount)) {
+    try {
+      storage.removeItem(key);
+      removed++;
+    } catch {
+    }
+  }
+  return removed;
+}
+function createQuotaSafeSessionStorage({
+  storageKey,
+  lockName
+}) {
+  return {
+    load: () => {
+      const raw = requireLocalStorage().getItem(storageKey);
+      if (raw === null) return null;
+      return JSON.parse(raw);
+    },
+    save: (record2) => {
+      const storage = requireLocalStorage();
+      const serialized = JSON.stringify({ ...record2, savedAt: Date.now() });
+      try {
+        storage.setItem(storageKey, serialized);
+      } catch (error2) {
+        if (!isStorageQuotaError(error2)) throw error2;
+        evictOldestStatewireSessions(storageKey);
+        try {
+          storage.setItem(storageKey, serialized);
+        } catch (retryError) {
+          if (!isStorageQuotaError(retryError)) throw retryError;
+          console.warn(
+            "[statewire] session save skipped — localStorage quota exhausted even after evicting old statewire sessions; the lane will not survive a reload",
+            { storageKey }
+          );
+        }
+      }
+    },
+    // localStorage is shared across tabs: record mutations serialize through a
+    // per-key Web Lock, and `subscribe` mirrors other sharers' saves. In
+    // browsers `globalThis` IS `window`, so the storage events land here.
+    lock: (fn) => {
+      var _a3;
+      const locks = (_a3 = browserGlobals.navigator) == null ? void 0 : _a3.locks;
+      if (!locks) {
+        throw new Error(
+          "statewire: QuotaSafeLocalStorageSession requires the Web Locks API (navigator.locks)"
+        );
+      }
+      return locks.request(lockName, async () => fn());
+    },
+    subscribe: (listener) => {
+      var _a3;
+      const onStorage = (event) => {
+        if (event.key === storageKey) listener();
+      };
+      (_a3 = browserGlobals.addEventListener) == null ? void 0 : _a3.call(browserGlobals, "storage", onStorage);
+      return () => {
+        var _a4;
+        return (_a4 = browserGlobals.removeEventListener) == null ? void 0 : _a4.call(browserGlobals, "storage", onStorage);
+      };
+    }
+  };
+}
+const useQuotaSafeLocalStorageSession = ({
+  threadId,
+  key = (id) => id
+}) => {
+  var _a3;
+  requireLocalStorage();
+  if (((_a3 = browserGlobals.navigator) == null ? void 0 : _a3.locks) === void 0)
+    throw new Error(
+      "statewire: QuotaSafeLocalStorageSession requires the Web Locks API (navigator.locks)"
+    );
+  const storageKey = SESSION_PREFIX + key(threadId);
+  const lockName = SESSION_LOCK_PREFIX + key(threadId);
+  return React.useMemo(
+    () => createQuotaSafeSessionStorage({ storageKey, lockName }),
+    [storageKey, lockName]
+  );
+};
+const QuotaSafeLocalStorageSession = tap.resource(useQuotaSafeLocalStorageSession);
 function useDeepAgentThreadStatus() {
   return store.useAuiState((s) => {
     var _a3;
@@ -11918,6 +12483,7 @@ function useDeepAgentThread({
   capabilities,
   laneProjection = "both",
   adapters,
+  diagnostics,
   onError,
   onStateChange,
   onCommandChange,
@@ -11948,6 +12514,8 @@ function useDeepAgentThread({
   onRawConnectionChangeRef.current = onRawConnectionChange;
   const headersRef = React.useRef(headers);
   headersRef.current = headers;
+  const diagnosticsRef = React.useRef(diagnostics);
+  diagnosticsRef.current = diagnostics;
   const lastRunningRef = React.useRef(null);
   const lastLegacyRunActiveRef = React.useRef(null);
   const appliedStateRunConfigThreadRef = React.useRef(null);
@@ -12078,7 +12646,11 @@ function useDeepAgentThread({
             // A never-started chat has no server session yet: the transport
             // makes no network calls until the first command send.
             ...preloadRef.current.preload && { isNew: true },
-            headers: (ctx) => headersRef.current(ctx),
+            headers: (ctx) => {
+              var _a3;
+              (_a3 = diagnosticsRef.current) == null ? void 0 : _a3.observeAuthResolve(ctx);
+              return headersRef.current(ctx);
+            },
             ...sessionStore && { sessionStore }
           },
           { sse }
@@ -12093,7 +12665,8 @@ function useDeepAgentThread({
     // former `runs: true` opt-in is gone) — the converter only maps app-owned
     // keys, including the `run/stop` runId stamp the lib projects itself.
     converter: (state, meta) => {
-      var _a3, _b2, _c2, _d2;
+      var _a3, _b2, _c2, _d2, _e2;
+      (_a3 = diagnosticsRef.current) == null ? void 0 : _a3.observeConnection(meta.connection);
       if (authDenialRef.current.attachId !== attachIdRef.current) {
         authDenialRef.current = {
           attachId: attachIdRef.current,
@@ -12112,7 +12685,7 @@ function useDeepAgentThread({
           );
         });
       }
-      if (awaitingFirstSendRef.current.awaiting && ((((_a3 = state == null ? void 0 : state.runs) == null ? void 0 : _a3.length) ?? 0) > 0 || (((_b2 = state == null ? void 0 : state.messages) == null ? void 0 : _b2.length) ?? 0) > 0)) {
+      if (awaitingFirstSendRef.current.awaiting && ((((_b2 = state == null ? void 0 : state.runs) == null ? void 0 : _b2.length) ?? 0) > 0 || (((_c2 = state == null ? void 0 : state.messages) == null ? void 0 : _c2.length) ?? 0) > 0)) {
         awaitingFirstSendRef.current = {
           threadId: awaitingFirstSendRef.current.threadId,
           awaiting: false
@@ -12131,7 +12704,7 @@ function useDeepAgentThread({
           (_a4 = onConnectionChangeRef.current) == null ? void 0 : _a4.call(onConnectionChangeRef, connection);
         });
       }
-      return converter(state, ((_d2 = (_c2 = state == null ? void 0 : state.runs) == null ? void 0 : _c2[0]) == null ? void 0 : _d2.status) === "running");
+      return converter(state, ((_e2 = (_d2 = state == null ? void 0 : state.runs) == null ? void 0 : _d2[0]) == null ? void 0 : _e2.status) === "running");
     },
     // Makes the server's dispatch record concrete in state (after the
     // optimistic folds); the lib's post-converter dispatch merge turns off.
@@ -12147,19 +12720,29 @@ function useDeepAgentThread({
     // deliberate user stop.
     stopPayload: () => ({ reason: "user_stop" }),
     onError: (error2) => {
-      var _a3;
-      return (_a3 = onErrorRef.current) == null ? void 0 : _a3.call(onErrorRef, error2);
+      var _a3, _b2;
+      (_a3 = diagnosticsRef.current) == null ? void 0 : _a3.observeError(error2);
+      (_b2 = onErrorRef.current) == null ? void 0 : _b2.call(onErrorRef, error2);
     },
     ...onStateChange && {
+      // The lib types the observed state `NonNullable`, but the runtime
+      // delivers `undefined` where the wire has no snapshot (pre-attach and
+      // replay boundaries republish it) — normalize so the type is true and
+      // host observers never crash on a field read.
       onStateChange: ((state, ctx) => {
         var _a3;
-        return (_a3 = onStateChangeRef.current) == null ? void 0 : _a3.call(onStateChangeRef, state, ctx);
+        return (_a3 = onStateChangeRef.current) == null ? void 0 : _a3.call(
+          onStateChangeRef,
+          readDeepAgentStreamValues(state),
+          ctx
+        );
       })
     },
-    ...onCommandChange && {
+    ...(onCommandChange || diagnostics) && {
       onCommandChange: ((update, ctx) => {
-        var _a3;
-        return (_a3 = onCommandChangeRef.current) == null ? void 0 : _a3.call(onCommandChangeRef, update, ctx);
+        var _a3, _b2;
+        (_a3 = diagnosticsRef.current) == null ? void 0 : _a3.observeCommand(update);
+        (_b2 = onCommandChangeRef.current) == null ? void 0 : _b2.call(onCommandChangeRef, update, ctx);
       })
     },
     ...onRawConnectionChange && {
@@ -12173,6 +12756,66 @@ function useDeepAgentThread({
     }
   });
 }
+function canPersistDeepAgentSession() {
+  try {
+    const storage = globalThis.localStorage;
+    if (!storage) return false;
+    const probeKey = "__athena_statewire_session_probe__";
+    storage.setItem(probeKey, probeKey);
+    storage.removeItem(probeKey);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function logUnhandledStatewireError(surface, error2) {
+  if (isStatewireChannelTeardown(error2)) {
+    console.debug(`[${surface}] statewire channel teardown:`, error2);
+    return;
+  }
+  console.error(`[${surface}] statewire transport error:`, error2);
+}
+function useDeepAgentRuntime(options) {
+  const { surface, session = false, useClient, runConfig, onError, ...threadOptions } = options;
+  const [canPersistLocalSession] = React.useState(canPersistDeepAgentSession);
+  const onErrorRef = React.useRef(onError);
+  onErrorRef.current = onError;
+  const surfaceRef = React.useRef(surface);
+  surfaceRef.current = surface;
+  const thread = useDeepAgentThread({
+    ...threadOptions,
+    ...session !== false && session.kind === "local-storage" && canPersistLocalSession && {
+      storage: {
+        session: QuotaSafeLocalStorageSession({
+          threadId: threadOptions.threadId,
+          key: session.key
+        })
+      }
+    },
+    ...session !== false && session.kind === "session-store" && { sessionStore: session.store },
+    onError: (error2) => {
+      const handler = onErrorRef.current;
+      if (handler) {
+        handler(error2);
+        return;
+      }
+      logUnhandledStatewireError(surfaceRef.current, error2);
+    }
+  });
+  const client = useClient(thread);
+  const getRunConfigRef = React.useRef(runConfig == null ? void 0 : runConfig.get);
+  getRunConfigRef.current = runConfig == null ? void 0 : runConfig.get;
+  const hasRunConfig = runConfig !== void 0;
+  const runConfigKey = runConfig == null ? void 0 : runConfig.key;
+  React.useEffect(() => {
+    if (!hasRunConfig) return void 0;
+    return registerDeepAgentRunConfig(client, () => {
+      var _a3;
+      return ((_a3 = getRunConfigRef.current) == null ? void 0 : _a3.call(getRunConfigRef)) ?? {};
+    });
+  }, [client, hasRunConfig, runConfigKey]);
+  return client;
+}
 function isStandardSchema(schema2) {
   return typeof schema2 === "object" && schema2 !== null && "~standard" in schema2 && typeof schema2["~standard"] === "object";
 }
@@ -12275,18 +12918,7 @@ function useAthenaStatewireRuntime(config2) {
     onLegacyReadOnly,
     onRunningChange
   } = config2;
-  const tokenRef = React.useRef(token);
-  tokenRef.current = token;
-  const getTokenRef = React.useRef(getToken);
-  getTokenRef.current = getToken;
-  const apiKeyRef = React.useRef(apiKey);
-  apiKeyRef.current = apiKey;
-  const onErrorRef = React.useRef(onError);
-  onErrorRef.current = onError;
   const clientTools = useStatewireClientTools(frontendToolkit);
-  const clientToolsRef = React.useRef(clientTools);
-  clientToolsRef.current = clientTools;
-  const [canPersistSession] = React.useState(() => typeof localStorage !== "undefined");
   React.useEffect(() => {
     if (agent2 && !parseCollabAgentRef(agent2)) {
       athenaDiagnostics.emit("sdk.config.warning", {
@@ -12309,16 +12941,22 @@ function useAthenaStatewireRuntime(config2) {
       { thread_id: threadId, is_new_chat: isNewChat }
     );
   }
-  const thread = useDeepAgentThread({
+  const auiTools = React.useMemo(() => react$1.Tools({ toolkit: frontendToolkit }), [frontendToolkit]);
+  const useSdkClient = (thread) => react$1.useAui({ thread, tools: auiTools });
+  return useDeepAgentRuntime({
+    surface: "AthenaSDK",
     threadId,
     baseUrl: syncUrl,
+    // Option closures are re-read per render by the core, so credential
+    // rotation (new `token`/`getToken`/`apiKey` props) reaches the next
+    // request without remounting the thread.
     headers: async () => {
-      const currentToken = getTokenRef.current ? await getTokenRef.current() ?? tokenRef.current : tokenRef.current;
+      const currentToken = getToken ? await getToken() ?? token : token;
       if (currentToken) {
         return { Authorization: `Bearer ${currentToken}` };
       }
-      if (apiKeyRef.current) {
-        return { "X-API-KEY": apiKeyRef.current };
+      if (apiKey) {
+        return { "X-API-KEY": apiKey };
       }
       return {};
     },
@@ -12328,16 +12966,12 @@ function useAthenaStatewireRuntime(config2) {
     laneProjection: "steer-only",
     // Durable session: a reload resumes the lane and resends whatever the
     // server has not marked durable. Scoped by host — a thread id is only
-    // meaningful against the backend that minted it.
-    ...canPersistSession && {
-      storage: {
-        session: localStorage$1.LocalStorageSession({
-          threadId,
-          key: (id) => `${syncUrl}:${id}`
-        })
-      }
-    },
+    // meaningful against the backend that minted it. (Consumers server-render
+    // this SDK; the core's availability probe keeps those sessions
+    // process-local, as before the seam existed.)
+    session: { kind: "local-storage", key: (id) => `${syncUrl}:${id}` },
     capabilities: { edit: true, reload: true, continue: true },
+    useClient: useSdkClient,
     onStateChange: () => {
       const endSpan = attachSpanRef.current;
       if (endSpan) {
@@ -12366,6 +13000,26 @@ function useAthenaStatewireRuntime(config2) {
       onLegacyReadOnly == null ? void 0 : onLegacyReadOnly(legacyReadOnly);
     },
     onRunningChange,
+    // The runConfig getter is pulled at command-send time through the core's
+    // per-render ref, so it reads the latest props — consumers commonly pass
+    // fresh array literals per render, which must not thrash the registration
+    // (no `key`: the provider registers once per client).
+    runConfig: {
+      get: () => buildStatewireRunConfig({
+        model,
+        agent: agent2,
+        channel,
+        tools,
+        frontendToolIds,
+        workbench,
+        knowledgeBase,
+        systemPrompt,
+        customToolConfigs,
+        appId,
+        extraRunConfig,
+        clientTools: statewireClientToolWireEntries(clientTools)
+      })
+    },
     onError: (error2) => {
       if (!isStatewireChannelTeardown(error2)) {
         athenaDiagnostics.error(
@@ -12379,60 +13033,17 @@ function useAthenaStatewireRuntime(config2) {
           { thread_id: threadId }
         );
       }
-      if (onErrorRef.current) {
-        onErrorRef.current(error2);
-        return;
-      }
-      if (isStatewireChannelTeardown(error2)) {
-        console.debug("[AthenaSDK] statewire channel teardown:", error2);
+      if (onError) {
+        onError(error2);
         return;
       }
-      console.error("[AthenaSDK] statewire transport error:", error2);
+      logUnhandledStatewireError("AthenaSDK", error2);
     }
   });
-  const auiTools = React.useMemo(() => react$1.Tools({ toolkit: frontendToolkit }), [frontendToolkit]);
-  const aui = react$1.useAui({ thread, tools: auiTools });
-  const runConfigInputsRef = React.useRef({
-    model,
-    agent: agent2,
-    channel,
-    tools,
-    frontendToolIds,
-    workbench,
-    knowledgeBase,
-    systemPrompt,
-    customToolConfigs,
-    appId,
-    extraRunConfig
-  });
-  runConfigInputsRef.current = {
-    model,
-    agent: agent2,
-    channel,
-    tools,
-    frontendToolIds,
-    workbench,
-    knowledgeBase,
-    systemPrompt,
-    customToolConfigs,
-    appId,
-    extraRunConfig
-  };
-  React.useEffect(
-    () => registerDeepAgentRunConfig(
-      aui,
-      () => buildStatewireRunConfig({
-        ...runConfigInputsRef.current,
-        clientTools: statewireClientToolWireEntries(clientToolsRef.current)
-      })
-    ),
-    [aui]
-  );
-  return aui;
 }
 function readDetailMessage(detail) {
   if (typeof detail === "string" && detail.length > 0) return detail;
-  if (!isRecord$2(detail)) return null;
+  if (!isRecord$3(detail)) return null;
   const message = detail.message;
   return typeof message === "string" && message.length > 0 ? message : null;
 }
@@ -12466,99 +13077,32 @@ function useAthenaStatewireLifecycle() {
   return React.useContext(AthenaStatewireLifecycleContext);
 }
 const clientToolRequests = createClientToolRequestTracker();
-function requestKey(threadId, requestId) {
-  return `${threadId}:${requestId}`;
-}
-function jsonSafeResult(value) {
-  const serialized = JSON.stringify(value);
-  return serialized === void 0 ? null : JSON.parse(serialized);
-}
-function isPendingClientToolRequest(request) {
-  if (request.type !== "interrupt" || "response" in request) return false;
-  return isClientToolInterrupt(request.payload);
-}
 function StatewireClientToolBridge({
   tools,
   threadId
 }) {
   const sendCommand = reactStatewire.useStatewireSendCommand();
   const inputRequests = reactStatewire.useStatewireRuns().inputRequests;
-  const toolsRef = React.useRef(tools);
-  toolsRef.current = tools;
-  const pendingRequest = inputRequests == null ? void 0 : inputRequests.find(isPendingClientToolRequest);
-  const ownedClaimsRef = React.useRef(/* @__PURE__ */ new Set());
-  const activeRef = React.useRef(true);
-  const releaseClaim = React.useCallback((claim) => {
-    ownedClaimsRef.current.delete(claim);
-    clientToolRequests.release(claim);
-  }, []);
-  React.useEffect(() => {
-    activeRef.current = true;
-    return () => {
-      activeRef.current = false;
-      for (const claim of ownedClaimsRef.current) clientToolRequests.release(claim);
-      ownedClaimsRef.current.clear();
-    };
-  }, []);
-  const liveRequestIdsRef = React.useRef(/* @__PURE__ */ new Set());
-  liveRequestIdsRef.current = new Set((inputRequests ?? []).map((request) => request.id));
-  const executeRequest = React.useCallback(
-    async (request) => {
-      const payload = request.payload;
-      if (!isClientToolInterrupt(payload)) return;
-      const calls = payload.context.requests;
-      const registry2 = new Map(toolsRef.current.map((tool) => [tool.name, tool]));
-      const results = {};
-      for (const call of calls) {
-        if (!activeRef.current || !liveRequestIdsRef.current.has(request.id)) {
-          releaseClaim(requestKey(threadId, request.id));
-          return;
-        }
-        const tool = registry2.get(call.tool_name);
-        if (!tool) {
-          results[call.interrupt_id] = clientToolErrorEnvelope(
-            `This surface has no tool named '${call.tool_name}'.`
-          );
-          continue;
-        }
-        try {
-          results[call.interrupt_id] = clientToolSuccessEnvelope(
-            jsonSafeResult(
-              await tool.handler(clientToolCallArgs(call), {
-                toolCallId: call.interrupt_id
-              })
-            )
-          );
-        } catch (error2) {
-          results[call.interrupt_id] = clientToolErrorEnvelope(error2);
-        }
-      }
-      if (!activeRef.current || !liveRequestIdsRef.current.has(request.id)) {
-        releaseClaim(requestKey(threadId, request.id));
-        return;
-      }
-      try {
-        const wireValue = clientToolResultsResumeValue(results);
-        sendCommand({
-          type: "run/input",
-          requestId: request.id,
-          response: { type: "resume", value: wireValue }
-        });
-        ownedClaimsRef.current.delete(requestKey(threadId, request.id));
-      } catch (error2) {
-        releaseClaim(requestKey(threadId, request.id));
-        console.error("[AthenaSDK] failed to resume client tool results:", error2);
-      }
-    },
-    [releaseClaim, sendCommand, threadId]
+  const bridgeTools = React.useMemo(
+    () => tools.map((tool) => ({
+      name: tool.name,
+      run: (args, context) => tool.handler(args, context)
+    })),
+    [tools]
   );
-  React.useEffect(() => {
-    if (!pendingRequest) return;
-    const claim = requestKey(threadId, pendingRequest.id);
-    if (!clientToolRequests.claim(claim)) return;
-    ownedClaimsRef.current.add(claim);
-    void executeRequest(pendingRequest);
-  }, [executeRequest, pendingRequest, threadId]);
+  useStatewireClientToolBridge({
+    threadId,
+    tools: bridgeTools,
+    tracker: clientToolRequests,
+    inputRequests,
+    sendResume: (requestId, value) => {
+      sendCommand({
+        type: "run/input",
+        requestId,
+        response: { type: "resume", value }
+      });
+    }
+  });
   return null;
 }
 const ATHENA_TRANSPORTS = {
@@ -52819,7 +53363,7 @@ const DEFAULT_PILL_STYLE = "border-gray-300 bg-gray-50 text-gray-800 dark:border
 function MentionNodeView({ node }) {
   const { type, name, params } = node.attrs;
   const config2 = getMentionConfig(type);
-  const icon = isRecord$2(params) && typeof params.icon === "string" ? params.icon : (config2 == null ? void 0 : config2.style.icon) ?? "📎";
+  const icon = isRecord$3(params) && typeof params.icon === "string" ? params.icon : (config2 == null ? void 0 : config2.style.icon) ?? "📎";
   const pillStyle = PILL_STYLES[type] ?? DEFAULT_PILL_STYLE;
   return /* @__PURE__ */ jsxRuntime.jsx(NodeViewWrapper, { as: "span", children: /* @__PURE__ */ jsxRuntime.jsxs(
     "span",
@@ -56271,102 +56815,103 @@ function Button({
     }
   );
 }
-function hasStatewireThreadExtras(extras) {
-  if (!isRecord$2(extras)) return false;
-  return typeof extras.sendCommand === "function" && Array.isArray(extras.inputRequests) && isRecord$2(extras.runs);
-}
-function isPendingInterrupt(request) {
-  return request.type === "interrupt" && !("response" in request);
-}
-function isApprovalCardInterrupt(request) {
-  if (!isPendingInterrupt(request)) return false;
-  return !hasClientToolInterruptSource(request.payload);
-}
-function asHitlApproval(value) {
-  if (!isRecord$2(value)) return null;
-  return value.type === "hitl" && value.source === "hitl_approval" && typeof value.message === "string" ? value : null;
-}
-function readInterruptMessage(value) {
-  if (isRecord$2(value) && typeof value.message === "string" && value.message.length > 0) {
-    return value.message;
+class AthenaChatErrorBoundary extends React.Component {
+  constructor(props) {
+    super(props);
+    __publicField(this, "handleRetry", () => {
+      this.setState((prev) => ({ error: null, retrySeq: prev.retrySeq + 1 }));
+    });
+    this.state = { error: null, retrySeq: 0 };
+  }
+  static getDerivedStateFromError(error2) {
+    return { error: error2 };
+  }
+  componentDidCatch(error2, errorInfo) {
+    var _a3;
+    athenaDiagnostics.error(
+      "sdk.error",
+      error2,
+      {
+        code: "chat_render_crash",
+        message: "The chat surface crashed while rendering",
+        hint: "Inspect component_stack — a custom tool UI or message component is the usual culprit."
+      },
+      { component_stack: ((_a3 = errorInfo.componentStack) == null ? void 0 : _a3.slice(0, 2e3)) ?? null }
+    );
+  }
+  render() {
+    if (this.state.error !== null) {
+      return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex h-full min-h-48 flex-col items-center justify-center gap-3 p-6 text-center", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(CircleAlert, { className: "size-6 text-destructive" }),
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "space-y-1", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm font-medium text-foreground", children: "The chat hit an error" }),
+          /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-xs text-muted-foreground", children: "Your conversation is safe on the server — reload the chat to continue." })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs(Button, { variant: "outline", size: "sm", onClick: this.handleRetry, children: [
+          /* @__PURE__ */ jsxRuntime.jsx(RefreshCw, { className: "mr-1.5 size-3.5" }),
+          "Reload chat"
+        ] })
+      ] });
+    }
+    return /* @__PURE__ */ jsxRuntime.jsx(React.Fragment, { children: this.props.children }, this.state.retrySeq);
   }
-  return "The agent is paused and waiting for input.";
 }
 const PENDING_RESUME_GRACE_MS = 15e3;
-const StatewireApprovalCard = () => {
+const StatewireApprovalCard = (props) => {
   const extras = react$1.useAuiState((s) => s.thread.extras);
   if (!hasStatewireThreadExtras(extras)) return null;
-  return /* @__PURE__ */ jsxRuntime.jsx(StatewireApprovalCardInner, {});
+  return /* @__PURE__ */ jsxRuntime.jsx(StatewireApprovalCardInner, { ...props });
 };
-const StatewireApprovalCardInner = () => {
+const StatewireApprovalCardInner = ({
+  classNames,
+  fallbackMessage,
+  interruptPredicate = isApprovalCardInterrupt
+}) => {
   var _a3, _b2, _c2, _d2, _e2;
   const sendCommand = reactStatewire.useStatewireSendCommand();
-  const request = (_a3 = reactStatewire.useStatewireRuns().inputRequests) == null ? void 0 : _a3.find(isApprovalCardInterrupt);
+  const request = (_a3 = reactStatewire.useStatewireRuns().inputRequests) == null ? void 0 : _a3.find(interruptPredicate);
   const requestId = request == null ? void 0 : request.id;
-  const abandoned = reactStatewire.useStatewireState(
-    (s) => s.abandonedInputRequests
-  );
-  const abandonedInterrupt = abandoned == null ? void 0 : abandoned.find((r2) => r2.type === "interrupt");
+  const abandoned = reactStatewire.useStatewireState(readAbandonedInputRequests);
+  const abandonedInterrupt = findAbandonedInterrupt(abandoned);
   const [dismissedId, setDismissedId] = React.useState();
-  const [pending, setPending] = React.useState(false);
-  const prevRequestIdRef = React.useRef(requestId);
-  if (prevRequestIdRef.current !== requestId) {
-    prevRequestIdRef.current = requestId;
-    if (pending) setPending(false);
-  }
   const isRunning = react$1.useAuiState((s) => s.thread.isRunning);
-  const sawResumeRunRef = React.useRef(false);
-  React.useEffect(() => {
-    if (!pending) {
-      sawResumeRunRef.current = false;
-      return;
-    }
-    if (isRunning) {
-      sawResumeRunRef.current = true;
-      return;
-    }
-    if (sawResumeRunRef.current) {
-      sawResumeRunRef.current = false;
-      setPending(false);
-    }
-  }, [pending, isRunning]);
-  React.useEffect(() => {
-    if (!pending) return;
-    const timer = setTimeout(() => {
-      if (!sawResumeRunRef.current) setPending(false);
-    }, PENDING_RESUME_GRACE_MS);
-    return () => clearTimeout(timer);
-  }, [pending, requestId]);
-  const resume = React.useCallback(
-    (value) => {
-      if (requestId === void 0) return;
-      setPending(true);
-      sendCommand({
-        type: "run/input",
-        requestId,
-        response: { type: "resume", value }
-      });
-    },
-    [sendCommand, requestId]
-  );
+  const { pending, resume } = useApprovalResumeLock({
+    requestId,
+    isRunning,
+    pendingResumeGraceMs: PENDING_RESUME_GRACE_MS,
+    sendResume: (id, value) => sendCommand({
+      type: "run/input",
+      requestId: id,
+      response: { type: "resume", value }
+    })
+  });
   if (!request) {
     if (!abandonedInterrupt || abandonedInterrupt.id === dismissedId) return null;
-    return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "aui-approval-abandoned flex w-full items-center justify-between gap-3 rounded-xl border border-amber-300 bg-amber-50 px-3 py-2 text-amber-800 text-xs", children: [
-      /* @__PURE__ */ jsxRuntime.jsx("p", { children: "Approval was cancelled — the run moved on." }),
-      /* @__PURE__ */ jsxRuntime.jsx(
-        "button",
-        {
-          type: "button",
-          "aria-label": "Dismiss cancelled approval",
-          onClick: () => setDismissedId(abandonedInterrupt.id),
-          className: "shrink-0 rounded-md p-1 hover:bg-amber-100",
-          children: /* @__PURE__ */ jsxRuntime.jsx(X, { className: "size-3.5" })
-        }
-      )
-    ] });
+    return /* @__PURE__ */ jsxRuntime.jsxs(
+      "div",
+      {
+        className: cn(
+          "aui-approval-abandoned flex w-full items-center justify-between gap-3 rounded-xl border border-amber-300 bg-amber-50 px-3 py-2 text-amber-800 text-xs",
+          classNames == null ? void 0 : classNames.abandoned
+        ),
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx("p", { children: "Approval was cancelled — the run moved on." }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "button",
+            {
+              type: "button",
+              "aria-label": "Dismiss cancelled approval",
+              onClick: () => setDismissedId(abandonedInterrupt.id),
+              className: "shrink-0 rounded-md p-1 hover:bg-amber-100",
+              children: /* @__PURE__ */ jsxRuntime.jsx(X, { className: "size-3.5" })
+            }
+          )
+        ]
+      }
+    );
   }
   const hitl = asHitlApproval(request.payload);
-  const message = readInterruptMessage(request.payload);
+  const message = readInterruptMessage(request.payload, fallbackMessage);
   const toolName = ((_b2 = hitl == null ? void 0 : hitl.context) == null ? void 0 : _b2.tool_name) ?? ((_c2 = hitl == null ? void 0 : hitl.context) == null ? void 0 : _c2.tool_id);
   const toolArgs = (_d2 = hitl == null ? void 0 : hitl.context) == null ? void 0 : _d2.tool_args;
   const pendingCount = ((_e2 = hitl == null ? void 0 : hitl.context) == null ? void 0 : _e2.pending_action_count) ?? 1;
@@ -56374,7 +56919,10 @@ const StatewireApprovalCardInner = () => {
     "section",
     {
       "aria-label": hitl ? "Approval required" : "Input required",
-      className: "aui-approval-card w-full rounded-2xl border border-amber-300 bg-amber-50 px-4 py-3 text-amber-900",
+      className: cn(
+        "aui-approval-card w-full rounded-2xl border border-amber-300 bg-amber-50 px-4 py-3 text-amber-900",
+        classNames == null ? void 0 : classNames.root
+      ),
       children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-start gap-3", children: [
         /* @__PURE__ */ jsxRuntime.jsx(TriangleAlert, { className: "mt-0.5 size-4 shrink-0" }),
         /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "min-w-0 flex-1", children: [
@@ -56396,7 +56944,7 @@ const StatewireApprovalCardInner = () => {
             {
               size: "sm",
               disabled: pending,
-              onClick: () => resume({ action: "approve" }),
+              onClick: () => resume(hitlResumeApprove()),
               className: "bg-green-600 text-white hover:bg-green-700",
               children: [
                 /* @__PURE__ */ jsxRuntime.jsx(Check, {}),
@@ -56410,31 +56958,18 @@ const StatewireApprovalCardInner = () => {
               size: "sm",
               variant: "outline",
               disabled: pending,
-              onClick: () => resume({ action: "reject", reason: "User rejected the action." }),
+              onClick: () => resume(hitlResumeReject()),
               children: [
                 /* @__PURE__ */ jsxRuntime.jsx(X, {}),
                 "Reject"
               ]
             }
           )
-        ] }) : /* @__PURE__ */ jsxRuntime.jsx(
-          Button,
-          {
-            size: "sm",
-            disabled: pending,
-            onClick: () => resume({ action: "continue" }),
-            children: "Continue"
-          }
-        ) })
+        ] }) : /* @__PURE__ */ jsxRuntime.jsx(Button, { size: "sm", disabled: pending, onClick: () => resume(hitlResumeContinue()), children: "Continue" }) })
       ] })
     }
   );
 };
-function queueItemText(parts) {
-  return parts.flatMap(
-    (part) => part.type === "text" && typeof part.text === "string" ? [part.text] : []
-  ).join("\n\n");
-}
 const StatewireQueuedMessages = () => {
   const extras = react$1.useAuiState((s) => s.thread.extras);
   if (!hasStatewireThreadExtras(extras)) return null;
@@ -56445,12 +56980,8 @@ const StatewireQueuedMessagesInner = () => {
   const status = useDeepAgentThreadStatus();
   const aui = react$1.useAui();
   const [expanded, setExpanded] = React.useState(true);
-  const isRunning = status === "running";
-  const isContinuable = status === "stopped" || status === "error";
-  const rows = [
-    ...isContinuable ? steerQueue.map((item) => ({ item, lane: "steer" })) : [],
-    ...queue.map((item) => ({ item, lane: "queue" }))
-  ];
+  const { isRunning, isContinuable } = queueLaneFlags(status);
+  const rows = buildStatewireQueueRows({ queue, steerQueue, isContinuable });
   if (rows.length === 0) return null;
   const queueHead = queue[0];
   return /* @__PURE__ */ jsxRuntime.jsxs(
@@ -56498,8 +57029,8 @@ const StatewireQueuedMessagesInner = () => {
             className: "max-h-40 overflow-y-auto",
             "data-testid": "athena-statewire-queue",
             children: rows.map(({ item, lane }, index2) => {
-              const text2 = queueItemText(item.parts);
-              const showSendNow = lane === "queue" && (isContinuable || isRunning && index2 === 0);
+              const text2 = queueEntryText(item.parts);
+              const showSendNow = showQueueRowSendNow({ lane, index: index2, isRunning, isContinuable });
               return /* @__PURE__ */ jsxRuntime.jsxs(
                 "li",
                 {
@@ -62070,15 +62601,15 @@ const AthenaDefaultUserMessage = () => {
   return /* @__PURE__ */ jsxRuntime.jsx(AthenaUserMessage, { TextComponent });
 };
 const getReasoningTokensFromMetadata = (metadata) => {
-  if (!isRecord$2(metadata)) {
+  if (!isRecord$3(metadata)) {
     return void 0;
   }
   const customMetadata = metadata.custom;
-  if (!isRecord$2(customMetadata)) {
+  if (!isRecord$3(customMetadata)) {
     return void 0;
   }
   const athenaMetadata = customMetadata._athena;
-  if (!isRecord$2(athenaMetadata)) {
+  if (!isRecord$3(athenaMetadata)) {
     return void 0;
   }
   const reasoningTokens = athenaMetadata.reasoningTokens;
@@ -62173,7 +62704,7 @@ const AthenaChat = ({
   );
   const AssistantMessageComponent = (components == null ? void 0 : components.AssistantMessage) ?? AthenaDefaultAssistantMessage;
   const UserMessageComponent = (components == null ? void 0 : components.UserMessage) ?? AthenaDefaultUserMessage;
-  return /* @__PURE__ */ jsxRuntime.jsx(AthenaChatDefaultComponentsContext.Provider, { value: defaultComponentsContextValue, children: /* @__PURE__ */ jsxRuntime.jsxs(
+  return /* @__PURE__ */ jsxRuntime.jsx(AthenaChatDefaultComponentsContext.Provider, { value: defaultComponentsContextValue, children: /* @__PURE__ */ jsxRuntime.jsx(AthenaChatErrorBoundary, { children: /* @__PURE__ */ jsxRuntime.jsxs(
     react$1.ThreadPrimitive.Root,
     {
       className: `aui-root aui-thread-root @container flex h-full flex-col bg-background ${className ?? ""}`,
@@ -62224,7 +62755,7 @@ const AthenaChat = ({
         )
       ]
     }
-  ) });
+  ) }) });
 };
 const ThreadLoadingOverlay = () => {
   const remoteId = useAthenaThreadId();
@@ -63619,6 +64150,7 @@ exports.AthenaAssetEmbed = AthenaAssetEmbed;
 exports.AthenaAssistantActionBar = AthenaAssistantActionBar;
 exports.AthenaAssistantMessage = AthenaAssistantMessage;
 exports.AthenaChat = AthenaChat;
+exports.AthenaChatErrorBoundary = AthenaChatErrorBoundary;
 exports.AthenaLayout = AthenaLayout;
 exports.AthenaProvider = AthenaProvider;
 exports.AthenaReasoningPart = AthenaReasoningPart;