@athenaintel/react 0.10.41-rc.2 → 0.11.0

package/dist/index.cjs

@@ -42,8 +42,8 @@ var __privateWrapper = (obj, member, setter, getter) => ({
 var _focused, _cleanup, _setup, _a2, _provider, _providerCalled, _b, _online, _cleanup2, _setup2, _c, _gcTimeout, _d, _initialState, _revertState, _cache, _client, _retryer, _defaultOptions, _abortSignalConsumed, _Query_instances, isInitialPausedFetch_fn, dispatch_fn, _e, _client2, _currentQuery, _currentQueryInitialState, _currentResult, _currentResultState, _currentResultOptions, _currentThenable, _selectError, _selectFn, _selectResult, _lastQueryWithDefinedData, _staleTimeoutId, _refetchIntervalId, _currentRefetchInterval, _trackedProps, _QueryObserver_instances, executeFetch_fn, updateStaleTimeout_fn, computeRefetchInterval_fn, updateRefetchInterval_fn, updateTimers_fn, clearStaleTimeout_fn, clearRefetchInterval_fn, updateQuery_fn, notify_fn, _f, _client3, _observers, _mutationCache, _retryer2, _Mutation_instances, dispatch_fn2, _g, _mutations, _scopes, _mutationId, _h, _queries, _i, _queryCache, _mutationCache2, _defaultOptions2, _queryDefaults, _mutationDefaults, _mountCount, _unsubscribeFocus, _unsubscribeOnline, _j;
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const jsxRuntime = require("react/jsx-runtime");
-const react$1 = require("@assistant-ui/react");
 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");
@@ -52,6 +52,7 @@ require("@assistant-ui/core");
 const react$2 = require("@assistant-ui/core/react");
 const reactLanggraph = require("@assistant-ui/react-langgraph");
 const reactStatewire = require("@assistant-ui/react-statewire");
+const store = require("@assistant-ui/store");
 const ReactDOM = require("react-dom");
 function _interopNamespaceDefault(e) {
   const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
@@ -71,6 +72,909 @@ function _interopNamespaceDefault(e) {
 }
 const React__namespace = /* @__PURE__ */ _interopNamespaceDefault(React);
 const ReactDOM__namespace = /* @__PURE__ */ _interopNamespaceDefault(ReactDOM);
+const version$1 = "0.11.0";
+const packageJson = {
+  version: version$1
+};
+const ATHENA_REACT_SDK_VERSION = packageJson.version;
+const DEFAULT_CAPTURE_GATE_CONFIG = {
+  globalMaxPerWindow: 50,
+  globalWindowMs: 1e4,
+  criticalReservePerWindow: 15,
+  defaultEventMaxPerWindow: 12,
+  defaultEventWindowMs: 6e4,
+  defaultDedupeWindowMs: 5e3,
+  flushIntervalMs: 3e4,
+  flushCoalesceThreshold: 20,
+  eventOverrides: {
+    memory_profile_sample: { maxPerWindow: 2, windowMs: 3e4, dedupeWindowMs: 15e3 },
+    long_task_detected: { maxPerWindow: 3, windowMs: 6e4, dedupeWindowMs: 1e4 },
+    collab_connection_status_changed: { maxPerWindow: 6, windowMs: 6e4 },
+    collab_first_remote_update: { maxPerWindow: 3, windowMs: 6e4 },
+    collab_first_local_update: { maxPerWindow: 3, windowMs: 6e4 },
+    collab_render_time_sync_fix: { maxPerWindow: 3, windowMs: 6e4 },
+    collab_visibility_recovery: { maxPerWindow: 4, windowMs: 6e4 },
+    langgraph_message_validation_error: {
+      maxPerWindow: 8,
+      windowMs: 6e4,
+      dedupeWindowMs: 15e3
+    },
+    langgraph_messages_validation_error: {
+      maxPerWindow: 5,
+      windowMs: 6e4,
+      dedupeWindowMs: 15e3
+    },
+    langgraph_interrupt_validation_error: {
+      maxPerWindow: 5,
+      windowMs: 6e4,
+      dedupeWindowMs: 15e3
+    },
+    langgraph_state_validation_error: {
+      maxPerWindow: 5,
+      windowMs: 6e4,
+      dedupeWindowMs: 15e3
+    },
+    graphql_error: { maxPerWindow: 12, windowMs: 6e4, dedupeWindowMs: 1e4 },
+    chat_error: { maxPerWindow: 8, windowMs: 6e4, dedupeWindowMs: 5e3 },
+    memory_critical_threshold: { maxPerWindow: 3, windowMs: 3e5 },
+    memory_warning_threshold: { maxPerWindow: 3, windowMs: 3e5 },
+    pptx_slide_changed: { maxPerWindow: 8, windowMs: 3e4 }
+  }
+};
+const CRITICAL_EVENT_PATTERNS = [
+  /(?:^|_)failed$/,
+  /(?:^|_)error(?:_|$)/,
+  /crash/,
+  /^oom_/,
+  /aw_snap/,
+  /chunk_load/,
+  /global_error/,
+  /\$exception$/,
+  /^404_error$/,
+  /^500_error$/,
+  /_boundary_/
+];
+const BYPASS_OPTION_KEY = "__posthog_gate_bypass";
+function isCriticalPosthogEvent(event) {
+  return CRITICAL_EVENT_PATTERNS.some((pattern) => pattern.test(event));
+}
+function shouldBypassCaptureGate(options) {
+  if (!options || typeof options !== "object") return false;
+  return options[BYPASS_OPTION_KEY] === true;
+}
+function withCaptureGateBypass(options) {
+  return {
+    ...options ?? {},
+    [BYPASS_OPTION_KEY]: true
+  };
+}
+function pruneWindow(window2, now, windowMs) {
+  const cutoff = now - windowMs;
+  while (window2.timestamps.length > 0 && window2.timestamps[0] < cutoff) {
+    window2.timestamps.shift();
+  }
+}
+function countInWindow(window2, now, windowMs) {
+  pruneWindow(window2, now, windowMs);
+  return window2.timestamps.length;
+}
+function recordInWindow(window2, now) {
+  window2.timestamps.push(now);
+}
+function stableStringify(value) {
+  if (value == null) return String(value);
+  if (typeof value !== "object") return String(value);
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+  }
+  const record2 = value;
+  const keys2 = Object.keys(record2).sort();
+  return `{${keys2.map((key) => `${key}:${stableStringify(record2[key])}`).join(",")}}`;
+}
+function fingerprintProperties(properties) {
+  if (!properties) return "";
+  const keys2 = [
+    "error",
+    "error_message",
+    "message",
+    "reason",
+    "status",
+    "code",
+    "asset_id",
+    "doc_id",
+    "thread_id",
+    "session_id",
+    "operation",
+    "path",
+    "url",
+    "chunk_identifier",
+    "validation_path"
+  ];
+  const subset = {};
+  for (const key of keys2) {
+    if (key in properties) {
+      subset[key] = properties[key];
+    }
+  }
+  return stableStringify(subset);
+}
+function buildCaptureFingerprint(event, properties) {
+  return `${event}|${fingerprintProperties(properties)}`;
+}
+function buildCoalescedCaptureProperties(payload) {
+  const windowMs = payload.lastAt - payload.firstAt;
+  return {
+    ...payload.properties,
+    coalesced: true,
+    coalesced_count: payload.coalescedCount,
+    coalesced_first_at: new Date(payload.firstAt).toISOString(),
+    coalesced_last_at: new Date(payload.lastAt).toISOString(),
+    coalesced_window_ms: windowMs,
+    coalesced_suppression_reason: payload.suppressionReason
+  };
+}
+class PosthogCaptureGate {
+  constructor(config2 = DEFAULT_CAPTURE_GATE_CONFIG) {
+    __publicField(this, "config");
+    __publicField(this, "globalWindow", { timestamps: [] });
+    __publicField(this, "eventWindows", /* @__PURE__ */ new Map());
+    __publicField(this, "activeDedupe", /* @__PURE__ */ new Map());
+    __publicField(this, "coalesceBuckets", /* @__PURE__ */ new Map());
+    __publicField(this, "emittedTotal", 0);
+    __publicField(this, "coalescedTotal", 0);
+    __publicField(this, "flushedCoalescedTotal", 0);
+    this.config = config2;
+  }
+  resetForTests() {
+    this.globalWindow.timestamps.length = 0;
+    this.eventWindows.clear();
+    this.activeDedupe.clear();
+    this.coalesceBuckets.clear();
+    this.emittedTotal = 0;
+    this.coalescedTotal = 0;
+    this.flushedCoalescedTotal = 0;
+  }
+  getSnapshot() {
+    const coalescedPendingByEvent = {};
+    let coalescedPending = 0;
+    for (const bucket of this.coalesceBuckets.values()) {
+      coalescedPending += bucket.count;
+      coalescedPendingByEvent[bucket.event] = (coalescedPendingByEvent[bucket.event] ?? 0) + bucket.count;
+    }
+    return {
+      coalescedPending,
+      coalescedPendingByEvent,
+      emittedTotal: this.emittedTotal,
+      coalescedTotal: this.coalescedTotal,
+      flushedCoalescedTotal: this.flushedCoalescedTotal
+    };
+  }
+  evaluateCapture(event, properties, options, now = Date.now()) {
+    if (shouldBypassCaptureGate(options)) {
+      return { action: "emit" };
+    }
+    const fingerprint = buildCaptureFingerprint(event, properties);
+    const bucketKey = fingerprint;
+    const override = this.config.eventOverrides[event];
+    const dedupeWindowMs = (override == null ? void 0 : override.dedupeWindowMs) ?? this.config.defaultDedupeWindowMs;
+    const lastDedupe = this.activeDedupe.get(event);
+    if (lastDedupe && lastDedupe.fingerprint === fingerprint && now - lastDedupe.at < dedupeWindowMs) {
+      return this.recordCoalesce(event, bucketKey, fingerprint, properties, "dedupe", now);
+    }
+    const critical = isCriticalPosthogEvent(event);
+    const globalCount = countInWindow(this.globalWindow, now, this.config.globalWindowMs);
+    const normalBudget = Math.max(
+      0,
+      this.config.globalMaxPerWindow - this.config.criticalReservePerWindow
+    );
+    if (critical) {
+      if (globalCount >= this.config.globalMaxPerWindow) {
+        return this.recordCoalesce(event, bucketKey, fingerprint, properties, "global_budget", now);
+      }
+    } else if (globalCount >= normalBudget) {
+      return this.recordCoalesce(event, bucketKey, fingerprint, properties, "global_budget", now);
+    }
+    const eventWindow = this.eventWindows.get(event) ?? { timestamps: [] };
+    this.eventWindows.set(event, eventWindow);
+    const eventMax = (override == null ? void 0 : override.maxPerWindow) ?? this.config.defaultEventMaxPerWindow;
+    const eventWindowMs = (override == null ? void 0 : override.windowMs) ?? this.config.defaultEventWindowMs;
+    const eventCount = countInWindow(eventWindow, now, eventWindowMs);
+    if (eventCount >= eventMax) {
+      return this.recordCoalesce(event, bucketKey, fingerprint, properties, "event_budget", now);
+    }
+    recordInWindow(this.globalWindow, now);
+    recordInWindow(eventWindow, now);
+    this.activeDedupe.set(event, { fingerprint, bucketKey, at: now });
+    this.emittedTotal += 1;
+    return { action: "emit" };
+  }
+  /** Returns payloads ready to flush (does not mutate buckets until caller confirms). */
+  collectFlushCandidates(now = Date.now()) {
+    const payloads = [];
+    for (const bucket of this.coalesceBuckets.values()) {
+      const shouldFlushBySize = bucket.count >= this.config.flushCoalesceThreshold;
+      const shouldFlushByAge = now - bucket.firstAt >= this.config.flushIntervalMs;
+      if (!shouldFlushBySize && !shouldFlushByAge) {
+        continue;
+      }
+      payloads.push({
+        bucketKey: bucket.bucketKey,
+        event: bucket.event,
+        properties: bucket.sampleProperties,
+        coalescedCount: bucket.count,
+        firstAt: bucket.firstAt,
+        lastAt: bucket.lastAt,
+        suppressionReason: bucket.suppressionReason
+      });
+    }
+    return payloads;
+  }
+  /** Remove flushed bucket keys after successful emit. */
+  acknowledgeFlushed(payloads) {
+    for (const payload of payloads) {
+      this.coalesceBuckets.delete(payload.bucketKey);
+      this.flushedCoalescedTotal += payload.coalescedCount;
+    }
+  }
+  /** After coalescing, flush immediately if the bucket crossed the early threshold. */
+  takeBucketIfReady(bucketKey, now = Date.now()) {
+    const bucket = this.coalesceBuckets.get(bucketKey);
+    if (!bucket) return null;
+    const shouldFlushBySize = bucket.count >= this.config.flushCoalesceThreshold;
+    const shouldFlushByAge = now - bucket.firstAt >= this.config.flushIntervalMs;
+    if (!shouldFlushBySize && !shouldFlushByAge) {
+      return null;
+    }
+    this.coalesceBuckets.delete(bucketKey);
+    this.flushedCoalescedTotal += bucket.count;
+    return {
+      bucketKey: bucket.bucketKey,
+      event: bucket.event,
+      properties: bucket.sampleProperties,
+      coalescedCount: bucket.count,
+      firstAt: bucket.firstAt,
+      lastAt: bucket.lastAt,
+      suppressionReason: bucket.suppressionReason
+    };
+  }
+  /** Force-flush every pending bucket (e.g. page hide). */
+  collectAllPending() {
+    return [...this.coalesceBuckets.values()].map((bucket) => ({
+      bucketKey: bucket.bucketKey,
+      event: bucket.event,
+      properties: bucket.sampleProperties,
+      coalescedCount: bucket.count,
+      firstAt: bucket.firstAt,
+      lastAt: bucket.lastAt,
+      suppressionReason: bucket.suppressionReason
+    }));
+  }
+  recordCoalesce(event, bucketKey, fingerprint, properties, reason, now) {
+    const existing = this.coalesceBuckets.get(bucketKey);
+    if (existing) {
+      existing.count += 1;
+      existing.lastAt = now;
+      existing.sampleProperties = { ...existing.sampleProperties, ...properties ?? {} };
+    } else {
+      this.coalesceBuckets.set(bucketKey, {
+        event,
+        bucketKey,
+        fingerprint,
+        count: 1,
+        firstAt: now,
+        lastAt: now,
+        suppressionReason: reason,
+        sampleProperties: { ...properties ?? {} }
+      });
+    }
+    this.coalescedTotal += 1;
+    this.activeDedupe.set(event, { fingerprint, bucketKey, at: now });
+    return { action: "coalesce", reason, bucketKey };
+  }
+}
+const gate = new PosthogCaptureGate(DEFAULT_CAPTURE_GATE_CONFIG);
+let wrappedClient = null;
+let originalCaptureRef = null;
+let flushTimer = null;
+let lifecycleHooksInstalled = false;
+function getPosthogCaptureGate() {
+  return gate;
+}
+function emitThroughOriginal(event, properties, options) {
+  if (!originalCaptureRef) return void 0;
+  return originalCaptureRef(event, properties, withCaptureGateBypass(options));
+}
+function flushCoalescedPayload(payload) {
+  emitThroughOriginal(payload.event, buildCoalescedCaptureProperties(payload));
+}
+function flushCoalescedCaptures(options) {
+  const payloads = (options == null ? void 0 : options.force) ? gate.collectAllPending() : gate.collectFlushCandidates();
+  if (payloads.length === 0) return;
+  for (const payload of payloads) {
+    flushCoalescedPayload(payload);
+  }
+  gate.acknowledgeFlushed(payloads);
+}
+function installLifecycleFlushHooks() {
+  if (lifecycleHooksInstalled || typeof window === "undefined") return;
+  lifecycleHooksInstalled = true;
+  const flushOnHide = () => {
+    flushCoalescedCaptures({ force: true });
+  };
+  window.addEventListener("pagehide", flushOnHide);
+  document.addEventListener("visibilitychange", () => {
+    if (document.visibilityState === "hidden") {
+      flushOnHide();
+    }
+  });
+  if (!flushTimer) {
+    flushTimer = setInterval(() => {
+      flushCoalescedCaptures();
+    }, DEFAULT_CAPTURE_GATE_CONFIG.flushIntervalMs);
+  }
+}
+function wrapPosthogClient(client) {
+  if (wrappedClient === client) {
+    return client;
+  }
+  originalCaptureRef = client.capture.bind(client);
+  const originalCaptureException = typeof client.captureException === "function" ? client.captureException.bind(client) : null;
+  installLifecycleFlushHooks();
+  client.capture = ((event, properties, options) => {
+    const outcome = gate.evaluateCapture(event, properties, options);
+    if (outcome.action === "coalesce") {
+      const readyPayload = gate.takeBucketIfReady(outcome.bucketKey);
+      if (readyPayload) {
+        flushCoalescedPayload(readyPayload);
+      }
+      return void 0;
+    }
+    return emitThroughOriginal(event, properties, options);
+  });
+  if (originalCaptureException) {
+    client.captureException = ((error2, additionalProperties) => {
+      const mergedProperties = {
+        ...additionalProperties ?? {},
+        $exception_message: error2 instanceof Error ? error2.message : String(error2),
+        $exception_type: error2 instanceof Error ? error2.name : typeof error2
+      };
+      const outcome = gate.evaluateCapture("$exception", mergedProperties);
+      if (outcome.action === "coalesce") {
+        const readyPayload = gate.takeBucketIfReady(outcome.bucketKey);
+        if (readyPayload) {
+          flushCoalescedPayload(readyPayload);
+        }
+        return void 0;
+      }
+      return originalCaptureException(error2, additionalProperties);
+    });
+  }
+  wrappedClient = client;
+  return client;
+}
+function capturePosthogEvent(client, event, properties, options) {
+  if (!client || typeof client.capture !== "function") return;
+  client.capture(event, properties, options);
+}
+function capturePosthogException(client, error2, properties, options) {
+  if (!client) return;
+  if (typeof client.captureException === "function") {
+    client.captureException(error2, properties);
+    return;
+  }
+  capturePosthogEvent(
+    client,
+    "$exception",
+    {
+      ...properties ?? {},
+      $exception_message: error2.message,
+      $exception_type: error2.name,
+      $exception_stack: error2.stack
+    },
+    options
+  );
+}
+let posthogInstance = null;
+let initPromise = null;
+const DEFAULT_HOST = "https://us.i.posthog.com";
+async function initializePostHog(apiKey, host, debug) {
+  if (posthogInstance) return posthogInstance;
+  if (typeof window === "undefined") return null;
+  try {
+    const posthog = (await import("posthog-js")).default;
+    posthog.init(apiKey, {
+      api_host: host,
+      autocapture: true,
+      capture_pageview: false,
+      session_recording: {
+        recordCrossOriginIframes: true,
+        maskAllInputs: true
+      },
+      loaded: (ph) => {
+        wrapPosthogClient(ph);
+        if (debug) {
+          ph.debug(true);
+        }
+      }
+    });
+    wrapPosthogClient(posthog);
+    posthogInstance = posthog;
+    return posthog;
+  } catch {
+    initPromise = null;
+    return null;
+  }
+}
+function getPostHogInstance() {
+  return posthogInstance;
+}
+function PostHogProvider({
+  children,
+  config: config2
+}) {
+  const apiKey = (config2 == null ? void 0 : config2.apiKey) ?? "";
+  const host = (config2 == null ? void 0 : config2.host) ?? DEFAULT_HOST;
+  const debug = (config2 == null ? void 0 : config2.debug) ?? false;
+  React.useEffect(() => {
+    if (!apiKey || typeof window === "undefined") return;
+    if (!initPromise) {
+      initPromise = initializePostHog(apiKey, host, debug);
+    }
+  }, [apiKey, host, debug]);
+  return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children });
+}
+const ATHENA_SDK_ERROR_CODES = {
+  /** No token and no API key resolved before a request had to be sent. */
+  auth_missing: "auth_missing",
+  /** The server refused the credential (401 / statewire `unauthorized` fin). */
+  auth_rejected: "auth_rejected",
+  /** `/_athena/auth` or the iframe bridge did not answer within the timeout. */
+  auth_bridge_timeout: "auth_bridge_timeout",
+  /** `/_athena/auth` answered with a non-404 error. */
+  auth_bridge_failed: "auth_bridge_failed",
+  /** The statewire sync URL could not be derived from the configuration. */
+  config_invalid: "config_invalid",
+  /** A prop was set that the active transport ignores (e.g. `agent` on statewire). */
+  config_ignored: "config_ignored",
+  /** The thread list request failed. */
+  threads_list_failed: "threads_list_failed",
+  /** Loading a thread's history failed. */
+  thread_load_failed: "thread_load_failed",
+  /** The statewire host rejected a command (structured `{status, detail}`). */
+  statewire_rejected: "statewire_rejected",
+  /** The statewire connection is gone and will not reconnect on its own. */
+  statewire_gone: "statewire_gone",
+  /** The legacy `/api/chat` stream failed. */
+  stream_failed: "stream_failed",
+  /** The selected collab agent / channel was refused by the backend. */
+  collab_agent_rejected: "collab_agent_rejected",
+  /** Anything else. */
+  unknown: "unknown"
+};
+class AthenaSdkError extends Error {
+  constructor(options) {
+    super(options.message, options.cause === void 0 ? void 0 : { cause: options.cause });
+    __publicField(this, "code");
+    __publicField(this, "hint");
+    __publicField(this, "status");
+    __publicField(this, "detail");
+    __publicField(this, "context");
+    this.name = "AthenaSdkError";
+    this.code = options.code;
+    this.hint = options.hint;
+    this.status = options.status;
+    this.detail = options.detail;
+    this.context = options.context ?? {};
+  }
+  /** A log/console-friendly one-liner: `[code] message — hint`. */
+  describe() {
+    return `[${this.code}] ${this.message}${this.hint ? ` — ${this.hint}` : ""}`;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      hint: this.hint,
+      status: this.status,
+      detail: this.detail,
+      context: this.context
+    };
+  }
+}
+function isAthenaSdkError(value) {
+  return value instanceof AthenaSdkError;
+}
+function toAthenaSdkError(value, fallback) {
+  if (isAthenaSdkError(value)) return value;
+  const message = value instanceof Error && value.message ? value.message : fallback.message;
+  return new AthenaSdkError({ ...fallback, message, cause: value });
+}
+function readRejectionDetail(detail) {
+  if (typeof detail === "string") return { code: null, message: detail || null };
+  if (!detail || typeof detail !== "object") return { code: null, message: null };
+  const record2 = detail;
+  return {
+    code: typeof record2.code === "string" ? record2.code : null,
+    message: typeof record2.message === "string" ? record2.message : null
+  };
+}
+const ATHENA_DIAGNOSTIC_LEVELS = ["debug", "info", "warn", "error"];
+const LEVEL_RANK = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+const DEFAULT_CONFIG = {
+  console: false,
+  posthog: false,
+  bufferSize: 300
+};
+const CONSOLE_PREFIX = "[AthenaSDK]";
+const LOCAL_STORAGE_DEBUG_KEY = "athena:debug";
+const GLOBAL_KEY = "__ATHENA_SDK__";
+const REDACT_KEYS = /token|secret|api[-_]?key|authorization|cookie|password/i;
+function redact(data) {
+  if (!data) return void 0;
+  const out = {};
+  for (const [key, value] of Object.entries(data)) {
+    if (REDACT_KEYS.test(key)) {
+      out[key] = typeof value === "string" && value.length > 0 ? `<redacted:${value.length}>` : "<redacted>";
+    } else {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+function nowMs() {
+  return typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+}
+function readLocalDebugLevel() {
+  try {
+    if (typeof localStorage === "undefined") return null;
+    const raw = localStorage.getItem(LOCAL_STORAGE_DEBUG_KEY);
+    if (!raw) return null;
+    if (ATHENA_DIAGNOSTIC_LEVELS.includes(raw)) {
+      return raw;
+    }
+    return raw === "1" || raw === "true" ? "debug" : null;
+  } catch {
+    return null;
+  }
+}
+class AthenaDiagnosticsBus {
+  constructor() {
+    __publicField(this, "config", { ...DEFAULT_CONFIG });
+    __publicField(this, "events", []);
+    __publicField(this, "listeners", /* @__PURE__ */ new Set());
+    __publicField(this, "snapshotListeners", /* @__PURE__ */ new Set());
+    __publicField(this, "seq", 0);
+    __publicField(this, "gauges", {});
+    __publicField(this, "timings", {});
+    __publicField(this, "spans", /* @__PURE__ */ new Map());
+    __publicField(this, "cachedSnapshot", null);
+  }
+  configure(partial2) {
+    this.config = { ...this.config, ...partial2 };
+    if (this.events.length > this.config.bufferSize) {
+      this.events = this.events.slice(-this.config.bufferSize);
+    }
+    this.invalidate();
+  }
+  getConfig() {
+    return this.config;
+  }
+  /** Effective console level: the configured one, or `localStorage['athena:debug']`. */
+  consoleLevel() {
+    if (this.config.console !== false) return this.config.console;
+    return readLocalDebugLevel() ?? false;
+  }
+  emit(name, options = {}) {
+    const level = options.level ?? (options.error !== void 0 ? "error" : "info");
+    const error2 = options.error === void 0 ? void 0 : toAthenaSdkError(options.error, {
+      code: "unknown",
+      message: `Unexpected error during ${name}`
+    });
+    const event = {
+      seq: ++this.seq,
+      t: Math.round(nowMs() * 10) / 10,
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      name,
+      level,
+      ...options.durationMs !== void 0 && { durationMs: Math.round(options.durationMs) },
+      ...options.data && { data: redact(options.data) },
+      ...error2 && { error: error2 }
+    };
+    this.events.push(event);
+    if (this.events.length > this.config.bufferSize) {
+      this.events.splice(0, this.events.length - this.config.bufferSize);
+    }
+    if (event.durationMs !== void 0) {
+      this.timings[name] = event.durationMs;
+    }
+    this.invalidate();
+    this.echoToConsole(event);
+    this.forwardToPostHog(event);
+    for (const listener of this.listeners) {
+      try {
+        listener(event);
+      } catch (listenerError) {
+        console.error(`${CONSOLE_PREFIX} diagnostics listener threw`, listenerError);
+      }
+    }
+    if (this.config.onEvent) {
+      try {
+        this.config.onEvent(event);
+      } catch (callbackError) {
+        console.error(`${CONSOLE_PREFIX} onDiagnostic callback threw`, callbackError);
+      }
+    }
+    if (error2 && this.config.onError) {
+      try {
+        this.config.onError(error2, event);
+      } catch (callbackError) {
+        console.error(`${CONSOLE_PREFIX} onError callback threw`, callbackError);
+      }
+    }
+    for (const notify of this.snapshotListeners) notify();
+    return event;
+  }
+  /** Record an error-level event. Returns the normalized `AthenaSdkError`. */
+  error(name, error2, fallback, data) {
+    const normalized = toAthenaSdkError(error2, fallback);
+    this.emit(name, { level: "error", error: normalized, data });
+    return normalized;
+  }
+  /**
+   * Start a named span. Returns a function that ends it and emits `doneName`
+   * with `durationMs` (or `errorName` when passed an error). Also records a
+   * `performance.measure` so the span shows in the browser's Performance panel.
+   */
+  span(spanName, startName, data) {
+    const startedAt = nowMs();
+    this.spans.set(spanName, startedAt);
+    this.mark(`${spanName}:start`);
+    this.emit(startName, { level: "debug", data });
+    return (doneName, doneOptions = {}) => {
+      const durationMs = nowMs() - startedAt;
+      this.spans.delete(spanName);
+      this.mark(`${spanName}:end`);
+      this.measure(spanName);
+      this.emit(doneName, {
+        level: doneOptions.error !== void 0 ? "error" : "info",
+        durationMs,
+        data: doneOptions.data,
+        error: doneOptions.error
+      });
+      return durationMs;
+    };
+  }
+  /** Set a gauge (latest-value metric): connection status, transport, auth mode. */
+  gauge(name, value) {
+    if (this.gauges[name] === value) return;
+    this.gauges[name] = value;
+    this.invalidate();
+    for (const notify of this.snapshotListeners) notify();
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  /**
+   * Additive consumer registration: every registered consumer receives every
+   * event (and every error), unlike the single `onEvent`/`onError` config
+   * slots which are last-writer-wins. `AthenaProvider` registers through this
+   * so two mounted providers never clobber each other's callbacks.
+   */
+  addConsumer(consumer) {
+    return this.subscribe((event) => {
+      var _a3, _b2;
+      try {
+        (_a3 = consumer.onEvent) == null ? void 0 : _a3.call(consumer, event);
+      } catch (callbackError) {
+        console.error(`${CONSOLE_PREFIX} onDiagnostic consumer threw`, callbackError);
+      }
+      if (event.error) {
+        try {
+          (_b2 = consumer.onError) == null ? void 0 : _b2.call(consumer, event.error, event);
+        } catch (callbackError) {
+          console.error(`${CONSOLE_PREFIX} onError consumer threw`, callbackError);
+        }
+      }
+    });
+  }
+  /** Subscribe to snapshot changes (for `useSyncExternalStore`). */
+  subscribeSnapshot(listener) {
+    this.snapshotListeners.add(listener);
+    return () => {
+      this.snapshotListeners.delete(listener);
+    };
+  }
+  snapshot() {
+    if (!this.cachedSnapshot) {
+      const { onEvent: _onEvent, onError: _onError, ...config2 } = this.config;
+      this.cachedSnapshot = {
+        sdkVersion: ATHENA_REACT_SDK_VERSION,
+        config: config2,
+        events: [...this.events],
+        gauges: { ...this.gauges },
+        timings: { ...this.timings }
+      };
+    }
+    return this.cachedSnapshot;
+  }
+  /** Copy-paste-able JSON of the current snapshot (errors serialized). */
+  export() {
+    return JSON.stringify(
+      this.snapshot(),
+      (_key, value) => isAthenaSdkError(value) ? value.toJSON() : value,
+      2
+    );
+  }
+  clear() {
+    this.events = [];
+    this.timings = {};
+    this.invalidate();
+    for (const notify of this.snapshotListeners) notify();
+  }
+  invalidate() {
+    this.cachedSnapshot = null;
+  }
+  mark(name) {
+    try {
+      if (typeof performance !== "undefined" && typeof performance.mark === "function") {
+        performance.mark(`athena-sdk:${name}`);
+      }
+    } catch {
+    }
+  }
+  measure(spanName) {
+    try {
+      if (typeof performance !== "undefined" && typeof performance.measure === "function") {
+        performance.measure(
+          `athena-sdk:${spanName}`,
+          `athena-sdk:${spanName}:start`,
+          `athena-sdk:${spanName}:end`
+        );
+      }
+    } catch {
+    }
+  }
+  echoToConsole(event) {
+    const level = this.consoleLevel();
+    if (level === false) {
+      if (event.level === "error" && event.error) {
+        console.error(`${CONSOLE_PREFIX} ${event.name}: ${event.error.describe()}`, event.data ?? "");
+      }
+      return;
+    }
+    if (LEVEL_RANK[event.level] < LEVEL_RANK[level]) return;
+    const suffix = event.durationMs !== void 0 ? ` (${event.durationMs}ms)` : "";
+    const line = `${CONSOLE_PREFIX} ${event.name}${suffix}`;
+    const payload = event.error ? { ...event.data, error: event.error.describe() } : event.data;
+    const method = event.level === "error" ? console.error : event.level === "warn" ? console.warn : event.level === "debug" ? console.debug : console.info;
+    method(line, payload ?? "");
+  }
+  forwardToPostHog(event) {
+    if (!this.config.posthog) return;
+    if (event.durationMs === void 0 && event.level !== "error") return;
+    try {
+      const client = getPostHogInstance();
+      capturePosthogEvent(client, `athena_sdk_${event.name.replace(/\./g, "_")}`, {
+        sdk_version: ATHENA_REACT_SDK_VERSION,
+        level: event.level,
+        ...event.durationMs !== void 0 && { duration_ms: event.durationMs },
+        ...event.error && {
+          error_code: event.error.code,
+          error_message: event.error.message,
+          error_status: event.error.status
+        },
+        ...event.data
+      });
+    } catch {
+    }
+  }
+}
+const athenaDiagnostics = new AthenaDiagnosticsBus();
+function installAthenaDiagnosticsGlobal() {
+  if (typeof window === "undefined") return;
+  const globalWindow = window;
+  const existing = globalWindow[GLOBAL_KEY] ?? {};
+  globalWindow[GLOBAL_KEY] = {
+    ...existing,
+    version: ATHENA_REACT_SDK_VERSION,
+    diagnostics: {
+      snapshot: () => athenaDiagnostics.snapshot(),
+      export: () => athenaDiagnostics.export(),
+      clear: () => athenaDiagnostics.clear(),
+      enableConsole: (level = "debug") => {
+        try {
+          localStorage.setItem(LOCAL_STORAGE_DEBUG_KEY, level);
+        } catch {
+        }
+        athenaDiagnostics.configure({ console: level });
+      },
+      disableConsole: () => {
+        try {
+          localStorage.removeItem(LOCAL_STORAGE_DEBUG_KEY);
+        } catch {
+        }
+        athenaDiagnostics.configure({ console: false });
+      }
+    }
+  };
+}
+function debugPropToDiagnosticsConfig(debug) {
+  if (debug === void 0) return {};
+  if (debug === true) return { console: "debug" };
+  if (debug === false) return { console: false };
+  if (typeof debug === "string") return { console: debug };
+  return debug;
+}
+function useAthenaDiagnostics() {
+  const snapshot = React.useSyncExternalStore(
+    athenaDiagnostics.subscribeSnapshot.bind(athenaDiagnostics),
+    athenaDiagnostics.snapshot.bind(athenaDiagnostics),
+    athenaDiagnostics.snapshot.bind(athenaDiagnostics)
+  );
+  const clear = React.useCallback(() => athenaDiagnostics.clear(), []);
+  const exportJson = React.useCallback(() => athenaDiagnostics.export(), []);
+  return { ...snapshot, clear, export: exportJson };
+}
+const DEEP_AGENT_RUNTIME_MARKER = "athena_deep_agent";
+const STATEWIRE_START_CHANNEL = "web";
+const STATEWIRE_RUN_LABEL = "Athena SDK";
+const DEFAULT_STATEWIRE_MODEL = "claude-sonnet-5";
+const COLLAB_AGENT_REF_PREFIX = "collab_agent:";
+function parseCollabAgentRef(agent2) {
+  if (typeof agent2 !== "string" || !agent2.startsWith(COLLAB_AGENT_REF_PREFIX)) return null;
+  const assetId = agent2.slice(COLLAB_AGENT_REF_PREFIX.length).trim();
+  return assetId || null;
+}
+function buildStatewireRunConfig(options = {}) {
+  var _a3, _b2, _c2, _d2, _e2;
+  const collabAgentId = parseCollabAgentRef(options.agent);
+  const collabChannelId = collabAgentId && ((_a3 = options.channel) == null ? void 0 : _a3.trim()) ? options.channel.trim() : void 0;
+  const model = options.model ?? (collabAgentId ? void 0 : DEFAULT_STATEWIRE_MODEL);
+  const panelModel = model ?? DEFAULT_STATEWIRE_MODEL;
+  const enabledTools = Array.from(
+    /* @__PURE__ */ new Set([...options.tools ?? [], ...options.frontendToolIds ?? []])
+  );
+  const systemPrompt = ((_b2 = options.systemPrompt) == null ? void 0 : _b2.trim()) ?? "";
+  return {
+    custom: {
+      runtime: DEEP_AGENT_RUNTIME_MARKER,
+      // With a collab channel selected, omit the SDK's own 'web' stamp: the
+      // request's explicit start_channel would win over the backend overlay's
+      // kind-mapped provenance (a custom SMS channel must stamp 'sms').
+      ...collabChannelId ? {} : { start_channel: STATEWIRE_START_CHANNEL },
+      ...model ? { model } : {},
+      // An empty list is behavior-identical to an absent key for the parser
+      // (both coerce to []), but the collab-agent overlay merges request keys
+      // OVER the agent definition — so an explicit empty list would erase the
+      // agent's configured tools. Omit it when empty.
+      ...enabledTools.length > 0 ? { enabled_tools: enabledTools } : {},
+      panel_config: {
+        model: panelModel,
+        enabled_tools: enabledTools,
+        system_prompt: systemPrompt,
+        run_label: STATEWIRE_RUN_LABEL
+      },
+      ...collabAgentId ? { collab_agent_id: collabAgentId } : {},
+      ...collabChannelId ? { collab_channel_id: collabChannelId } : {},
+      ...systemPrompt ? { system_prompt: systemPrompt } : {},
+      ...((_c2 = options.workbench) == null ? void 0 : _c2.length) ? { workbench: options.workbench } : {},
+      ...((_d2 = options.knowledgeBase) == null ? void 0 : _d2.length) ? { knowledge_base: options.knowledgeBase } : {},
+      ...options.customToolConfigs ? { custom_tool_configs: options.customToolConfigs } : {},
+      ...options.appId ? { app_id: options.appId } : {},
+      ...((_e2 = options.clientTools) == null ? void 0 : _e2.length) ? { client_tools: options.clientTools } : {},
+      ...options.extraRunConfig ?? {}
+    }
+  };
+}
 const ATHENA_ENVIRONMENT_URLS = {
   production: {
     apiUrl: "https://iris.prd.athenaintel.com/api/chat",
@@ -274,7 +1178,7 @@ const normalizeOrigin = (value) => {
     return null;
   }
 };
-const getTokenRefreshDelay = (expiresAt, nowMs) => {
+const getTokenRefreshDelay = (expiresAt, nowMs2) => {
   if (typeof expiresAt !== "string") {
     return DEFAULT_TOKEN_REFRESH_MS;
   }
@@ -282,7 +1186,7 @@ const getTokenRefreshDelay = (expiresAt, nowMs) => {
   if (!Number.isFinite(expiresAtMs)) {
     return DEFAULT_TOKEN_REFRESH_MS;
   }
-  return Math.max(TOKEN_REFRESH_RETRY_BASE_MS, expiresAtMs - nowMs - TOKEN_REFRESH_BUFFER_MS);
+  return Math.max(TOKEN_REFRESH_RETRY_BASE_MS, expiresAtMs - nowMs2 - TOKEN_REFRESH_BUFFER_MS);
 };
 const getAuthRetryDelay = (retryAttempt) => {
   const safeAttempt = Number.isFinite(retryAttempt) ? Math.max(0, Math.floor(retryAttempt)) : 0;
@@ -316,6 +1220,15 @@ function useParentBridge({
   const configReceived = React.useRef(false);
   React.useEffect(() => {
     if (!isInIframe) return;
+    const endBridgeSpan = athenaDiagnostics.span("auth.bridge", "auth.bridge.start", {
+      mode: "iframe"
+    });
+    let spanEnded = false;
+    const endOnce = (name, options) => {
+      if (spanEnded) return 0;
+      spanEnded = true;
+      return endBridgeSpan(name, options);
+    };
     const handler = (event) => {
       if (!isTrustedOrigin({ origin: event.origin, trustedOrigins: runtimeTrustedOrigins })) {
         return;
@@ -334,6 +1247,11 @@ function useParentBridge({
         }));
       }
       if (event.data.type === "athena-auth" && typeof event.data.token === "string") {
+        endOnce("auth.bridge.ready", { data: { mode: "iframe" } });
+        athenaDiagnostics.emit("auth.token.acquired", {
+          level: "debug",
+          data: { source: "iframe-postmessage" }
+        });
         setState((prev) => ({
           ...prev,
           token: event.data.token,
@@ -347,6 +1265,13 @@ function useParentBridge({
       readySignalSent.current = true;
     }
     const timer = setTimeout(() => {
+      endOnce("auth.bridge.timeout", {
+        data: {
+          mode: "iframe",
+          timeout_ms: BRIDGE_TIMEOUT_MS,
+          config_received: configReceived.current
+        }
+      });
       setState((prev) => prev.ready ? prev : { ...prev, ready: true });
     }, BRIDGE_TIMEOUT_MS);
     return () => {
@@ -399,9 +1324,20 @@ function useParentBridge({
     }) => {
       controller == null ? void 0 : controller.abort();
       controller = new AbortController();
+      const isInitial = markReadyOnFailure;
+      const rawEndSpan = isInitial ? athenaDiagnostics.span("auth.bridge", "auth.bridge.start", { mode: "marathon" }) : null;
+      let spanEnded = false;
+      const endBridgeSpan = rawEndSpan ? (name, options) => {
+        if (spanEnded) return 0;
+        spanEnded = true;
+        return rawEndSpan(name, options);
+      } : null;
       clearRequestTimer();
       requestTimer = setTimeout(() => {
         controller == null ? void 0 : controller.abort();
+        endBridgeSpan == null ? void 0 : endBridgeSpan("auth.bridge.timeout", {
+          data: { mode: "marathon", timeout_ms: BRIDGE_TIMEOUT_MS }
+        });
         if (markReadyOnFailure) {
           markReady();
         }
@@ -415,17 +1351,43 @@ function useParentBridge({
         if (cancelled) return;
         if (!resp.ok) {
           if (resp.status === 404) {
+            endBridgeSpan == null ? void 0 : endBridgeSpan("auth.bridge.absent", {
+              data: { mode: "marathon", status: resp.status }
+            });
             markReady();
-          } else if (markReadyOnFailure) {
-            markReady();
-            scheduleRetry();
           } else {
+            const failure = {
+              level: "warn",
+              data: { mode: "marathon", status: resp.status }
+            };
+            if (endBridgeSpan) {
+              endBridgeSpan("auth.bridge.error", failure);
+            } else {
+              athenaDiagnostics.emit("auth.token.refresh_failed", failure);
+            }
+            if (markReadyOnFailure) {
+              markReady();
+            }
             scheduleRetry();
           }
           return;
         }
         const data = await resp.json();
         if (cancelled) return;
+        if (endBridgeSpan) {
+          endBridgeSpan("auth.bridge.ready", {
+            data: { mode: "marathon", has_token: typeof data.token === "string" }
+          });
+          athenaDiagnostics.emit("auth.token.acquired", {
+            level: "debug",
+            data: { source: "marathon", expires_at: data.expires_at }
+          });
+        } else {
+          athenaDiagnostics.emit("auth.token.refreshed", {
+            level: "debug",
+            data: { source: "marathon", expires_at: data.expires_at }
+          });
+        }
         setState({
           token: typeof data.token === "string" ? data.token : null,
           apiUrl: typeof data.apiUrl === "string" ? data.apiUrl : null,
@@ -434,7 +1396,15 @@ function useParentBridge({
           ready: true
         });
         scheduleRefresh(data.expires_at);
-      } catch {
+      } catch (error2) {
+        if (!cancelled && !(error2 instanceof DOMException && error2.name === "AbortError")) {
+          const failure = { level: "warn", data: { mode: "marathon" }, error: error2 };
+          if (endBridgeSpan) {
+            endBridgeSpan("auth.bridge.error", failure);
+          } else {
+            athenaDiagnostics.emit("auth.token.refresh_failed", failure);
+          }
+        }
         if (markReadyOnFailure) {
           markReady();
         }
@@ -9880,24 +10850,42 @@ function getAthenaApiBaseUrl(backendUrl) {
   return stripped;
 }
 async function listThreads(backendUrl, auth, opts = {}) {
+  var _a3;
   const base2 = getAthenaApiBaseUrl(backendUrl);
-  const res = await fetch(`${base2}/api/conversations/threads/list`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json", ...getAuthHeaders(auth) },
-    body: JSON.stringify({
-      limit: opts.limit ?? 50,
-      offset: opts.offset ?? 0,
-      // Default to the full recent-conversations set unless a caller
-      // explicitly asks to hide triggered/background sessions.
-      exclude_triggered: opts.exclude_triggered ?? false,
-      ...opts.app_id ? { app_id: opts.app_id } : {},
-      ...opts.start_channel ? { start_channel: opts.start_channel } : {}
-    })
+  const endSpan = athenaDiagnostics.span("threads.list", "threads.list.start", {
+    auth_mode: getAuthMode(auth),
+    app_id: opts.app_id
   });
-  if (!res.ok) {
-    throw new Error(`[AthenaSDK] Failed to list threads: ${res.status}`);
+  try {
+    const res = await fetch(`${base2}/api/conversations/threads/list`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...getAuthHeaders(auth) },
+      body: JSON.stringify({
+        limit: opts.limit ?? 50,
+        offset: opts.offset ?? 0,
+        // Default to the full recent-conversations set unless a caller
+        // explicitly asks to hide triggered/background sessions.
+        exclude_triggered: opts.exclude_triggered ?? false,
+        ...opts.app_id ? { app_id: opts.app_id } : {},
+        ...opts.start_channel ? { start_channel: opts.start_channel } : {}
+      })
+    });
+    if (!res.ok) {
+      throw new AthenaSdkError({
+        code: res.status === 401 || res.status === 403 ? "auth_rejected" : "threads_list_failed",
+        message: `Failed to list threads: ${res.status}`,
+        status: res.status,
+        hint: res.status === 401 || res.status === 403 ? "The credential was refused. Check the token/API key and that the user belongs to the workspace." : "Check backendUrl points at the Agora API base.",
+        context: { auth_mode: getAuthMode(auth) }
+      });
+    }
+    const data = await res.json();
+    endSpan("threads.list.done", { data: { count: ((_a3 = data.threads) == null ? void 0 : _a3.length) ?? 0 } });
+    return data;
+  } catch (error2) {
+    endSpan("threads.list.error", { error: error2 });
+    throw error2;
   }
-  return res.json();
 }
 async function setThreadReadState(backendUrl, auth, opts) {
   const base2 = getAthenaApiBaseUrl(backendUrl);
@@ -9958,31 +10946,49 @@ function getResponseErrorBody(response) {
   return response.text().catch(() => "");
 }
 async function getThreadState(backendUrl, auth, threadId) {
+  var _a3, _b2, _c2, _d2;
   const base2 = getAthenaApiBaseUrl(backendUrl);
   const authMode = getAuthMode(auth);
   const endpoint = `${base2}/api/conversations/threads/get`;
-  console.info("[AthenaSDK] Loading thread state from conversations API:", {
-    threadId,
-    endpoint,
-    authMode,
-    hasToken: Boolean(auth.token),
-    hasApiKey: Boolean(auth.apiKey)
-  });
-  const res = await fetch(endpoint, {
-    method: "POST",
-    headers: { "Content-Type": "application/json", ...getAuthHeaders(auth) },
-    body: JSON.stringify({
-      thread_id: threadId,
-      skip_cache: true
-    })
+  const endSpan = athenaDiagnostics.span("threads.history", "threads.history.start", {
+    thread_id: threadId,
+    auth_mode: authMode
   });
+  let res;
+  try {
+    res = await fetch(endpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...getAuthHeaders(auth) },
+      body: JSON.stringify({
+        thread_id: threadId,
+        skip_cache: true
+      })
+    });
+  } catch (error2) {
+    endSpan("threads.history.error", { error: error2, data: { thread_id: threadId } });
+    throw error2;
+  }
   if (!res.ok) {
     const body = await getResponseErrorBody(res);
-    throw new Error(
-      `[AthenaSDK] Failed to get thread state: ${res.status} (${authMode})${body ? `: ${body.slice(0, 300)}` : ""}`
-    );
+    const error2 = new AthenaSdkError({
+      code: res.status === 401 || res.status === 403 ? "auth_rejected" : "thread_load_failed",
+      message: `Failed to get thread state: ${res.status} (${authMode})${body ? `: ${body.slice(0, 300)}` : ""}`,
+      status: res.status,
+      hint: "A brand-new thread may not be persisted yet; anything else means the credential or backendUrl is wrong.",
+      context: { thread_id: threadId, auth_mode: authMode }
+    });
+    endSpan("threads.history.error", { error: error2, data: { thread_id: threadId } });
+    throw error2;
   }
   const data = await res.json();
+  const channelMessages = (_b2 = (_a3 = data.thread) == null ? void 0 : _a3.channel_values) == null ? void 0 : _b2.messages;
+  endSpan("threads.history.done", {
+    data: {
+      thread_id: threadId,
+      found: data.thread_found !== false,
+      message_count: Array.isArray(channelMessages) ? channelMessages.length : ((_d2 = (_c2 = data.thread) == null ? void 0 : _c2.messages) == null ? void 0 : _d2.length) ?? 0
+    }
+  });
   const thread = data.thread;
   if (data.thread_found === false || !thread) {
     return {
@@ -10264,17 +11270,35 @@ const useAthenaRuntime = (config2) => {
       };
     },
     onResponse: () => {
+      athenaDiagnostics.emit("stream.connected", {
+        level: "debug",
+        data: { transport: "legacy", thread_id: threadIdRef.current }
+      });
       if (IS_DEV) {
         console.log("[AthenaSDK] Stream connected");
       }
     },
     onFinish: () => {
+      athenaDiagnostics.emit("run.done", {
+        level: "debug",
+        data: { transport: "legacy", thread_id: threadIdRef.current }
+      });
       if (IS_DEV) {
         console.log("[AthenaSDK] Stream completed");
       }
     },
     onError: (error2, { commands: commands2, updateState }) => {
       var _a3;
+      athenaDiagnostics.error(
+        "stream.error",
+        error2,
+        {
+          code: /\b401\b|unauthori[sz]ed/i.test(error2.message) ? "auth_rejected" : "stream_failed",
+          message: error2.message || "The chat stream failed",
+          hint: "Check the Iris apiUrl and the credential; the raw error is in `cause`."
+        },
+        { transport: "legacy", thread_id: threadIdRef.current }
+      );
       const pendingCommands = commandsToMessages(commands2);
       const isInvalidStringLength = error2 instanceof RangeError && /Invalid string length/i.test(error2.message);
       const userErrorMessage = isInvalidStringLength ? "The response was too large to process. Try reducing the amount of content in a single request or starting a new chat." : error2.message;
@@ -10396,33 +11420,21 @@ const useAthenaRuntime = (config2) => {
     if (isExistingThread && !hasResumedRef.current) {
       hasResumedRef.current = true;
       (async () => {
-        var _a3, _b2;
+        var _a3;
         const currentToken = getTokenRef.current ? await getTokenRef.current() ?? tokenRef.current : tokenRef.current;
         const auth = { apiKey: apiKeyRef.current, token: currentToken };
-        console.log("[AthenaSDK] Loading existing thread state:", {
-          threadId,
-          backendUrl
-        });
         try {
           const state = await getThreadState(backendUrl, auth, threadId);
-          const messageCount = ((_a3 = state == null ? void 0 : state.messages) == null ? void 0 : _a3.length) ?? 0;
-          console.log("[AthenaSDK] Got thread state:", {
-            threadId,
-            messageCount,
-            hasMessages: messageCount > 0
-          });
           runtime.thread.importExternalState({
             ...state
           });
-          console.log(
-            "[AthenaSDK] importExternalState completed, runtime messages:",
-            runtime.thread.getState().messages.length
-          );
         } catch (err) {
-          console.warn(
-            "[AthenaSDK] Failed to load thread state (may be a new streaming thread):",
-            err
-          );
+          if (IS_DEV) {
+            console.warn(
+              "[AthenaSDK] Failed to load thread state (may be a new streaming thread):",
+              err
+            );
+          }
         }
         try {
           const statusRes = await fetch(resolvedStatusApiUrl, {
@@ -10434,7 +11446,7 @@ const useAthenaRuntime = (config2) => {
             const status = await statusRes.json();
             if (status.isRunning) {
               try {
-                const lastMessageId = ((_b2 = runtime.thread.getState().messages.at(-1)) == null ? void 0 : _b2.id) ?? null;
+                const lastMessageId = ((_a3 = runtime.thread.getState().messages.at(-1)) == null ? void 0 : _a3.id) ?? null;
                 runtime.thread.resumeRun({ parentId: lastMessageId });
               } catch (resumeErr) {
                 if (IS_DEV) {
@@ -10582,6 +11594,7 @@ function projectDeepAgentConnection(connection) {
     return {
       status: connection.status,
       cause: connection.cause,
+      attempt: connection.attempt,
       ...message !== void 0 && { message }
     };
   }
@@ -10757,6 +11770,22 @@ function liftAopSourceIntoMetadata(message) {
     }
   };
 }
+function liftBranchIntoMetadata(message) {
+  if (message.type !== "human" && message.type !== "ai") return message;
+  const branch = message.branch;
+  if (typeof branch !== "object" || branch === null || Array.isArray(branch)) return message;
+  const kwargs = message.additional_kwargs;
+  const existingMetadata = kwargs == null ? void 0 : kwargs.metadata;
+  const metadata = typeof existingMetadata === "object" && existingMetadata !== null ? existingMetadata : {};
+  if (typeof metadata.branch === "object" && metadata.branch !== null) return message;
+  return {
+    ...message,
+    additional_kwargs: {
+      ...kwargs,
+      metadata: { ...metadata, branch }
+    }
+  };
+}
 const TOOL_MESSAGE_INTERNAL_KWARGS = /* @__PURE__ */ new Set([
   "reasoning",
   "tool_outputs",
@@ -10809,11 +11838,13 @@ function isConvertibleChatMessage(message) {
 }
 function sanitizeLangChainMessages(messages) {
   return messages.filter((message) => isConvertibleChatMessage(message) && !isMessageHiddenFromFrontend(message)).map(
-    (message) => liftToolMessageMetadataIntoArtifact(
-      liftAopSourceIntoMetadata(
-        liftCompactionBoundaryIntoMetadata(
-          liftConversationStatsIntoMetadata(
-            liftModelIntoMetadata(liftRunMarkerIntoMetadata(message))
+    (message) => liftBranchIntoMetadata(
+      liftToolMessageMetadataIntoArtifact(
+        liftAopSourceIntoMetadata(
+          liftCompactionBoundaryIntoMetadata(
+            liftConversationStatsIntoMetadata(
+              liftModelIntoMetadata(liftRunMarkerIntoMetadata(message))
+            )
           )
         )
       )
@@ -10846,14 +11877,15 @@ function registerDeepAgentRunConfig(aui, getRunConfig) {
     })
   });
 }
-function deepAgentThreadStatus(state) {
-  var _a3;
-  const runs = state == null ? void 0 : state.runs;
-  if (runs === void 0) return "loading";
-  return ((_a3 = runs[0]) == null ? void 0 : _a3.status) ?? "ready";
-}
 function useDeepAgentThreadStatus() {
-  return reactStatewire.useStatewireState(deepAgentThreadStatus);
+  return store.useAuiState((s) => {
+    var _a3;
+    const status = (_a3 = s.thread.extras) == null ? void 0 : _a3.status;
+    if (status === void 0) {
+      throw new Error("useDeepAgentThreadStatus requires a statewire thread");
+    }
+    return status;
+  });
 }
 function shouldNotifyRunningChange(previous, next) {
   if (previous === null) return next.isRunning;
@@ -11074,7 +12106,7 @@ function useDeepAgentThread({
       }
       const connection = projectDeepAgentConnection(meta.connection);
       const previous = lastConnectionRef.current;
-      if ((previous == null ? void 0 : previous.threadId) !== attachId || previous.connection.status !== connection.status || previous.connection.cause !== connection.cause || previous.connection.message !== connection.message) {
+      if ((previous == null ? void 0 : previous.threadId) !== attachId || previous.connection.status !== connection.status || previous.connection.cause !== connection.cause || previous.connection.message !== connection.message || previous.connection.attempt !== connection.attempt) {
         const update = { threadId: attachId, connection };
         lastConnectionRef.current = update;
         queueMicrotask(() => {
@@ -11146,46 +12178,30 @@ function toJSONSchema(schema2) {
   if (isStandardSchema(schema2)) throw new Error("Could not convert schema to JSON Schema. The schema implements Standard Schema but does not support JSON Schema conversion. If you are using Zod, please upgrade to Zod v4 (npm install zod@latest). Alternatively, pass a plain JSON Schema object instead.");
   return schema2;
 }
-function defaultToolFilter(_name, tool) {
-  return !tool.disabled && tool.type !== "backend" && (tool.type !== "frontend" || tool.execute !== void 0);
-}
-function toolHasUploadableParameters(tool) {
-  var _a3;
-  return tool.parameters !== void 0 && !((_a3 = tool.unstable_backendDefault) == null ? void 0 : _a3.parameters);
-}
-function toToolsJSONSchema(tools, options = {}) {
-  if (!tools) return {};
-  const filter = options.filter ?? defaultToolFilter;
-  return Object.fromEntries(Object.entries(tools).filter(([name, tool]) => filter(name, tool)).filter((entry) => toolHasUploadableParameters(entry[1])).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([name, tool]) => [name, {
-    ...tool.description && { description: tool.description },
-    parameters: toJSONSchema(tool.parameters),
-    ...tool.providerOptions && { providerOptions: tool.providerOptions }
-  }]));
-}
 function hasCallableExecute(entry) {
   return !!entry && typeof entry === "object" && typeof entry.execute === "function";
 }
 function collectStatewireClientTools(toolkit) {
   const executable = Object.entries(toolkit).filter(([, entry]) => hasCallableExecute(entry));
   if (executable.length === 0) return [];
-  let schemas;
-  try {
-    schemas = toToolsJSONSchema(toolkit, {
-      filter: (name) => executable.some(([toolName]) => toolName === name)
-    });
-  } catch (error2) {
-    console.warn("[AthenaSDK] failed to convert frontend tool schemas for statewire:", error2);
-    return [];
-  }
   return executable.flatMap(([name, entry]) => {
-    const schema2 = schemas[name];
-    if (!schema2) return [];
+    if (entry.parameters === void 0) return [];
+    let parameters;
+    try {
+      parameters = toJSONSchema(entry.parameters);
+    } catch (error2) {
+      console.warn(
+        `[AthenaSDK] failed to convert frontend tool schema for statewire (${name}):`,
+        error2
+      );
+      return [];
+    }
     const execute = entry.execute;
     return [
       {
         name,
-        description: schema2.description,
-        parameters: schema2.parameters ?? { type: "object" },
+        description: entry.description,
+        parameters,
         handler: async (args, { toolCallId }) => {
           const controller = new AbortController();
           const output = await execute(args, {
@@ -11209,39 +12225,6 @@ function statewireClientToolWireEntries(tools) {
     requires_write: false
   }));
 }
-const DEEP_AGENT_RUNTIME_MARKER = "athena_deep_agent";
-const STATEWIRE_START_CHANNEL = "web";
-const STATEWIRE_RUN_LABEL = "Athena SDK";
-const DEFAULT_STATEWIRE_MODEL = "claude-sonnet-5";
-function buildStatewireRunConfig(options = {}) {
-  var _a3, _b2, _c2, _d2;
-  const model = options.model ?? DEFAULT_STATEWIRE_MODEL;
-  const enabledTools = Array.from(
-    /* @__PURE__ */ new Set([...options.tools ?? [], ...options.frontendToolIds ?? []])
-  );
-  const systemPrompt = ((_a3 = options.systemPrompt) == null ? void 0 : _a3.trim()) ?? "";
-  return {
-    custom: {
-      runtime: DEEP_AGENT_RUNTIME_MARKER,
-      start_channel: STATEWIRE_START_CHANNEL,
-      model,
-      enabled_tools: enabledTools,
-      panel_config: {
-        model,
-        enabled_tools: enabledTools,
-        system_prompt: systemPrompt,
-        run_label: STATEWIRE_RUN_LABEL
-      },
-      ...systemPrompt ? { system_prompt: systemPrompt } : {},
-      ...((_b2 = options.workbench) == null ? void 0 : _b2.length) ? { workbench: options.workbench } : {},
-      ...((_c2 = options.knowledgeBase) == null ? void 0 : _c2.length) ? { knowledge_base: options.knowledgeBase } : {},
-      ...options.customToolConfigs ? { custom_tool_configs: options.customToolConfigs } : {},
-      ...options.appId ? { app_id: options.appId } : {},
-      ...((_d2 = options.clientTools) == null ? void 0 : _d2.length) ? { client_tools: options.clientTools } : {},
-      ...options.extraRunConfig ?? {}
-    }
-  };
-}
 const EMPTY_TOOLKIT = {};
 const EMPTY_TOOL_IDS = [];
 function useStatewireClientTools(frontendToolkit) {
@@ -11259,6 +12242,8 @@ function useAthenaStatewireRuntime(config2) {
     token,
     getToken,
     model,
+    agent: agent2,
+    channel,
     tools = EMPTY_TOOL_IDS,
     frontendToolIds = EMPTY_TOOL_IDS,
     frontendToolkit = EMPTY_TOOLKIT,
@@ -11286,6 +12271,28 @@ function useAthenaStatewireRuntime(config2) {
   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", {
+        level: "warn",
+        data: {
+          prop: "agent",
+          value: agent2,
+          reason: "the statewire transport always runs the Athena deep agent; only 'collab_agent:<asset_id>' refs apply. Use transport='legacy' for named agents."
+        }
+      });
+    }
+  }, [agent2]);
+  const attachSpanRef = React.useRef(null);
+  const attachThreadRef = React.useRef(null);
+  if (attachThreadRef.current !== threadId) {
+    attachThreadRef.current = threadId;
+    attachSpanRef.current = athenaDiagnostics.span(
+      `statewire.attach:${threadId}`,
+      "statewire.attach.start",
+      { thread_id: threadId, is_new_chat: isNewChat }
+    );
+  }
   const thread = useDeepAgentThread({
     threadId,
     baseUrl: syncUrl,
@@ -11315,11 +12322,47 @@ function useAthenaStatewireRuntime(config2) {
       }
     },
     capabilities: { edit: true, reload: true, continue: true },
-    onConnectionChange,
+    onStateChange: () => {
+      const endSpan = attachSpanRef.current;
+      if (endSpan) {
+        attachSpanRef.current = null;
+        endSpan("statewire.snapshot", { data: { thread_id: threadId } });
+      }
+    },
+    onConnectionChange: (connection) => {
+      athenaDiagnostics.gauge("statewire.connection", (connection == null ? void 0 : connection.status) ?? null);
+      if ((connection == null ? void 0 : connection.status) === "gone") {
+        athenaDiagnostics.emit("statewire.connection", {
+          level: "warn",
+          data: { status: connection.status, message: connection.message }
+        });
+      }
+      onConnectionChange == null ? void 0 : onConnectionChange(connection);
+    },
     onRawConnectionChange,
-    onLegacyReadOnly,
+    onLegacyReadOnly: (legacyReadOnly) => {
+      if (legacyReadOnly) {
+        athenaDiagnostics.emit("statewire.read_only", {
+          level: "warn",
+          data: { thread_id: threadId }
+        });
+      }
+      onLegacyReadOnly == null ? void 0 : onLegacyReadOnly(legacyReadOnly);
+    },
     onRunningChange,
     onError: (error2) => {
+      if (!isStatewireChannelTeardown(error2)) {
+        athenaDiagnostics.error(
+          "statewire.error",
+          error2,
+          {
+            code: "statewire_rejected",
+            message: "The statewire host rejected a command",
+            hint: "Inspect error.detail — agora rejections carry a structured {code, message}."
+          },
+          { thread_id: threadId }
+        );
+      }
       if (onErrorRef.current) {
         onErrorRef.current(error2);
         return;
@@ -11335,6 +12378,8 @@ function useAthenaStatewireRuntime(config2) {
   const aui = react$1.useAui({ thread, tools: auiTools });
   const runConfigInputsRef = React.useRef({
     model,
+    agent: agent2,
+    channel,
     tools,
     frontendToolIds,
     workbench,
@@ -11346,6 +12391,8 @@ function useAthenaStatewireRuntime(config2) {
   });
   runConfigInputsRef.current = {
     model,
+    agent: agent2,
+    channel,
     tools,
     frontendToolIds,
     workbench,
@@ -11393,7 +12440,9 @@ function athenaStatewireErrorNotice(error2) {
   return {
     kind: "command",
     title: "Message was not sent",
-    message: error2 instanceof Error && error2.message.length > 0 ? error2.message : "The chat runtime rejected the command. Please try again."
+    // The server's own detail names the actionable reason; the Error message is
+    // generic client-side text like `command rejected (500)`.
+    message: readDetailMessage(rejection == null ? void 0 : rejection.detail) ?? (error2 instanceof Error && error2.message.length > 0 ? error2.message : "The chat runtime rejected the command. Please try again.")
   };
 }
 const AthenaStatewireLifecycleContext = React.createContext(null);
@@ -11421,6 +12470,20 @@ function StatewireClientToolBridge({
   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(
@@ -11431,8 +12494,8 @@ function StatewireClientToolBridge({
       const registry2 = new Map(toolsRef.current.map((tool) => [tool.name, tool]));
       const results = {};
       for (const call of calls) {
-        if (!liveRequestIdsRef.current.has(request.id)) {
-          clientToolRequests.release(requestKey(threadId, request.id));
+        if (!activeRef.current || !liveRequestIdsRef.current.has(request.id)) {
+          releaseClaim(requestKey(threadId, request.id));
           return;
         }
         const tool = registry2.get(call.tool_name);
@@ -11454,8 +12517,8 @@ function StatewireClientToolBridge({
           results[call.interrupt_id] = clientToolErrorEnvelope(error2);
         }
       }
-      if (!liveRequestIdsRef.current.has(request.id)) {
-        clientToolRequests.release(requestKey(threadId, request.id));
+      if (!activeRef.current || !liveRequestIdsRef.current.has(request.id)) {
+        releaseClaim(requestKey(threadId, request.id));
         return;
       }
       try {
@@ -11465,16 +12528,19 @@ function StatewireClientToolBridge({
           requestId: request.id,
           response: { type: "resume", value: wireValue }
         });
+        ownedClaimsRef.current.delete(requestKey(threadId, request.id));
       } catch (error2) {
-        clientToolRequests.release(requestKey(threadId, request.id));
+        releaseClaim(requestKey(threadId, request.id));
         console.error("[AthenaSDK] failed to resume client tool results:", error2);
       }
     },
-    [sendCommand, threadId]
+    [releaseClaim, sendCommand, threadId]
   );
   React.useEffect(() => {
     if (!pendingRequest) return;
-    if (!clientToolRequests.claim(requestKey(threadId, pendingRequest.id))) return;
+    const claim = requestKey(threadId, pendingRequest.id);
+    if (!clientToolRequests.claim(claim)) return;
+    ownedClaimsRef.current.add(claim);
     void executeRequest(pendingRequest);
   }, [executeRequest, pendingRequest, threadId]);
   return null;
@@ -11489,6 +12555,9 @@ function resolveAthenaTransport({
 }) {
   return { transport: transport ?? DEFAULT_ATHENA_TRANSPORT, fallbackReason: null };
 }
+function allowsMidRunSend(transport) {
+  return transport === ATHENA_TRANSPORTS.statewire;
+}
 var __defProp$i = Object.defineProperty;
 var __name$h = (target, value) => __defProp$i(target, "name", { value, configurable: true });
 function setRef$1(ref, value) {
@@ -15892,11 +16961,11 @@ const pickNumber = (...candidates) => {
   return void 0;
 };
 const autoOpen = (assetId, options = {}) => {
-  const store = useAssetPanelStore.getState();
-  if (!store.markAutoOpened(assetId)) return;
-  const existing = store.tabs.find((tab) => tab.id === assetId);
+  const store2 = useAssetPanelStore.getState();
+  if (!store2.markAutoOpened(assetId)) return;
+  const existing = store2.tabs.find((tab) => tab.id === assetId);
   const keepCurrentSlide = options.preserveExistingSlide && existing;
-  store.openAsset(assetId, {
+  store2.openAsset(assetId, {
     type: options.type ?? "unknown",
     ...keepCurrentSlide || options.slideNumber === void 0 ? {} : { slideNumber: options.slideNumber }
   });
@@ -18824,16 +19893,19 @@ function StatewireThreadListState({
   initialThreadId,
   children
 }) {
+  var _a3;
   const [active, setActive] = React.useState(
     () => initialThreadId ? { id: initialThreadId, isNew: false } : { id: mintThreadId(), isNew: true }
   );
   const tokenRef = React.useRef(token);
   tokenRef.current = token;
+  const authContext = React.useContext(AthenaAuthContext.AthenaAuthContext);
+  const principal = ((_a3 = authContext == null ? void 0 : authContext.user) == null ? void 0 : _a3.userId) ?? "";
   const hasAuth = !!(apiKey || token);
   const { data, isLoading, refetch } = useQuery({
-    // Keyed on the user identity surface, not the raw token — token rotation
-    // for the same session must not refetch the whole list.
-    queryKey: [THREADS_QUERY_KEY, backendUrl, appId ?? "", apiKey ?? "", hasAuth],
+    queryKey: [THREADS_QUERY_KEY, backendUrl, appId ?? "", principal, hasAuth],
+    // Never serve another principal's list while the new one loads.
+    placeholderData: void 0,
     queryFn: async () => {
       const { threads } = await listThreads(
         backendUrl,
@@ -18851,6 +19923,7 @@ function StatewireThreadListState({
     void refetch();
   }, [refetch]);
   const selectThread = React.useCallback((threadId) => {
+    if (!threadId) return;
     setActive(
       (current) => current.id === threadId ? current : { id: threadId, isNew: false }
     );
@@ -18858,6 +19931,12 @@ function StatewireThreadListState({
   const newThread = React.useCallback(() => {
     setActive({ id: mintThreadId(), isNew: true });
   }, []);
+  const isPersisted = !!(data == null ? void 0 : data.some((thread) => thread.id === active.id));
+  React.useEffect(() => {
+    if (isPersisted) {
+      setActive((current) => current.isNew ? { ...current, isNew: false } : current);
+    }
+  }, [isPersisted]);
   const value = React.useMemo(
     () => ({
       threads: data ?? [],
@@ -19027,8 +20106,6 @@ function useAthenaThreadManager() {
   const statewireManager = React.useMemo(() => {
     if (!statewireList) return null;
     return {
-      // A never-started local chat stays out of the URL, mirroring the
-      // legacy manager's local-placeholder handling.
       activeThreadId: statewireList.isNewChat ? null : statewireList.activeThreadId,
       isListLoading: statewireList.isLoading,
       isThreadLoading: statewireIsThreadLoading,
@@ -19310,452 +20387,6 @@ const themes = {
     radius: "0.625rem"
   }
 };
-const DEFAULT_CAPTURE_GATE_CONFIG = {
-  globalMaxPerWindow: 50,
-  globalWindowMs: 1e4,
-  criticalReservePerWindow: 15,
-  defaultEventMaxPerWindow: 12,
-  defaultEventWindowMs: 6e4,
-  defaultDedupeWindowMs: 5e3,
-  flushIntervalMs: 3e4,
-  flushCoalesceThreshold: 20,
-  eventOverrides: {
-    memory_profile_sample: { maxPerWindow: 2, windowMs: 3e4, dedupeWindowMs: 15e3 },
-    long_task_detected: { maxPerWindow: 3, windowMs: 6e4, dedupeWindowMs: 1e4 },
-    collab_connection_status_changed: { maxPerWindow: 6, windowMs: 6e4 },
-    collab_first_remote_update: { maxPerWindow: 3, windowMs: 6e4 },
-    collab_first_local_update: { maxPerWindow: 3, windowMs: 6e4 },
-    collab_render_time_sync_fix: { maxPerWindow: 3, windowMs: 6e4 },
-    collab_visibility_recovery: { maxPerWindow: 4, windowMs: 6e4 },
-    langgraph_message_validation_error: {
-      maxPerWindow: 8,
-      windowMs: 6e4,
-      dedupeWindowMs: 15e3
-    },
-    langgraph_messages_validation_error: {
-      maxPerWindow: 5,
-      windowMs: 6e4,
-      dedupeWindowMs: 15e3
-    },
-    langgraph_interrupt_validation_error: {
-      maxPerWindow: 5,
-      windowMs: 6e4,
-      dedupeWindowMs: 15e3
-    },
-    langgraph_state_validation_error: {
-      maxPerWindow: 5,
-      windowMs: 6e4,
-      dedupeWindowMs: 15e3
-    },
-    graphql_error: { maxPerWindow: 12, windowMs: 6e4, dedupeWindowMs: 1e4 },
-    chat_error: { maxPerWindow: 8, windowMs: 6e4, dedupeWindowMs: 5e3 },
-    memory_critical_threshold: { maxPerWindow: 3, windowMs: 3e5 },
-    memory_warning_threshold: { maxPerWindow: 3, windowMs: 3e5 },
-    pptx_slide_changed: { maxPerWindow: 8, windowMs: 3e4 }
-  }
-};
-const CRITICAL_EVENT_PATTERNS = [
-  /(?:^|_)failed$/,
-  /(?:^|_)error(?:_|$)/,
-  /crash/,
-  /^oom_/,
-  /aw_snap/,
-  /chunk_load/,
-  /global_error/,
-  /\$exception$/,
-  /^404_error$/,
-  /^500_error$/,
-  /_boundary_/
-];
-const BYPASS_OPTION_KEY = "__posthog_gate_bypass";
-function isCriticalPosthogEvent(event) {
-  return CRITICAL_EVENT_PATTERNS.some((pattern) => pattern.test(event));
-}
-function shouldBypassCaptureGate(options) {
-  if (!options || typeof options !== "object") return false;
-  return options[BYPASS_OPTION_KEY] === true;
-}
-function withCaptureGateBypass(options) {
-  return {
-    ...options ?? {},
-    [BYPASS_OPTION_KEY]: true
-  };
-}
-function pruneWindow(window2, now, windowMs) {
-  const cutoff = now - windowMs;
-  while (window2.timestamps.length > 0 && window2.timestamps[0] < cutoff) {
-    window2.timestamps.shift();
-  }
-}
-function countInWindow(window2, now, windowMs) {
-  pruneWindow(window2, now, windowMs);
-  return window2.timestamps.length;
-}
-function recordInWindow(window2, now) {
-  window2.timestamps.push(now);
-}
-function stableStringify(value) {
-  if (value == null) return String(value);
-  if (typeof value !== "object") return String(value);
-  if (Array.isArray(value)) {
-    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
-  }
-  const record2 = value;
-  const keys2 = Object.keys(record2).sort();
-  return `{${keys2.map((key) => `${key}:${stableStringify(record2[key])}`).join(",")}}`;
-}
-function fingerprintProperties(properties) {
-  if (!properties) return "";
-  const keys2 = [
-    "error",
-    "error_message",
-    "message",
-    "reason",
-    "status",
-    "code",
-    "asset_id",
-    "doc_id",
-    "thread_id",
-    "session_id",
-    "operation",
-    "path",
-    "url",
-    "chunk_identifier",
-    "validation_path"
-  ];
-  const subset = {};
-  for (const key of keys2) {
-    if (key in properties) {
-      subset[key] = properties[key];
-    }
-  }
-  return stableStringify(subset);
-}
-function buildCaptureFingerprint(event, properties) {
-  return `${event}|${fingerprintProperties(properties)}`;
-}
-function buildCoalescedCaptureProperties(payload) {
-  const windowMs = payload.lastAt - payload.firstAt;
-  return {
-    ...payload.properties,
-    coalesced: true,
-    coalesced_count: payload.coalescedCount,
-    coalesced_first_at: new Date(payload.firstAt).toISOString(),
-    coalesced_last_at: new Date(payload.lastAt).toISOString(),
-    coalesced_window_ms: windowMs,
-    coalesced_suppression_reason: payload.suppressionReason
-  };
-}
-class PosthogCaptureGate {
-  constructor(config2 = DEFAULT_CAPTURE_GATE_CONFIG) {
-    __publicField(this, "config");
-    __publicField(this, "globalWindow", { timestamps: [] });
-    __publicField(this, "eventWindows", /* @__PURE__ */ new Map());
-    __publicField(this, "activeDedupe", /* @__PURE__ */ new Map());
-    __publicField(this, "coalesceBuckets", /* @__PURE__ */ new Map());
-    __publicField(this, "emittedTotal", 0);
-    __publicField(this, "coalescedTotal", 0);
-    __publicField(this, "flushedCoalescedTotal", 0);
-    this.config = config2;
-  }
-  resetForTests() {
-    this.globalWindow.timestamps.length = 0;
-    this.eventWindows.clear();
-    this.activeDedupe.clear();
-    this.coalesceBuckets.clear();
-    this.emittedTotal = 0;
-    this.coalescedTotal = 0;
-    this.flushedCoalescedTotal = 0;
-  }
-  getSnapshot() {
-    const coalescedPendingByEvent = {};
-    let coalescedPending = 0;
-    for (const bucket of this.coalesceBuckets.values()) {
-      coalescedPending += bucket.count;
-      coalescedPendingByEvent[bucket.event] = (coalescedPendingByEvent[bucket.event] ?? 0) + bucket.count;
-    }
-    return {
-      coalescedPending,
-      coalescedPendingByEvent,
-      emittedTotal: this.emittedTotal,
-      coalescedTotal: this.coalescedTotal,
-      flushedCoalescedTotal: this.flushedCoalescedTotal
-    };
-  }
-  evaluateCapture(event, properties, options, now = Date.now()) {
-    if (shouldBypassCaptureGate(options)) {
-      return { action: "emit" };
-    }
-    const fingerprint = buildCaptureFingerprint(event, properties);
-    const bucketKey = fingerprint;
-    const override = this.config.eventOverrides[event];
-    const dedupeWindowMs = (override == null ? void 0 : override.dedupeWindowMs) ?? this.config.defaultDedupeWindowMs;
-    const lastDedupe = this.activeDedupe.get(event);
-    if (lastDedupe && lastDedupe.fingerprint === fingerprint && now - lastDedupe.at < dedupeWindowMs) {
-      return this.recordCoalesce(event, bucketKey, fingerprint, properties, "dedupe", now);
-    }
-    const critical = isCriticalPosthogEvent(event);
-    const globalCount = countInWindow(this.globalWindow, now, this.config.globalWindowMs);
-    const normalBudget = Math.max(
-      0,
-      this.config.globalMaxPerWindow - this.config.criticalReservePerWindow
-    );
-    if (critical) {
-      if (globalCount >= this.config.globalMaxPerWindow) {
-        return this.recordCoalesce(event, bucketKey, fingerprint, properties, "global_budget", now);
-      }
-    } else if (globalCount >= normalBudget) {
-      return this.recordCoalesce(event, bucketKey, fingerprint, properties, "global_budget", now);
-    }
-    const eventWindow = this.eventWindows.get(event) ?? { timestamps: [] };
-    this.eventWindows.set(event, eventWindow);
-    const eventMax = (override == null ? void 0 : override.maxPerWindow) ?? this.config.defaultEventMaxPerWindow;
-    const eventWindowMs = (override == null ? void 0 : override.windowMs) ?? this.config.defaultEventWindowMs;
-    const eventCount = countInWindow(eventWindow, now, eventWindowMs);
-    if (eventCount >= eventMax) {
-      return this.recordCoalesce(event, bucketKey, fingerprint, properties, "event_budget", now);
-    }
-    recordInWindow(this.globalWindow, now);
-    recordInWindow(eventWindow, now);
-    this.activeDedupe.set(event, { fingerprint, bucketKey, at: now });
-    this.emittedTotal += 1;
-    return { action: "emit" };
-  }
-  /** Returns payloads ready to flush (does not mutate buckets until caller confirms). */
-  collectFlushCandidates(now = Date.now()) {
-    const payloads = [];
-    for (const bucket of this.coalesceBuckets.values()) {
-      const shouldFlushBySize = bucket.count >= this.config.flushCoalesceThreshold;
-      const shouldFlushByAge = now - bucket.firstAt >= this.config.flushIntervalMs;
-      if (!shouldFlushBySize && !shouldFlushByAge) {
-        continue;
-      }
-      payloads.push({
-        bucketKey: bucket.bucketKey,
-        event: bucket.event,
-        properties: bucket.sampleProperties,
-        coalescedCount: bucket.count,
-        firstAt: bucket.firstAt,
-        lastAt: bucket.lastAt,
-        suppressionReason: bucket.suppressionReason
-      });
-    }
-    return payloads;
-  }
-  /** Remove flushed bucket keys after successful emit. */
-  acknowledgeFlushed(payloads) {
-    for (const payload of payloads) {
-      this.coalesceBuckets.delete(payload.bucketKey);
-      this.flushedCoalescedTotal += payload.coalescedCount;
-    }
-  }
-  /** After coalescing, flush immediately if the bucket crossed the early threshold. */
-  takeBucketIfReady(bucketKey, now = Date.now()) {
-    const bucket = this.coalesceBuckets.get(bucketKey);
-    if (!bucket) return null;
-    const shouldFlushBySize = bucket.count >= this.config.flushCoalesceThreshold;
-    const shouldFlushByAge = now - bucket.firstAt >= this.config.flushIntervalMs;
-    if (!shouldFlushBySize && !shouldFlushByAge) {
-      return null;
-    }
-    this.coalesceBuckets.delete(bucketKey);
-    this.flushedCoalescedTotal += bucket.count;
-    return {
-      bucketKey: bucket.bucketKey,
-      event: bucket.event,
-      properties: bucket.sampleProperties,
-      coalescedCount: bucket.count,
-      firstAt: bucket.firstAt,
-      lastAt: bucket.lastAt,
-      suppressionReason: bucket.suppressionReason
-    };
-  }
-  /** Force-flush every pending bucket (e.g. page hide). */
-  collectAllPending() {
-    return [...this.coalesceBuckets.values()].map((bucket) => ({
-      bucketKey: bucket.bucketKey,
-      event: bucket.event,
-      properties: bucket.sampleProperties,
-      coalescedCount: bucket.count,
-      firstAt: bucket.firstAt,
-      lastAt: bucket.lastAt,
-      suppressionReason: bucket.suppressionReason
-    }));
-  }
-  recordCoalesce(event, bucketKey, fingerprint, properties, reason, now) {
-    const existing = this.coalesceBuckets.get(bucketKey);
-    if (existing) {
-      existing.count += 1;
-      existing.lastAt = now;
-      existing.sampleProperties = { ...existing.sampleProperties, ...properties ?? {} };
-    } else {
-      this.coalesceBuckets.set(bucketKey, {
-        event,
-        bucketKey,
-        fingerprint,
-        count: 1,
-        firstAt: now,
-        lastAt: now,
-        suppressionReason: reason,
-        sampleProperties: { ...properties ?? {} }
-      });
-    }
-    this.coalescedTotal += 1;
-    this.activeDedupe.set(event, { fingerprint, bucketKey, at: now });
-    return { action: "coalesce", reason, bucketKey };
-  }
-}
-const gate = new PosthogCaptureGate(DEFAULT_CAPTURE_GATE_CONFIG);
-let wrappedClient = null;
-let originalCaptureRef = null;
-let flushTimer = null;
-let lifecycleHooksInstalled = false;
-function getPosthogCaptureGate() {
-  return gate;
-}
-function emitThroughOriginal(event, properties, options) {
-  if (!originalCaptureRef) return void 0;
-  return originalCaptureRef(event, properties, withCaptureGateBypass(options));
-}
-function flushCoalescedPayload(payload) {
-  emitThroughOriginal(payload.event, buildCoalescedCaptureProperties(payload));
-}
-function flushCoalescedCaptures(options) {
-  const payloads = (options == null ? void 0 : options.force) ? gate.collectAllPending() : gate.collectFlushCandidates();
-  if (payloads.length === 0) return;
-  for (const payload of payloads) {
-    flushCoalescedPayload(payload);
-  }
-  gate.acknowledgeFlushed(payloads);
-}
-function installLifecycleFlushHooks() {
-  if (lifecycleHooksInstalled || typeof window === "undefined") return;
-  lifecycleHooksInstalled = true;
-  const flushOnHide = () => {
-    flushCoalescedCaptures({ force: true });
-  };
-  window.addEventListener("pagehide", flushOnHide);
-  document.addEventListener("visibilitychange", () => {
-    if (document.visibilityState === "hidden") {
-      flushOnHide();
-    }
-  });
-  if (!flushTimer) {
-    flushTimer = setInterval(() => {
-      flushCoalescedCaptures();
-    }, DEFAULT_CAPTURE_GATE_CONFIG.flushIntervalMs);
-  }
-}
-function wrapPosthogClient(client) {
-  if (wrappedClient === client) {
-    return client;
-  }
-  originalCaptureRef = client.capture.bind(client);
-  const originalCaptureException = typeof client.captureException === "function" ? client.captureException.bind(client) : null;
-  installLifecycleFlushHooks();
-  client.capture = ((event, properties, options) => {
-    const outcome = gate.evaluateCapture(event, properties, options);
-    if (outcome.action === "coalesce") {
-      const readyPayload = gate.takeBucketIfReady(outcome.bucketKey);
-      if (readyPayload) {
-        flushCoalescedPayload(readyPayload);
-      }
-      return void 0;
-    }
-    return emitThroughOriginal(event, properties, options);
-  });
-  if (originalCaptureException) {
-    client.captureException = ((error2, additionalProperties) => {
-      const mergedProperties = {
-        ...additionalProperties ?? {},
-        $exception_message: error2 instanceof Error ? error2.message : String(error2),
-        $exception_type: error2 instanceof Error ? error2.name : typeof error2
-      };
-      const outcome = gate.evaluateCapture("$exception", mergedProperties);
-      if (outcome.action === "coalesce") {
-        const readyPayload = gate.takeBucketIfReady(outcome.bucketKey);
-        if (readyPayload) {
-          flushCoalescedPayload(readyPayload);
-        }
-        return void 0;
-      }
-      return originalCaptureException(error2, additionalProperties);
-    });
-  }
-  wrappedClient = client;
-  return client;
-}
-function capturePosthogEvent(client, event, properties, options) {
-  if (!client || typeof client.capture !== "function") return;
-  client.capture(event, properties, options);
-}
-function capturePosthogException(client, error2, properties, options) {
-  if (!client) return;
-  if (typeof client.captureException === "function") {
-    client.captureException(error2, properties);
-    return;
-  }
-  capturePosthogEvent(
-    client,
-    "$exception",
-    {
-      ...properties ?? {},
-      $exception_message: error2.message,
-      $exception_type: error2.name,
-      $exception_stack: error2.stack
-    },
-    options
-  );
-}
-let posthogInstance = null;
-let initPromise = null;
-const DEFAULT_HOST = "https://us.i.posthog.com";
-async function initializePostHog(apiKey, host, debug) {
-  if (posthogInstance) return posthogInstance;
-  if (typeof window === "undefined") return null;
-  try {
-    const posthog = (await import("posthog-js")).default;
-    posthog.init(apiKey, {
-      api_host: host,
-      autocapture: true,
-      capture_pageview: false,
-      session_recording: {
-        recordCrossOriginIframes: true,
-        maskAllInputs: true
-      },
-      loaded: (ph) => {
-        wrapPosthogClient(ph);
-        if (debug) {
-          ph.debug(true);
-        }
-      }
-    });
-    wrapPosthogClient(posthog);
-    posthogInstance = posthog;
-    return posthog;
-  } catch {
-    initPromise = null;
-    return null;
-  }
-}
-function getPostHogInstance() {
-  return posthogInstance;
-}
-function PostHogProvider({
-  children,
-  config: config2
-}) {
-  const apiKey = (config2 == null ? void 0 : config2.apiKey) ?? "";
-  const host = (config2 == null ? void 0 : config2.host) ?? DEFAULT_HOST;
-  const debug = (config2 == null ? void 0 : config2.debug) ?? false;
-  React.useEffect(() => {
-    if (!apiKey || typeof window === "undefined") return;
-    if (!initPromise) {
-      initPromise = initializePostHog(apiKey, host, debug);
-    }
-  }, [apiKey, host, debug]);
-  return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children });
-}
 const resolveTokenOverride = ({
   config: config2,
   token
@@ -19858,9 +20489,16 @@ const initialStatewireLifecycle = {
   reconnect: null
 };
 function statewireLifecycleReducer(state, action) {
+  var _a3, _b2;
   switch (action.type) {
-    case "connection":
-      return { ...state, connection: action.connection };
+    case "connection": {
+      const healthy = ((_a3 = action.connection) == null ? void 0 : _a3.status) === "live" || ((_b2 = action.connection) == null ? void 0 : _b2.status) === "idle";
+      return {
+        ...state,
+        connection: action.connection,
+        error: healthy ? null : state.error
+      };
+    }
     case "error":
       return { ...state, error: action.error };
     case "legacy-read-only":
@@ -19878,6 +20516,8 @@ function AthenaStatewireStandalone({
   token,
   getToken,
   model,
+  agent: agent2,
+  channel,
   tools,
   frontendToolIds,
   frontendTools,
@@ -19909,6 +20549,8 @@ function AthenaStatewireStandalone({
     token,
     getToken,
     model,
+    agent: agent2,
+    channel,
     tools,
     frontendToolIds,
     frontendToolkit: frontendTools,
@@ -20184,6 +20826,7 @@ function AthenaProvider({
   apiKey,
   token: tokenProp,
   agent: agent2,
+  channel,
   model,
   tools = [],
   frontendTools = {},
@@ -20206,8 +20849,32 @@ function AthenaProvider({
   theme,
   linkClicks,
   citationLinks,
-  posthog: posthogProp
+  posthog: posthogProp,
+  debug,
+  onDiagnostic,
+  onError
 }) {
+  const onDiagnosticRef = React.useRef(onDiagnostic);
+  onDiagnosticRef.current = onDiagnostic;
+  const onErrorRef = React.useRef(onError);
+  onErrorRef.current = onError;
+  React.useEffect(() => {
+    installAthenaDiagnosticsGlobal();
+    return athenaDiagnostics.addConsumer({
+      onEvent: (event) => {
+        var _a3;
+        return (_a3 = onDiagnosticRef.current) == null ? void 0 : _a3.call(onDiagnosticRef, event);
+      },
+      onError: (error2, event) => {
+        var _a3;
+        return (_a3 = onErrorRef.current) == null ? void 0 : _a3.call(onErrorRef, error2, event);
+      }
+    });
+  }, []);
+  const debugKey = JSON.stringify(debugPropToDiagnosticsConfig(debug));
+  React.useEffect(() => {
+    athenaDiagnostics.configure(debugPropToDiagnosticsConfig(debug));
+  }, [debugKey]);
   const frontendToolNames = React.useMemo(() => Object.keys(frontendTools), [frontendTools]);
   const effectiveFrontendTools = React.useMemo(
     () => disableAutoOpen ? frontendTools : { ...DEFAULT_AUTO_OPEN_TOOLS, ...frontendTools },
@@ -20226,16 +20893,39 @@ function AthenaProvider({
   const configuredAppUrl = (config2 == null ? void 0 : config2.appUrl) ?? appUrl;
   const configuredTransport = (config2 == null ? void 0 : config2.transport) ?? transport;
   const configuredStatewireSyncUrl = (config2 == null ? void 0 : config2.statewireSyncUrl) ?? statewireSyncUrl;
+  const configuredGetToken = (config2 == null ? void 0 : config2.getToken) ?? getToken;
+  const configuredExtraRunConfig = (config2 == null ? void 0 : config2.extraRunConfig) ?? extraRunConfig;
   const configuredTrustedParentOrigins = config2 == null ? void 0 : config2.trustedParentOrigins;
   const posthogConfig = (config2 == null ? void 0 : config2.posthog) ?? posthogProp;
   const { transport: effectiveTransport, fallbackReason: transportFallbackReason } = resolveAthenaTransport({
     transport: configuredTransport
   });
   React.useEffect(() => {
+    athenaDiagnostics.gauge("sdk.transport", effectiveTransport);
+    athenaDiagnostics.emit("sdk.transport", {
+      level: "debug",
+      data: { transport: effectiveTransport, thread_list: enableThreadList }
+    });
     if (transportFallbackReason) {
+      athenaDiagnostics.emit("sdk.config.warning", {
+        level: "warn",
+        data: { prop: "transport", reason: transportFallbackReason }
+      });
       console.warn(`[AthenaSDK] ${transportFallbackReason}`);
     }
-  }, [transportFallbackReason]);
+  }, [effectiveTransport, enableThreadList, transportFallbackReason]);
+  React.useEffect(() => {
+    if (channel && effectiveTransport !== "statewire") {
+      athenaDiagnostics.emit("sdk.config.warning", {
+        level: "warn",
+        data: {
+          prop: "channel",
+          value: channel,
+          reason: "the 'channel' prop requires transport='statewire'; the legacy transport ignores it."
+        }
+      });
+    }
+  }, [channel, effectiveTransport]);
   const bridge = useParentBridge({
     trustedOrigins: configuredTrustedParentOrigins
   });
@@ -20260,8 +20950,10 @@ function AthenaProvider({
       appUrl: effectiveAppUrl,
       apiKey: configuredApiKey,
       token: effectiveToken,
-      getToken,
+      getToken: configuredGetToken,
       model,
+      agent: agent2,
+      channel,
       tools,
       frontendToolIds: frontendToolNames,
       frontendTools: effectiveFrontendTools,
@@ -20270,7 +20962,7 @@ function AthenaProvider({
       systemPrompt,
       customToolConfigs,
       appId,
-      extraRunConfig,
+      extraRunConfig: configuredExtraRunConfig,
       linkClicks,
       citationLinks
     };
@@ -54613,13 +55305,13 @@ function getEmptyMessage(scope, query) {
 function MentionIcon({ item }) {
   return /* @__PURE__ */ jsxRuntime.jsx("span", { className: "flex size-7 shrink-0 items-center justify-center rounded-md bg-muted text-muted-foreground", children: /* @__PURE__ */ jsxRuntime.jsx(MentionIconGlyph, { icon: item.fallbackIcon }) });
 }
-const MentionSuggestionList = React.forwardRef(({ store, query, command: command2, closeMenu }, ref) => {
+const MentionSuggestionList = React.forwardRef(({ store: store2, query, command: command2, closeMenu }, ref) => {
   const [selectedIndex, setSelectedIndex] = React.useState(0);
   const [currentScope, setCurrentScope] = React.useState("root");
   const scrollContainerRef = React.useRef(null);
-  const hasGlobalSearch = store.state.registry.entries.has(GLOBAL_SEARCH_SCOPE$1);
+  const hasGlobalSearch = store2.state.registry.entries.has(GLOBAL_SEARCH_SCOPE$1);
   const effectiveScope = currentScope === "root" && query.trim() && hasGlobalSearch ? GLOBAL_SEARCH_SCOPE$1 : currentScope;
-  const { items, isFetching } = useStore(store, (state) => ({
+  const { items, isFetching } = useStore(store2, (state) => ({
     items: getFilteredItems(state.cache, effectiveScope, query),
     isFetching: false
   }));
@@ -54738,7 +55430,7 @@ const MentionSuggestionList = React.forwardRef(({ store, query, command: command
   ] });
 });
 MentionSuggestionList.displayName = "MentionSuggestionList";
-const MentionSuggestionPopup = React.forwardRef(({ store, query, command: command2, clientRect: clientRect2, closeMenu, isHidden: isHidden3 = false }, ref) => {
+const MentionSuggestionPopup = React.forwardRef(({ store: store2, query, command: command2, clientRect: clientRect2, closeMenu, isHidden: isHidden3 = false }, ref) => {
   const listRef = React.useRef(null);
   const virtualRef = React.useRef({
     getBoundingClientRect: () => clientRect2 ? clientRect2() : new DOMRect()
@@ -54785,7 +55477,7 @@ const MentionSuggestionPopup = React.forwardRef(({ store, query, command: comman
         MentionSuggestionList,
         {
           ref: listRef,
-          store,
+          store: store2,
           query,
           command: command2,
           closeMenu
@@ -55012,9 +55704,9 @@ function useMentionSuggestions(tools, options = {}) {
     populateMentionCache({ cache, tools, rootCategories });
     storeRef.current = new Store({ registry: registry2, cache });
   }
-  const store = storeRef.current;
+  const store2 = storeRef.current;
   React.useEffect(() => {
-    store.setState((prev) => {
+    store2.setState((prev) => {
       const newCache = createItemCache();
       if (rootCategories) {
         registerStaticSource(prev.registry, "toolkits");
@@ -55024,8 +55716,8 @@ function useMentionSuggestions(tools, options = {}) {
       populateMentionCache({ cache: newCache, tools, rootCategories });
       return { ...prev, cache: newCache };
     });
-  }, [tools, store, rootCategories, rootCategoriesKey]);
-  return store;
+  }, [tools, store2, rootCategories, rootCategoriesKey]);
+  return store2;
 }
 const AttachmentCtx = React.createContext(null);
 function AttachmentProvider({ children }) {
@@ -55323,7 +56015,7 @@ const TiptapComposer = ({ tools = [], rootCategories }) => {
   const isUploadingRef = React.useRef(isUploading);
   isUploadingRef.current = isUploading;
   const isRunningThread = react$1.useAuiState((s) => s.thread.isRunning);
-  const isThreadRunning = transport === "statewire" ? false : isRunningThread;
+  const isThreadRunning = allowsMidRunSend(transport) ? false : isRunningThread;
   const isThreadRunningRef = React.useRef(isThreadRunning);
   isThreadRunningRef.current = isThreadRunning;
   const handleSubmit = React.useCallback(() => {
@@ -55345,10 +56037,8 @@ const TiptapComposer = ({ tools = [], rootCategories }) => {
         appUrl
       });
       if (fullMessage) {
-        aui.thread.append({
-          role: "user",
-          content: [{ type: "text", text: fullMessage }]
-        });
+        aui.composer.setText(fullMessage);
+        aui.composer.send();
         clearAttachments();
         clearQuote();
       }
@@ -55597,14 +56287,20 @@ const StatewireApprovalCardInner = () => {
   }
   const isRunning = react$1.useAuiState((s) => s.thread.isRunning);
   const sawResumeRunRef = React.useRef(false);
-  if (pending && isRunning) {
-    sawResumeRunRef.current = true;
-  } else if (pending && sawResumeRunRef.current && !isRunning) {
-    sawResumeRunRef.current = false;
-    setPending(false);
-  } else if (!pending) {
-    sawResumeRunRef.current = 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(() => {
@@ -55895,7 +56591,7 @@ const StatewireLegacyReadOnlyBanner = () => {
     /* @__PURE__ */ jsxRuntime.jsx(Archive, { className: "mt-0.5 size-4 shrink-0" }),
     /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "min-w-0 flex-1", children: [
       /* @__PURE__ */ jsxRuntime.jsx("p", { className: "font-semibold text-xs", children: "Read-only conversation" }),
-      /* @__PURE__ */ jsxRuntime.jsx("p", { className: "pt-0.5 text-xs leading-snug text-amber-800", children: "Its history remains available, but new messages cannot be added. Start a new chat to continue." })
+      /* @__PURE__ */ jsxRuntime.jsx("p", { className: "pt-0.5 text-xs leading-snug text-amber-800", children: "This conversation’s history remains available, but new messages cannot be added. Start a new chat to continue." })
     ] })
   ] });
 };
@@ -57446,10 +58142,10 @@ function openStudioAsset({
   slideNumber,
   preserveExistingSlide
 }) {
-  const store = useAssetPanelStore.getState();
-  const existing = store.tabs.find((tab) => tab.id === assetId);
+  const store2 = useAssetPanelStore.getState();
+  const existing = store2.tabs.find((tab) => tab.id === assetId);
   const shouldKeepCurrentSlide = preserveExistingSlide && existing;
-  store.openAsset(assetId, {
+  store2.openAsset(assetId, {
     type: assetType,
     ...!shouldKeepCurrentSlide && slideNumber !== void 0 ? { slideNumber } : {}
   });
@@ -61134,7 +61830,7 @@ const ThreadScrollToBottom = () => /* @__PURE__ */ jsxRuntime.jsx(react$1.Thread
 ) });
 const ComposerAction = () => {
   const { transport } = useAthenaConfig();
-  const queuesWhileRunning = transport === "statewire";
+  const queuesWhileRunning = allowsMidRunSend(transport);
   return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "aui-composer-action-wrapper relative mx-2 mb-2 flex items-center justify-between", children: [
     /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex items-center gap-1", children: /* @__PURE__ */ jsxRuntime.jsx(FileUploadButton, {}) }),
     /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-1", children: [
@@ -61161,7 +61857,7 @@ const ComposerSendWithQuote = () => {
   const editorRef = useComposerEditorRef();
   const editorEmpty = useComposerEditorEmpty();
   const isRunningThread = react$1.useAuiState((s) => s.thread.isRunning);
-  const isThreadRunning = transport === "statewire" ? false : isRunningThread;
+  const isThreadRunning = allowsMidRunSend(transport) ? false : isRunningThread;
   const hasExtras = !!quote || attachments.length > 0;
   const handleSend = React.useCallback(() => {
     var _a3;
@@ -61177,10 +61873,8 @@ const ComposerSendWithQuote = () => {
         appUrl
       });
       if (!fullMessage) return;
-      aui.thread.append({
-        role: "user",
-        content: [{ type: "text", text: fullMessage }]
-      });
+      aui.composer.setText(fullMessage);
+      aui.composer.send();
       clearQuote();
       clearAttachments();
     } else {
@@ -62416,6 +63110,8 @@ function useComposerAttachment() {
   }, [aui]);
   return { addFile, addContent, clear };
 }
+exports.ATHENA_REACT_SDK_VERSION = ATHENA_REACT_SDK_VERSION;
+exports.ATHENA_SDK_ERROR_CODES = ATHENA_SDK_ERROR_CODES;
 exports.ATHENA_TRANSPORTS = ATHENA_TRANSPORTS;
 exports.AppendDocumentToolUI = AppendDocumentToolUI;
 exports.AssetPanel = AssetPanel;
@@ -62426,10 +63122,12 @@ exports.AthenaChat = AthenaChat;
 exports.AthenaLayout = AthenaLayout;
 exports.AthenaProvider = AthenaProvider;
 exports.AthenaReasoningPart = AthenaReasoningPart;
+exports.AthenaSdkError = AthenaSdkError;
 exports.AthenaThreadIdContext = AthenaThreadIdContext;
 exports.AthenaUserMessage = AthenaUserMessage;
 exports.BrowseToolUI = BrowseToolUI;
 exports.Button = Button;
+exports.COLLAB_AGENT_REF_PREFIX = COLLAB_AGENT_REF_PREFIX;
 exports.Collapsible = Collapsible;
 exports.CollapsibleContent = CollapsibleContent;
 exports.CollapsibleTrigger = CollapsibleTrigger;
@@ -62486,8 +63184,10 @@ exports.TooltipProvider = TooltipProvider;
 exports.TooltipTrigger = TooltipTrigger;
 exports.UpdateSheetRangeToolUI = UpdateSheetRangeToolUI;
 exports.WebSearchToolUI = WebSearchToolUI;
+exports.allowsMidRunSend = allowsMidRunSend;
 exports.archiveThread = archiveThread;
 exports.asHitlApproval = asHitlApproval;
+exports.athenaDiagnostics = athenaDiagnostics;
 exports.athenaStatewireErrorNotice = athenaStatewireErrorNotice;
 exports.autoCloseInFlightSubgraphMessages = autoCloseInFlightSubgraphMessages;
 exports.buildCoalescedCaptureProperties = buildCoalescedCaptureProperties;
@@ -62511,13 +63211,17 @@ exports.getPostHogInstance = getPostHogInstance;
 exports.getPosthogCaptureGate = getPosthogCaptureGate;
 exports.getThreadState = getThreadState;
 exports.hasStatewireThreadExtras = hasStatewireThreadExtras;
+exports.installAthenaDiagnosticsGlobal = installAthenaDiagnosticsGlobal;
 exports.isAthenaCitationUrl = isAthenaCitationUrl;
+exports.isAthenaSdkError = isAthenaSdkError;
 exports.isCriticalPosthogEvent = isCriticalPosthogEvent;
 exports.isPendingInterrupt = isPendingInterrupt;
 exports.listThreads = listThreads;
 exports.normalizeResult = normalizeResult;
 exports.parseAthenaCitationLink = parseAthenaCitationLink;
+exports.parseCollabAgentRef = parseCollabAgentRef;
 exports.readInterruptMessage = readInterruptMessage;
+exports.readRejectionDetail = readRejectionDetail;
 exports.resetAssetAutoOpen = resetAssetAutoOpen;
 exports.resolveAthenaTransport = resolveAthenaTransport;
 exports.resolveStatewireSyncUrl = resolveStatewireSyncUrl;
@@ -62525,6 +63229,7 @@ exports.setThreadReadState = setThreadReadState;
 exports.statewireClientToolWireEntries = statewireClientToolWireEntries;
 exports.themeToStyleVars = themeToStyleVars;
 exports.themes = themes;
+exports.toAthenaSdkError = toAthenaSdkError;
 exports.truncate = truncate;
 exports.tryParseJson = tryParseJson$2;
 exports.useAppendToComposer = useAppendToComposer;
@@ -62532,6 +63237,7 @@ exports.useAssetEmbed = useAssetEmbed;
 exports.useAssetPanelStore = useAssetPanelStore;
 exports.useAthenaCitationLinkHandler = useAthenaCitationLinkHandler;
 exports.useAthenaConfig = useAthenaConfig;
+exports.useAthenaDiagnostics = useAthenaDiagnostics;
 exports.useAthenaLinkClickHandler = useAthenaLinkClickHandler;
 exports.useAthenaRuntime = useAthenaRuntime;
 exports.useAthenaStatewireLifecycle = useAthenaStatewireLifecycle;