@invergent/agent-chat-react 1.6.5 → 1.6.6

package/dist/index.js

@@ -8119,10 +8119,16 @@ function applyLlmResponse(state, event) {
   const responseContent = stringValue2(message?.content) || stringValue2(event.data.content);
   const toolCalls = Array.isArray(message?.tool_calls) ? message?.tool_calls : [];
   const hasToolCalls = toolCalls.length > 0;
+  const responseToolCallIds = toolCallIdsFromResponse(toolCalls);
   const idx = findLastAssistantIndex(messages);
   const prevAssistant = idx >= 0 ? messages[idx] : void 0;
   const prevHasTools = Boolean(prevAssistant?.toolCalls?.length);
   const hasUserAfter = idx >= 0 && hasUserAfterIndex(messages, idx);
+  const matchesExistingToolTurn = Boolean(
+    hasToolCalls && prevAssistant?.toolCalls?.length && responseToolCallIds.length > 0 && !hasUserAfter && responseToolCallIds.every(
+      (id) => prevAssistant.toolCalls?.some((tc) => tc.id === id)
+    )
+  );
   if (state.hadDeltas && idx >= 0 && !hasUserAfter) {
     const current = messages[idx];
     if (hasToolCalls) {
@@ -8135,6 +8141,13 @@ function applyLlmResponse(state, event) {
     } else {
       messages[idx] = { ...current, status: "complete" };
     }
+  } else if (matchesExistingToolTurn && idx >= 0) {
+    const current = messages[idx];
+    messages[idx] = {
+      ...current,
+      reasoning: responseContent ? appendText(current.reasoning, responseContent) : current.reasoning,
+      status: "streaming"
+    };
   } else if (prevHasTools || !prevAssistant || hasUserAfter) {
     messages.push({
       id: `evt-${event.eventId}`,
@@ -8178,6 +8191,15 @@ function applyLlmResponse(state, event) {
     }
   };
 }
+function toolCallIdsFromResponse(toolCalls) {
+  return toolCalls.map((toolCall) => stringValue2(objectValue(toolCall)?.id)).filter((id) => id.length > 0);
+}
+function appendText(existing, addition) {
+  if (!existing) return addition;
+  if (existing.includes(addition)) return existing;
+  return `${existing}
+${addition}`;
+}
 function applyLlmThinking(state, event) {
   const reasoningText = stringValue2(event.data.reasoning) || stringValue2(event.data.content);
   const messages = [...state.messages];
@@ -8471,9 +8493,13 @@ function useAgentChatRuntime({
   const streamRef = useRef(null);
   const reconnectTimerRef = useRef(null);
   const previousSessionIdRef = useRef(sessionId);
+  const sessionIdRef = useRef(sessionId);
   useEffect(() => {
     stateRef.current = state;
   }, [state]);
+  useEffect(() => {
+    sessionIdRef.current = sessionId;
+  }, [sessionId]);
   const clearReconnectTimer = useCallback(() => {
     if (reconnectTimerRef.current) {
       clearTimeout(reconnectTimerRef.current);
@@ -8485,21 +8511,10 @@ function useAgentChatRuntime({
     streamRef.current = null;
     stream?.close();
   }, []);
-  useEffect(() => {
-    const previousSessionId = previousSessionIdRef.current;
-    previousSessionIdRef.current = sessionId;
-    clearReconnectTimer();
-    closeStream();
-    if (!sessionId) {
-      setSession(null);
-      setState(createInitialAgentChatState());
-      return;
-    }
-    let cancelled = false;
-    const connect = (after) => {
-      if (cancelled) return;
+  const openStream = useCallback(
+    (targetSessionId, after) => {
       const stream = adapter.openEventStream({
-        sessionId,
+        sessionId: targetSessionId,
         after: after ?? stateRef.current.lastEventId
       });
       streamRef.current = stream;
@@ -8522,11 +8537,41 @@ function useAgentChatRuntime({
         if (streamRef.current === stream) {
           streamRef.current = null;
         }
-        if (!stateRef.current.sessionDone && !cancelled) {
-          reconnectTimerRef.current = setTimeout(() => connect(), 3e3);
+        if (!stateRef.current.sessionDone && sessionIdRef.current === targetSessionId) {
+          reconnectTimerRef.current = setTimeout(
+            () => openStream(targetSessionId),
+            3e3
+          );
         }
       };
-    };
+    },
+    [adapter]
+  );
+  const ensureStreamForNewTurn = useCallback(
+    (targetSessionId) => {
+      if (streamRef.current && !stateRef.current.sessionDone) return;
+      const after = stateRef.current.lastEventId;
+      clearReconnectTimer();
+      closeStream();
+      stateRef.current = {
+        ...stateRef.current,
+        sessionDone: false,
+        terminal: false
+      };
+      openStream(targetSessionId, after);
+    },
+    [clearReconnectTimer, closeStream, openStream]
+  );
+  useEffect(() => {
+    const previousSessionId = previousSessionIdRef.current;
+    previousSessionIdRef.current = sessionId;
+    clearReconnectTimer();
+    closeStream();
+    if (!sessionId) {
+      setSession(null);
+      setState(createInitialAgentChatState());
+      return;
+    }
     const currentState = stateRef.current;
     const preservePendingFirstMessage = previousSessionId === null && currentState.isRunning && currentState.messages.some(
       (message) => message.role === "user" && message.id.startsWith("local-")
@@ -8541,9 +8586,9 @@ function useAgentChatRuntime({
     stateRef.current = initialState;
     setSession(null);
     setState(initialState);
-    connect(0);
+    openStream(sessionId, 0);
     adapter.getSession({ sessionId }).then((loadedSession) => {
-      if (cancelled) return;
+      if (sessionIdRef.current !== sessionId) return;
       setSession(loadedSession);
       if (loadedSession.messageCount === 0) {
         setState((prev) => ({
@@ -8560,16 +8605,16 @@ function useAgentChatRuntime({
       }
     }).catch(() => void 0);
     return () => {
-      cancelled = true;
       clearReconnectTimer();
       closeStream();
     };
-  }, [adapter, clearReconnectTimer, closeStream, sessionId]);
+  }, [adapter, clearReconnectTimer, closeStream, openStream, sessionId]);
   const markSending = useCallback(
     (content, images) => {
       setState((prev) => ({
         ...prev,
         terminal: false,
+        sessionDone: false,
         isRunning: true,
         messages: [
           ...prev.messages,
@@ -8650,13 +8695,22 @@ function useAgentChatRuntime({
         return;
       }
       try {
+        ensureStreamForNewTurn(sessionId);
         await adapter.sendMessage({ sessionId, content, images });
       } catch (error) {
         markSendError(error instanceof Error ? error.message : "send failed");
         throw error;
       }
     },
-    [adapter, agentId, markSendError, markSending, onSessionChange, sessionId]
+    [
+      adapter,
+      agentId,
+      ensureStreamForNewTurn,
+      markSendError,
+      markSending,
+      onSessionChange,
+      sessionId
+    ]
   );
   const stop = useCallback(async () => {
     if (!sessionId) return;