@agents24/react 0.2.21 → 0.2.23

package/compatibility.json

@@ -1,5 +1,5 @@
 {
-  "contractHash": "8a4ba9d84fcc75c06d6d066e3d888aa0db713eb4e4a9f1b7a8043a78142e038f",
+  "contractHash": "904701fe1c173854cd4154f2156020da471397fbc6bb644cea60f44c71a1a0d2",
   "contractVersion": "0.3.0",
   "corpus": "conformance/v1/corpus.json",
   "generatedBy": "@agents24/sdk-contract",
@@ -15,11 +15,11 @@
       "reactDom": ">=19 <20"
     },
     "@agents24/client": {
-      "contract": "8a4ba9d84fcc75c06d6d066e3d888aa0db713eb4e4a9f1b7a8043a78142e038f",
+      "contract": "904701fe1c173854cd4154f2156020da471397fbc6bb644cea60f44c71a1a0d2",
       "runtime": "run-stream.v3"
     },
     "@agents24/node": {
-      "contract": "8a4ba9d84fcc75c06d6d066e3d888aa0db713eb4e4a9f1b7a8043a78142e038f",
+      "contract": "904701fe1c173854cd4154f2156020da471397fbc6bb644cea60f44c71a1a0d2",
       "node": "^22.0.0 || ^24.0.0"
     },
     "@agents24/react": {
@@ -27,11 +27,11 @@
       "react": ">=19 <20"
     },
     "@talmudpedia/runtime-sdk": {
-      "contract": "8a4ba9d84fcc75c06d6d066e3d888aa0db713eb4e4a9f1b7a8043a78142e038f",
+      "contract": "904701fe1c173854cd4154f2156020da471397fbc6bb644cea60f44c71a1a0d2",
       "protocolOwner": "@agents24/client"
     },
     "agents24": {
-      "contract": "8a4ba9d84fcc75c06d6d066e3d888aa0db713eb4e4a9f1b7a8043a78142e038f",
+      "contract": "904701fe1c173854cd4154f2156020da471397fbc6bb644cea60f44c71a1a0d2",
       "python": ">=3.10"
     }
   },

package/dist/chat-observation.d.ts

