@hef2024/llmasaservice-ui 0.25.1 → 0.25.3

package/dist/index.js

@@ -5533,6 +5533,10 @@ var AIChatPanel = ({
   const queuedToolRequestsRef = (0, import_react14.useRef)(null);
   const suppressAbortHistoryUpdateRef = (0, import_react14.useRef)(false);
   const toolReplaySummariesByKeyRef = (0, import_react14.useRef)({});
+  const continuationDispatchPendingRef = (0, import_react14.useRef)(false);
+  const successfulMutationSignaturesRef = (0, import_react14.useRef)(/* @__PURE__ */ new Set());
+  const queuedDrainTimerRef = (0, import_react14.useRef)(null);
+  const queuedDrainScheduledRef = (0, import_react14.useRef)(false);
   (0, import_react14.useEffect)(() => {
     if (!initialHistory) return;
     setHistory((prev) => {
@@ -6041,6 +6045,8 @@ var AIChatPanel = ({
     return false;
   }, [customerEmailCaptureMode, emailInputSet]);
   const pendingToolRequestsRef = (0, import_react14.useRef)(pendingToolRequests);
+  const activeToolCallsRef = (0, import_react14.useRef)(activeToolCalls);
+  const turnLockRef = (0, import_react14.useRef)(false);
   const streamIdleRef = (0, import_react14.useRef)(idle);
   streamIdleRef.current = idle;
   const waitForStreamIdle = (0, import_react14.useCallback)((timeoutMs = 2500) => __async(void 0, null, function* () {
@@ -6054,6 +6060,36 @@ var AIChatPanel = ({
   (0, import_react14.useEffect)(() => {
     pendingToolRequestsRef.current = pendingToolRequests;
   }, [pendingToolRequests]);
+  (0, import_react14.useEffect)(() => {
+    activeToolCallsRef.current = activeToolCalls;
+  }, [activeToolCalls]);
+  const hasUnresolvedToolRequestsInLatestResponse = (0, import_react14.useCallback)(() => {
+    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 = (0, import_react14.useCallback)(() => {
+    return toolRequestProcessingRef.current || continuationDispatchPendingRef.current || (queuedToolRequestsRef.current || []).length > 0 || (pendingToolRequestsRef.current || []).length > 0 || (activeToolCallsRef.current || []).length > 0 || !streamIdleRef.current || hasUnresolvedToolRequestsInLatestResponse();
+  }, [hasUnresolvedToolRequestsInLatestResponse]);
+  const queuePromptForLater = (0, import_react14.useCallback)((promptText) => {
+    const normalizedPrompt = String(promptText || "").trim();
+    if (!normalizedPrompt) return;
+    const nextQueuedPrompts = [...queuedPromptsRef.current, normalizedPrompt];
+    queuedPromptsRef.current = nextQueuedPrompts;
+    setQueuedPrompts(nextQueuedPrompts);
+  }, []);
+  const releaseTurnLockIfSettled = (0, import_react14.useCallback)(() => {
+    if (hasInFlightTurnWork()) return;
+    turnLockRef.current = false;
+  }, [hasInFlightTurnWork]);
   const processGivenToolRequests = (0, import_react14.useCallback)(
     (requests) => __async(void 0, null, function* () {
       var _a2, _b, _c;
@@ -6080,6 +6116,7 @@ var AIChatPanel = ({
         return;
       }
       toolRequestProcessingRef.current = true;
+      turnLockRef.current = true;
       try {
         let requestsToProcess = requests;
         if (!requestsToProcess || requestsToProcess.length === 0) {
@@ -6158,6 +6195,44 @@ ${traceSummary}` : traceSummary;
             });
           }
         }
+        const normalizeToolArgsForSignature = (value) => {
+          if (Array.isArray(value)) {
+            return value.map((item) => normalizeToolArgsForSignature(item));
+          }
+          if (value && typeof value === "object") {
+            const normalizedObject = {};
+            Object.keys(value).sort().forEach((key) => {
+              normalizedObject[key] = normalizeToolArgsForSignature(
+                value[key]
+              );
+            });
+            return normalizedObject;
+          }
+          return value != null ? value : null;
+        };
+        const getSemanticMutationSignature = (toolName, args) => {
+          const normalizedName = String(toolName || "").trim().toLowerCase();
+          const normalizedArgs = normalizeToolArgsForSignature(args);
+          return `${normalizedName}::${JSON.stringify(normalizedArgs)}`;
+        };
+        const isLikelyMutatingCall = (toolName, args) => {
+          const normalizedName = String(toolName || "").trim().toLowerCase();
+          const action = String((args == null ? void 0 : args.action) || "").trim().toLowerCase();
+          const mutatingActions = /* @__PURE__ */ 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 = yield Promise.all(
           requestsToProcess.map((req, index) => __async(void 0, null, function* () {
             var _a3, _b2, _c2, _d, _e, _f;
@@ -6186,27 +6261,44 @@ ${traceSummary}` : traceSummary;
             const serviceTag = typeof req.serviceTag === "string" && req.serviceTag || typeof req.groups[3] === "string" && req.groups[3] || typeof (parsedToolCall == null ? void 0 : parsedToolCall.service) === "string" && parsedToolCall.service || "";
             const callSignature = getToolCallSignature(toolName, callId);
             if (!callSignature) return null;
+            const semanticMutationSignature = getSemanticMutationSignature(toolName, args);
+            const likelyMutating = isLikelyMutatingCall(toolName, args);
             return {
               req,
               toolName,
               callId,
               args,
               serviceTag,
-              callSignature
+              callSignature,
+              semanticMutationSignature,
+              likelyMutating
             };
           }))
         );
         const toolCallBatch = parsedToolCalls.filter(Boolean);
         const seenCallSignatures = /* @__PURE__ */ new Set();
+        const seenMutationSemanticsInBatch = /* @__PURE__ */ new Set();
         const callsToRun = [];
+        const suppressedMutationDuplicates = [];
         toolCallBatch.forEach((toolCall) => {
           if (seenCallSignatures.has(toolCall.callSignature)) return;
           seenCallSignatures.add(toolCall.callSignature);
           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);
@@ -6218,11 +6310,14 @@ ${traceSummary}` : traceSummary;
           setIsLoading(false);
           return;
         }
-        const callsToRunSignatures = new Set(callsToRun.map((toolCall) => toolCall.callSignature));
+        const handledBatchSignatures = /* @__PURE__ */ 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) => {
@@ -6235,7 +6330,7 @@ ${traceSummary}` : traceSummary;
             args: toolCall.args
           }))
         );
-        const finalToolCalls = callsToRun.map((toolCall) => ({
+        const finalToolCalls = [...callsToRun, ...suppressedMutationDuplicates].map((toolCall) => ({
           id: toolCall.callId,
           type: "tool_use",
           name: toolCall.toolName,
@@ -6366,12 +6461,30 @@ ${traceSummary}` : traceSummary;
               }
             }))
           );
-          finalToolResponses = toolResponses.filter(Boolean);
+          const executedResponses = toolResponses.filter(Boolean);
+          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(
+              (response2) => (response2 == null ? void 0 : response2.tool_call_id) === toolCall.callId
+            );
+            if (!(matchedResponse == null ? void 0 : 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);
+          });
         }
         setActiveToolCalls([]);
         const currentLastKey = lastKeyRef.current;
@@ -6475,6 +6588,7 @@ ${traceSummary}` : traceSummary;
         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"
@@ -6490,6 +6604,7 @@ ${traceSummary}` : traceSummary;
         } else {
           activeStreamAppendBaseRef.current = null;
         }
+        continuationDispatchPendingRef.current = true;
         send(
           "",
           newMessages,
@@ -6507,12 +6622,14 @@ ${traceSummary}` : traceSummary;
           newController,
           void 0,
           (errorMsg) => {
+            continuationDispatchPendingRef.current = false;
             setActiveToolCalls([]);
             setIsLoading(false);
             setError({
               message: errorMsg,
               code: "TOOL_ERROR"
             });
+            releaseTurnLockIfSettled();
           }
         );
       } finally {
@@ -6523,6 +6640,8 @@ ${traceSummary}` : traceSummary;
           queueMicrotask(() => {
             void processGivenToolRequests(queued);
           });
+        } else {
+          releaseTurnLockIfSettled();
         }
       }
     }),
@@ -6541,7 +6660,8 @@ ${traceSummary}` : traceSummary;
       idle,
       stop,
       lastController,
-      waitForStreamIdle
+      waitForStreamIdle,
+      releaseTurnLockIfSettled
     ]
   );
   const handleToolApproval = (0, import_react14.useCallback)(
@@ -6566,6 +6686,8 @@ ${traceSummary}` : traceSummary;
   );
   (0, import_react14.useEffect)(() => {
     if (pendingToolRequests.length === 0) return;
+    if (!idle) return;
+    if (continuationDispatchPendingRef.current) return;
     const configuredAutoApproveTools = Array.isArray(autoApproveTools) ? new Set(
       autoApproveTools.map((toolName) => normalizeToolName(String(toolName))).filter(Boolean)
     ) : null;
@@ -6594,6 +6716,7 @@ ${traceSummary}` : traceSummary;
     }
   }, [
     autoApproveTools,
+    idle,
     pendingToolRequests,
     sessionApprovedTools,
     alwaysApprovedTools,
@@ -6902,11 +7025,20 @@ ${traceSummary}` : traceSummary;
     lastScrollTimeRef.current = now;
   }, []);
   const continueChat = (0, import_react14.useCallback)((promptText) => {
+    const promptToSend = String(promptText || "").trim();
+    if (!promptToSend) return;
+    if (turnLockRef.current || hasInFlightTurnWork()) {
+      queuePromptForLater(promptToSend);
+      return;
+    }
+    turnLockRef.current = true;
     handledToolCallSignaturesRef.current = /* @__PURE__ */ new Set();
     inFlightToolCallSignaturesRef.current = /* @__PURE__ */ new Set();
     toolContinuationCountRef.current = 0;
+    successfulMutationSignaturesRef.current = /* @__PURE__ */ new Set();
     activeStreamAppendBaseRef.current = null;
     toolReplaySummariesByKeyRef.current = {};
+    continuationDispatchPendingRef.current = false;
     setPendingToolRequests([]);
     setActiveToolCalls([]);
     setCollapsedBlocks((prev) => {
@@ -6926,29 +7058,17 @@ ${traceSummary}` : traceSummary;
     setUserHasScrolled(false);
     prevResponseLengthRef.current = 0;
     setResponse("");
-    if (!idle) {
-      stop(lastController);
-      setHistory((prevHistory) => __spreadProps(__spreadValues({}, prevHistory), {
-        [lastKey != null ? 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);
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-    const promptKey = `${timestamp}:${promptToSend.trim()}`;
+    const promptKey = `${timestamp}:${promptToSend}`;
     setHistory((prevHistory) => __spreadProps(__spreadValues({}, prevHistory), {
       [promptKey]: { content: "", callId: "" }
     }));
     toolReplaySummariesByKeyRef.current[promptKey] = [];
-    setLastPrompt(promptToSend.trim());
+    setLastPrompt(promptToSend);
     setLastKey(promptKey);
     setTimeout(() => {
       scrollToBottom(true);
@@ -6965,7 +7085,7 @@ ${traceSummary}` : traceSummary;
         messagesAndHistory.push({ role: "user", content: promptForHistory });
         messagesAndHistory.push({ role: "assistant", content: assistantContextContent });
       });
-      let fullPromptToSend = promptToSend.trim();
+      let fullPromptToSend = promptToSend;
       if (messagesAndHistory.length === 0 && promptTemplate) {
         fullPromptToSend = promptTemplate.replace("{{prompt}}", fullPromptToSend);
       }
@@ -6974,7 +7094,7 @@ ${traceSummary}` : traceSummary;
       if (onBeforeSend) {
         void Promise.resolve(
           onBeforeSend({
-            prompt: promptToSend.trim(),
+            prompt: promptToSend,
             conversationId: convId || null,
             agentId: agent,
             service,
@@ -7008,6 +7128,7 @@ ${traceSummary}` : traceSummary;
           if (isAbortError) {
             if (suppressAbortHistoryUpdateRef.current) {
               setIsLoading(false);
+              releaseTurnLockIfSettled();
               return;
             }
             console.log("[AIChatPanel] Request was aborted by user");
@@ -7072,6 +7193,7 @@ ${traceSummary}` : traceSummary;
             }
           }
           setIsLoading(false);
+          releaseTurnLockIfSettled();
         }
       );
       setLastMessages(messagesAndHistory);
@@ -7080,15 +7202,16 @@ ${traceSummary}` : traceSummary;
           onConversationCreated(convId);
         }, 100);
       }
+    }).catch((error2) => {
+      console.error("[AIChatPanel] Failed to send prompt:", error2);
+      setError({
+        message: error2 instanceof Error ? error2.message : "Failed to send prompt",
+        code: "UNKNOWN_ERROR"
+      });
+      setIsLoading(false);
+      releaseTurnLockIfSettled();
     });
   }, [
-    idle,
-    stop,
-    lastController,
-    lastKey,
-    response,
-    lastCallId,
-    processThinkingTags,
     clearFollowOnQuestionsNextPrompt,
     promptTemplate,
     send,
@@ -7102,17 +7225,16 @@ ${traceSummary}` : traceSummary;
     scrollToBottom,
     onConversationCreated,
     onBeforeSend,
+    hasInFlightTurnWork,
+    queuePromptForLater,
+    releaseTurnLockIfSettled,
     getThinkingBlockCollapseKey,
     getThinkingBlockRenderKey,
     setResponse
   ]);
   const handleQueuePrompt = (0, import_react14.useCallback)((promptText) => {
-    const normalizedPrompt = String(promptText || "").trim();
-    if (!normalizedPrompt) return;
-    const nextQueuedPrompts = [...queuedPromptsRef.current, normalizedPrompt];
-    queuedPromptsRef.current = nextQueuedPrompts;
-    setQueuedPrompts(nextQueuedPrompts);
-  }, []);
+    queuePromptForLater(promptText);
+  }, [queuePromptForLater]);
   const handleClearQueuedPrompt = (0, import_react14.useCallback)((index) => {
     const nextQueuedPrompts = queuedPromptsRef.current.filter((_, queueIndex) => queueIndex !== index);
     queuedPromptsRef.current = nextQueuedPrompts;
@@ -7124,18 +7246,6 @@ ${traceSummary}` : traceSummary;
   const handleStop = (0, import_react14.useCallback)(() => {
     stop(lastController);
   }, [stop, lastController]);
-  (0, import_react14.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]);
   const handleNewConversation = (0, import_react14.useCallback)(() => {
     if (!newConversationConfirm) {
       setNewConversationConfirm(true);
@@ -7176,6 +7286,7 @@ ${traceSummary}` : traceSummary;
     setUserHasScrolled(false);
     setError(null);
     setActiveToolCalls([]);
+    turnLockRef.current = false;
     setTimeout(() => {
       var _a2;
       setJustReset(false);
@@ -7195,6 +7306,7 @@ ${traceSummary}` : traceSummary;
       if (inFlightToolCallSignaturesRef.current.has(callSignature)) return false;
       return true;
     });
+    pendingToolRequestsRef.current = unseenToolRequests;
     setPendingToolRequests((prev) => {
       if (areToolRequestListsEqual(prev, unseenToolRequests)) {
         return prev;
@@ -7285,9 +7397,11 @@ ${traceSummary}` : traceSummary;
           responseCompleteCallbackRef.current(currentLastCallId, currentLastPrompt || "", entry.content);
         }
       }
+      releaseTurnLockIfSettled();
     }
     if (!isNowIdle && hasNotifiedCompletionRef.current) {
       hasNotifiedCompletionRef.current = false;
+      continuationDispatchPendingRef.current = false;
       prevResponseLengthRef.current = 0;
       const currentLastKey = lastKeyRef.current;
       const existingContent = currentLastKey ? ((_a2 = latestHistoryRef.current[currentLastKey]) == null ? void 0 : _a2.content) || "" : "";
@@ -7296,7 +7410,48 @@ ${traceSummary}` : traceSummary;
         base: existingContent
       } : null;
     }
-  }, [idle]);
+  }, [idle, releaseTurnLockIfSettled]);
+  (0, import_react14.useEffect)(() => {
+    if (!idle) return;
+    releaseTurnLockIfSettled();
+  }, [idle, response, pendingToolRequests.length, activeToolCalls.length, releaseTurnLockIfSettled]);
+  (0, import_react14.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
+  ]);
+  (0, import_react14.useEffect)(() => {
+    return () => {
+      if (queuedDrainTimerRef.current !== null) {
+        window.clearTimeout(queuedDrainTimerRef.current);
+        queuedDrainTimerRef.current = null;
+      }
+      queuedDrainScheduledRef.current = false;
+    };
+  }, []);
   (0, import_react14.useEffect)(() => {
     scrollToEndRef.current = scrollToEnd || false;
   }, [scrollToEnd]);
@@ -8589,7 +8744,49 @@ var parseCallMessages = (rawMessages) => {
   return normalized;
 };
 var shouldSkipTranscriptMessage = (message) => {
-  return message.role === "system" || message.role === "user" && message.content.startsWith("__system__:");
+  const normalizedContent = message.content.trim().toLowerCase();
+  const isInternalContinuationPrompt = message.role === "user" && normalizedContent.startsWith("original request:") && normalizedContent.includes("tool execution summary for the previous request:");
+  return message.role === "system" || message.role === "user" && message.content.startsWith("__system__:") || isInternalContinuationPrompt;
+};
+var looksLikeToolStubResponse = (value) => {
+  const text = value.trim();
+  if (!text) return false;
+  return text.includes('"type":"tool_use"') || text.includes('"type": "tool_use"') || text.includes('"type":"function"') || text.includes('"type": "function"');
+};
+var pickMoreCompleteResponse = (primaryResponse, fallbackResponse) => {
+  const primary = primaryResponse.trim();
+  const fallback = fallbackResponse.trim();
+  if (!fallback) return primary;
+  if (!primary) return fallback;
+  if (primary === fallback) return primary;
+  if (looksLikeToolStubResponse(primary) && !looksLikeToolStubResponse(fallback)) {
+    return fallback;
+  }
+  if (fallback.startsWith(primary) || fallback.length > primary.length + 40) {
+    return fallback;
+  }
+  return primary;
+};
+var mergeContinuationResponse = (baseResponse, continuationResponse) => {
+  const base = baseResponse.trim();
+  const continuation = continuationResponse.trim();
+  if (!base) return continuation;
+  if (!continuation) return base;
+  if (looksLikeToolStubResponse(base) && !looksLikeToolStubResponse(continuation)) {
+    return continuation;
+  }
+  if (base.includes(continuation)) {
+    return base;
+  }
+  const maxOverlap = Math.min(base.length, continuation.length);
+  for (let overlap = maxOverlap; overlap > 0; overlap -= 1) {
+    if (base.slice(-overlap) === continuation.slice(0, overlap)) {
+      return `${base}${continuation.slice(overlap)}`;
+    }
+  }
+  return `${base}
+
+${continuation}`;
 };
 var parseTimestampMs = (value) => {
   const timestamp = toStringValue(value).trim();
@@ -8669,22 +8866,29 @@ var buildTurnsFromMessages = (messages, fallbackResponse, callId, timestampMs) =
     const prompt = message.content.trim();
     if (!prompt) continue;
     let response = "";
+    let lastAssistantIndex = -1;
     let reachedNextUser = false;
     for (let lookAhead = index + 1; lookAhead < messages.length; lookAhead += 1) {
       const nextMessage = messages[lookAhead];
       if (!nextMessage) continue;
       if (nextMessage.role === "assistant") {
-        response = nextMessage.content.trim();
-        index = lookAhead;
-        break;
+        const assistantResponse = nextMessage.content.trim();
+        if (assistantResponse) {
+          response = assistantResponse;
+          lastAssistantIndex = lookAhead;
+        }
+        continue;
       }
       if (nextMessage.role === "user") {
         reachedNextUser = true;
         break;
       }
     }
-    if (!response && !reachedNextUser) {
-      response = fallbackResponse;
+    if (lastAssistantIndex >= 0) {
+      index = lastAssistantIndex;
+    }
+    if (!reachedNextUser) {
+      response = pickMoreCompleteResponse(response, fallbackResponse);
     }
     if (!response) continue;
     turns.push({
@@ -8730,6 +8934,17 @@ var buildTranscriptTurnsFromCalls = (calls) => {
             timestampMs
           }
         ];
+      } else if (fallbackResponse && mergedTurns.length > 0) {
+        const previousTurn = mergedTurns[mergedTurns.length - 1];
+        mergedTurns = [
+          ...mergedTurns.slice(0, -1),
+          __spreadProps(__spreadValues({}, previousTurn), {
+            response: mergeContinuationResponse(previousTurn.response, fallbackResponse),
+            callId: callId || previousTurn.callId,
+            timestampMs: Math.max(previousTurn.timestampMs, timestampMs)
+          })
+        ];
+        continue;
       }
     }
     mergedTurns = mergeTranscriptTurns(mergedTurns, callTurns);