@agent-native/core 0.84.38 → 0.84.40

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,62 @@ 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) {
+    let active = null;
+    for (const event of events) {
+        if (isPreparingActionActivityEvent(event)) {
+            const tool = event.tool?.trim();
+            if (tool) {
+                active = {
+                    tool,
+                    ...(event.id?.trim() ? { id: event.id.trim() } : {}),
+                };
+            }
+            continue;
+        }
+        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;
+        }
+        if (event.type === "error" && isRecoverableContinuationError(event)) {
+            continue;
+        }
+        if (event.type === "clear" ||
+            event.type === "done" ||
+            event.type === "error" ||
+            event.type === "missing_api_key") {
+            active = null;
+        }
+    }
+    return active?.tool;
+}
+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 }));
+    }
+    return "run_timeout";
+}
 /**
  * Hard cap on server-driven background→background continuation chunks for a
  * single logical turn. A `backgroundFunction` run gets a ~13-min soft timeout,
@@ -3809,7 +3950,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);
                 }
@@ -4109,6 +4259,8 @@ export function createProductionAgentHandler(options) {
                         // 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 +4281,10 @@ export function createProductionAgentHandler(options) {
                                         runId: nextRunId,
                                         turnId: effectiveTurnId,
                                         continuationCount: backgroundContinuationCount + 1,
+                                        continuationReason,
+                                        ...(actionPreparationTool
+                                            ? { actionPreparationTool }
+                                            : {}),
                                         backgroundFunctionRuntimeExpected: continuationExpectsNetlifyBackgroundFunction,
                                     },
                                 },