@copilotz/chat-adapter 0.9.19 → 0.9.22

package/dist/index.js

@@ -583,6 +583,20 @@ async function fetchThreads(userId, getRequestHeaders) {
   }
   return data;
 }
+async function fetchThreadActivity(threadId, getRequestHeaders) {
+  const res = await fetch(apiUrl(`/v1/threads/${encodeURIComponent(threadId)}/activity`), {
+    headers: await withAuthHeaders(
+      { Accept: "application/json" },
+      getRequestHeaders
+    )
+  });
+  if (!res.ok) {
+    const errorText = await res.text().catch(() => res.statusText);
+    throw new Error(errorText || `Failed to load thread activity (${res.status})`);
+  }
+  const { data } = await res.json();
+  return data;
+}
 async function fetchAgents(getRequestHeaders) {
   const response = await fetch(apiUrl("/v1/agents"), {
     method: "GET",
@@ -1665,6 +1679,8 @@ function useCopilotz({ userId, userName, userAvatar, assistantName, agentOptions
   });
   const persistedToolUpdatesRef = useRef2([]);
   const liveToolUpdatesRef = useRef2([]);
+  const stopRequestedRef = useRef2(false);
+  const recoveryPollGenerationRef = useRef2(0);
   threadsRef.current = threads;
   threadMetadataMapRef.current = threadMetadataMap;
   threadExternalIdMapRef.current = threadExternalIdMap;
@@ -2070,6 +2086,8 @@ function useCopilotz({ userId, userName, userAvatar, assistantName, agentOptions
     [userId, fetchAndSetThreadsState, loadThreadMessages, getRequestHeaders]
   );
   const handleStop = useCallback2(() => {
+    stopRequestedRef.current = true;
+    recoveryPollGenerationRef.current += 1;
     abortControllerRef.current?.abort();
     abortControllerRef.current = null;
     setIsStreaming(false);
@@ -2100,6 +2118,52 @@ function useCopilotz({ userId, userName, userAvatar, assistantName, agentOptions
       )
     );
   }, []);
+  const finalizeStreamingPlaceholders = useCallback2(() => {
+    setIsStreaming(false);
+    setMessages((prev) => {
+      const hasStreaming = prev.some((msg) => msg.isStreaming);
+      if (!hasStreaming) return prev;
+      return prev.map((msg) => msg.isStreaming ? closeAssistantMessage(msg) : msg);
+    });
+  }, []);
+  const startThreadActivityRecovery = useCallback2(
+    (threadId) => {
+      const generation = ++recoveryPollGenerationRef.current;
+      setIsStreaming(true);
+      void (async () => {
+        let delayMs = 2e3;
+        let attempts = 0;
+        while (recoveryPollGenerationRef.current === generation) {
+          await new Promise((resolve) => setTimeout(resolve, delayMs));
+          if (recoveryPollGenerationRef.current !== generation) return;
+          if (currentThreadIdRef.current !== threadId) return;
+          try {
+            const activity = await fetchThreadActivity(threadId, getRequestHeaders);
+            if (activity.status === "running") {
+              attempts += 1;
+              if (attempts % 3 === 0) {
+                await loadThreadMessages(threadId);
+              }
+              if (attempts >= 15) {
+                delayMs = 5e3;
+              }
+              continue;
+            }
+            await loadThreadMessages(threadId);
+            finalizeStreamingPlaceholders();
+            return;
+          } catch (error) {
+            if (isAbortError(error)) return;
+            attempts += 1;
+            if (attempts >= 15) {
+              delayMs = 5e3;
+            }
+          }
+        }
+      })();
+    },
+    [finalizeStreamingPlaceholders, getRequestHeaders, loadThreadMessages]
+  );
   const sendCopilotzMessage = useCallback2(
     async (params) => {
       let currentAssistantId = params.assistantMessageId ?? generateId();
@@ -2242,8 +2306,22 @@ function useCopilotz({ userId, userName, userAvatar, assistantName, agentOptions
       const abortController = new AbortController();
       abortControllerRef.current?.abort();
       abortControllerRef.current = abortController;
+      stopRequestedRef.current = false;
+      recoveryPollGenerationRef.current += 1;
       setIsStreaming(true);
       liveToolUpdatesRef.current = [];
+      let streamError = null;
+      const resolveActivityThreadId = async () => {
+        if (params.threadId) return params.threadId;
+        const curId = currentThreadIdRef.current;
+        if (curId && threadExternalIdMapRef.current[curId] !== curId) {
+          return curId;
+        }
+        if (params.threadExternalId) {
+          return await fetchAndSetThreadsState(params.userId, params.threadExternalId);
+        }
+        return null;
+      };
       try {
         const normalizedUserMetadata = params.userMetadata ? JSON.parse(JSON.stringify(params.userMetadata)) : void 0;
         const contextSeed = userContextSeedRef.current;
@@ -2405,18 +2483,40 @@ function useCopilotz({ userId, userName, userAvatar, assistantName, agentOptions
           },
           signal: abortController.signal
         });
-      } finally {
-        setIsStreaming(false);
-        setMessages((prev) => {
-          const hasStreaming = prev.some((msg) => msg.isStreaming);
-          if (!hasStreaming) return prev;
-          return prev.map((msg) => msg.isStreaming ? closeAssistantMessage(msg) : msg);
-        });
-        abortControllerRef.current = null;
+      } catch (error) {
+        streamError = error;
+      }
+      const wasStopped = stopRequestedRef.current || abortController.signal.aborted || isAbortError(streamError);
+      let recoveryStarted = false;
+      if (!wasStopped) {
+        try {
+          const activityThreadId = await resolveActivityThreadId();
+          if (activityThreadId) {
+            const activity = await fetchThreadActivity(activityThreadId, getRequestHeaders);
+            if (activity.status === "running") {
+              recoveryStarted = true;
+              startThreadActivityRecovery(activityThreadId);
+            } else if (streamError || activity.status === "failed") {
+              await loadThreadMessages(activityThreadId);
+            }
+          }
+        } catch (activityError) {
+          if (!streamError) {
+            console.warn("Unable to verify Copilotz thread activity after stream close", activityError);
+          }
+        }
+      }
+      abortControllerRef.current = null;
+      if (recoveryStarted) {
+        return currentAssistantId;
+      }
+      finalizeStreamingPlaceholders();
+      if (streamError) {
+        throw streamError;
       }
       return currentAssistantId;
     },
-    [applyEventInterceptor, handleStreamMessageEvent, handleStreamAssetEvent, getRequestHeaders]
+    [applyEventInterceptor, handleStreamMessageEvent, handleStreamAssetEvent, fetchAndSetThreadsState, finalizeStreamingPlaceholders, getRequestHeaders, loadThreadMessages, startThreadActivityRecovery]
   );
   const handleSendMessage = useCallback2(
     async (content, attachments = []) => {