@@ -8,6 +8,8 @@ export type ChatObservationState = {
     paused: boolean;
     degraded?: boolean;
     mode?: "on-demand" | "realtime";
+    background?: boolean;
+    sidebar?: boolean;
 };
 /** One observation policy for SDK chats and platform transport adapters. */
 export declare function createChatObservation(input: {

package/dist/index.js

@@ -17,32 +17,22 @@ function createChatObservation(input) {
   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 = () => {
+  const needed = () => !disposed && visible && Boolean(state.threadId || state.sidebar);
+  const interval = () => failures ? Math.min(3e4, 5e3 * 2 ** Math.min(failures, 3)) : state.running || state.pending || state.degraded || state.waiting || state.paused || state.background ? 5e3 : 3e4;
+  const stop = () => {
     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);
+  const schedule = () => {
+    stop();
+    if (needed()) timer = clock.setTimeout(poll, interval());
   };
   function refresh() {
-    if (disposed || !visible || !state.threadId) return Promise.resolve();
+    if (!needed()) return Promise.resolve();
     if (refreshing) return refreshing;
     const owned = generation;
     const controller = input.createAbortController();
@@ -65,137 +55,51 @@ function createChatObservation(input) {
     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() {
+    stop();
     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);
-        }
+    void refresh().then(() => {
+      if (owned === generation && needed()) {
+        failures = 0;
+        input.onResume();
       }
     }).catch((error) => {
-      if (owned !== generation || controller.signal.aborted || isAbortLike(error)) return;
-      connection = void 0;
+      if (owned !== generation || !needed()) return;
       failures += 1;
       input.onError(error);
-      poll();
-      reconnectTimer = clock.setTimeout(connect, Math.min(3e4, 1e3 * 2 ** Math.min(failures - 1, 5)));
+    }).finally(() => {
+      if (owned === generation) schedule();
     });
   }
-  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) {
+      generation += 1;
       stop();
       recovery?.abort();
       refreshing = void 0;
       input.onDetach();
-    } else {
-      reconcile();
-      if (!needed()) void refresh().then(input.onResume).catch(input.onError);
-    }
+    } else poll();
   });
   return {
     refresh,
     update(next) {
-      if (next.threadId !== state.threadId) {
+      const changed = next.threadId !== state.threadId;
+      const accelerated = !(state.running || state.pending || state.background || state.waiting) && Boolean(next.running || next.pending || next.background || next.waiting);
+      if (changed) {
         generation += 1;
         stop();
         recovery?.abort();
         refreshing = void 0;
-        cursor = void 0;
-        buffered = void 0;
         failures = 0;
-        handoffAt = void 0;
       }
       state = next;
-      reconcile();
+      if (!needed()) stop();
+      else if (changed || accelerated) poll();
+      else if (timer === void 0 && !refreshing) schedule();
     },
     dispose() {
       disposed = true;
@@ -232,10 +136,10 @@ function useChatObservation(input) {
       if (owner.current === observation) owner.current = null;
     };
   }, [input.createAbortController, input.visibility]);
-  const { threadId, running, waiting, pending, paused, degraded, mode } = input.state;
+  const { threadId, running, waiting, pending, paused, degraded, mode, background, sidebar } = input.state;
   React.useEffect(() => {
-    owner.current?.update({ threadId, running, waiting, pending, paused, degraded, mode });
-  }, [threadId, running, waiting, pending, paused, degraded, mode]);
+    owner.current?.update({ threadId, running, waiting, pending, paused, degraded, mode, background, sidebar });
+  }, [threadId, running, waiting, pending, paused, degraded, mode, background, sidebar]);
   return React.useCallback(() => owner.current?.refresh() ?? Promise.resolve(), []);
 }
 
@@ -258,7 +162,7 @@ function getThreadActivity(thread) {
   return {
     status,
     runId: activeRun?.run_id || thread.last_run_id || null,
-    isSpinning: Boolean(activeRun) && !["waiting", "interrupted"].includes(status || ""),
+    isSpinning: Boolean(activeRun) && ["queued", "running", "cancelling"].includes(status || ""),
     isPaused: status === "paused",
     isFailed: status === "failed",
     isCompleted: status === "completed",
@@ -1027,13 +931,23 @@ function applyRuntimeEvent(state, event) {
       ...segment ? { durableId: segment.message_id } : {}
     };
   });
