@hef2024/llmasaservice-ui 0.25.0 → 0.25.2

package/src/AIChatPanel.tsx

@@ -2141,6 +2141,10 @@ const AIChatPanel: React.FC<AIChatPanelProps> = ({
   const queuedToolRequestsRef = useRef<ToolRequestMatch[] | null>(null);
   const suppressAbortHistoryUpdateRef = useRef<boolean>(false);
   const toolReplaySummariesByKeyRef = useRef<Record<string, ToolReplaySummaryEntry[]>>({});
+  const continuationDispatchPendingRef = useRef<boolean>(false);
+  const successfulMutationSignaturesRef = useRef<Set<string>>(new Set());
+  const queuedDrainTimerRef = useRef<number | null>(null);
+  const queuedDrainScheduledRef = useRef<boolean>(false);
 
   // Sync new entries from initialHistory into local history state
   // This allows parent components to inject messages (e.g., page-based agent suggestions)
@@ -2798,6 +2802,8 @@ const AIChatPanel: React.FC<AIChatPanelProps> = ({
   }, [customerEmailCaptureMode, emailInputSet]);
 
   const pendingToolRequestsRef = useRef<ToolRequestMatch[]>(pendingToolRequests);
+  const activeToolCallsRef = useRef(activeToolCalls);
+  const turnLockRef = useRef<boolean>(false);
   const streamIdleRef = useRef(idle);
   streamIdleRef.current = idle;
 
@@ -2814,6 +2820,50 @@ const AIChatPanel: React.FC<AIChatPanelProps> = ({
     pendingToolRequestsRef.current = pendingToolRequests;
   }, [pendingToolRequests]);
 
+  useEffect(() => {
+    activeToolCallsRef.current = activeToolCalls;
+  }, [activeToolCalls]);
+
+  const hasUnresolvedToolRequestsInLatestResponse = useCallback((): boolean => {
+    const latestResponse = String(responseRef.current || '');
+    if (!latestResponse.trim()) return false;
+    const latestRequests = extractToolRequestMatchesFromText(latestResponse);
+    if (latestRequests.length === 0) return false;
+
+    return latestRequests.some((request) => {
+      const signature = getToolCallSignature(request.toolName, request.callId);
+      if (!signature) return false;
+      if (handledToolCallSignaturesRef.current.has(signature)) return false;
+      if (inFlightToolCallSignaturesRef.current.has(signature)) return false;
+      return true;
+    });
+  }, [getToolCallSignature]);
+
+  const hasInFlightTurnWork = useCallback((): boolean => {
+    return (
+      toolRequestProcessingRef.current ||
+      continuationDispatchPendingRef.current ||
+      (queuedToolRequestsRef.current || []).length > 0 ||
+      (pendingToolRequestsRef.current || []).length > 0 ||
+      (activeToolCallsRef.current || []).length > 0 ||
+      !streamIdleRef.current ||
+      hasUnresolvedToolRequestsInLatestResponse()
+    );
+  }, [hasUnresolvedToolRequestsInLatestResponse]);
+
+  const queuePromptForLater = useCallback((promptText: string) => {
+    const normalizedPrompt = String(promptText || '').trim();
+    if (!normalizedPrompt) return;
+    const nextQueuedPrompts = [...queuedPromptsRef.current, normalizedPrompt];
+    queuedPromptsRef.current = nextQueuedPrompts;
+    setQueuedPrompts(nextQueuedPrompts);
+  }, []);
+
+  const releaseTurnLockIfSettled = useCallback(() => {
+    if (hasInFlightTurnWork()) return;
+    turnLockRef.current = false;
+  }, [hasInFlightTurnWork]);
+
   const processGivenToolRequests = useCallback(
     async (requests: ToolRequestMatch[]) => {
       const dedupeToolRequests = (input: ToolRequestMatch[]): ToolRequestMatch[] => {
@@ -2840,6 +2890,7 @@ const AIChatPanel: React.FC<AIChatPanelProps> = ({
         return;
       }
       toolRequestProcessingRef.current = true;
+      turnLockRef.current = true;
 
       try {
         let requestsToProcess = requests;
@@ -2931,6 +2982,61 @@ const AIChatPanel: React.FC<AIChatPanelProps> = ({
           }
         }
 
+        const normalizeToolArgsForSignature = (value: unknown): unknown => {
+          if (Array.isArray(value)) {
+            return value.map((item) => normalizeToolArgsForSignature(item));
+          }
+          if (value && typeof value === 'object') {
+            const normalizedObject: Record<string, unknown> = {};
+            Object.keys(value as Record<string, unknown>)
+              .sort()
+              .forEach((key) => {
+                normalizedObject[key] = normalizeToolArgsForSignature(
+                  (value as Record<string, unknown>)[key],
+                );
+              });
+            return normalizedObject;
+          }
+          return value ?? null;
+        };
+
+        const getSemanticMutationSignature = (
+          toolName: string,
+          args: Record<string, unknown>,
+        ): string => {
+          const normalizedName = String(toolName || '').trim().toLowerCase();
+          const normalizedArgs = normalizeToolArgsForSignature(args);
+          return `${normalizedName}::${JSON.stringify(normalizedArgs)}`;
+        };
+
+        const isLikelyMutatingCall = (
+          toolName: string,
+          args: Record<string, unknown>,
+        ): boolean => {
+          const normalizedName = String(toolName || '').trim().toLowerCase();
+          const action = String((args as Record<string, unknown>)?.action || '').trim().toLowerCase();
+          const mutatingActions = new Set([
+            'add',
+            'create',
+            'materialize_from_sourcing_result',
+            'materialize',
+            'update',
+            'delete',
+            'remove',
+            'cancel',
+            'complete',
+            'move',
+          ]);
+
+          if (action && mutatingActions.has(action)) return true;
+          return (
+            normalizedName.includes('pipeline') ||
+            normalizedName.includes('work_item') ||
+            normalizedName.includes('candidate_pipeline') ||
+            normalizedName.includes('cron')
+          );
+        };
+
         const parsedToolCalls = await Promise.all(
           requestsToProcess.map(async (req, index) => {
             let parsedToolCall: any = null;
@@ -2990,6 +3096,8 @@ const AIChatPanel: React.FC<AIChatPanelProps> = ({
 
             const callSignature = getToolCallSignature(toolName, callId);
             if (!callSignature) return null;
+            const semanticMutationSignature = getSemanticMutationSignature(toolName, args);
+            const likelyMutating = isLikelyMutatingCall(toolName, args);
 
             return {
               req,
@@ -2998,6 +3106,8 @@ const AIChatPanel: React.FC<AIChatPanelProps> = ({
               args,
               serviceTag,
               callSignature,
+              semanticMutationSignature,
+              likelyMutating,
             };
           }),
         );
@@ -3009,9 +3119,12 @@ const AIChatPanel: React.FC<AIChatPanelProps> = ({
           args: Record<string, unknown>;
           serviceTag: string;
           callSignature: string;
+          semanticMutationSignature: string;
+          likelyMutating: boolean;
         }>;
 
         const seenCallSignatures = new Set<string>();
+        const seenMutationSemanticsInBatch = new Set<string>();
         const callsToRun: Array<{
           req: ToolRequestMatch;
           toolName: string;
@@ -3019,6 +3132,18 @@ const AIChatPanel: React.FC<AIChatPanelProps> = ({
           args: Record<string, unknown>;
           serviceTag: string;
           callSignature: string;
+          semanticMutationSignature: string;
+          likelyMutating: boolean;
+        }> = [];
+        const suppressedMutationDuplicates: Array<{
+          req: ToolRequestMatch;
+          toolName: string;
+          callId: string;
+          args: Record<string, unknown>;
+          serviceTag: string;
+          callSignature: string;
+          semanticMutationSignature: string;
+          likelyMutating: boolean;
         }> = [];
 
         toolCallBatch.forEach((toolCall) => {
@@ -3027,11 +3152,25 @@ const AIChatPanel: React.FC<AIChatPanelProps> = ({
 
           if (handledToolCallSignaturesRef.current.has(toolCall.callSignature)) return;
           if (inFlightToolCallSignaturesRef.current.has(toolCall.callSignature)) return;
+          if (toolCall.likelyMutating && seenMutationSemanticsInBatch.has(toolCall.semanticMutationSignature)) {
+            suppressedMutationDuplicates.push(toolCall);
+            return;
+          }
+          if (
+            toolCall.likelyMutating &&
+            successfulMutationSignaturesRef.current.has(toolCall.semanticMutationSignature)
+          ) {
+            suppressedMutationDuplicates.push(toolCall);
+            return;
+          }
+          if (toolCall.likelyMutating) {
+            seenMutationSemanticsInBatch.add(toolCall.semanticMutationSignature);
+          }
 
           callsToRun.push(toolCall);
         });
 
-        if (callsToRun.length === 0) {
+        if (callsToRun.length === 0 && suppressedMutationDuplicates.length === 0) {
           setPendingToolRequests((prev) =>
             prev.filter((request) => {
               const signature = getToolCallSignature(request.toolName, request.callId);
@@ -3044,11 +3183,14 @@ const AIChatPanel: React.FC<AIChatPanelProps> = ({
           return;
         }
 
-        const callsToRunSignatures = new Set(callsToRun.map((toolCall) => toolCall.callSignature));
+        const handledBatchSignatures = new Set([
+          ...callsToRun.map((toolCall) => toolCall.callSignature),
+          ...suppressedMutationDuplicates.map((toolCall) => toolCall.callSignature),
+        ]);
         setPendingToolRequests((prev) =>
           prev.filter((request) => {
             const signature = getToolCallSignature(request.toolName, request.callId);
-            return !signature || !callsToRunSignatures.has(signature);
+            return !signature || !handledBatchSignatures.has(signature);
           }),
         );
         callsToRun.forEach((toolCall) => {
@@ -3063,7 +3205,7 @@ const AIChatPanel: React.FC<AIChatPanelProps> = ({
           })),
         );
 
-        const finalToolCalls = callsToRun.map((toolCall) => ({
+        const finalToolCalls = [...callsToRun, ...suppressedMutationDuplicates].map((toolCall) => ({
           id: toolCall.callId,
           type: 'tool_use',
           name: toolCall.toolName,
@@ -3233,12 +3375,32 @@ const AIChatPanel: React.FC<AIChatPanelProps> = ({
             }),
           );
 
-          finalToolResponses = toolResponses.filter(Boolean) as any[];
+          const executedResponses = toolResponses.filter(Boolean) as any[];
+          const suppressedResponses = suppressedMutationDuplicates.map((toolCall) => ({
+            tool_call_id: toolCall.callId,
+            tool_name: toolCall.toolName,
+            result:
+              'Duplicate mutating call suppressed: this exact action already succeeded earlier in the same turn.',
+            isError: false,
+          }));
+          finalToolResponses = [...executedResponses, ...suppressedResponses];
+
+          callsToRun.forEach((toolCall) => {
+            const matchedResponse = executedResponses.find(
+              (response) => response?.tool_call_id === toolCall.callId,
+            );
+            if (!matchedResponse?.isError && toolCall.likelyMutating) {
+              successfulMutationSignaturesRef.current.add(toolCall.semanticMutationSignature);
+            }
+          });
         } finally {
           callsToRun.forEach((toolCall) => {
             inFlightToolCallSignaturesRef.current.delete(toolCall.callSignature);
             handledToolCallSignaturesRef.current.add(toolCall.callSignature);
           });
+          suppressedMutationDuplicates.forEach((toolCall) => {
+            handledToolCallSignaturesRef.current.add(toolCall.callSignature);
+          });
         }
 
         // Keep the running state visible during execution; clear it only after completion.
@@ -3369,6 +3531,7 @@ const AIChatPanel: React.FC<AIChatPanelProps> = ({
         if (!streamIdleRef.current) {
           setActiveToolCalls([]);
           setIsLoading(false);
+          continuationDispatchPendingRef.current = false;
           setError({
             message: 'Timed out waiting for the previous stream to settle before tool continuation.',
             code: 'TOOL_CONTINUATION_WAIT_TIMEOUT',
@@ -3388,6 +3551,7 @@ const AIChatPanel: React.FC<AIChatPanelProps> = ({
         } else {
           activeStreamAppendBaseRef.current = null;
         }
+        continuationDispatchPendingRef.current = true;
         send(
           '',
           newMessages,
@@ -3405,12 +3569,14 @@ const AIChatPanel: React.FC<AIChatPanelProps> = ({
           newController,
           undefined,
           (errorMsg: string) => {
+            continuationDispatchPendingRef.current = false;
             setActiveToolCalls([]);
             setIsLoading(false);
             setError({
               message: errorMsg,
               code: 'TOOL_ERROR',
             });
+            releaseTurnLockIfSettled();
           },
         );
       } finally {
@@ -3421,6 +3587,8 @@ const AIChatPanel: React.FC<AIChatPanelProps> = ({
           queueMicrotask(() => {
             void processGivenToolRequests(queued);
           });
+        } else {
+          releaseTurnLockIfSettled();
         }
       }
     },
@@ -3440,6 +3608,7 @@ const AIChatPanel: React.FC<AIChatPanelProps> = ({
       stop,
       lastController,
       waitForStreamIdle,
+      releaseTurnLockIfSettled,
     ],
   );
 
@@ -3469,6 +3638,8 @@ const AIChatPanel: React.FC<AIChatPanelProps> = ({
 
   useEffect(() => {
     if (pendingToolRequests.length === 0) return;
+    if (!idle) return;
+    if (continuationDispatchPendingRef.current) return;
 
     const configuredAutoApproveTools = Array.isArray(autoApproveTools)
       ? new Set(
@@ -3503,6 +3674,7 @@ const AIChatPanel: React.FC<AIChatPanelProps> = ({
     }
   }, [
     autoApproveTools,
+    idle,
     pendingToolRequests,
     sessionApprovedTools,
     alwaysApprovedTools,
@@ -3955,11 +4127,24 @@ const AIChatPanel: React.FC<AIChatPanelProps> = ({
   // Continue chat (send message) - matches ChatPanel behavior exactly
   // promptText is now required - comes from the isolated ChatInput component
   const continueChat = useCallback((promptText: string) => {
+    const promptToSend = String(promptText || '').trim();
+    if (!promptToSend) return;
+
+    // Hard serialization guard: never start a second send while the current turn
+    // is still settling (including tool/continuation phases).
+    if (turnLockRef.current || hasInFlightTurnWork()) {
+      queuePromptForLater(promptToSend);
+      return;
+    }
+    turnLockRef.current = true;
+
     handledToolCallSignaturesRef.current = new Set();
     inFlightToolCallSignaturesRef.current = new Set();
     toolContinuationCountRef.current = 0;
+    successfulMutationSignaturesRef.current = new Set();
     activeStreamAppendBaseRef.current = null;
     toolReplaySummariesByKeyRef.current = {};
+    continuationDispatchPendingRef.current = false;
     setPendingToolRequests([]);
     setActiveToolCalls([]);
 
@@ -3993,33 +4178,16 @@ const AIChatPanel: React.FC<AIChatPanelProps> = ({
     // when the history update effect runs
     setResponse('');
     
-    // Handle stop if not idle (matches ChatPanel)
-    if (!idle) {
-      stop(lastController);
-      setHistory((prevHistory) => ({
-        ...prevHistory,
-        [lastKey ?? '']: {
-          content: processThinkingTags(response).cleanedText + '\n\n(response cancelled)',
-          callId: lastCallId || '',
-        },
-      }));
-      return;
-    }
-    
     if (clearFollowOnQuestionsNextPrompt) {
       setFollowOnQuestionsState([]);
     }
-    
-    const promptToSend = promptText;
-    
-    if (!promptToSend || !promptToSend.trim()) return;
-    
+
     setIsLoading(true);
     
     // === OPTIMISTIC UPDATE: Show prompt immediately in UI ===
     // Generate unique key using ISO timestamp prefix + prompt
     const timestamp = new Date().toISOString();
-    const promptKey = `${timestamp}:${promptToSend.trim()}`;
+    const promptKey = `${timestamp}:${promptToSend}`;
     
     // Add prompt to history IMMEDIATELY - this makes it appear in the UI right away
     setHistory((prevHistory) => ({
@@ -4029,7 +4197,7 @@ const AIChatPanel: React.FC<AIChatPanelProps> = ({
     toolReplaySummariesByKeyRef.current[promptKey] = [];
     
     // Store the key for later use
-    setLastPrompt(promptToSend.trim());
+    setLastPrompt(promptToSend);
     setLastKey(promptKey);
     
     // Scroll to bottom immediately to show the new prompt
@@ -4060,7 +4228,7 @@ const AIChatPanel: React.FC<AIChatPanelProps> = ({
       
       // Build the full prompt - only apply template for first message (matches ChatPanel)
       // Check if this is the first message by seeing if messagesAndHistory is empty
-      let fullPromptToSend = promptToSend.trim();
+      let fullPromptToSend = promptToSend;
       if (messagesAndHistory.length === 0 && promptTemplate) {
         fullPromptToSend = promptTemplate.replace('{{prompt}}', fullPromptToSend);
       }
@@ -4071,7 +4239,7 @@ const AIChatPanel: React.FC<AIChatPanelProps> = ({
       if (onBeforeSend) {
         void Promise.resolve(
           onBeforeSend({
-            prompt: promptToSend.trim(),
+            prompt: promptToSend,
             conversationId: convId || null,
             agentId: agent,
             service,
@@ -4110,6 +4278,7 @@ const AIChatPanel: React.FC<AIChatPanelProps> = ({
           if (isAbortError) {
             if (suppressAbortHistoryUpdateRef.current) {
               setIsLoading(false);
+              releaseTurnLockIfSettled();
               return;
             }
             // User canceled the request - don't show error banner
@@ -4200,6 +4369,7 @@ const AIChatPanel: React.FC<AIChatPanelProps> = ({
           
           // Reset loading state
           setIsLoading(false);
+          releaseTurnLockIfSettled();
         }
       );
       
@@ -4213,15 +4383,16 @@ const AIChatPanel: React.FC<AIChatPanelProps> = ({
           onConversationCreated(convId);
         }, 100);
       }
+    }).catch((error) => {
+      console.error('[AIChatPanel] Failed to send prompt:', error);
+      setError({
+        message: error instanceof Error ? error.message : 'Failed to send prompt',
+        code: 'UNKNOWN_ERROR',
+      });
+      setIsLoading(false);
+      releaseTurnLockIfSettled();
     });
   }, [
-    idle,
-    stop,
-    lastController,
-    lastKey,
-    response,
-    lastCallId,
-    processThinkingTags,
     clearFollowOnQuestionsNextPrompt,
     promptTemplate,
     send,
@@ -4235,18 +4406,17 @@ const AIChatPanel: React.FC<AIChatPanelProps> = ({
     scrollToBottom,
     onConversationCreated,
     onBeforeSend,
+    hasInFlightTurnWork,
+    queuePromptForLater,
+    releaseTurnLockIfSettled,
     getThinkingBlockCollapseKey,
     getThinkingBlockRenderKey,
     setResponse,
   ]);
 
   const handleQueuePrompt = useCallback((promptText: string) => {
-    const normalizedPrompt = String(promptText || '').trim();
-    if (!normalizedPrompt) return;
-    const nextQueuedPrompts = [...queuedPromptsRef.current, normalizedPrompt];
-    queuedPromptsRef.current = nextQueuedPrompts;
-    setQueuedPrompts(nextQueuedPrompts);
-  }, []);
+    queuePromptForLater(promptText);
+  }, [queuePromptForLater]);
 
   const handleClearQueuedPrompt = useCallback((index: number) => {
     const nextQueuedPrompts = queuedPromptsRef.current.filter((_, queueIndex) => queueIndex !== index);
@@ -4264,20 +4434,6 @@ const AIChatPanel: React.FC<AIChatPanelProps> = ({
     stop(lastController);
   }, [stop, lastController]);
 
-  useEffect(() => {
-    const nextQueuedPrompt = String(queuedPromptsRef.current[0] || '').trim();
-    if (!nextQueuedPrompt) return;
-    if (!idle || isLoading) return;
-    if (pendingToolRequests.length > 0 || activeToolCalls.length > 0) return;
-    if (toolRequestProcessingRef.current) return;
-    if ((queuedToolRequestsRef.current || []).length > 0) return;
-
-    const remainingQueuedPrompts = queuedPromptsRef.current.slice(1);
-    queuedPromptsRef.current = remainingQueuedPrompts;
-    setQueuedPrompts(remainingQueuedPrompts);
-    continueChat(nextQueuedPrompt);
-  }, [activeToolCalls.length, continueChat, idle, isLoading, pendingToolRequests.length, queuedPrompts.length]);
-
   // Reset conversation
   const handleNewConversation = useCallback(() => {
     if (!newConversationConfirm) {
@@ -4323,6 +4479,7 @@ const AIChatPanel: React.FC<AIChatPanelProps> = ({
     setUserHasScrolled(false);
     setError(null); // Clear any errors
     setActiveToolCalls([]);
+    turnLockRef.current = false;
     
     setTimeout(() => {
       setJustReset(false);
@@ -4354,6 +4511,9 @@ const AIChatPanel: React.FC<AIChatPanelProps> = ({
       return true;
     });
 
+    // Keep ref synchronized immediately so completion/drain guards evaluate
+    // against the same response pass, not the previous render.
+    pendingToolRequestsRef.current = unseenToolRequests;
     setPendingToolRequests((prev) => {
       if (areToolRequestListsEqual(prev, unseenToolRequests)) {
         return prev;
@@ -4483,11 +4643,14 @@ const AIChatPanel: React.FC<AIChatPanelProps> = ({
           responseCompleteCallbackRef.current(currentLastCallId, currentLastPrompt || '', entry.content);
         }
       }
+
+      releaseTurnLockIfSettled();
     }
     
     // Reset notification flag when starting a new stream
     if (!isNowIdle && hasNotifiedCompletionRef.current) {
       hasNotifiedCompletionRef.current = false;
+      continuationDispatchPendingRef.current = false;
       // Reset response length tracking for new stream
       prevResponseLengthRef.current = 0;
       const currentLastKey = lastKeyRef.current;
@@ -4504,7 +4667,59 @@ const AIChatPanel: React.FC<AIChatPanelProps> = ({
       // Keep thinking UI state across follow-on streams triggered by tool calls.
       // New user prompts already reset this state explicitly before send().
     }
-  }, [idle]); // ONLY depends on idle - no history, no callbacks in deps
+  }, [idle, releaseTurnLockIfSettled]); // ONLY depends on idle transition + lock-release guard
+
+  // Reconcile lock state on idle renders where tool markers/cards are cleared without
+  // another idle transition (e.g., follow-up response replaces a prior tool-only payload).
+  useEffect(() => {
+    if (!idle) return;
+    releaseTurnLockIfSettled();
+  }, [idle, response, pendingToolRequests.length, activeToolCalls.length, releaseTurnLockIfSettled]);
+
+  // Drain queued prompts only after response history has been reconciled.
+  // This effect intentionally sits after the response-processing/completion effects above
+  // so queued sends inherit the latest finalized assistant turn context.
+  useEffect(() => {
+    const nextQueuedPrompt = String(queuedPromptsRef.current[0] || '').trim();
+    if (!nextQueuedPrompt) return;
+    if (!idle || isLoading) return;
+    if (pendingToolRequests.length > 0 || activeToolCalls.length > 0) return;
+    if (turnLockRef.current || hasInFlightTurnWork()) return;
+    if (queuedDrainScheduledRef.current) return;
+
+    queuedDrainScheduledRef.current = true;
+    queuedDrainTimerRef.current = window.setTimeout(() => {
+      queuedDrainScheduledRef.current = false;
+      queuedDrainTimerRef.current = null;
+
+      const queuedPrompt = String(queuedPromptsRef.current[0] || '').trim();
+      if (!queuedPrompt) return;
+      if (turnLockRef.current || hasInFlightTurnWork()) return;
+
+      const remainingQueuedPrompts = queuedPromptsRef.current.slice(1);
+      queuedPromptsRef.current = remainingQueuedPrompts;
+      setQueuedPrompts(remainingQueuedPrompts);
+      continueChat(queuedPrompt);
+    }, 0);
+  }, [
+    continueChat,
+    hasInFlightTurnWork,
+    idle,
+    isLoading,
+    pendingToolRequests.length,
+    activeToolCalls.length,
+    queuedPrompts.length,
+  ]);
+
+  useEffect(() => {
+    return () => {
+      if (queuedDrainTimerRef.current !== null) {
+        window.clearTimeout(queuedDrainTimerRef.current);
+        queuedDrainTimerRef.current = null;
+      }
+      queuedDrainScheduledRef.current = false;
+    };
+  }, []);
   
   // Keep refs in sync
   useEffect(() => {