@agents24/react 0.2.15 → 0.2.17

package/dist/index.js

@@ -802,10 +802,13 @@ function reconcileRefreshedThreads(current, incoming, activeThreadId, concurrent
   return concurrentEvents.reduce(applyThreadSummaryEvent, base);
 }
 function preferNewestThreadSummary(current, incoming) {
-  if (!current?.updated_at || !incoming.updated_at) return incoming;
-  const currentTime = Date.parse(current.updated_at);
-  const incomingTime = Date.parse(incoming.updated_at);
-  return Number.isFinite(currentTime) && Number.isFinite(incomingTime) && currentTime > incomingTime ? current : incoming;
+  const currentTime = Date.parse(current?.updated_at || "");
+  const incomingTime = Date.parse(incoming.updated_at || "");
+  const newest = current && Number.isFinite(currentTime) && Number.isFinite(incomingTime) && currentTime > incomingTime ? current : incoming;
+  if (current?.last_run_id && current.last_run_id === incoming.last_run_id && !current.active_run && ["completed", "failed", "cancelled"].includes(current.last_run_status || "") && (!incoming.active_run || incoming.active_run.run_id === current.last_run_id)) {
+    return { ...newest, active_run: null, last_run_status: current.last_run_status };
+  }
+  return newest;
 }
 function adoptStreamingThread(state, threadId) {
   const normalizedThreadId = threadId.trim();
@@ -846,7 +849,23 @@ function reconcileThreadTimeline(current, canonical, activeRunId, streamingMessa
     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, feedback: message.feedback, durableId: message.durableId || live.durableId } : message;
   });
-  return [...retained, ...reconciled];
+  const retainedIds = new Set(retained.map((message) => message.id));
+  const userByRun = new Map(reconciled.filter((message) => message.role === "user").map((message) => [message.runId, message.id]));
+  const after = /* @__PURE__ */ new Map();
+  let anchor = null;
+  let anchorRun;
+  for (const message of current) {
+    if (canonicalIds.has(message.id)) {
+      anchor = message.id;
+      anchorRun = message.runId;
+    } else if (retainedIds.has(message.id)) {
+      const position = message.role === "assistant" && message.runId && message.runId !== anchorRun ? userByRun.get(message.runId) ?? anchor : anchor;
+      const group = after.get(position) || [];
+      group.push(message);
+      after.set(position, group);
+    }
+  }
+  return [...after.get(null) || [], ...reconciled.flatMap((message) => [message, ...after.get(message.id) || []])];
 }
 function prependThreadTimeline(current, older) {
   const mounted = preserveMountedMessageIds(older, current);
@@ -1008,11 +1027,13 @@ function applyRuntimeEvent(state, event) {
       ...segment ? { durableId: segment.message_id } : {}
     };
   });
