@agent-native/core 0.84.39 → 0.84.41

package/dist/agent/production-agent.js

@@ -16,6 +16,7 @@ import { readBody } from "../server/h3-helpers.js";
 import { getRequestRunContext, ensureRequestRunContext, getRequestContext, getRequestOrgId, getRequestUserEmail, runWithRequestContext, } from "../server/request-context.js";
 import { fireInternalDispatch } from "../server/self-dispatch.js";
 import { isReasoningEffort, normalizeReasoningEffortForModel, } from "../shared/reasoning-effort.js";
+import { actionPreparationContinuationNote } from "./action-continuation-guidance.js";
 import { applyContextDirectives } from "./context-xray/apply-directives.js";
 import { loadContextDirectives } from "./context-xray/directives-store.js";
 import { buildManifest, writeContextManifest, } from "./context-xray/manifest.js";
@@ -558,6 +559,7 @@ function maxRetriesForError(err) {
     return MAX_RETRIES;
 }
 const TOOL_INPUT_ACTIVITY_INTERVAL_MS = 1500;
+const ACTION_PREPARATION_NO_PROGRESS_TIMEOUT_MS = 90_000;
 const MAX_TEXT_ATTACHMENT_CHARS = 60_000;
 const MAX_SELECTION_CONTEXT_CHARS = 8_000;
 const MAX_RESOURCE_INVENTORY_ITEMS = 40;
@@ -1098,7 +1100,7 @@ function collectTextParts(parts) {
         .join("");
 }
 export const AGENT_INTERNAL_CONTINUE_PROMPT = "Continue from where you left off and finish the user's original request. Do not repeat completed work, do not mention internal reconnects, time limits, or step limits, and continue as if this is the same uninterrupted run.";
