@agents24/react 0.2.14 → 0.2.16

package/dist/index.js

@@ -10,6 +10,235 @@ function isAbortLike(error) {
   return input.name === "AbortError" || input.kind === "aborted" || input.code === "ABORTED";
 }
 
+// src/chat-observation.ts
+function createChatObservation(input) {
+  const clock = globalThis;
+  let state = { threadId: null, running: false, waiting: false, pending: false, paused: false };
+  let visible = input.visibility?.isVisible() ?? true;
+  let disposed = false;
+  let generation = 0;
+  let cursor;
+  let connection;
+  let recovery;
+  let refreshing;
+  let timer;
+  let reconnectTimer;
+  let failures = 0;
+  let handoffAt;
+  let buffered;
+  const needed = () => !disposed && visible && Boolean(state.threadId) && !state.waiting && !state.paused && (state.running || state.pending || state.mode === "realtime");
+  const clearTimer = () => {
+    clock.clearTimeout(timer);
+    timer = void 0;
+  };
+  const stop = () => {
+    clearTimer();
+    clock.clearTimeout(reconnectTimer);
+    connection?.abort();
+    connection = void 0;
+  };
+  const schedule = (callback, ms) => {
+    clearTimer();
+    timer = clock.setTimeout(callback, ms);
+  };
+  function refresh() {
+    if (disposed || !visible || !state.threadId) return Promise.resolve();
+    if (refreshing) return refreshing;
+    const owned = generation;
+    const controller = input.createAbortController();
+    recovery = controller;
+    const timeout = clock.setTimeout(() => controller.abort("Observation refresh timed out."), 5e3);
+    let onAbort = () => {
+    };
+    const aborted = new Promise((_, reject) => {
+      onAbort = () => reject(Object.assign(new Error("Observation refresh detached."), { name: "AbortError" }));
+      controller.signal.addEventListener("abort", onAbort, { once: true });
+    });
+    const promise = Promise.race([input.refresh(controller.signal), aborted]).then(() => {
+      if (owned === generation && !controller.signal.aborted) input.onRecovered();
+    }).finally(() => {
+      clock.clearTimeout(timeout);
+      controller.signal.removeEventListener("abort", onAbort);
+      if (recovery === controller) recovery = void 0;
+      if (refreshing === promise) refreshing = void 0;
+    });
+    refreshing = promise;
+    return promise;
+  }
+  function recover() {
+    const owned = generation;
+    return refresh().then(() => {
+      if (owned === generation && !disposed && visible) {
+        failures = 0;
+        input.onResume();
+      }
+    }).catch((error) => {
+      if (owned !== generation || disposed || !visible) return;
+      failures += 1;
+      input.onError(error);
+      if (needed()) schedule(poll, 1e3);
+    });
+  }
+  function poll() {
+    if (!needed()) return;
+    void recover().finally(() => {
+      if (needed() && (state.pending && !state.running || state.degraded || failures > 0)) schedule(poll, 1e3);
+    });
+  }
+  function connect() {
+    if (!needed() || connection) return;
+    const owned = generation;
+    const controller = input.createAbortController();
+    connection = controller;
+    buffered = [];
+    let ready = false;
+    let leased = false;
+    let hydration;
+    const hydrate = () => hydration ??= recover().finally(() => {
+      if (owned !== generation || controller.signal.aborted) return;
+      const notices = buffered || [];
+      buffered = void 0;
+      for (const event of notices) input.onEvent(event);
+      if (notices.length) void recover();
+    });
+    void input.events({
+      threadId: state.threadId,
+      cursor,
+      leaseSeconds: 60,
+      signal: controller.signal,
+      onControl(control) {
+        if (control.type === "lease_expired") leased = true;
+        if (control.type === "ready") {
+          ready = true;
+          cursor ??= control.cursor;
+          void hydrate().catch(input.onError);
+        }
+      }
+    }, (event) => {
+      if (owned !== generation || controller.signal.aborted) return;
+      if (event.event === "snapshot_required") {
+        cursor = void 0;
+        void refresh().catch(input.onError);
+        return;
+      }
+      cursor = Math.max(cursor ?? 0, event.cursor);
+      failures = 0;
+      if (buffered) buffered.push(event);
+      else {
+        input.onEvent(event);
+        void recover();
+      }
+      if (!ready) {
+        ready = true;
+        void hydrate().catch(input.onError);
+      }
+    }).then(() => {
+      if (owned !== generation || controller.signal.aborted) return;
+      connection = void 0;
+      if (needed()) {
+        if (leased) connect();
+        else {
+          void refresh().catch(input.onError);
+          reconnectTimer = clock.setTimeout(connect, 1e3);
+        }
+      }
+    }).catch((error) => {
+      if (owned !== generation || controller.signal.aborted || isAbortLike(error)) return;
+      connection = void 0;
+      failures += 1;
+      input.onError(error);
+      poll();
+      reconnectTimer = clock.setTimeout(connect, Math.min(3e4, 1e3 * 2 ** Math.min(failures - 1, 5)));
+    });
+  }
+  function reconcile() {
+    if (!needed()) {
+      handoffAt = void 0;
+      stop();
+      return;
+    }
+    connect();
+    if (state.pending && !state.running) {
+      handoffAt ??= Date.now() + 2e3;
+      schedule(poll, Math.max(0, handoffAt - Date.now()));
+    } else {
+      handoffAt = void 0;
+      if (state.degraded) schedule(poll, 1e3);
+      else if (!failures) clearTimer();
+    }
+  }
+  const unsubscribe = input.visibility?.subscribe(() => {
+    const next = input.visibility.isVisible();
+    if (next === visible) return;
+    visible = next;
+    if (!visible) {
+      stop();
+      recovery?.abort();
+      refreshing = void 0;
+      input.onDetach();
+    } else {
+      reconcile();
+      if (!needed()) void refresh().then(input.onResume).catch(input.onError);
+    }
+  });
+  return {
+    refresh,
+    update(next) {
+      if (next.threadId !== state.threadId) {
+        generation += 1;
+        stop();
+        recovery?.abort();
+        refreshing = void 0;
+        cursor = void 0;
+        buffered = void 0;
+        failures = 0;
+        handoffAt = void 0;
+      }
+      state = next;
+      reconcile();
+    },
+    dispose() {
+      disposed = true;
+      generation += 1;
+      stop();
+      recovery?.abort();
+      unsubscribe?.();
+    }
+  };
+}
+
+// src/use-chat-observation.ts
+import * as React from "react";
+function useChatObservation(input) {
+  const latest = React.useRef(input);
+  latest.current = input;
+  const owner = React.useRef(null);
+  React.useEffect(() => {
+    const observation = createChatObservation({
+      createAbortController: input.createAbortController,
+      visibility: input.visibility,
+      events: (options, handler) => latest.current.events(options, handler),
+      refresh: (signal) => latest.current.refresh(signal),
+      onEvent: (event) => latest.current.onEvent(event),
+      onError: (error) => latest.current.onError(error),
+      onRecovered: () => latest.current.onRecovered(),
+      onDetach: () => latest.current.onDetach(),
+      onResume: () => latest.current.onResume()
+    });
+    owner.current = observation;
+    observation.update(latest.current.state);
+    return () => {
+      observation.dispose();
+      if (owner.current === observation) owner.current = null;
+    };
+  }, [input.createAbortController, input.visibility]);
+  const { threadId, running, waiting, pending, paused, degraded, mode } = input.state;
+  React.useEffect(() => {
+    owner.current?.update({ threadId, running, waiting, pending, paused, degraded, mode });
+  }, [threadId, running, waiting, pending, paused, degraded, mode]);
+  return React.useCallback(() => owner.current?.refresh() ?? Promise.resolve(), []);
+}
+
 // src/model.ts
 import {
   compressionFromContextWindow,
@@ -389,8 +618,7 @@ function threadDetailToMessages(detail) {
     return output;
   });
 }
