@agent-native/core 0.84.40 → 0.84.42

package/dist/agent/production-agent.js

@@ -560,6 +560,7 @@ function maxRetriesForError(err) {
 }
 const TOOL_INPUT_ACTIVITY_INTERVAL_MS = 1500;
 const ACTION_PREPARATION_NO_PROGRESS_TIMEOUT_MS = 90_000;
+const ACTION_PREPARATION_ZERO_BYTE_RESTART_LIMIT = 2;
 const MAX_TEXT_ATTACHMENT_CHARS = 60_000;
 const MAX_SELECTION_CONTEXT_CHARS = 8_000;
 const MAX_RESOURCE_INVENTORY_ITEMS = 40;
@@ -1977,6 +1978,7 @@ export async function runAgentLoop(opts) {
                 const toolInputBytes = new Map();
                 let lastToolInputActivityAt = 0;
                 const activeToolInputs = new Map();
+                let zeroByteToolInputRestart;
                 let endedForActionPreparationNoProgress = false;
                 const sendToolInputActivity = (toolName, toolInputId, progressBytes, force = false) => {
                     const now = Date.now();
@@ -2031,6 +2033,37 @@ export async function runAgentLoop(opts) {
                         bytes,
                     });
                 };
+                const resetZeroByteToolInputRestart = (toolName) => {
+                    if (!zeroByteToolInputRestart)
+                        return;
+                    if (!toolName || zeroByteToolInputRestart.toolName === toolName) {
+                        zeroByteToolInputRestart = undefined;
+                    }
+                };
+                const noteZeroByteToolInputStart = (toolName) => {
+                    if (!toolName)
+                        return false;
+                    const now = Date.now();
+                    if (zeroByteToolInputRestart?.toolName === toolName) {
+                        zeroByteToolInputRestart = {
+                            ...zeroByteToolInputRestart,
+                            lastStartedAt: now,
+                            count: zeroByteToolInputRestart.count + 1,
+                        };
+                    }
+                    else {
+                        zeroByteToolInputRestart = {
+                            toolName,
+                            firstStartedAt: now,
+                            lastStartedAt: now,
+                            count: 1,
+                        };
+                    }
+                    return (zeroByteToolInputRestart.count >
+                        ACTION_PREPARATION_ZERO_BYTE_RESTART_LIMIT &&
+                        now - zeroByteToolInputRestart.firstStartedAt >=
+                            ACTION_PREPARATION_NO_PROGRESS_TIMEOUT_MS);
+                };
                 const clearActiveToolInputs = () => {
                     activeToolInputs.clear();
                 };
@@ -2060,6 +2093,7 @@ export async function runAgentLoop(opts) {
                         }
                     }
                     if (event.type === "text-delta") {
+                        resetZeroByteToolInputRestart();
                         streamedAssistantText += event.text;
                         send({ type: "text", text: event.text });
                     }
@@ -2078,6 +2112,14 @@ export async function runAgentLoop(opts) {
                             trackActiveToolInput(key, event.name, 0);
                         }
                         sendToolInputActivity(event.name, key, undefined, true);