-export function appendAgentLoopContinuation(messages, reason) {
+export function appendAgentLoopContinuation(messages, reason, options = {}) {
     const note = reason === "loop_limit"
         ? "The previous run reached an internal step budget."
         : reason === "max_tokens"
@@ -1109,17 +1111,31 @@ export function appendAgentLoopContinuation(messages, reason) {
                     ? "The previous LLM call hit an upstream gateway timeout before the response finished streaming."
                     : reason === "network_interrupted"
                         ? "The previous LLM call was cut off by a transport-level interruption (socket dropped, connection reset, or stream closed unexpectedly)."
-                        : "The previous run reached an internal execution budget.";
+                        : reason === "no_progress"
+                            ? "The previous run stopped producing progress events while the connection stayed open."
+                            : "The previous run reached an internal execution budget.";
+    const actionInputNote = options.actionPreparationTool
+        ? actionPreparationContinuationNote(options.actionPreparationTool)
+        : "";
     messages.push({
         role: "user",
         content: [
             {
                 type: "text",
-                text: `${AGENT_INTERNAL_CONTINUE_PROMPT}\n\nInternal note: ${note}`,
+                text: `${AGENT_INTERNAL_CONTINUE_PROMPT}\n\nInternal note: ${note}${actionInputNote}`,
             },
         ],
     });
 }
+function isAgentLoopContinuationReason(reason) {
+    return (reason === "run_timeout" ||
+        reason === "loop_limit" ||
+        reason === "max_tokens" ||
+        reason === "stream_ended" ||
+        reason === "gateway_timeout" ||
+        reason === "network_interrupted" ||
+        reason === "no_progress");
+}
 /**
  * True when an error thrown by `runAgentLoop` is a recoverable transport- or
  * gateway-level interruption that the agent can resume from rather than a
@@ -1960,6 +1976,8 @@ export async function runAgentLoop(opts) {
                 const toolInputNames = new Map();
                 const toolInputBytes = new Map();
                 let lastToolInputActivityAt = 0;
+                const activeToolInputs = new Map();
+                let endedForActionPreparationNoProgress = false;
                 const sendToolInputActivity = (toolName, toolInputId, progressBytes, force = false) => {
                     const now = Date.now();
                     if (!force &&
@@ -1975,7 +1993,56 @@ export async function runAgentLoop(opts) {
                         ...(typeof progressBytes === "number" ? { progressBytes } : {}),
                     });
                 };
+                const resetActiveToolInput = (toolName, toolInputId) => {
+                    if (toolInputId) {
+                        activeToolInputs.delete(toolInputId);
+                        return;
+                    }
+                    if (toolName) {
+                        for (const [id, active] of activeToolInputs) {
+                            if (active.toolName === toolName) {
+                                activeToolInputs.delete(id);
+                            }
+                        }
+                    }
+                };
+                const hasActionPreparationStalled = () => {
+                    if (activeToolInputs.size === 0)
+                        return false;
+                    const now = Date.now();
+                    for (const active of activeToolInputs.values()) {
+                        if (now - active.lastProgressAt >=
+                            ACTION_PREPARATION_NO_PROGRESS_TIMEOUT_MS) {
+                            return true;
+                        }
+                    }
+                    return false;
+                };
+                const trackActiveToolInput = (key, toolName, bytes) => {
+                    const now = Date.now();
+                    const previous = activeToolInputs.get(key);
+                    activeToolInputs.set(key, {
+                        id: key,
+                        ...((toolName ?? previous?.toolName)
+                            ? { toolName: toolName ?? previous?.toolName }
+                            : {}),
+                        startedAt: previous?.startedAt ?? now,
+                        lastProgressAt: now,
+                        bytes,
+                    });
+                };
+                const clearActiveToolInputs = () => {
+                    activeToolInputs.clear();
+                };
                 for await (const event of eventStream) {
+                    if (hasActionPreparationStalled()) {
+                        send({
+                            type: "auto_continue",
+                            reason: "no_progress",
+                        });
+                        endedForActionPreparationNoProgress = true;
+                        break;
+                    }
                     // In-loop processor seam (stream hook). Each chunk is offered to every
                     // processor's `processOutputStream` before the loop handles it. A
                     // processor `abort()` throws a TripWire; catch it locally so it is not
@@ -2008,6 +2075,7 @@ export async function runAgentLoop(opts) {
                         if (key && event.name) {
                             toolInputNames.set(key, event.name);
                             toolInputBytes.set(key, 0);
+                            trackActiveToolInput(key, event.name, 0);
                         }
                         sendToolInputActivity(event.name, key, undefined, true);
                     }
@@ -2022,6 +2090,9 @@ export async function runAgentLoop(opts) {
                                 previous +
                                     new TextEncoder().encode(event.text ?? "").byteLength;
                             toolInputBytes.set(key, progressBytes);
+                            if (progressBytes > previous) {
+                                trackActiveToolInput(key, toolName, progressBytes);
+                            }
                         }
                         sendToolInputActivity(toolName, key, progressBytes);
                     }
@@ -2030,8 +2101,10 @@ 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);
                     }
                     else if (event.type === "tool-call-error") {
+                        resetActiveToolInput(event.name, event.id);
                         toolCallErrors.set(event.id, {
                             name: event.name,
                             input: event.input,
@@ -2039,6 +2112,7 @@ export async function runAgentLoop(opts) {
                         });
                     }
                     else if (event.type === "assistant-content") {
+                        clearActiveToolInputs();
                         assistantContent = event.parts;
                     }
                     else if (event.type === "usage") {
@@ -2058,6 +2132,17 @@ export async function runAgentLoop(opts) {
                             });
                         }
                     }
+                    if (hasActionPreparationStalled()) {
+                        send({
+                            type: "auto_continue",
+                            reason: "no_progress",
+                        });
+                        endedForActionPreparationNoProgress = true;
+                        break;
+                    }
+                }
+                if (endedForActionPreparationNoProgress) {
+                    return usage;
                 }
                 break;
             }
@@ -3043,6 +3128,141 @@ function endsAtInternalContinuationBoundary(run) {
     }
     return last.type === "error" && isRecoverableContinuationError(last);
 }
+function isPreparingActionActivityEvent(event) {
+    if (event.type !== "activity")
+        return false;
+    const label = event.label.trim().toLowerCase();
+    return label.startsWith("preparing ") && label.includes(" action");
+}
+export function lastUnfinishedPreparingActionToolFromEvents(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) {
+                const id = event.id?.trim();
+                const key = id ? `id:${id}` : `tool:${tool}:${order}`;
+                active.set(key, {
+                    tool,
+                    order,
+                    ...(id ? { id } : {}),
+                });
+            }
+            return;
+        }
+        if (event.type === "tool_start" || event.type === "tool_done") {
+            removeMatchingActivePreparation(event);
+            return;
+        }
+        if (event.type === "error" && isRecoverableContinuationError(event)) {
+            return;
+        }
+        if (event.type === "clear" ||
+            event.type === "done" ||
+            event.type === "error" ||
+            event.type === "missing_api_key") {
+            active.clear();
+            idlessToolStarts.clear();
+        }
+    });
+    let latest;
+    for (const value of active.values()) {
+        if (!latest || value.order > latest.order) {
+            latest = value;
+        }
+    }
+    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));
+}
+export function backgroundContinuationReasonForRun(run) {
+    const last = run.events.at(-1)?.event;
+    if (last?.type === "loop_limit")
+        return "loop_limit";
+    if (last?.type === "auto_continue" &&
+        isAgentLoopContinuationReason(last.reason)) {
+        return last.reason;
+    }
+    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,
@@ -3054,14 +3274,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) {
@@ -3809,7 +4028,16 @@ export function createProductionAgentHandler(options) {
                     ?.threadData;
                 const resumed = threadDataToEngineMessages(priorThreadData);
                 if (resumed.length > 0) {
-                    appendAgentLoopContinuation(resumed, "run_timeout");
+                    const actionPreparationTool = typeof backgroundRunMarker?.actionPreparationTool === "string" &&
+                        backgroundRunMarker.actionPreparationTool.trim()
+                        ? backgroundRunMarker.actionPreparationTool.trim()
+                        : undefined;
+                    const continuationReason = isAgentLoopContinuationReason(backgroundRunMarker?.continuationReason)
+                        ? backgroundRunMarker.continuationReason
+                        : "run_timeout";
+                    appendAgentLoopContinuation(resumed, continuationReason, {
+                        ...(actionPreparationTool ? { actionPreparationTool } : {}),
+                    });
                     messages.length = 0;
                     messages.push(...resumed);
                 }
@@ -3972,10 +4200,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"
@@ -4060,7 +4293,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;
@@ -4081,34 +4314,32 @@ 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
                         // its seq log starts clean; same turnId folds the assistant
                         // message across chunks.
                         const nextRunId = generateRunId();
+                        const actionPreparationTool = lastUnfinishedPreparingActionTool(run);
+                        const continuationReason = backgroundContinuationReasonForRun(run);
                         const continuationDispatchPath = resolveAgentChatProcessRunDispatchPath();
                         const continuationExpectsNetlifyBackgroundFunction = dispatchPathTargetsNetlifyBackgroundFunction(continuationDispatchPath);
                         try {
@@ -4129,6 +4360,10 @@ export function createProductionAgentHandler(options) {
                                         runId: nextRunId,
                                         turnId: effectiveTurnId,
                                         continuationCount: backgroundContinuationCount + 1,
+                                        continuationReason,
+                                        ...(actionPreparationTool
+                                            ? { actionPreparationTool }
+                                            : {}),
                                         backgroundFunctionRuntimeExpected: continuationExpectsNetlifyBackgroundFunction,
                                     },
                                 },