@agent-native/core 0.84.2 → 0.84.3

package/dist/client/agent-chat-adapter.js

@@ -529,6 +529,34 @@ function hasContinuationProgress(content) {
         ? part.text.trim().length > 0
         : part.result !== undefined);
 }
+function lastCompletedSideEffectTool(content) {
+    for (let i = content.length - 1; i >= 0; i--) {
+        const part = content[i];
+        if (part.type === "tool-call" &&
+            part.activity !== true &&
+            part.result !== undefined &&
+            part.isError !== true &&
+            part.completedSideEffect === true) {
+            return part;
+        }
+    }
+    return undefined;
+}
+function humanizeActionName(toolName) {
+    return toolName
+        .replace(/^agent:/, "")
+        .replace(/[-_]+/g, " ")
+        .trim();
+}
+function completedToolTimeoutMessage(toolName) {
+    if (toolName === "generate-design" || toolName === "update-design") {
+        return "The design was saved, but the assistant timed out before sending its final note. You can open the generated design from the completed tool card above.";
+    }
+    if (toolName === "present-design-variants") {
+        return "The design variants were saved, but the assistant timed out before sending its final note. You can review the completed variants from the tool card above.";
+    }
+    return `The ${humanizeActionName(toolName)} action completed, but the assistant timed out before sending its final response. The saved result is in the completed tool card above.`;
+}
 /**
  * Signature of the *unique* sentence-like segments in a continuation's newly
  * streamed text, used to detect a degenerate repetition loop. A stuck model
@@ -603,6 +631,8 @@ function toolContinuationKey(part) {
         stableJson(part.args),
         part.result === undefined ? "pending" : "done",
         part.result ?? "",
+        part.isError === true ? "error" : "",
+        part.completedSideEffect === true ? "side-effect" : "",
         part.activity === true ? "activity" : "tool",
         part.mcpApp ? "mcp-app" : "",
     ].join("\u0000");
@@ -657,6 +687,8 @@ function incrementalActionGuidance(tool) {
         case "generate-design":
         case "update-design":
             return "persist a minimal first version (fewer files) with `generate-design`, then refine individual files with `edit-design` search/replace instead of resending everything";
+        case "present-design-variants":
+            return "save compact but complete variant screens with `present-design-variants` first, keeping each HTML direction focused enough to finish, then refine the chosen direction with `generate-design` or `edit-design`";
         case "create-visual-plan":
         case "create-ui-plan":
         case "create-plan-design":
@@ -1039,6 +1071,7 @@ export function createAgentChatAdapter(options) {
             // its own budget rather than inheriting the prior payload's.
             let lastInFlightToolSignature;
             let repeatedInFlightToolCount = 0;
+            let recoveryGaveUpOnInFlightTool = false;
             const MAX_REPEATED_INFLIGHT_TOOL_STALLS = 3;
             const continuationHistoryFragments = [];
             const structuredContinuationFragments = [];
@@ -1077,6 +1110,9 @@ export function createAgentChatAdapter(options) {
                     .join("\n");
             };
             const exhaustedRecoveryMessage = (reason) => {
+                if (recoveryGaveUpOnInFlightTool) {
+                    return "The agent got stuck waiting for the same tool to finish, so I stopped the automatic retries. The tool did not report a completed result.";
+                }
                 if (recoveryGaveUpOnRepetition) {
                     return "The agent got stuck repeating the same response without finishing, so I stopped the automatic retries. This often happens when it tries to re-type a large pasted file into one action — starting a new chat, or asking for a smaller first step, usually gets it unstuck.";
                 }
@@ -1309,6 +1345,73 @@ export function createAgentChatAdapter(options) {
                     }
                     return false;
                 };
+                const reconnectBackgroundContinuationForRunTimeout = async function* () {
+                    if (!threadId || !runId)
+                        return false;
+                    const interruptedRunId = runId;
+                    const interruptedLastSeq = lastSeq;
+                    let lastActiveRunError = null;
+                    for (let attempt = 0; attempt < 3; attempt++) {
+                        if (attempt > 0) {
+                            await delay(500, abortSignal);
+                        }
+                        if (abortSignal.aborted)
+                            return true;
+                        try {
+                            const activeRes = await fetch(`${apiUrl}/runs/active?threadId=${encodeURIComponent(threadId)}`, { signal: abortSignal });
+                            if (!activeRes.ok) {
+                                if (activeRes.status === 404)
+                                    return false;
+                                lastActiveRunError = new Error(`Active run lookup failed: ${activeRes.status}`);
+                                continue;
+                            }
+                            const active = await activeRes.json();
+                            if (!active?.active || !active.runId)
+                                return false;
+                            const activeRunId = String(active.runId);
+                            const dispatchMode = typeof active.dispatchMode === "string"
+                                ? active.dispatchMode
+                                : "";
+                            if (activeRunId === interruptedRunId) {
+                                if (dispatchMode.startsWith("background"))
+                                    continue;
+                                return false;
+                            }
+                            const activeTurnId = typeof active.turnId === "string" ? active.turnId : "";
+                            const activeStatus = typeof active.status === "string" ? active.status : "";
+                            if (!dispatchMode.startsWith("background"))
+                                return false;
+                            if (activeTurnId && activeTurnId !== turnId)
+                                return false;
+                            if (activeStatus !== "running" && activeStatus !== "starting") {
+                                return false;
+                            }
+                            runId = activeRunId;
+                            if (!attemptedRunIds.includes(activeRunId)) {
+                                attemptedRunIds.push(activeRunId);
+                            }
+                            lastSeq = -1;
+                            setActiveRun({ threadId, runId: activeRunId, lastSeq: -1 });
+                            const reconnected = yield* reconnectCurrentRun();
+                            if (reconnected)
+                                return true;
+                        }
+                        catch (activeErr) {
+                            if (activeErr instanceof Error &&
+                                activeErr.name === "AbortError") {
+                                clearActiveRun();
+                                return true;
+                            }
+                            lastActiveRunError = activeErr;
+                        }
+                    }
+                    if (lastActiveRunError) {
+                        captureChatClientError(lastActiveRunError, "reconnect-background-continuation-failed");
+                    }
+                    runId = interruptedRunId;
+                    lastSeq = interruptedLastSeq;
+                    return false;
+                };
                 const visibleContentForContinuation = () => {
                     return contentAfterContinuationPrefix(content, visibleContinuationPrefix);
                 };
@@ -1331,6 +1434,7 @@ export function createAgentChatAdapter(options) {
                     // before tool_start; treating it as progress caused silent retry
                     // loops when the LLM timed out while assembling a large tool input.
                     const hasInFlightTool = hasInFlightToolCall(visibleContent);
+                    const completedSideEffectTool = lastCompletedSideEffectTool(content);
                     // Either real output or an actively-running tool counts as progress
                     // for the stalled/empty caps.
                     const madeProgress = madeContentProgress || hasInFlightTool;
@@ -1343,11 +1447,11 @@ export function createAgentChatAdapter(options) {
                     // MAX_REPEATED_INFLIGHT_TOOL_STALLS consecutive stream_ended events,
                     // bail with a clear message.
                     //
-                    // Only count stream_ended (connection drop / reconnect failed), NOT
-                    // run_timeout (server legitimately still executing a slow tool). A
-                    // run_timeout with an in-flight tool means the server is actively
-                    // working and reconnection may still recover the result; a repeated
-                    // stream_ended means the connection keeps breaking under that payload.
+                    // Count broken streams (connection drop / reconnect failed) and
+                    // no_progress stalls (the client aborts a stream that stayed open but
+                    // stopped producing events). Do NOT count run_timeout: with an
+                    // in-flight tool that means the server is still actively executing a
+                    // slow action and reconnection may recover the result.
                     const currentInFlightToolPart = visibleContent.find((p) => p.type === "tool-call" &&
                         p.result === undefined &&
                         p.activity !== true);
@@ -1355,8 +1459,8 @@ export function createAgentChatAdapter(options) {
                     const currentInFlightToolSignature = currentInFlightToolPart
                         ? inFlightToolInputSignature(currentInFlightToolPart)
                         : undefined;
-                    const isConnectionDrop = signal.reason === "stream_ended";
-                    if (currentInFlightToolName && isConnectionDrop) {
+                    const isBrokenInFlightTool = signal.reason === "stream_ended" || signal.reason === "no_progress";
+                    if (currentInFlightToolName && isBrokenInFlightTool) {
                         if (currentInFlightToolName === lastInFlightToolName &&
                             currentInFlightToolSignature === lastInFlightToolSignature) {
                             repeatedInFlightToolCount += 1;
@@ -1393,11 +1497,27 @@ export function createAgentChatAdapter(options) {
                     }
                     else {
                         totalTransientContinuationAttempts += 1;
+                        // If a mutating action already completed, do not turn a missing
+                        // closing sentence into a scary connection failure. Give the model
+                        // one continuation opportunity (the completed tool itself counts
+                        // as progress on the first timeout); if the follow-up produces no
+                        // new content, stop locally with a clear "saved, final note timed
+                        // out" message.
+                        if (completedSideEffectTool &&
+                            !hasInFlightToolCall(content) &&
+                            !madeContentProgress &&
+                            !hasInFlightTool) {
+                            return {
+                                ok: false,
+                                resetVisibleContent: false,
+                                completedToolName: completedSideEffectTool.toolName,
+                            };
+                        }
                         // Bail when the same write tool is stuck in-flight across too many
                         // consecutive continuations. Checked before the text-repeat guard
                         // because hasInFlightTool=true would mask the repeat as progress.
                         if (repeatedInFlightToolCount >= MAX_REPEATED_INFLIGHT_TOOL_STALLS) {
-                            recoveryGaveUpOnRepetition = true;
+                            recoveryGaveUpOnInFlightTool = true;
                             return { ok: false, resetVisibleContent: false };
                         }
                         // Bail fast on a non-advancing repetition loop, well before the
@@ -1760,6 +1880,11 @@ export function createAgentChatAdapter(options) {
                             if (err.reason === "no_progress") {
                                 await abortCurrentRun();
                             }
+                            if (err.reason === "run_timeout" && !err.errorInfo) {
+                                const reconnected = yield* reconnectBackgroundContinuationForRunTimeout();
+                                if (reconnected)
+                                    return;
+                            }
                             if (err.reason === "stream_ended") {
                                 const reconnected = yield* reconnectCurrentRun();
                                 if (reconnected)
@@ -1770,6 +1895,29 @@ export function createAgentChatAdapter(options) {
                             }
                             const continuation = prepareAutoContinuation(err);
                             if (!continuation.ok) {
+                                if (continuation.completedToolName) {
+                                    const message = completedToolTimeoutMessage(continuation.completedToolName);
+                                    content.push({ type: "text", text: message });
+                                    yield {
+                                        content: [...content],
+                                        status: {
+                                            type: "complete",
+                                            reason: "stop",
+                                        },
+                                        metadata: {
+                                            custom: {
+                                                ...(runId ? { runId } : {}),
+                                                runWarning: {
+                                                    message,
+                                                    errorCode: "final_response_timeout_after_tool",
+                                                    recoverable: true,
+                                                },
+                                            },
+                                        },
+                                    };
+                                    clearActiveRun();
+                                    return;
+                                }
                                 const preservedError = err.errorInfo ?? lastRecoverableRunError ?? null;
                                 const message = preservedError?.message ??
                                     exhaustedRecoveryMessage(err.reason);
@@ -1920,6 +2068,29 @@ export function createAgentChatAdapter(options) {
                         if (content.length > 0) {
                             const continuation = prepareAutoContinuation(new AgentAutoContinueSignal({ reason: "stream_ended" }));
                             if (!continuation.ok) {
+                                if (continuation.completedToolName) {
+                                    const message = completedToolTimeoutMessage(continuation.completedToolName);
+                                    content.push({ type: "text", text: message });
+                                    yield {
+                                        content: [...content],
+                                        status: {
+                                            type: "complete",
+                                            reason: "stop",
+                                        },
+                                        metadata: {
+                                            custom: {
+                                                ...(runId ? { runId } : {}),
+                                                runWarning: {
+                                                    message,
+                                                    errorCode: "final_response_timeout_after_tool",
+                                                    recoverable: true,
+                                                },
+                                            },
+                                        },
+                                    };
+                                    clearActiveRun();
+                                    return;
+                                }
                                 const message = exhaustedRecoveryMessage("stream_ended");
                                 captureChatClientError(err, "recovery-exhausted");
                                 const runError = {