-  const terminalThread = terminal ? { active_run: null, last_run_status: eventName.slice(4) } : {};
+  const activityStatus = suspension || (paused ? "paused" : cancelling ? "cancelling" : "running");
+  const terminalThread = runId && !sealedAfterTerminal ? {
+    active_run: terminal ? null : {
+      run_id: runId,
+      status: activityStatus,
+      started_at: state.threads.find((thread) => thread.id === activeThreadId)?.active_run?.started_at ?? null,
+      created_at: state.threads.find((thread) => thread.id === activeThreadId && thread.active_run?.run_id === runId)?.active_run?.created_at ?? event.ts,
+      is_cancellable: !cancelling
+    },
+    last_run_status: terminal ? eventName.slice(4) : activityStatus
+  } : {};
   const threads = activeThreadId ? state.threads.some((thread) => thread.id === activeThreadId) ? state.threads.map((thread) => thread.id === activeThreadId ? {
     ...thread,
     messages,
     isHydrated: true,
     last_run_id: terminal && thread.active_run && thread.active_run.run_id !== runId ? thread.last_run_id : runId ?? thread.last_run_id,
-    ...!thread.active_run || thread.active_run.run_id === runId ? terminalThread : {},
+    ...!terminal || !thread.active_run || thread.active_run.run_id === runId ? terminalThread : {},
     contextWindow,
     contextCompression
   } : thread) : [{
@@ -1471,6 +1385,53 @@ function discardOptimisticSubmission(state, message) {
 // src/use-agent-chat.ts
 import * as React7 from "react";
 
+// src/refresh-chat-summaries.ts
+async function refreshChatSummaries(input) {
+  const before = input.current();
+  const page = await input.client.threads.list({ limit: input.limit, signal: input.signal });
+  if (input.signal.aborted) return null;
+  const summaries = [...page.items];
+  const seen = new Set(summaries.map((thread) => thread.id));
+  const missing = before.threads.filter((thread) => !seen.has(thread.id) && (thread.active_run || thread.id === before.activeThreadId)).map((thread) => thread.id);
+  if (before.activeThreadId && !seen.has(before.activeThreadId) && !missing.includes(before.activeThreadId)) {
+    missing.push(before.activeThreadId);
+  }
+  const deleted = /* @__PURE__ */ new Set();
+  const errors = [];
+  for (let offset = 0; offset < missing.length && !input.signal.aborted; offset += 4) {
+    const ids = missing.slice(offset, offset + 4);
+    const results = await Promise.allSettled(ids.map((threadId) => input.client.threads.get({ threadId, limit: 1, signal: input.signal })));
+    results.forEach((result, index) => {
+      if (result.status === "fulfilled") summaries.push(result.value);
+      else if (result.reason?.name === "Agents24ClientError" && result.reason.kind === "not_found" && result.reason.status === 404) {
+        deleted.add(ids[index]);
+      } else errors.push(result.reason);
+    });
+  }
+  if (input.signal.aborted) return null;
+  const removed = [];
+  input.update((current) => ({ ...current, threads: summaries.reduce((threads, thread) => {
+    const previous = before.threads.find((item) => item.id === thread.id);
+    const latest = current.threads.find((item) => item.id === thread.id);
+    if (previous && !latest) return threads;
+    if (latest && (previous?.last_run_id !== latest.last_run_id || previous?.active_run?.status !== latest.active_run?.status || previous?.last_run_status !== latest.last_run_status)) return threads;
+    return applyThreadSummaryEvent(threads, {
+      schema_version: "agents24.thread_summary_event.v1",
+      event: "thread.summary.updated",
+      cursor: 0,
+      thread
+    });
+  }, current.threads.filter((thread) => {
+    if (!deleted.has(thread.id) || before.threads.find((item) => item.id === thread.id) !== thread) return true;
+    removed.push(thread.id);
+    return false;
+  })) }));
+  if (before.activeThreadId && deleted.has(before.activeThreadId) && !input.current().threads.some((thread) => thread.id === before.activeThreadId) && !removed.includes(before.activeThreadId)) removed.push(before.activeThreadId);
+  for (const id of removed) input.onDeleted?.(id);
+  if (errors.length) throw errors[0];
+  return input.current().threads.find((thread) => thread.id === before.activeThreadId) || null;
+}
+
 // src/use-agent-chat-thread-list.ts
 import * as React4 from "react";
 function summaryToStored(thread) {
@@ -1670,7 +1631,7 @@ function shouldHydrateSelectedThread(selectedThreadId, activeThreadId, activeThr
 function activeRunIdFromThread(thread) {
   if (!thread) return null;
   const activity = getThreadActivity(thread);
-  return activity.isSpinning ? activity.runId : null;
+  return thread.active_run ? activity.runId : null;
 }
 function useAgentChat(options = {}) {
   const runtime = useAgents24Runtime();
@@ -1746,7 +1707,16 @@ function useAgentChat(options = {}) {
   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);
+    update((current) => current.activeThreadId === message.thread_id ? {
+      ...current,
+      messages: promoteThreadMessage(current.messages, userMessage, runId),
+      threads: current.threads.map((thread) => thread.id === message.thread_id ? {
+        ...thread,
+        last_run_id: runId,
+        last_run_status: "running",
+        active_run: { run_id: runId, status: "running", started_at: null, created_at: message.created_at, is_cancellable: true }
+      } : thread)
+    } : current);
     attachPromotion(runId, message.thread_id);
   }, [update, attachPromotion]);
   const queue = useThreadMessageQueue({
@@ -1892,10 +1862,11 @@ function useAgentChat(options = {}) {
         ...context,
         contextCompressionRevision: 0,
         activeRunId: activeRunIdFromThread(stored),
+        runState: getThreadActivity(stored).isSpinning ? "reconnecting" : stored.active_run?.status || "idle",
         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 && isCurrent()) void attachRunRef.current(activeRunId).catch(() => void 0);
+      if (activeRunId && getThreadActivity(stored).isSpinning && isCurrent()) void attachRunRef.current(activeRunId).catch(() => void 0);
     } catch (error) {
       if (!requestController.signal.aborted && !isAbortLike(error) && requestGeneration === threadOpenGenerationRef.current) {
         failOperation("open_thread", error);
@@ -2254,6 +2225,8 @@ function useAgentChat(options = {}) {
       threadId: state.activeThreadId,
       running: Boolean(state.activeRunId) && !["idle", "completed", "failed", "cancelled"].includes(state.runState),
       waiting: ["paused", "waiting", "interrupted"].includes(state.runState),
+      sidebar: true,
+      background: state.threads.some((thread) => thread.id !== state.activeThreadId && Boolean(thread.active_run || thread.message_queue?.pending_count)),
       pending: pendingMessages.length > 0,
       paused: Boolean(messageQueue?.paused),
       degraded: state.runState === "reconnecting",
@@ -2264,22 +2237,36 @@ function useAgentChat(options = {}) {
     events: (input, handler) => client.threads.events(input, handler),
     async refresh(signal) {
       const target = stateRef.current.activeThreadId;
-      if (!target) return;
+      const previous = stateRef.current.threads.find((thread) => thread.id === target);
       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 summary = await refreshChatSummaries({
+        client,
+        limit: threadPageSize,
+        signal,
+        current: () => stateRef.current,
+        update,
+        onDeleted(threadId) {
+          if (isCurrent() && stateRef.current.activeThreadId === threadId) startNewThread();
+        }
+      });
+      if (!target || !summary || !isCurrent() || signal.aborted || threadOpenControllerRef.current) return;
       const runId = activeRunIdFromThread(summary);
-      if (runId && !streamControllerRef.current) {
+      const changed = previous?.active_run?.run_id !== summary.active_run?.run_id || previous?.active_run?.status !== summary.active_run?.status;
+      if (runId && getThreadActivity(summary).isSpinning && (!streamControllerRef.current || stateRef.current.activeRunId !== runId)) {
         void attachRunRef.current(runId, runId === stateRef.current.activeRunId ? stateRef.current.cursor ?? void 0 : 0).catch(() => void 0);
+      } else if (!getThreadActivity(summary).isSpinning && changed) {
+        streamControllerRef.current?.abort();
+        streamControllerRef.current = null;
+        update((current) => ({
+          ...current,
+          activeRunId: summary.active_run?.run_id || null,
+          streamingMessageId: null,
+          runState: summary.active_run?.status || summary.last_run_status || "idle"
+        }));
+      }
+      if (changed || pendingMessages.length || stateRef.current.runState === "reconnecting" || !streamControllerRef.current) {
+        await refreshMessages(target, runId || void 0, signal);
       }
-      await refreshMessages(target, runId || void 0, signal);
     },
     onEvent(event) {
       if (event.event === "thread.deleted" && event.thread_id === stateRef.current.activeThreadId) startNewThread();
@@ -2305,7 +2292,7 @@ function useAgentChat(options = {}) {
     onDetach: detach,
     onResume() {
       const current = stateRef.current;
-      if (current.activeRunId && !streamControllerRef.current && !["paused", "waiting", "interrupted", "completed", "idle"].includes(current.runState)) {
+      if (current.activeRunId && !streamControllerRef.current && !["paused", "waiting", "interrupted", "completed", "failed", "cancelled", "idle"].includes(current.runState)) {
         void attachRunRef.current(current.activeRunId, current.cursor ?? void 0).catch(() => void 0);
       }
     }