+                        if (noteZeroByteToolInputStart(event.name)) {
+                            send({
+                                type: "auto_continue",
+                                reason: "no_progress",
+                            });
+                            endedForActionPreparationNoProgress = true;
+                            break;
+                        }
                     }
                     else if (event.type === "tool-input-delta") {
                         const key = event.id ?? event.name;
@@ -2092,6 +2134,7 @@ export async function runAgentLoop(opts) {
                             toolInputBytes.set(key, progressBytes);
                             if (progressBytes > previous) {
                                 trackActiveToolInput(key, toolName, progressBytes);
+                                resetZeroByteToolInputRestart(toolName);
                             }
                         }
                         sendToolInputActivity(toolName, key, progressBytes);
@@ -2102,9 +2145,11 @@ export async function runAgentLoop(opts) {
                     else if (event.type === "tool-call") {
                         // The authoritative tool-call blocks arrive in assistant-content.
                         resetActiveToolInput(event.name, event.id);
+                        resetZeroByteToolInputRestart(event.name);
                     }
                     else if (event.type === "tool-call-error") {
                         resetActiveToolInput(event.name, event.id);
+                        resetZeroByteToolInputRestart(event.name);
                         toolCallErrors.set(event.id, {
                             name: event.name,
                             input: event.input,
@@ -3135,38 +3180,110 @@ function isPreparingActionActivityEvent(event) {
     return label.startsWith("preparing ") && label.includes(" action");
 }
 export function lastUnfinishedPreparingActionToolFromEvents(events) {
-    let active = null;
-    for (const event of events) {
+    const active = new Map();
+    const idlessToolStarts = new Map();
+    const removeOldestMatchingActivePreparation = (tool, shouldRemove = () => true) => {
+        let oldest;
+        for (const [key, value] of active) {
+            if (value.tool !== tool || !shouldRemove(value))
+                continue;
+            if (!oldest || value.order < oldest.order) {
+                oldest = {
+                    key,
+                    order: value.order,
+                };
+            }
+        }
+        if (oldest)
+            active.delete(oldest.key);
+        return Boolean(oldest);
+    };
+    const removeMatchingActivePreparation = (event) => {
+        const id = event.id?.trim();
+        const tool = event.tool?.trim();
+        if (!tool)
+            return;
+        if (id) {
+            if (!active.delete(`id:${id}`)) {
+                removeOldestMatchingActivePreparation(tool, (value) => !value.id);
+            }
+            return;
+        }
+        if (event.type === "tool_start") {
+            if (removeOldestMatchingActivePreparation(tool)) {
+                idlessToolStarts.set(tool, (idlessToolStarts.get(tool) ?? 0) + 1);
+            }
+            return;
+        }
+        const startedCount = idlessToolStarts.get(tool) ?? 0;
+        if (startedCount > 0) {
+            if (startedCount === 1) {
+                idlessToolStarts.delete(tool);
+            }
+            else {
+                idlessToolStarts.set(tool, startedCount - 1);
+            }
+            return;
+        }
+        removeOldestMatchingActivePreparation(tool);
+    };
+    events.forEach((event, order) => {
         if (isPreparingActionActivityEvent(event)) {
             const tool = event.tool?.trim();
             if (tool) {
-                active = {
+                const id = event.id?.trim();
+                const key = id ? `id:${id}` : `tool:${tool}:${order}`;
+                active.set(key, {
                     tool,
-                    ...(event.id?.trim() ? { id: event.id.trim() } : {}),
-                };
+                    order,
+                    ...(id ? { id } : {}),
+                });
             }
-            continue;
+            return;
         }
         if (event.type === "tool_start" || event.type === "tool_done") {
-            const tool = event.tool?.trim();
-            const id = event.id?.trim();
-            if (active &&
-                ((id && active.id === id) || (!id && tool && active.tool === tool))) {
-                active = null;
-            }
-            continue;
+            removeMatchingActivePreparation(event);
+            return;
         }
         if (event.type === "error" && isRecoverableContinuationError(event)) {
-            continue;
+            return;
         }
         if (event.type === "clear" ||
             event.type === "done" ||
             event.type === "error" ||
             event.type === "missing_api_key") {
-            active = null;
+            active.clear();
+            idlessToolStarts.clear();
+        }
+    });
+    let latest;
+    for (const value of active.values()) {
+        if (!latest || value.order > latest.order) {
+            latest = value;
         }
     }
-    return active?.tool;
+    return latest?.tool;
+}
+function endsAfterCompletedToolWithoutAssistantFinal(run) {
+    let completedToolAfterLastAssistantText = false;
+    for (const { event } of run.events) {
+        if (event.type === "text" && event.text.trim().length > 0) {
+            completedToolAfterLastAssistantText = false;
+            continue;
+        }
+        if (event.type === "tool_done" && event.isError !== true) {
+            completedToolAfterLastAssistantText = true;
+            continue;
+        }
+        if (event.type === "clear" ||
+            event.type === "error" ||
+            event.type === "missing_api_key" ||
+            event.type === "auto_continue" ||
+            event.type === "loop_limit") {
+            completedToolAfterLastAssistantText = false;
+        }
+    }
+    return completedToolAfterLastAssistantText;
 }
 function lastUnfinishedPreparingActionTool(run) {
     return lastUnfinishedPreparingActionToolFromEvents(run.events.map(({ event }) => event));
@@ -3182,8 +3299,15 @@ export function backgroundContinuationReasonForRun(run) {
     if (last?.type === "error" && isRecoverableContinuationError(last)) {
         return continuationReasonForResumableError(new EngineError(last.error, { errorCode: last.errorCode }));
     }
+    if (endsAfterCompletedToolWithoutAssistantFinal(run)) {
+        return "stream_ended";
+    }
     return "run_timeout";
 }
+function endsAtContinuationBoundary(run) {
+    return (endsAtInternalContinuationBoundary(run) ||
+        endsAfterCompletedToolWithoutAssistantFinal(run));
+}
 /**
  * Hard cap on server-driven background→background continuation chunks for a
  * single logical turn. A `backgroundFunction` run gets a ~13-min soft timeout,
@@ -3195,14 +3319,13 @@ export const MAX_BACKGROUND_RUN_CONTINUATIONS = 20;
 /**
  * Whether the background worker should self-fire the next server-driven
  * continuation chunk. True only when this is a background worker run that ended
- * at a recoverable soft-timeout boundary (not aborted/stopped) and the chain is
- * still under its budget. Extracted so the decision is unit testable without
- * booting the whole handler.
+ * at a recoverable unfinished boundary (not aborted/stopped) and the chain is
+ * still under its budget. Aborted / user-stopped runs do NOT chain.
  */
 export function shouldChainBackgroundContinuation(opts) {
     return (opts.isBackgroundWorker &&
         opts.run.status !== "aborted" &&
-        endsAtInternalContinuationBoundary(opts.run) &&
+        endsAtContinuationBoundary(opts.run) &&
         opts.continuationCount < MAX_BACKGROUND_RUN_CONTINUATIONS);
 }
 export async function claimBackgroundWorkerRunEarly(opts) {
@@ -4122,10 +4245,15 @@ export function createProductionAgentHandler(options) {
                 turnId: effectiveTurnId,
             }
             : null;
+        const willChainBackgroundContinuation = (run) => shouldChainBackgroundContinuation({
+            isBackgroundWorker,
+            run,
+            continuationCount: backgroundContinuationCount,
+        });
         const completeTrackedProgressRun = async (run, completionError) => {
             if (!trackedProgressRunId || !trackedProgressOwner)
                 return;
-            if (!completionError && endsAtInternalContinuationBoundary(run)) {
+            if (!completionError && willChainBackgroundContinuation(run)) {
                 return;
             }
             const terminalStatus = run.status === "aborted"
@@ -4210,7 +4338,7 @@ export function createProductionAgentHandler(options) {
                     // below, they did not "throw").
                     if (isBackgroundWorker &&
                         run.status === "errored" &&
-                        !endsAtInternalContinuationBoundary(run)) {
+                        !willChainBackgroundContinuation(run)) {
                         const errEvent = [...run.events]
                             .reverse()
                             .find((e) => e.event.type === "error")?.event;
@@ -4231,28 +4359,24 @@ export function createProductionAgentHandler(options) {
                     // agent-teams `fireInternalDispatch({ body: { mode: "continue" }})`
                     // chain. Bounded by MAX_BACKGROUND_RUN_CONTINUATIONS. Aborted /
                     // user-stopped runs do NOT chain.
-                    if (shouldChainBackgroundContinuation({
-                        // Self-chain server-side for EVERY durable worker, not only the
-                        // ones inside a `-background` function. Server-driven
-                        // continuation is the whole point of durable background: the run
-                        // must survive the client disconnecting (closed tab), so it
-                        // cannot depend on the browser re-POSTing `auto_continue`. A
-                        // worker on the regular ~60s function — a Netlify routing miss,
-                        // or a non-Netlify host (Vercel/Cloudflare/Render/Fly) that
-                        // never emits a `-background` function — checkpoints at the 40s
-                        // soft-timeout and self-dispatches the next 40s chunk; a worker
-                        // in a real `-background` function chains ~13-min chunks. Only
-                        // the per-chunk BUDGET differs by function type (gated by
-                        // `runsInBackgroundFunction` at the startRun call below); the
-                        // continuation itself must stay server-driven on both. (The
-                        // self-chain is only reachable when the initial dispatch already
-                        // succeeded — a dispatch fast-fail degrades to the inline
-                        // foreground fallback, which is not a worker and rides the
-                        // connected client's auto_continue instead.)
-                        isBackgroundWorker,
-                        run,
-                        continuationCount: backgroundContinuationCount,
-                    })) {
+                    // Self-chain server-side for EVERY durable worker, not only the
+                    // ones inside a `-background` function. Server-driven
+                    // continuation is the whole point of durable background: the run
+                    // must survive the client disconnecting (closed tab), so it
+                    // cannot depend on the browser re-POSTing `auto_continue`. A
+                    // worker on the regular ~60s function — a Netlify routing miss,
+                    // or a non-Netlify host (Vercel/Cloudflare/Render/Fly) that
+                    // never emits a `-background` function — checkpoints at the 40s
+                    // soft-timeout and self-dispatches the next 40s chunk; a worker
+                    // in a real `-background` function chains ~13-min chunks. Only
+                    // the per-chunk BUDGET differs by function type (gated by
+                    // `runsInBackgroundFunction` at the startRun call below); the
+                    // continuation itself must stay server-driven on both. (The
+                    // self-chain is only reachable when the initial dispatch already
+                    // succeeded — a dispatch fast-fail degrades to the inline
+                    // foreground fallback, which is not a worker and rides the
+                    // connected client's auto_continue instead.)
+                    if (willChainBackgroundContinuation(run)) {
                         // Mint the next chunk's runId here and sign the dispatch token
                         // over it, so the `_process-run` route's HMAC check and the
                         // worker's run identity agree. Fresh runId (not this chunk's) so