-function threadTimelineToMessages(items, detail) {
-  const feedbackByRun = new Map((detail?.turns || []).flatMap((turn) => turn.run_id && turn.feedback ? [[turn.run_id, turn.feedback]] : []));
+function threadTimelineToMessages(items) {
   return items.map((item) => ({
     id: item.id,
     clientSubmissionId: item.client_submission_id || void 0,
@@ -406,7 +634,7 @@ function threadTimelineToMessages(items, detail) {
       const descriptor = item.attachments?.find((attachment) => attachment.id === id);
       return { id, filename: descriptor?.filename || "Attachment", mediaType: descriptor?.mime_type || "application/octet-stream" };
     }) : void 0,
-    feedback: item.role === "assistant" && item.run_id ? feedbackByRun.get(item.run_id) : void 0
+    feedback: item.role === "assistant" ? item.feedback ?? null : void 0
   }));
 }
 function latestThreadContext(detail) {
@@ -430,24 +658,25 @@ function attachmentResultToChatAttachment(result) {
 }
 
 // src/provider.tsx
-import * as React from "react";
+import * as React2 from "react";
 import { jsx } from "react/jsx-runtime";
-var Agents24Context = React.createContext(null);
+var Agents24Context = React2.createContext(null);
 function Agents24Provider({
   children,
   client,
   createAbortController,
   createId = createPortableId,
-  storage
+  storage,
+  visibility
 }) {
-  const value = React.useMemo(
-    () => ({ client, createAbortController, createId, storage }),
-    [client, createAbortController, createId, storage]
+  const value = React2.useMemo(
+    () => ({ client, createAbortController, createId, storage, visibility: visibility ?? client.visibility }),
+    [client, createAbortController, createId, storage, visibility]
   );
   return /* @__PURE__ */ jsx(Agents24Context.Provider, { value, children });
 }
 function useAgents24Runtime() {
-  const value = React.useContext(Agents24Context);
+  const value = React2.useContext(Agents24Context);
   if (!value) throw new Error("Agents24 hooks must be rendered inside Agents24Provider.");
   return value;
 }
@@ -615,10 +844,15 @@ function reconcileThreadTimeline(current, canonical, activeRunId, streamingMessa
   const retained = current.filter((message) => !canonicalIds.has(message.id) && (message.isFinal || activeRunId && (!message.runId || message.runId === activeRunId)));
   const reconciled = mounted.map((message) => {
     const live = current.find((item) => item.id === message.id);
-    return activeRunId && live?.role === "assistant" && live.runId === activeRunId && (live.id === streamingMessageId || !live.isFinal || live.responseCompletion) ? message.responseCompletion && !live.responseCompletion ? { ...message, id: live.id, durableId: message.durableId || live.durableId } : { ...message, ...live, durableId: message.durableId || live.durableId } : message;
+    return activeRunId && live?.role === "assistant" && live.runId === activeRunId && (live.id === streamingMessageId || !live.isFinal || live.responseCompletion) ? message.responseCompletion && !live.responseCompletion ? { ...message, id: live.id, durableId: message.durableId || live.durableId } : { ...message, ...live, feedback: message.feedback, durableId: message.durableId || live.durableId } : message;
   });
   return [...retained, ...reconciled];
 }
+function prependThreadTimeline(current, older) {
+  const mounted = preserveMountedMessageIds(older, current);
+  const ids = new Set(current.map((message) => message.id));
+  return [...mounted.filter((message) => !ids.has(message.id)), ...current];
+}
 function promoteThreadMessage(current, message, runId) {
   const promoted = { ...message, runId, isFinal: true };
   const index = current.findIndex((item) => item.id === message.id || item.durableId === message.id || Boolean(message.clientSubmissionId && item.clientSubmissionId === message.clientSubmissionId));
@@ -839,7 +1073,18 @@ function applyThreadSummaryEvent(threads, event) {
 }
 
 // src/thread-message-queue.ts
-import * as React2 from "react";
+import * as React3 from "react";
+
+// src/operation-ownership.ts
+function captureChatOperation(read, options = {}) {
+  const owner = read();
+  return () => {
+    const current = read();
+    return current.generation === owner.generation && (options.adoptThread || current.threadId === owner.threadId) && (!options.run || current.runId === owner.runId) && (!options.stream || current.stream === owner.stream);
+  };
+}
+
+// src/thread-message-queue.ts
 async function retrySubmissionAdmission(admit) {
   try {
     return await admit();
@@ -849,23 +1094,42 @@ async function retrySubmissionAdmission(admit) {
     return admit();
   }
 }
-function useThreadMessageQueue({ threadId, transport, onPromoted, onOptimistic, onDiscard }) {
-  const [pendingMessages, setPendingMessages] = React2.useState([]);
-  const [messageQueue, setMessageQueue] = React2.useState(null);
-  const pendingRef = React2.useRef(/* @__PURE__ */ new Map());
-  const versionRef = React2.useRef(0);
-  const cursorRef = React2.useRef(0);
-  const promotedRef = React2.useRef(/* @__PURE__ */ new Set());
-  const threadRef = React2.useRef(threadId);
-  const transportRef = React2.useRef(transport);
-  const onPromotedRef = React2.useRef(onPromoted);
+function useThreadMessageQueue({ threadId, transport, onPromoted, onUnknownPromotion, onOptimistic, onDiscard, ownOperation: ownSelection }) {
+  const [pendingMessages, setPendingMessages] = React3.useState([]);
+  const [messageQueue, setMessageQueue] = React3.useState(null);
+  const pendingRef = React3.useRef(/* @__PURE__ */ new Map());
+  const admissionRef = React3.useRef(null);
+  const initialAdmissionRef = React3.useRef(null);
+  const versionRef = React3.useRef(0);
+  const cursorRef = React3.useRef(0);
+  const promotedRef = React3.useRef(/* @__PURE__ */ new Set());
+  const threadRef = React3.useRef(threadId);
+  const selectionGenerationRef = React3.useRef(0);
+  if (threadRef.current !== threadId && initialAdmissionRef.current?.threadId !== threadId) selectionGenerationRef.current += 1;
+  const transportRef = React3.useRef(transport);
+  const onPromotedRef = React3.useRef(onPromoted);
   threadRef.current = threadId;
   transportRef.current = transport;
   onPromotedRef.current = onPromoted;
-  const callbacksRef = React2.useRef({ onOptimistic, onDiscard });
-  callbacksRef.current = { onOptimistic, onDiscard };
+  const ownSelectionRef = React3.useRef(ownSelection);
+  ownSelectionRef.current = ownSelection;
+  const callbacksRef = React3.useRef({ onOptimistic, onDiscard, onUnknownPromotion });
+  callbacksRef.current = { onOptimistic, onDiscard, onUnknownPromotion };
+  const ownOperation = React3.useCallback((options) => ownSelectionRef.current?.(options) ?? captureChatOperation(() => ({
+    generation: selectionGenerationRef.current,
+    threadId: threadRef.current
+  }), options), []);
+  const confirmThreadAdmission = React3.useCallback((admittedThreadId) => {
+    const initial = initialAdmissionRef.current;
+    if (!initial || !initial.isCurrent()) return;
+    initial.threadId = admittedThreadId;
+    initial.resolve(admittedThreadId);
+  }, []);
+  const assertCurrent = (isCurrent) => {
+    if (!isCurrent()) throw Object.assign(new Error("Thread selection changed."), { name: "AbortError" });
+  };
   const knownMessage = (id, submissionId) => pendingRef.current.get(id) || (submissionId ? [...pendingRef.current.values()].find((item) => item.client_submission_id === submissionId) : void 0);
-  const hydrate = React2.useCallback((page, selectedThreadId) => {
+  const hydrate = React3.useCallback((page, selectedThreadId) => {
     if (threadRef.current !== selectedThreadId) return;
     const pending = page.pending.filter((message) => !promotedRef.current.has(message.id)).map((message) => {
       const known = knownMessage(message.id, message.client_submission_id);
@@ -877,11 +1141,12 @@ function useThreadMessageQueue({ threadId, transport, onPromoted, onOptimistic,
     setPendingMessages([...pending, ...optimistic]);
     setMessageQueue(page.queue);
   }, []);
-  const refresh = React2.useCallback(async (selectedThreadId = threadRef.current) => {
+  const refresh = React3.useCallback(async (selectedThreadId = threadRef.current, signal) => {
     if (!selectedThreadId) return null;
+    const isCurrent = ownOperation();
     const version = ++versionRef.current;
-    const page = await transportRef.current.list(selectedThreadId);
-    if (version !== versionRef.current || threadRef.current !== selectedThreadId) return null;
+    const page = await transportRef.current.list(selectedThreadId, signal);
+    if (signal?.aborted || !isCurrent() || version !== versionRef.current || threadRef.current !== selectedThreadId) return null;
     for (const item of page.items) {
       if (item.role === "user" && item.status === "delivered" && item.run_id) {
         const pending = knownMessage(item.id, item.client_submission_id);
@@ -899,23 +1164,24 @@ function useThreadMessageQueue({ threadId, transport, onPromoted, onOptimistic,
     }
     hydrate(page, selectedThreadId);
     return page;
-  }, [hydrate]);
-  const acceptNotice = React2.useCallback((notice) => {
+  }, [hydrate, ownOperation]);
+  const acceptNotice = React3.useCallback((notice) => {
     if (notice.cursor && notice.cursor <= cursorRef.current) return false;
     if (notice.cursor) cursorRef.current = notice.cursor;
     const pending = knownMessage(notice.messageId, notice.clientSubmissionId);
-    if (notice.status === "delivered" && notice.runId && pending && !promotedRef.current.has(notice.messageId)) {
+    if (notice.status === "delivered" && notice.runId && !promotedRef.current.has(notice.messageId)) {
       promotedRef.current.add(notice.messageId);
-      pendingRef.current.delete(pending.id);
       versionRef.current += 1;
-      setPendingMessages((current) => current.filter((message) => message.id !== pending.id));
-      onPromotedRef.current({ ...pending, id: notice.messageId, run_id: notice.runId, status: "delivered" }, notice.runId);
+      if (pending) {
+        pendingRef.current.delete(pending.id);
+        setPendingMessages((current) => current.filter((message) => message.id !== pending.id));
+        onPromotedRef.current({ ...pending, id: notice.messageId, run_id: notice.runId, status: "delivered" }, notice.runId);
+      } else if (threadRef.current) callbacksRef.current.onUnknownPromotion?.(notice.runId, threadRef.current);
     }
     if (notice.status === "removed") pendingRef.current.delete(notice.messageId);
-    void refresh().catch(() => void 0);
     return true;
-  }, [refresh]);
-  const beginSubmission = React2.useCallback((input, queued = false) => {
+  }, []);
+  const beginSubmission = React3.useCallback((input, queued = false) => {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const message = {
       id: input.clientSubmissionId,
@@ -937,34 +1203,60 @@ function useThreadMessageQueue({ threadId, transport, onPromoted, onOptimistic,
       updated_at: now
     };
     pendingRef.current.set(message.id, { ...message, optimisticQueued: queued });
+    if (!queued && !threadRef.current && !initialAdmissionRef.current) {
+      let resolve;
+      const done = new Promise((callback) => {
+        resolve = callback;
+      });
+      initialAdmissionRef.current = { id: message.id, done, resolve, isCurrent: ownOperation({ adoptThread: true }) };
+    }
     versionRef.current += 1;
     if (queued) setPendingMessages((current) => [...current, message]);
     else callbacksRef.current.onOptimistic?.(message, Boolean(input.uploading));
     return message;
-  }, []);
-  const discardSubmission = React2.useCallback((message) => {
+  }, [ownOperation]);
+  const discardSubmission = React3.useCallback((message, failure) => {
+    if (initialAdmissionRef.current?.id === message.id) {
+      initialAdmissionRef.current.failure = failure;
+      initialAdmissionRef.current.resolve(null);
+      initialAdmissionRef.current = null;
+    }
     if (!pendingRef.current.has(message.id)) return;
     pendingRef.current.delete(message.id);
     callbacksRef.current.onDiscard?.(message);
     versionRef.current += 1;
     setPendingMessages((current) => current.filter((item) => item.client_submission_id !== message.client_submission_id));
   }, []);
-  const submit = React2.useCallback(async (input) => {
-    const selectedThreadId = threadRef.current;
-    if (!selectedThreadId) throw new Error("No active Agent thread is available.");
-    const { queued, prepare, attachments, uploading, ...submission } = input;
+  const submit = React3.useCallback(async (input) => {
+    const initial = !threadRef.current ? initialAdmissionRef.current : null;
+    let selectedThreadId = threadRef.current;
+    if (!selectedThreadId && !initial) throw new Error("No active Agent thread is available.");
+    const isCurrent = ownOperation({ adoptThread: Boolean(initial) });
+    const { queued: requestedQueued, prepare, attachments, uploading, ...submission } = input;
+    const priorAdmission = admissionRef.current?.threadId === (selectedThreadId || "") ? admissionRef.current.done : void 0;
+    const queued = Boolean(requestedQueued || priorAdmission || initial);
     const optimistic = beginSubmission({
       ...submission,
       attachments,
       uploading,
       clientSubmissionId: submission.clientSubmissionId || submission.idempotencyKey
     }, queued);
+    let releaseAdmission;
+    const admission = { threadId: selectedThreadId || "", done: new Promise((resolve) => {
+      releaseAdmission = resolve;
+    }) };
+    admissionRef.current = admission;
     try {
       const prepared = prepare ? await prepare() : {};
-      if (threadRef.current === selectedThreadId) pendingRef.current.set(optimistic.id, { ...optimistic, optimisticQueued: queued, attachment_ids: prepared.attachmentIds || optimistic.attachment_ids, attachments: prepared.attachments || attachments });
+      if (initial) selectedThreadId = await initial.done;
+      if (priorAdmission) await priorAdmission;
+      assertCurrent(isCurrent);
+      if (!selectedThreadId) throw Object.assign(new Error("Initial message admission did not complete."), { name: "AbortError" });
+      admission.threadId = selectedThreadId;
+      pendingRef.current.set(optimistic.id, { ...optimistic, optimisticQueued: queued, attachment_ids: prepared.attachmentIds || optimistic.attachment_ids, attachments: prepared.attachments || attachments });
       const request = { ...submission, ...prepared, clientSubmissionId: optimistic.client_submission_id, threadId: selectedThreadId };
       const result = await retrySubmissionAdmission(() => transportRef.current.submit(request));
-      if (threadRef.current !== selectedThreadId) return result;
+      if (!isCurrent()) return result;
       versionRef.current += 1;
       const bound = {
         ...optimistic,
@@ -991,53 +1283,105 @@ function useThreadMessageQueue({ threadId, transport, onPromoted, onOptimistic,
       void refresh().catch(() => void 0);
       return result;
     } catch (error) {
-      if (threadRef.current === selectedThreadId) discardSubmission(optimistic);
+      if (isCurrent()) discardSubmission(optimistic);
       throw error;
+    } finally {
+      void Promise.resolve(priorAdmission).then(() => {
+        releaseAdmission();
+        if (admissionRef.current === admission) admissionRef.current = null;
+      });
     }
-  }, [beginSubmission, discardSubmission, refresh]);
-  const edit = React2.useCallback(async (message, input) => {
+  }, [beginSubmission, discardSubmission, refresh, ownOperation]);
+  const edit = React3.useCallback(async (message, input) => {
+    const isCurrent = ownOperation();
     const updated = await transportRef.current.edit(message, input);
+    assertCurrent(isCurrent);
     versionRef.current += 1;
     pendingRef.current.set(updated.id, updated);
     await refresh(message.thread_id);
     return updated;
-  }, [refresh]);
-  const remove = React2.useCallback(async (message) => {
+  }, [refresh, ownOperation]);
+  const remove = React3.useCallback(async (message) => {
+    const isCurrent = ownOperation();
     await transportRef.current.remove(message);
+    assertCurrent(isCurrent);
     versionRef.current += 1;
     pendingRef.current.delete(message.id);
     setPendingMessages((current) => current.filter((item) => item.id !== message.id));
     await refresh(message.thread_id);
-  }, [refresh]);
-  const retractForEdit = React2.useCallback(async (message) => {
+  }, [refresh, ownOperation]);
+  const retractForEdit = React3.useCallback(async (message) => {
+    const isCurrent = ownOperation();
     await remove(message);
+    assertCurrent(isCurrent);
     return { text: message.text, attachment_ids: message.attachment_ids, attachments: message.attachments };
-  }, [remove]);
-  const resume = React2.useCallback(async () => {
+  }, [remove, ownOperation]);
+  const resume = React3.useCallback(async () => {
     const selectedThreadId = threadRef.current;
     if (!selectedThreadId) return null;
+    const isCurrent = ownOperation();
     const result = await transportRef.current.resume(selectedThreadId);
+    if (!isCurrent()) return null;
     await refresh(selectedThreadId);
     return result;
-  }, [refresh]);
-  React2.useEffect(() => {
+  }, [refresh, ownOperation]);
+  const reset = React3.useCallback(() => {
+    initialAdmissionRef.current?.resolve(null);
+    initialAdmissionRef.current = null;
+    admissionRef.current = null;
+    selectionGenerationRef.current += 1;
     versionRef.current += 1;
     cursorRef.current = 0;
     promotedRef.current.clear();
     pendingRef.current.clear();
     setPendingMessages([]);
     setMessageQueue(null);
+  }, []);
+  React3.useEffect(() => {
+    const initial = initialAdmissionRef.current;
+    const adopting = Boolean(initial?.threadId && initial.threadId === threadId && initial.isCurrent());
+    if (adopting) {
+      for (const [id, message] of pendingRef.current) pendingRef.current.set(id, { ...message, thread_id: threadId });
+      initialAdmissionRef.current = null;
+    } else {
+      initial?.resolve(null);
+      initialAdmissionRef.current = null;
+      pendingRef.current.clear();
+      setPendingMessages([]);
+    }
+    versionRef.current += 1;
+    cursorRef.current = 0;
+    promotedRef.current.clear();
+    setMessageQueue(null);
     if (threadId) void refresh(threadId).catch(() => void 0);
+    return () => {
+      initialAdmissionRef.current?.resolve(null);
+    };
   }, [threadId, refresh]);
-  React2.useEffect(() => {
-    if (!threadId || !pendingMessages.length || messageQueue?.paused) return;
-    const clock = globalThis;
-    const timer = clock.setInterval(() => {
-      void refresh(threadId).catch(() => void 0);
-    }, 3e3);
-    return () => clock.clearInterval(timer);
-  }, [threadId, pendingMessages.length, messageQueue?.paused, refresh]);
-  return { pendingMessages, messageQueue, refresh, hydrate, acceptNotice, beginSubmission, discardSubmission, submit, edit, remove, retractForEdit, resume };
+  return {
+    pendingMessages,
+    messageQueue,
+    refresh,
+    hydrate,
+    acceptNotice,
+    beginSubmission,
+    discardSubmission,
+    reset,
+    confirmThreadAdmission,
+    hasPendingAdmission: () => Boolean(initialAdmissionRef.current?.isCurrent()),
+    waitForInitialAdmission: () => {
+      const initial = initialAdmissionRef.current;
+      return initial ? initial.done.then((threadId2) => {
+        if (!threadId2) throw initial.failure || Object.assign(new Error("Initial message admission detached."), { name: "AbortError" });
+        return threadId2;
+      }) : Promise.resolve(threadRef.current);
+    },
+    submit,
+    edit,
+    remove,
+    retractForEdit,
+    resume
+  };
 }
 function optimisticSubmissionTurn(message) {
   const user = {
@@ -1085,72 +1429,20 @@ function discardOptimisticSubmission(state, message) {
 }
 
 // src/use-agent-chat.ts
-import * as React6 from "react";
-
-// src/thread-summary-subscription.ts
-function waitForReconnect(signal, delay) {
-  return new Promise((resolve) => {
-    if (signal.aborted) return resolve();
-    const clock = globalThis;
-    const finish = () => {
-      clock.clearTimeout(timer);
-      signal.removeEventListener("abort", finish);
-      resolve();
-    };
-    const timer = clock.setTimeout(finish, delay);
-    signal.addEventListener("abort", finish, { once: true });
-  });
-}
-async function subscribeToThreadSummaries(input) {
-  let cursor;
-  let failures = 0;
-  while (!input.signal.aborted) {
-    let refreshedFromSnapshot = false;
-    try {
-      await input.client.threads.events({ cursor, signal: input.signal }, async (event) => {
-        if (event.event === "snapshot_required") {
-          await input.refresh();
-          cursor = void 0;
-          refreshedFromSnapshot = true;
-          return;
-        }
-        cursor = event.cursor;
-        failures = 0;
-        await input.onEvent(event);
-      });
-      if (input.signal.aborted) break;
-      if (!refreshedFromSnapshot) await input.refresh();
-      input.onRecovered();
-      failures = 0;
-    } catch (error) {
-      if (input.signal.aborted || isAbortLike(error)) break;
-      input.onError(error);
-      failures += 1;
-      try {
-        await input.refresh();
-        input.onRecovered();
-      } catch (refreshError) {
-        if (!input.signal.aborted && !isAbortLike(refreshError)) input.onError(refreshError);
-      }
-    }
-    if (!input.signal.aborted) {
-      await waitForReconnect(input.signal, Math.min(3e4, 1e3 * 2 ** Math.min(failures, 5)));
-    }
-  }
-}
+import * as React7 from "react";
 
 // src/use-agent-chat-thread-list.ts
-import * as React3 from "react";
+import * as React4 from "react";
 function summaryToStored(thread) {
   return { ...thread, id: String(thread.id), messages: [], isHydrated: false };
 }
 function useAgentChatThreadList({ client, threadPageSize, stateRef, update, clearOperationError, failOperation }) {
-  const [isLoadingThreads, setIsLoadingThreads] = React3.useState(false);
-  const [isLoadingMoreThreads, setIsLoadingMoreThreads] = React3.useState(false);
-  const [threadTotal, setThreadTotal] = React3.useState();
-  const refreshPromiseRef = React3.useRef(null);
-  const eventsDuringRefreshRef = React3.useRef(null);
-  const refreshThreads = React3.useCallback(() => {
+  const [isLoadingThreads, setIsLoadingThreads] = React4.useState(false);
+  const [isLoadingMoreThreads, setIsLoadingMoreThreads] = React4.useState(false);
+  const [threadTotal, setThreadTotal] = React4.useState();
+  const refreshPromiseRef = React4.useRef(null);
+  const eventsDuringRefreshRef = React4.useRef(null);
+  const refreshThreads = React4.useCallback(() => {
     if (refreshPromiseRef.current) return refreshPromiseRef.current;
     clearOperationError();
     setIsLoadingThreads(true);
@@ -1185,7 +1477,7 @@ function useAgentChatThreadList({ client, threadPageSize, stateRef, update, clea
     }).catch(() => void 0);
     return request;
   }, [clearOperationError, client, failOperation, threadPageSize, update]);
-  const loadMoreThreads = React3.useCallback(async () => {
+  const loadMoreThreads = React4.useCallback(async () => {
     if (isLoadingMoreThreads) return;
     const skip = stateRef.current.threads.length;
     if (threadTotal !== void 0 && skip >= threadTotal) return;
@@ -1220,15 +1512,30 @@ function useAgentChatThreadList({ client, threadPageSize, stateRef, update, clea
 }
 
 // src/use-agent-chat-feedback.ts
-import * as React4 from "react";
-function useAgentChatFeedback({ client, update, clearOperationError, failOperation }) {
-  return React4.useCallback(async (message, input) => {
+import * as React5 from "react";
+function useAgentChatFeedback({ client, update, clearOperationError, failOperation, ownOperation, refreshMessages }) {
+  const mutations = React5.useRef(/* @__PURE__ */ new Map());
+  const captureRead = React5.useCallback(() => {
+    const revisions = new Map([...mutations.current].map(([run, mutation]) => [run, mutation.readRevision]));
+    return (incoming, current) => incoming.map((message) => {
+      const mutation = message.runId ? mutations.current.get(message.runId) : void 0;
+      const preserve = mutation && (mutation.pending > 0 || mutation.readRevision !== revisions.get(message.runId));
+      const live = preserve && current.find((item) => item.role === "assistant" && item.runId === message.runId);
+      return live ? { ...message, feedback: live.feedback } : message;
+    });
+  }, []);
+  const setFeedback = React5.useCallback(async (message, input) => {
     const runId = message.runId;
     if (!runId || message.role !== "assistant" || message.isFinal === false) {
       const error = new Error("Only persisted final responses can receive feedback.");
       failOperation("set_feedback", error);
       throw error;
     }
+    const isCurrent = ownOperation();
+    const revision = (mutations.current.get(runId)?.revision ?? 0) + 1;
+    const pending = (mutations.current.get(runId)?.pending ?? 0) + 1;
+    mutations.current.set(runId, { revision, pending, readRevision: (mutations.current.get(runId)?.readRevision ?? 0) + 1 });
+    const isLatest = () => mutations.current.get(runId)?.revision === revision;
     const previous = message.feedback ?? null;
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
     const optimistic = input.rating ? {
@@ -1240,26 +1547,34 @@ function useAgentChatFeedback({ client, update, clearOperationError, failOperati
     } : null;
     const replaceFeedback = (current, feedback) => ({
       ...current,
-      messages: current.messages.map((item) => item.id === message.id ? { ...item, feedback } : item),
+      messages: current.messages.map((item) => item.role === "assistant" && item.runId === runId ? { ...item, feedback } : item),
       threads: current.threads.map((thread) => ({
         ...thread,
-        messages: thread.messages.map((item) => item.id === message.id ? { ...item, feedback } : item)
+        messages: thread.messages.map((item) => item.role === "assistant" && item.runId === runId ? { ...item, feedback } : item)
       }))
     });
     clearOperationError();
     update((current) => replaceFeedback(current, optimistic));
     try {
       const result = await client.runs.setFeedback({ runId, ...input });
-      update((current) => replaceFeedback(current, result.feedback));
+      if (isLatest() && isCurrent()) update((current) => replaceFeedback(current, result.feedback));
     } catch (error) {
-      update((current) => withAgentChatOperationError(replaceFeedback(current, previous), "set_feedback", error));
+      if (isLatest() && isCurrent()) update((current) => {
+        const restored = replaceFeedback(current, previous);
+        return isCurrent() ? withAgentChatOperationError(restored, "set_feedback", error) : restored;
+      });
       throw error;
+    } finally {
+      const mutation = mutations.current.get(runId);
+      mutations.current.set(runId, { ...mutation, readRevision: mutation.readRevision + 1, pending: mutation.pending - 1 });
+      if (mutation.pending === 1 && isCurrent()) await refreshMessages().catch(() => void 0);
     }
-  }, [clearOperationError, client, failOperation, update]);
+  }, [clearOperationError, client, failOperation, update, ownOperation, refreshMessages]);
+  return { setFeedback, captureRead };
 }
 
 // src/use-agent-chat-queue-actions.ts
-import * as React5 from "react";
+import * as React6 from "react";
 function useAgentChatQueueActions({
   queue,
   stateRef,
@@ -1267,21 +1582,23 @@ function useAgentChatQueueActions({
   clearOperationError,
   failOperation,
   refreshMessages,
-  attachRun
+  attachRun,
+  ownOperation
 }) {
-  const steer = React5.useCallback(async (text2) => {
+  const steer = React6.useCallback(async (text2) => {
     const threadId = stateRef.current.activeThreadId;
     if (!threadId || !text2.trim()) throw new Error("An active thread and text are required to steer.");
+    const isCurrent = ownOperation();
     clearOperationError();
     try {
       await queue.submit({ mode: "steer", input: text2.trim(), idempotencyKey: createId() });
-      await refreshMessages(threadId);
+      if (isCurrent()) await refreshMessages(threadId);
     } catch (error) {
-      failOperation("submit", error);
+      if (isCurrent()) failOperation("submit", error);
       throw error;
     }
-  }, [clearOperationError, createId, failOperation, queue.submit, refreshMessages, stateRef]);
-  const editPendingMessage = React5.useCallback(async (message, input) => {
+  }, [clearOperationError, createId, failOperation, queue.submit, refreshMessages, stateRef, ownOperation]);
+  const editPendingMessage = React6.useCallback(async (message, input) => {
     await queue.edit(message, {
       text: input.text,
       attachmentIds: input.attachmentIds ?? message.attachment_ids,
@@ -1289,14 +1606,15 @@ function useAgentChatQueueActions({
       requestedModelId: input.requestedModelId
     });
   }, [queue.edit]);
-  const steerPendingMessage = React5.useCallback(async (message) => {
+  const steerPendingMessage = React6.useCallback(async (message) => {
     await queue.edit(message, { text: message.text, attachmentIds: message.attachment_ids, mode: "steer" });
   }, [queue.edit]);
-  const resumeQueue = React5.useCallback(async () => {
+  const resumeQueue = React6.useCallback(async () => {
     if (!stateRef.current.activeThreadId) return;
+    const isCurrent = ownOperation();
     const result = await queue.resume();
-    if (result?.run_id) void attachRun(result.run_id).catch(() => void 0);
-  }, [attachRun, queue.resume, stateRef]);
+    if (isCurrent() && result?.run_id && stateRef.current.activeRunId !== result.run_id) void attachRun(result.run_id).catch(() => void 0);
+  }, [attachRun, queue.resume, stateRef, ownOperation]);
   return { steer, editPendingMessage, steerPendingMessage, removePendingMessage: queue.remove, resumeQueue };
 }
 
@@ -1307,9 +1625,6 @@ function resolveInitialActiveThreadId(options, storedThreadId) {
 function shouldHydrateSelectedThread(selectedThreadId, activeThreadId, activeThreadIsHydrated) {
   return Boolean(selectedThreadId) && (selectedThreadId !== activeThreadId || !activeThreadIsHydrated);
 }
-function isCurrentThreadOpenRequest(input) {
-  return !input.signalAborted && input.requestGeneration === input.currentGeneration && input.requestedThreadId === input.activeThreadId;
-}
 
 // src/use-agent-chat.ts
 function activeRunIdFromThread(thread) {
@@ -1322,7 +1637,7 @@ function useAgentChat(options = {}) {
   const client = options.client || runtime.client;
   const pageSize = options.pageSize ?? 30;
   const threadPageSize = options.threadPageSize ?? 50;
-  const [state, setState] = React6.useState(() => ({
+  const [state, setState] = React7.useState(() => ({
     ...initialAgentChatState,
     activeThreadId: resolveInitialActiveThreadId(
       options,
@@ -1330,34 +1645,38 @@ function useAgentChat(options = {}) {
     ),
     threads: runtime.storage?.loadThreads() ?? []
   }));
-  const [isLoadingHistory, setIsLoadingHistory] = React6.useState(false);
-  const [isLoadingOlder, setIsLoadingOlder] = React6.useState(false);
-  const [isSubmitting, setIsSubmitting] = React6.useState(false);
-  const streamControllerRef = React6.useRef(null);
-  const threadOpenControllerRef = React6.useRef(null);
-  const threadOpenGenerationRef = React6.useRef(0);
-  const attachRunRef = React6.useRef(async () => void 0);
-  const messageRefreshVersionRef = React6.useRef(0);
-  const promotedRunHintRef = React6.useRef(null);
-  const promotedAttachRef = React6.useRef(null);
-  const firstSubmissionRef = React6.useRef(null);
-  const firstSubmissionAdmittedRef = React6.useRef(null);
-  const stateRef = React6.useRef(state);
+  const [isLoadingHistory, setIsLoadingHistory] = React7.useState(false);
+  const [isLoadingOlder, setIsLoadingOlder] = React7.useState(false);
+  const [isSubmitting, setIsSubmitting] = React7.useState(false);
+  const streamControllerRef = React7.useRef(null);
+  const threadOpenControllerRef = React7.useRef(null);
+  const threadOpenGenerationRef = React7.useRef(0);
+  const attachRunRef = React7.useRef(async () => void 0);
+  const messageRefreshVersionRef = React7.useRef(0);
+  const promotedRunHintRef = React7.useRef(null);
+  const promotedAttachRef = React7.useRef(null);
+  const olderRequestRef = React7.useRef(null);
+  const submissionGenerationRef = React7.useRef(0);
+  const stateRef = React7.useRef(state);
   stateRef.current = state;
-  const persist = React6.useCallback((next) => {
+  const ownOperation = React7.useCallback((options2) => captureChatOperation(() => ({
+    generation: threadOpenGenerationRef.current,
+    threadId: stateRef.current.activeThreadId,
+    runId: stateRef.current.activeRunId,
+    stream: streamControllerRef.current
+  }), options2), []);
+  const persist = React7.useCallback((next) => {
     runtime.storage?.saveThreads(next.threads);
     runtime.storage?.saveActiveThreadId?.(next.activeThreadId);
   }, [runtime.storage]);
-  const update = React6.useCallback((updater) => {
-    setState((current) => {
-      const next = updater(current);
-      stateRef.current = next;
-      persist(next);
-      return next;
-    });
+  const update = React7.useCallback((updater) => {
+    const next = updater(stateRef.current);
+    stateRef.current = next;
+    persist(next);
+    setState(next);
   }, [persist]);
-  const queueTransport = React6.useMemo(() => ({
-    list: (threadId) => client.threads.messages.list({ threadId, limit: pageSize }),
+  const queueTransport = React7.useMemo(() => ({
+    list: (threadId, signal) => client.threads.messages.list({ threadId, limit: pageSize, signal }),
     submit: (input) => client.threads.messages.submit(input),
     edit: (message, input) => client.threads.messages.edit({
       threadId: message.thread_id,
@@ -1374,40 +1693,46 @@ function useAgentChat(options = {}) {
     },
     resume: (threadId) => client.threads.resumeQueue({ threadId })
   }), [client, pageSize]);
-  const onQueuePromotion = React6.useCallback((message, runId) => {
-    if (stateRef.current.activeThreadId !== message.thread_id) return;
+  const attachPromotion = React7.useCallback((runId, threadId) => {
+    if (stateRef.current.activeThreadId !== threadId) return;
     promotedRunHintRef.current = runId;
+    if (stateRef.current.activeRunId === runId || promotedAttachRef.current === runId) return;
+    promotedAttachRef.current = runId;
+    const isCurrent = ownOperation();
+    void attachRunRef.current(runId, 0).catch(() => {
+      if (isCurrent() && promotedAttachRef.current === runId) promotedAttachRef.current = null;
+    });
+  }, [ownOperation]);
+  const onQueuePromotion = React7.useCallback((message, runId) => {
+    if (stateRef.current.activeThreadId !== message.thread_id) return;
     const userMessage = threadTimelineToMessages([{ ...message, run_id: runId, status: "delivered" }])[0];
     update((current) => current.activeThreadId === message.thread_id ? { ...current, messages: promoteThreadMessage(current.messages, userMessage, runId) } : current);
-    if (stateRef.current.activeRunId !== runId && promotedAttachRef.current !== runId) {
-      promotedAttachRef.current = runId;
-      void attachRunRef.current(runId).catch(() => {
-        promotedAttachRef.current = null;
-      });
-    }
-  }, [update]);
+    attachPromotion(runId, message.thread_id);
+  }, [update, attachPromotion]);
   const queue = useThreadMessageQueue({
     threadId: state.activeThreadId,
     transport: queueTransport,
+    ownOperation,
     onPromoted: onQueuePromotion,
+    onUnknownPromotion: attachPromotion,
     onOptimistic: (message, uploading) => update((current) => optimisticSubmissionState(current, message, uploading)),
     onDiscard: (message) => update((current) => discardOptimisticSubmission(current, message))
   });
   const { pendingMessages, messageQueue } = queue;
-  const eventBuffer = React6.useMemo(
+  const eventBuffer = React7.useMemo(
     () => createRuntimeEventFrameBuffer(
       (events) => update((current) => applyRuntimeEvents(current, events)),
       runtimeEventFrameScheduler()
     ),
     [update]
   );
-  const clearOperationError = React6.useCallback((operation) => {
+  const clearOperationError = React7.useCallback((operation) => {
     update((current) => clearAgentChatOperationError(current, operation));
   }, [update]);
-  const clearBackgroundError = React6.useCallback(() => {
+  const clearBackgroundError = React7.useCallback(() => {
     update(clearAgentChatBackgroundError);
   }, [update]);
-  const failOperation = React6.useCallback((operation, cause) => {
+  const failOperation = React7.useCallback((operation, cause) => {
     update((current) => withAgentChatOperationError(current, operation, cause));
   }, [update]);
   const {
@@ -1418,60 +1743,66 @@ function useAgentChat(options = {}) {
     refreshThreads,
     loadMoreThreads
   } = useAgentChatThreadList({ client, threadPageSize, stateRef, update, clearOperationError, failOperation });
-  const invalidateThreadOpen = React6.useCallback(() => {
+  const invalidateThreadOpen = React7.useCallback(() => {
     threadOpenGenerationRef.current += 1;
     threadOpenControllerRef.current?.abort("Thread selection changed.");
     threadOpenControllerRef.current = null;
+    messageRefreshVersionRef.current += 1;
+    promotedAttachRef.current = null;
+    promotedRunHintRef.current = null;
+    olderRequestRef.current = null;
+    queue.reset();
+    setIsSubmitting(false);
+    setIsLoadingOlder(false);
     setIsLoadingHistory(false);
-  }, []);
-  const detach = React6.useCallback(() => {
+  }, [queue.reset]);
+  const detach = React7.useCallback(() => {
     eventBuffer.flush();
     streamControllerRef.current?.abort();
     streamControllerRef.current = null;
     update((current) => ({ ...current, streamingMessageId: null, runState: current.activeRunId ? "reconnecting" : "idle" }));
   }, [eventBuffer, update]);
-  const refreshMessages = React6.useCallback(async (threadId, promotedRunId) => {
+  const refreshMessagesRef = React7.useRef(async () => void 0);
+  const { setFeedback, captureRead: captureFeedbackRead } = useAgentChatFeedback({
+    client,
+    update,
+    clearOperationError,
+    failOperation,
+    ownOperation,
+    refreshMessages: React7.useCallback(() => refreshMessagesRef.current(), [])
+  });
+  const refreshMessages = React7.useCallback(async (threadId, promotedRunId, signal) => {
     const target = threadId || stateRef.current.activeThreadId;
     if (!target) return;
+    const isCurrent = ownOperation();
+    const reconcileFeedback = captureFeedbackRead();
     const version = ++messageRefreshVersionRef.current;
-    const page = await client.threads.messages.list({ threadId: target, limit: pageSize });
-    if (stateRef.current.activeThreadId !== target || version !== messageRefreshVersionRef.current) return;
+    const page = await client.threads.messages.list({ threadId: target, limit: pageSize, ...signal ? { signal } : {} });
+    if (!isCurrent() || stateRef.current.activeThreadId !== target || version !== messageRefreshVersionRef.current) return;
     queue.hydrate(page, target);
     const promoted = promotedRunId || promotedRunHintRef.current;
-    if (promoted && page.items.some((message) => message.role === "user" && message.run_id === promoted)) {
-      promotedRunHintRef.current = null;
-      update((current) => {
-        if (current.activeThreadId !== target) return current;
-        return {
-          ...current,
-          messages: reconcileThreadTimeline(current.messages, threadTimelineToMessages(page.items), current.activeRunId, current.streamingMessageId)
-        };
-      });
-      return;
-    }
-    if (stateRef.current.activeRunId) {
-      const delivered = threadTimelineToMessages(page.items.filter((item) => item.role === "user" && item.run_id === stateRef.current.activeRunId && (item.segment_index ?? 0) > 0));
-      if (delivered.length) update((current) => {
-        if (current.activeThreadId !== target) return current;
-        const additions = delivered.filter((item) => !current.messages.some((existing) => existing.id === item.id));
-        return additions.length ? { ...current, messages: [...current.messages, ...additions] } : current;
-      });
-    }
-    if (!stateRef.current.activeRunId && page.items.length) {
-      update((current) => current.activeThreadId === target && !current.activeRunId ? (() => {
-        const messages = reconcileThreadTimeline(current.messages, threadTimelineToMessages(page.items), null, null);
-        return { ...current, messages, threads: current.threads.map((thread) => thread.id === target ? { ...thread, messages } : thread) };
-      })() : current);
-    }
-  }, [client, pageSize, queue.hydrate, update]);
-  React6.useEffect(() => () => {
+    if (promoted && page.items.some((message) => message.run_id === promoted)) promotedRunHintRef.current = null;
+    update((current) => {
+      if (!isCurrent() || current.activeThreadId !== target) return current;
+      const messages = reconcileThreadTimeline(
+        current.messages,
+        reconcileFeedback(threadTimelineToMessages(page.items), current.messages),
+        current.activeRunId,
+        current.streamingMessageId
+      );
+      return { ...current, messages, threads: current.threads.map((thread) => thread.id === target ? { ...thread, messages } : thread) };
+    });
+  }, [client, ownOperation, pageSize, queue.hydrate, update, captureFeedbackRead]);
+  refreshMessagesRef.current = refreshMessages;
+  React7.useEffect(() => () => {
+    threadOpenGenerationRef.current += 1;
     eventBuffer.dispose();
     streamControllerRef.current?.abort();
     threadOpenControllerRef.current?.abort();
   }, [eventBuffer]);
-  const openThread = React6.useCallback(async (threadId) => {
+  const openThread = React7.useCallback(async (threadId) => {
     const previousSelection = captureAgentChatThreadSelection(stateRef.current);
-    threadOpenControllerRef.current?.abort();
+    invalidateThreadOpen();
     const requestController = runtime.createAbortController();
     threadOpenControllerRef.current = requestController;
     const requestGeneration = threadOpenGenerationRef.current + 1;
@@ -1491,6 +1822,8 @@ function useAgentChat(options = {}) {
       runState: "idle",
       streamingMessageId: null
     }));
+    const isCurrent = ownOperation();
+    const reconcileFeedback = captureFeedbackRead();
     setIsLoadingHistory(true);
     try {
       const detail = await client.threads.get({
@@ -1498,39 +1831,21 @@ function useAgentChat(options = {}) {
         limit: pageSize,
         signal: requestController.signal
       });
-      if (!isCurrentThreadOpenRequest({
-        activeThreadId: stateRef.current.activeThreadId,
-        currentGeneration: threadOpenGenerationRef.current,
-        requestGeneration,
-        requestedThreadId: threadId,
-        signalAborted: requestController.signal.aborted
-      })) return;
+      if (!isCurrent()) return;
       const timeline = await client.threads.messages.list({ threadId, limit: pageSize, signal: requestController.signal });
-      if (!isCurrentThreadOpenRequest({
-        activeThreadId: stateRef.current.activeThreadId,
-        currentGeneration: threadOpenGenerationRef.current,
-        requestGeneration,
-        requestedThreadId: threadId,
-        signalAborted: requestController.signal.aborted
-      })) return;
+      if (!isCurrent()) return;
       queue.hydrate(timeline, threadId);
-      const messages = timeline.items.length ? threadTimelineToMessages(timeline.items, detail) : threadDetailToMessages(detail);
+      const messages = reconcileFeedback(threadTimelineToMessages(timeline.items), stateRef.current.messages);
       const context = latestThreadContext(detail);
       const stored = {
         ...detail,
         messages,
         isHydrated: true,
-        hasOlderTurns: Boolean(detail.paging?.has_more),
-        nextBeforeTurnIndex: detail.paging?.next_before_turn_index ?? null,
+        hasOlderTurns: Boolean(timeline.paging.has_more),
+        nextBeforeTurnIndex: timeline.paging.next_before_turn_index,
         ...context
       };
-      update((current) => isCurrentThreadOpenRequest({
-        activeThreadId: current.activeThreadId,
-        currentGeneration: threadOpenGenerationRef.current,
-        requestGeneration,
-        requestedThreadId: threadId,
-        signalAborted: requestController.signal.aborted
-      }) ? {
+      update((current) => isCurrent() ? {
         ...current,
         activeThreadId: threadId,
         messages,
@@ -1540,13 +1855,7 @@ function useAgentChat(options = {}) {
         threads: current.threads.some((thread) => thread.id === threadId) ? current.threads.map((thread) => thread.id === threadId ? stored : thread) : [stored, ...current.threads]
       } : current);
       const activeRunId = activeRunIdFromThread(stored);
-      if (activeRunId && isCurrentThreadOpenRequest({
-        activeThreadId: stateRef.current.activeThreadId,
-        currentGeneration: threadOpenGenerationRef.current,
-        requestGeneration,
-        requestedThreadId: threadId,
-        signalAborted: requestController.signal.aborted
-      })) await attachRunRef.current(activeRunId).catch(() => void 0);
+      if (activeRunId && isCurrent()) void attachRunRef.current(activeRunId).catch(() => void 0);
     } catch (error) {
       if (!requestController.signal.aborted && !isAbortLike(error) && requestGeneration === threadOpenGenerationRef.current) {
         failOperation("open_thread", error);
@@ -1562,28 +1871,34 @@ function useAgentChat(options = {}) {
         setIsLoadingHistory(false);
       }
     }
-  }, [clearOperationError, client, detach, failOperation, pageSize, queue.hydrate, runtime, update]);
-  const consumeEvent = React6.useCallback((event) => {
+  }, [clearOperationError, client, detach, failOperation, pageSize, queue.hydrate, runtime, update, invalidateThreadOpen, ownOperation, captureFeedbackRead]);
+  const consumeEvent = React7.useCallback((event) => {
     const eventThreadId = typeof event.payload?.thread_id === "string" ? event.payload.thread_id.trim() : "";
     if (eventThreadId && !stateRef.current.activeThreadId) {
+      queue.confirmThreadAdmission(eventThreadId);
       update((current) => adoptStreamingThread(current, eventThreadId));
-      firstSubmissionAdmittedRef.current?.();
+      setIsSubmitting(false);
     }
     eventBuffer.push(event);
-  }, [eventBuffer, update]);
-  const attachRun = React6.useCallback(async (runId, cursor) => {
+  }, [eventBuffer, update, queue.confirmThreadAdmission]);
+  const attachRun = React7.useCallback(async (runId, cursor) => {
+    eventBuffer.flush();
     streamControllerRef.current?.abort();
     const controller = runtime.createAbortController();
     streamControllerRef.current = controller;
-    clearOperationError();
+    const isCurrent = ownOperation({ stream: true });
+    clearOperationError("attach_run");
     update((current) => ({ ...current, activeRunId: runId, runState: "reconnecting", error: null }));
     try {
-      const result = await client.runs.attach({ runId, cursor, signal: controller.signal }, consumeEvent);
+      const result = await client.runs.attach({ runId, cursor, leaseSeconds: 60, signal: controller.signal }, (event) => {
+        if (isCurrent()) consumeEvent(event);
+      });
+      if (!isCurrent()) return;
       eventBuffer.flush();
       update((current) => ({ ...current, activeRunId: result.detached ? runId : current.activeRunId, cursor: result.cursor ?? current.cursor, runState: result.detached ? "reconnecting" : current.runState }));
       if (!result.detached && result.threadId) await refreshMessages(result.threadId);
     } catch (error) {
-      if (!isAbortLike(error)) {
+      if (isCurrent() && !isAbortLike(error)) {
         update((current) => ({ ...current, runState: "failed", streamingMessageId: null }));
         failOperation("attach_run", error);
         throw error;
@@ -1591,15 +1906,14 @@ function useAgentChat(options = {}) {
     } finally {
       if (streamControllerRef.current === controller) streamControllerRef.current = null;
     }
-  }, [clearOperationError, client, consumeEvent, eventBuffer, failOperation, refreshMessages, runtime, update]);
+  }, [clearOperationError, client, consumeEvent, eventBuffer, failOperation, refreshMessages, runtime, update, ownOperation]);
   attachRunRef.current = attachRun;
-  const submit = React6.useCallback(async (input) => {
+  const submit = React7.useCallback(async (input) => {
     if (!input.text.trim() && !input.attachmentIds?.length && !input.uploads?.length) return;
-    if (firstSubmissionRef.current && !stateRef.current.activeThreadId) {
-      await firstSubmissionRef.current;
-    }
     const existingThreadId = stateRef.current.activeThreadId;
-    if (existingThreadId) {
+    if (existingThreadId || queue.hasPendingAdmission()) {
+      const isCurrent = ownOperation({ adoptThread: !existingThreadId });
+      const submissionGeneration = ++submissionGenerationRef.current;
       clearOperationError();
       setIsSubmitting(true);
       try {
@@ -1627,7 +1941,7 @@ function useAgentChat(options = {}) {
           prepare: async () => {
             const uploaded = input.uploads?.length ? await client.attachments.uploadBatch({
               uploads: input.uploads,
-              threadId: existingThreadId,
+              threadId: existingThreadId || void 0,
               requestedAgentId: input.requestedAgentId,
               idempotencyKey: runtime.createId()
             }) : [];
@@ -1644,21 +1958,21 @@ function useAgentChat(options = {}) {
           }
         });
       } catch (error) {
-        failOperation("submit", error);
+        if (isCurrent()) failOperation("submit", error);
         throw error;
       } finally {
-        setIsSubmitting(false);
+        if (isCurrent() && submissionGeneration === submissionGenerationRef.current) setIsSubmitting(false);
       }
       return;
     }
-    const admission = new Promise((resolve) => {
-      firstSubmissionAdmittedRef.current = resolve;
-    });
+    invalidateThreadOpen();
+    const submissionOwner = ownOperation({ adoptThread: true });
     const stream = (async () => {
-      invalidateThreadOpen();
       detach();
       const controller = runtime.createAbortController();
       streamControllerRef.current = controller;
+      const isCurrent = ownOperation({ stream: true, adoptThread: true });
+      const submissionGeneration = ++submissionGenerationRef.current;
       const ticket = queue.beginSubmission({
         input: input.text.trim(),
         clientSubmissionId: runtime.createId(),
@@ -1689,6 +2003,7 @@ function useAgentChat(options = {}) {
           idempotencyKey: runtime.createId(),
           signal: controller.signal
         }) : [];
+        if (!isCurrent()) return;
         if (hasPendingUploads && uploaded.length !== input.uploads?.length) {
           throw new Error("Attachment upload returned an incomplete batch");
         }
@@ -1701,7 +2016,20 @@ function useAgentChat(options = {}) {
             runState: "streaming"
           }));
         }
-        const result = await client.chat.stream({ clientSubmissionId: ticket.client_submission_id, input: input.text.trim(), threadId: stateRef.current.activeThreadId || void 0, attachmentIds, requestedModelId: input.requestedModelId, requestedAgentId: input.requestedAgentId, idempotencyKey, signal: controller.signal }, consumeEvent);
+        const result = await client.chat.stream({
+          leaseSeconds: 60,
+          clientSubmissionId: ticket.client_submission_id,
+          input: input.text.trim(),
+          threadId: stateRef.current.activeThreadId || void 0,
+          attachmentIds,
+          requestedModelId: input.requestedModelId,
+          requestedAgentId: input.requestedAgentId,
+          idempotencyKey,
+          signal: controller.signal
+        }, (event) => {
+          if (isCurrent()) consumeEvent(event);
+        });
+        if (!isCurrent()) return;
         eventBuffer.flush();
         update((current) => {
           const threadId = result.threadId || current.activeThreadId;
@@ -1717,8 +2045,9 @@ function useAgentChat(options = {}) {
         if (result.threadId) await refreshThreads().catch(() => void 0);
         if (result.threadId && !result.detached) await refreshMessages(result.threadId);
       } catch (error) {
+        if (!isCurrent()) return;
         const admitted = Boolean(stateRef.current.messages.find((message) => message.id === userId)?.runId);
-        if (!admitted) queue.discardSubmission(ticket);
+        if (!admitted) queue.discardSubmission(ticket, error);
         if (!isAbortLike(error)) {
           update((current) => ({
             ...current,
@@ -1729,19 +2058,17 @@ function useAgentChat(options = {}) {
           throw error;
         }
       } finally {
-        setIsSubmitting(false);
+        if (!stateRef.current.messages.some((message) => (message.id === ticket.id || message.clientSubmissionId === ticket.client_submission_id) && message.runId)) queue.discardSubmission(ticket);
+        if (isCurrent() && submissionGeneration === submissionGenerationRef.current) setIsSubmitting(false);
         if (streamControllerRef.current === controller) streamControllerRef.current = null;
       }
     })();
-    const accepted = Promise.race([stream, admission]);
-    firstSubmissionRef.current = accepted;
     try {
-      await accepted;
-    } finally {
-      if (firstSubmissionRef.current === accepted) firstSubmissionRef.current = null;
-      firstSubmissionAdmittedRef.current = null;
+      await Promise.race([stream, queue.waitForInitialAdmission()]);
+    } catch (error) {
+      if (submissionOwner() || !isAbortLike(error)) throw error;
     }
-  }, [clearOperationError, client, consumeEvent, detach, eventBuffer, failOperation, invalidateThreadOpen, queue.submit, refreshMessages, refreshThreads, runtime, update]);
+  }, [clearOperationError, client, consumeEvent, detach, eventBuffer, failOperation, invalidateThreadOpen, queue.submit, refreshMessages, refreshThreads, runtime, update, ownOperation]);
   const { steer, editPendingMessage, steerPendingMessage, removePendingMessage, resumeQueue } = useAgentChatQueueActions({
     queue,
     stateRef,
@@ -1749,42 +2076,38 @@ function useAgentChat(options = {}) {
     clearOperationError,
     failOperation,
     refreshMessages,
-    attachRun
+    attachRun,
+    ownOperation
   });
-  const startNewThread = React6.useCallback(() => {
+  const startNewThread = React7.useCallback(() => {
     invalidateThreadOpen();
     detach();
     update((current) => ({ ...initialAgentChatState, threads: current.threads }));
   }, [detach, invalidateThreadOpen, update]);
-  const deleteThread = React6.useCallback(async (threadId) => {
-    if (stateRef.current.activeThreadId === threadId) invalidateThreadOpen();
+  const deleteThread = React7.useCallback(async (threadId) => {
+    const isCurrent = ownOperation();
     clearOperationError();
     try {
       await client.threads.delete({ threadId, idempotencyKey: runtime.createId() });
-      update((current) => ({
-        ...current,
-        activeThreadId: current.activeThreadId === threadId ? null : current.activeThreadId,
-        messages: current.activeThreadId === threadId ? [] : current.messages,
-        contextWindow: current.activeThreadId === threadId ? null : current.contextWindow,
-        contextCompression: current.activeThreadId === threadId ? null : current.contextCompression,
-        contextCompressionRevision: current.activeThreadId === threadId ? 0 : current.contextCompressionRevision,
-        threads: current.threads.filter((thread) => thread.id !== threadId)
-      }));
+      if (stateRef.current.activeThreadId === threadId) startNewThread();
+      update((current) => ({ ...current, threads: current.threads.filter((thread) => thread.id !== threadId) }));
     } catch (error) {
       if (!isAbortLike(error)) {
-        failOperation("delete_thread", error);
+        if (isCurrent()) failOperation("delete_thread", error);
         throw error;
       }
     }
-  }, [clearOperationError, client, failOperation, invalidateThreadOpen, runtime, update]);
-  const cancelRun = React6.useCallback(async () => {
+  }, [clearOperationError, client, failOperation, ownOperation, runtime, startNewThread, update]);
+  const cancelRun = React7.useCallback(async () => {
     const runId = stateRef.current.activeRunId;
     if (!runId || stateRef.current.runState === "cancelling") return;
+    const isCurrent = ownOperation({ run: true, stream: true });
     const previousRunState = stateRef.current.runState;
     clearOperationError();
     update((current) => current.activeRunId === runId ? { ...current, runState: "cancelling" } : current);
     try {
       const result = await client.runs.cancel({ runId, idempotencyKey: runtime.createId() });
+      if (!isCurrent()) return;
       if (result.status === "cancelled") {
         detach();
         update((current) => ({
@@ -1809,14 +2132,15 @@ function useAgentChat(options = {}) {
         }));
       }
     } catch (error) {
-      if (!isAbortLike(error)) {
+      if (isCurrent() && !isAbortLike(error)) {
         update((current) => current.activeRunId === runId ? { ...current, runState: previousRunState } : current);
         failOperation("cancel_run", error);
         throw error;
       }
     }
-  }, [clearOperationError, client, detach, failOperation, runtime, update]);
-  const resumeHitl = React6.useCallback(async (part, response) => {
+  }, [clearOperationError, client, detach, failOperation, runtime, update, ownOperation]);
+  const resumeHitl = React7.useCallback(async (part, response) => {
+    const isCurrent = ownOperation({ run: true, stream: true });
     const runId = stateRef.current.activeRunId || stateRef.current.messages.find((message) => message.parts.includes(part))?.runId;
     clearOperationError();
     if (!runId) {
@@ -1831,32 +2155,52 @@ function useAgentChat(options = {}) {
         ...response,
         idempotencyKey: runtime.createId()
       });
-      await attachRun(result.run_id || runId);
+      if (isCurrent()) await attachRun(result.run_id || runId);
     } catch (error) {
-      if (!isAbortLike(error)) failOperation("resume_hitl", error);
+      if (isCurrent() && !isAbortLike(error)) failOperation("resume_hitl", error);
       throw error;
     }
-  }, [attachRun, clearOperationError, client, failOperation, runtime]);
-  const setFeedback = useAgentChatFeedback({ client, update, clearOperationError, failOperation });
-  const loadOlder = React6.useCallback(async () => {
+  }, [attachRun, clearOperationError, client, failOperation, runtime, ownOperation]);
+  const loadOlder = React7.useCallback(() => {
     const thread = stateRef.current.threads.find((item) => item.id === stateRef.current.activeThreadId);
-    if (!thread?.nextBeforeTurnIndex) return;
+    if (thread?.nextBeforeTurnIndex == null) return Promise.resolve();
+    const cursor = thread.nextBeforeTurnIndex;
+    const reconcileFeedback = captureFeedbackRead();
+    const key = `${threadOpenGenerationRef.current}:${thread.id}:${cursor}`;
+    if (olderRequestRef.current?.key === key) return olderRequestRef.current.promise;
+    const isCurrent = ownOperation();
     clearOperationError();
     setIsLoadingOlder(true);
-    try {
-      const detail = await client.threads.get({ threadId: thread.id, limit: pageSize, beforeTurnIndex: thread.nextBeforeTurnIndex });
-      const older = threadDetailToMessages(detail);
-      update((current) => ({ ...current, messages: [...older, ...current.messages.filter((message) => !older.some((item) => item.id === message.id))], threads: current.threads.map((item) => item.id === thread.id ? { ...item, hasOlderTurns: Boolean(detail.paging?.has_more), nextBeforeTurnIndex: detail.paging?.next_before_turn_index ?? null } : item) }));
-    } catch (error) {
-      if (!isAbortLike(error)) {
-        failOperation("load_older_turns", error);
-        throw error;
+    const promise = (async () => {
+      try {
+        const page = await client.threads.messages.list({ threadId: thread.id, limit: pageSize, before: cursor });
+        if (!isCurrent()) return;
+        const older = reconcileFeedback(threadTimelineToMessages(page.items), stateRef.current.messages);
+        update((current) => ({
+          ...current,
+          messages: prependThreadTimeline(current.messages, older),
+          threads: current.threads.map((item) => item.id === thread.id ? {
+            ...item,
+            hasOlderTurns: page.paging.has_more,
+            nextBeforeTurnIndex: page.paging.next_before_turn_index
+          } : item)
+        }));
+      } catch (error) {
+        if (isCurrent() && !isAbortLike(error)) {
+          failOperation("load_older_turns", error);
+          throw error;
+        }
+      } finally {
+        if (olderRequestRef.current?.key === key) {
+          olderRequestRef.current = null;
+          setIsLoadingOlder(false);
+        }
       }
-    } finally {
-      setIsLoadingOlder(false);
-    }
-  }, [clearOperationError, client, failOperation, pageSize, update]);
-  const regenerate = React6.useCallback(async (message) => {
+    })();
+    olderRequestRef.current = { key, promise };
+    return promise;
+  }, [clearOperationError, client, failOperation, ownOperation, pageSize, update, captureFeedbackRead]);
+  const regenerate = React7.useCallback(async (message) => {
     const index = stateRef.current.messages.findIndex((item) => item.id === message.id);
     const user = stateRef.current.messages.slice(0, index).reverse().find((item) => item.role === "user");
     if (user) await submit({
@@ -1865,51 +2209,68 @@ function useAgentChat(options = {}) {
       attachments: user.attachments
     });
   }, [submit]);
-  React6.useEffect(() => {
-    const controller = runtime.createAbortController();
-    clearBackgroundError();
-    void subscribeToThreadSummaries({
-      client,
-      signal: controller.signal,
-      refresh: refreshThreads,
-      onEvent(event) {
-        threadEventsDuringRefreshRef.current?.push(event);
-        update((current) => ({
-          ...clearAgentChatBackgroundError(current),
-          threads: applyThreadSummaryEvent(current.threads, event)
-        }));
-        if (event.event === "thread.message.updated" && event.thread_id === stateRef.current.activeThreadId) {
-          const wasQueued = queue.acceptNotice({
-            messageId: event.message_id,
-            status: event.status,
-            runId: event.run_id,
-            cursor: event.cursor,
-            clientSubmissionId: event.client_submission_id
-          });
-          if (wasQueued) void refreshMessages(event.thread_id, event.run_id || void 0).catch(() => void 0);
-        }
-        if (event.event === "thread.summary.updated" && event.thread.id === stateRef.current.activeThreadId) {
-          if (streamControllerRef.current && stateRef.current.messages.some((message) => message.role === "user" && !message.runId)) return;
-          const promotedRunId = activeRunIdFromThread(summaryToStored(event.thread));
-          void (async () => {
-            await refreshMessages(String(event.thread.id), promotedRunId || void 0);
-            if (promotedRunId && stateRef.current.activeRunId !== promotedRunId && stateRef.current.activeThreadId === String(event.thread.id) && promotedAttachRef.current !== promotedRunId) {
-              promotedAttachRef.current = promotedRunId;
-              await attachRunRef.current(promotedRunId);
-            }
-          })().catch(() => void 0);
-        }
-      },
-      onError(error) {
-        update((current) => withAgentChatBackgroundError(current, error));
-      },
-      onRecovered() {
-        clearBackgroundError();
+  useChatObservation({
+    state: {
+      threadId: state.activeThreadId,
+      running: Boolean(state.activeRunId) && !["idle", "completed", "failed", "cancelled"].includes(state.runState),
+      waiting: ["paused", "waiting", "interrupted"].includes(state.runState),
+      pending: pendingMessages.length > 0,
+      paused: Boolean(messageQueue?.paused),
+      degraded: state.runState === "reconnecting",
+      mode: options.observation
+    },
+    visibility: runtime.visibility,
+    createAbortController: runtime.createAbortController,
+    events: (input, handler) => client.threads.events(input, handler),
+    async refresh(signal) {
+      const target = stateRef.current.activeThreadId;
+      if (!target) return;
+      const isCurrent = ownOperation();
+      const detail = await client.threads.get({ threadId: target, limit: 1, signal });
+      if (!isCurrent() || signal.aborted) return;
+      const summary = summaryToStored(detail);
+      update((current) => ({ ...current, threads: applyThreadSummaryEvent(current.threads, {
+        schema_version: "agents24.thread_summary_event.v1",
+        event: "thread.summary.updated",
+        cursor: 0,
+        thread: detail
+      }) }));
+      const runId = activeRunIdFromThread(summary);
+      if (runId && !streamControllerRef.current) {
+        void attachRunRef.current(runId, runId === stateRef.current.activeRunId ? stateRef.current.cursor ?? void 0 : 0).catch(() => void 0);
       }
-    });
-    return () => controller.abort();
-  }, [clearBackgroundError, client, queue.acceptNotice, refreshMessages, refreshThreads, runtime.createAbortController, update]);
-  React6.useEffect(() => {
+      await refreshMessages(target, runId || void 0, signal);
+    },
+    onEvent(event) {
+      if (event.event === "thread.deleted" && event.thread_id === stateRef.current.activeThreadId) startNewThread();
+      threadEventsDuringRefreshRef.current?.push(event);
+      update((current) => ({
+        ...clearAgentChatBackgroundError(current),
+        threads: applyThreadSummaryEvent(current.threads, event)
+      }));
+      if (event.event === "thread.message.updated" && event.thread_id === stateRef.current.activeThreadId) {
+        queue.acceptNotice({
+          messageId: event.message_id,
+          status: event.status,
+          runId: event.run_id,
+          cursor: event.cursor,
+          clientSubmissionId: event.client_submission_id
+        });
+      }
+    },
+    onError(error) {
+      if (!isAbortLike(error)) update((current) => withAgentChatBackgroundError(current, error));
+    },
+    onRecovered: clearBackgroundError,
+    onDetach: detach,
+    onResume() {
+      const current = stateRef.current;
+      if (current.activeRunId && !streamControllerRef.current && !["paused", "waiting", "interrupted", "completed", "idle"].includes(current.runState)) {
+        void attachRunRef.current(current.activeRunId, current.cursor ?? void 0).catch(() => void 0);
+      }
+    }
+  });
+  React7.useEffect(() => {
     const threadId = options.activeThreadId;
     const activeThread2 = stateRef.current.threads.find((thread) => thread.id === stateRef.current.activeThreadId);
     if (shouldHydrateSelectedThread(threadId, stateRef.current.activeThreadId, Boolean(activeThread2?.isHydrated))) {
@@ -1956,15 +2317,15 @@ function useAgentChat(options = {}) {
 }
 
 // src/use-agent-resources.ts
-import * as React7 from "react";
+import * as React8 from "react";
 function useAgentThreads(options = {}) {
   const { client, createAbortController } = useAgents24Runtime();
-  const [threads, setThreads] = React7.useState([]);
-  const [total, setTotal] = React7.useState();
-  const [isLoading, setIsLoading] = React7.useState(true);
-  const [error, setError] = React7.useState(null);
-  const controllerRef = React7.useRef(null);
-  const load = React7.useCallback(async () => {
+  const [threads, setThreads] = React8.useState([]);
+  const [total, setTotal] = React8.useState();
+  const [isLoading, setIsLoading] = React8.useState(true);
+  const [error, setError] = React8.useState(null);
+  const controllerRef = React8.useRef(null);
+  const load = React8.useCallback(async () => {
     controllerRef.current?.abort();
     const controller = createAbortController();
     controllerRef.current = controller;
@@ -1983,7 +2344,7 @@ function useAgentThreads(options = {}) {
       }
     }
   }, [client, createAbortController, options.limit, options.skip]);
-  React7.useEffect(() => {
+  React8.useEffect(() => {
     void load();
     return () => controllerRef.current?.abort();
   }, [load]);
@@ -1991,11 +2352,11 @@ function useAgentThreads(options = {}) {
 }
 function useAgentThread(threadId, options = {}) {
   const { client, createAbortController } = useAgents24Runtime();
-  const [thread, setThread] = React7.useState(null);
-  const [isLoading, setIsLoading] = React7.useState(Boolean(threadId));
-  const [error, setError] = React7.useState(null);
-  const controllerRef = React7.useRef(null);
-  const load = React7.useCallback(async () => {
+  const [thread, setThread] = React8.useState(null);
+  const [isLoading, setIsLoading] = React8.useState(Boolean(threadId));
+  const [error, setError] = React8.useState(null);
+  const controllerRef = React8.useRef(null);
+  const load = React8.useCallback(async () => {
     if (!threadId) {
       controllerRef.current?.abort();
       controllerRef.current = null;
@@ -2022,7 +2383,7 @@ function useAgentThread(threadId, options = {}) {
       }
     }
   }, [client, createAbortController, options.beforeTurnIndex, options.limit, threadId]);
-  React7.useEffect(() => {
+  React8.useEffect(() => {
     void load();
     return () => controllerRef.current?.abort();
   }, [load]);
@@ -2030,11 +2391,11 @@ function useAgentThread(threadId, options = {}) {
 }
 function useThreadComputer(threadId) {
   const { client, createAbortController } = useAgents24Runtime();
-  const [computer, setComputer] = React7.useState(null);
-  const [isLoading, setIsLoading] = React7.useState(Boolean(threadId));
-  const [error, setError] = React7.useState(null);
-  const controllerRef = React7.useRef(null);
-  const refresh = React7.useCallback(async () => {
+  const [computer, setComputer] = React8.useState(null);
+  const [isLoading, setIsLoading] = React8.useState(Boolean(threadId));
+  const [error, setError] = React8.useState(null);
+  const controllerRef = React8.useRef(null);
+  const refresh = React8.useCallback(async () => {
     controllerRef.current?.abort();
     if (!threadId) {
       setComputer(null);
@@ -2059,19 +2420,19 @@ function useThreadComputer(threadId) {
       }
     }
   }, [client, createAbortController, threadId]);
-  React7.useEffect(() => {
+  React8.useEffect(() => {
     void refresh();
     return () => controllerRef.current?.abort();
   }, [refresh]);
-  const list = React7.useCallback((input) => {
+  const list = React8.useCallback((input) => {
     if (!threadId) throw new Error("A thread is required to list computer files");
     return client.threads.computer.list({ threadId, ...input });
   }, [client, threadId]);
-  const read = React7.useCallback((path) => {
+  const read = React8.useCallback((path) => {
     if (!threadId) throw new Error("A thread is required to read a computer file");
     return client.threads.computer.read({ threadId, path });
   }, [client, threadId]);
-  const createContentAccess = React7.useCallback((path, download = false) => {
+  const createContentAccess = React8.useCallback((path, download = false) => {
     if (!threadId) throw new Error("A thread is required to access a computer file");
     return client.threads.computer.createContentAccess({ threadId, path, download });
   }, [client, threadId]);
@@ -2079,16 +2440,16 @@ function useThreadComputer(threadId) {
 }
 function useAgentRun() {
   const { client, createAbortController, createId } = useAgents24Runtime();
-  const controllerRef = React7.useRef(null);
-  const [isAttached, setIsAttached] = React7.useState(false);
-  const [error, setError] = React7.useState(null);
-  React7.useEffect(() => () => controllerRef.current?.abort(), []);
-  const detach = React7.useCallback(() => {
+  const controllerRef = React8.useRef(null);
+  const [isAttached, setIsAttached] = React8.useState(false);
+  const [error, setError] = React8.useState(null);
+  React8.useEffect(() => () => controllerRef.current?.abort(), []);
+  const detach = React8.useCallback(() => {
     controllerRef.current?.abort();
     controllerRef.current = null;
     setIsAttached(false);
   }, []);
-  const attach = React7.useCallback(async (runId, onEvent, cursor) => {
+  const attach = React8.useCallback(async (runId, onEvent, cursor) => {
     detach();
     const controller = createAbortController();
     controllerRef.current = controller;
@@ -2104,7 +2465,7 @@ function useAgentRun() {
       setIsAttached(false);
     }
   }, [client, createAbortController, detach]);
-  const cancel = React7.useCallback(async (runId) => {
+  const cancel = React8.useCallback(async (runId) => {
     const result = await client.runs.cancel({ runId, idempotencyKey: createId() });
     detach();
     return result;
@@ -2113,9 +2474,9 @@ function useAgentRun() {
 }
 function useAgentAttachments() {
   const { client, createId } = useAgents24Runtime();
-  const [uploads, setUploads] = React7.useState({});
-  const [isUploading, setIsUploading] = React7.useState(false);
-  const uploadBatch = React7.useCallback(async (input) => {
+  const [uploads, setUploads] = React8.useState({});
+  const [isUploading, setIsUploading] = React8.useState(false);
+  const uploadBatch = React8.useCallback(async (input) => {
     setIsUploading(true);
     try {
       const results = await client.attachments.uploadBatch({ uploads: input.uploads, threadId: input.threadId, requestedAgentId: input.requestedAgentId, idempotencyKey: createId(), signal: input.signal });
@@ -2128,7 +2489,7 @@ function useAgentAttachments() {
       setIsUploading(false);
     }
   }, [client, createId]);
-  const createContentAccess = React7.useCallback(
+  const createContentAccess = React8.useCallback(
     (input) => client.attachments.createContentAccess(input),
     [client]
   );
@@ -2136,9 +2497,9 @@ function useAgentAttachments() {
 }
 function useAgentHitl() {
   const { client, createId } = useAgents24Runtime();
-  const [isResolving, setIsResolving] = React7.useState(false);
-  const [lastResult, setLastResult] = React7.useState(null);
-  const resume = React7.useCallback(async (input) => {
+  const [isResolving, setIsResolving] = React8.useState(false);
+  const [lastResult, setLastResult] = React8.useState(null);
+  const resume = React8.useCallback(async (input) => {
     setIsResolving(true);
     try {
       const result = await client.hitl.resume({ ...input, idempotencyKey: createId() });
@@ -2152,8 +2513,8 @@ function useAgentHitl() {
 }
 function useAgentMcp() {
   const { client, createId } = useAgents24Runtime();
-  const [isAuthorizing, setIsAuthorizing] = React7.useState(false);
-  const startAuthorization = React7.useCallback(async (input) => {
+  const [isAuthorizing, setIsAuthorizing] = React8.useState(false);
+  const startAuthorization = React8.useCallback(async (input) => {
     setIsAuthorizing(true);
     try {
       return await client.mcp.startAuthorization({ ...input, idempotencyKey: createId() });
@@ -2161,7 +2522,7 @@ function useAgentMcp() {
       setIsAuthorizing(false);
     }
   }, [client, createId]);
-  const redeemCallback = React7.useCallback(async (input) => client.mcp.redeemCallback({ ...input, idempotencyKey: createId() }), [client, createId]);
+  const redeemCallback = React8.useCallback(async (input) => client.mcp.redeemCallback({ ...input, idempotencyKey: createId() }), [client, createId]);
   return { isAuthorizing, redeemCallback, startAuthorization };
 }
 export {
@@ -2174,11 +2535,13 @@ export {
   assistantProjectionFromEvent,
   attachmentResultToChatAttachment,
   captureAgentChatThreadSelection,
+  captureChatOperation,
   chatAttachmentIds,
   clearAgentChatBackgroundError,
   clearAgentChatOperationError,
   computerResourceTargets,
   contextCompressionPartFromEvent,
+  createChatObservation,
   createPortableId,
   createRuntimeEventFrameBuffer,
   discardOptimisticSubmission,
@@ -2191,6 +2554,7 @@ export {
   optimisticSubmissionTurn,
   partsFromResponseBlocks,
   preferNewestThreadSummary,
+  prependThreadTimeline,
   preserveMountedMessageIds,
   promoteThreadMessage,
   reconcileRefreshedThreads,
@@ -2203,6 +2567,7 @@ export {
   upsertStableAssistantMessage,
   useAgentAttachments,
   useAgentChat,
+  useAgentChatFeedback,
   useAgentClient,
   useAgentHitl,
   useAgentMcp,
@@ -2210,6 +2575,7 @@ export {
   useAgentThread,
   useAgentThreads,
   useAgents24Runtime,
+  useChatObservation,
   useThreadComputer,
   useThreadMessageQueue,
   withAgentChatBackgroundError,