+  const terminalThread = terminal ? { active_run: null, last_run_status: eventName.slice(4) } : {};
   const threads = activeThreadId ? state.threads.some((thread) => thread.id === activeThreadId) ? state.threads.map((thread) => thread.id === activeThreadId ? {
     ...thread,
     messages,
     isHydrated: true,
-    last_run_id: runId ?? thread.last_run_id,
+    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 : {},
     contextWindow,
     contextCompression
   } : thread) : [{
@@ -1023,6 +1044,7 @@ function applyRuntimeEvent(state, event) {
     messages,
     isHydrated: true,
     last_run_id: runId,
+    ...terminalThread,
     contextWindow,
     contextCompression
   }, ...state.threads] : state.threads;
@@ -1098,12 +1120,14 @@ function useThreadMessageQueue({ threadId, transport, onPromoted, onUnknownPromo
   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) selectionGenerationRef.current += 1;
+  if (threadRef.current !== threadId && initialAdmissionRef.current?.threadId !== threadId) selectionGenerationRef.current += 1;
   const transportRef = React3.useRef(transport);
   const onPromotedRef = React3.useRef(onPromoted);
   threadRef.current = threadId;
@@ -1113,10 +1137,16 @@ function useThreadMessageQueue({ threadId, transport, onPromoted, onUnknownPromo
   ownSelectionRef.current = ownSelection;
   const callbacksRef = React3.useRef({ onOptimistic, onDiscard, onUnknownPromotion });
   callbacksRef.current = { onOptimistic, onDiscard, onUnknownPromotion };
-  const ownOperation = React3.useCallback(() => ownSelectionRef.current?.() ?? captureChatOperation(() => ({
+  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" });
   };
@@ -1195,12 +1225,24 @@ function useThreadMessageQueue({ threadId, transport, onPromoted, onUnknownPromo
       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 = React3.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);
@@ -1208,19 +1250,31 @@ function useThreadMessageQueue({ threadId, transport, onPromoted, onUnknownPromo
     setPendingMessages((current) => current.filter((item) => item.client_submission_id !== message.client_submission_id));
   }, []);
   const submit = React3.useCallback(async (input) => {
-    const selectedThreadId = threadRef.current;
-    if (!selectedThreadId) throw new Error("No active Agent thread is available.");
-    const isCurrent = ownOperation();
-    const { queued, prepare, attachments, uploading, ...submission } = 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 (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));
@@ -1253,6 +1307,11 @@ function useThreadMessageQueue({ threadId, transport, onPromoted, onUnknownPromo
     } catch (error) {
       if (isCurrent()) discardSubmission(optimistic);
       throw error;
+    } finally {
+      void Promise.resolve(priorAdmission).then(() => {
+        releaseAdmission();
+        if (admissionRef.current === admission) admissionRef.current = null;
+      });
     }
   }, [beginSubmission, discardSubmission, refresh, ownOperation]);
   const edit = React3.useCallback(async (message, input) => {
@@ -1288,16 +1347,63 @@ function useThreadMessageQueue({ threadId, transport, onPromoted, onUnknownPromo
     await refresh(selectedThreadId);
     return result;
   }, [refresh, ownOperation]);
-  React3.useEffect(() => {
+  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]);
-  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 = {
@@ -1573,8 +1679,6 @@ function useAgentChat(options = {}) {
   const promotedAttachRef = React7.useRef(null);
   const olderRequestRef = React7.useRef(null);
   const submissionGenerationRef = React7.useRef(0);
-  const firstSubmissionRef = React7.useRef(null);
-  const firstSubmissionAdmittedRef = React7.useRef(null);
   const stateRef = React7.useRef(state);
   stateRef.current = state;
   const ownOperation = React7.useCallback((options2) => captureChatOperation(() => ({
@@ -1669,12 +1773,11 @@ function useAgentChat(options = {}) {
     promotedAttachRef.current = null;
     promotedRunHintRef.current = null;
     olderRequestRef.current = null;
-    firstSubmissionRef.current = null;
-    firstSubmissionAdmittedRef.current = null;
+    queue.reset();
     setIsSubmitting(false);
     setIsLoadingOlder(false);
     setIsLoadingHistory(false);
-  }, []);
+  }, [queue.reset]);
   const detach = React7.useCallback(() => {
     eventBuffer.flush();
     streamControllerRef.current?.abort();
@@ -1794,12 +1897,12 @@ function useAgentChat(options = {}) {
   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));
       setIsSubmitting(false);
-      firstSubmissionAdmittedRef.current?.();
     }
     eventBuffer.push(event);
-  }, [eventBuffer, update]);
+  }, [eventBuffer, update, queue.confirmThreadAdmission]);
   const attachRun = React7.useCallback(async (runId, cursor) => {
     eventBuffer.flush();
     streamControllerRef.current?.abort();
@@ -1829,12 +1932,9 @@ function useAgentChat(options = {}) {
   attachRunRef.current = attachRun;
   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) {
-      const isCurrent = ownOperation();
+    if (existingThreadId || queue.hasPendingAdmission()) {
+      const isCurrent = ownOperation({ adoptThread: !existingThreadId });
       const submissionGeneration = ++submissionGenerationRef.current;
       clearOperationError();
       setIsSubmitting(true);
@@ -1863,7 +1963,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()
             }) : [];
@@ -1888,9 +1988,7 @@ function useAgentChat(options = {}) {
       return;
     }
     invalidateThreadOpen();
-    const admission = new Promise((resolve) => {
-      firstSubmissionAdmittedRef.current = resolve;
-    });
+    const submissionOwner = ownOperation({ adoptThread: true });
     const stream = (async () => {
       detach();
       const controller = runtime.createAbortController();
@@ -1971,7 +2069,7 @@ function useAgentChat(options = {}) {
       } 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,
@@ -1982,19 +2080,15 @@ function useAgentChat(options = {}) {
           throw error;
         }
       } finally {
+        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, ownOperation]);
   const { steer, editPendingMessage, steerPendingMessage, removePendingMessage, resumeQueue } = useAgentChatQueueActions({