@agents24/react 0.2.15 → 0.2.16

package/dist/index.js

@@ -1098,12 +1098,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 +1115,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 +1203,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 +1228,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 +1285,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 +1325,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 +1657,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 +1751,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 +1875,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 +1910,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 +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()
             }) : [];
@@ -1888,9 +1966,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 +2047,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 +2058,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({