@agent-native/core 0.41.1 → 0.43.0

package/dist/client/agent-chat-adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent-chat-adapter.d.ts","sourceRoot":"","sources":["../../src/client/agent-chat-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAsB,MAAM,qBAAqB,CAAC;AAgBhF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAKrE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE7D,MAAM,MAAM,oBAAoB;AAC9B;;;;GAIG;AACD,KAAK;AACP,0EAA0E;GACxE,WAAW,CAAC;AAm6BhB;;;;GAIG;AACH;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,CAAC,EAAE;IAC/C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE;QAAE,OAAO,EAAE,MAAM,GAAG,SAAS,CAAA;KAAE,CAAC;IAC3C,SAAS,CAAC,EAAE;QAAE,OAAO,EAAE,MAAM,GAAG,SAAS,CAAA;KAAE,CAAC;IAC5C,SAAS,CAAC,EAAE;QAAE,OAAO,EAAE,eAAe,GAAG,SAAS,CAAA;KAAE,CAAC;IACrD,WAAW,CAAC,EAAE;QAAE,OAAO,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAAA;KAAE,CAAC;IACxD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE;QAAE,OAAO,EAAE,eAAe,GAAG,IAAI,GAAG,SAAS,CAAA;KAAE,CAAC;IAC3D,OAAO,CAAC,EAAE,oBAAoB,CAAC;CAChC,GAAG,gBAAgB,CAygCnB"}
+{"version":3,"file":"agent-chat-adapter.d.ts","sourceRoot":"","sources":["../../src/client/agent-chat-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAsB,MAAM,qBAAqB,CAAC;AAgBhF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAKrE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE7D,MAAM,MAAM,oBAAoB;AAC9B;;;;GAIG;AACD,KAAK;AACP,0EAA0E;GACxE,WAAW,CAAC;AAm+BhB;;;;GAIG;AACH;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,CAAC,EAAE;IAC/C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE;QAAE,OAAO,EAAE,MAAM,GAAG,SAAS,CAAA;KAAE,CAAC;IAC3C,SAAS,CAAC,EAAE;QAAE,OAAO,EAAE,MAAM,GAAG,SAAS,CAAA;KAAE,CAAC;IAC5C,SAAS,CAAC,EAAE;QAAE,OAAO,EAAE,eAAe,GAAG,SAAS,CAAA;KAAE,CAAC;IACrD,WAAW,CAAC,EAAE;QAAE,OAAO,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAAA;KAAE,CAAC;IACxD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE;QAAE,OAAO,EAAE,eAAe,GAAG,IAAI,GAAG,SAAS,CAAA;KAAE,CAAC;IAC3D,OAAO,CAAC,EAAE,oBAAoB,CAAC;CAChC,GAAG,gBAAgB,CA4nCnB"}

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

@@ -29,9 +29,29 @@ const MAX_TOTAL_TRANSIENT_CONTINUATIONS = 32;
 // times lets a transient slow start recover, while the cap still terminates a
 // genuinely stuck turn with a clear message instead of looping forever.
 const MAX_EMPTY_TRANSIENT_CONTINUATIONS = 3;
+// How many consecutive continuations that re-stream the SAME narration without
+// advancing (no in-flight tool, no completed tool) we tolerate before giving
+// up. A model that degenerates into repeating one phrase ("I have the full
+// HTML. Creating the extension now!") emits "new" text every continuation,
+// which keeps resetting the stalled/empty budgets — so without this guard the
+// stuck turn burns the entire MAX_TOTAL_TRANSIENT_CONTINUATIONS budget (each
+// round re-sending any large pasted payload) before bailing. Catching the
+// repeat ends it in a few rounds with a clear, actionable message instead.
+const MAX_REPEATED_TRANSIENT_CONTINUATIONS = 3;
 const RETRY_BASE_DELAY_MS = 500;
 const RETRY_MAX_DELAY_MS = 8_000;
 const MAX_HISTORY_ATTACHMENT_CHARS = 60_000;
+// The attachment submitted with the CURRENT turn gets a much larger cap than
+// prior-history embedding. The server threads this turn's attachments into each
+// action's ActionRunContext, and `create-extension`/`update-extension` host a
+// pasted file verbatim from it via `contentFromAttachment` — a feature whose
+// whole point is large pastes. Truncating the outbound payload to the 60K
+// history cap would silently cut a >60K HTML/Alpine file before the server ever
+// reads it, hosting a broken extension. Mirror the large-input tool-arg cap
+// (MAX_HISTORY_LARGE_TOOL_ARGS_CHARS) so realistic pasted files survive intact;
+// the trailing truncation notice still makes a pathological multi-MB paste
+// visibly (not silently) capped.
+const MAX_OUTBOUND_ATTACHMENT_CHARS = 200_000;
 const MAX_HISTORY_MESSAGES = 24;
 const MAX_HISTORY_TOTAL_CHARS = 64_000;
 const MAX_HISTORY_MESSAGE_CHARS = 12_000;
@@ -216,10 +236,10 @@ function truncateHistoryAttachment(text) {
     return `${text.slice(0, MAX_HISTORY_ATTACHMENT_CHARS)}\n\n[Attachment truncated after ${MAX_HISTORY_ATTACHMENT_CHARS.toLocaleString()} characters; ${omitted.toLocaleString()} characters omitted from prior chat history.]`;
 }
 function truncateOutboundAttachment(text) {
-    if (text.length <= MAX_HISTORY_ATTACHMENT_CHARS)
+    if (text.length <= MAX_OUTBOUND_ATTACHMENT_CHARS)
         return text;
-    const omitted = text.length - MAX_HISTORY_ATTACHMENT_CHARS;
-    return `${text.slice(0, MAX_HISTORY_ATTACHMENT_CHARS)}\n\n[Attachment truncated after ${MAX_HISTORY_ATTACHMENT_CHARS.toLocaleString()} characters; ${omitted.toLocaleString()} characters omitted from the submitted attachment.]`;
+    const omitted = text.length - MAX_OUTBOUND_ATTACHMENT_CHARS;
+    return `${text.slice(0, MAX_OUTBOUND_ATTACHMENT_CHARS)}\n\n[Attachment truncated after ${MAX_OUTBOUND_ATTACHMENT_CHARS.toLocaleString()} characters; ${omitted.toLocaleString()} characters omitted from the submitted attachment.]`;
 }
 function attachmentHistoryText(attachment) {
     if (typeof attachment.text === "string" && attachment.text.length > 0) {
@@ -448,6 +468,30 @@ function hasContinuationProgress(content) {
         ? part.text.trim().length > 0
         : part.result !== undefined);
 }
+/**
+ * Signature of the *unique* sentence-like segments in a continuation's newly
+ * streamed text, used to detect a degenerate repetition loop. A stuck model
+ * re-emits the same phrase ("I have the full HTML. Creating the extension
+ * now!") an arbitrary number of times per run, so the set of unique segments
+ * is small and stable across continuations regardless of how many times any
+ * single run repeated it. An empty signature (no visible text) is never a
+ * repeat — the stalled/empty budgets handle no-output stalls instead.
+ */
+function continuationRepeatSignature(content) {
+    const text = content
+        .map((part) => (part.type === "text" ? part.text : ""))
+        .join(" ")
+        .toLowerCase();
+    const segments = text
+        // Split after sentence punctuation even when runs are concatenated without
+        // a following space ("...now!I have..."), and on newlines.
+        .split(/(?<=[.!?])|\n+/)
+        .map((segment) => segment.replace(/[^a-z0-9]+/g, " ").trim())
+        .filter((segment) => segment.length > 0);
+    if (segments.length === 0)
+        return "";
+    return Array.from(new Set(segments)).sort().join("");
+}
 /**
  * True when an action was streamed but never returned a result yet — i.e. a
  * `tool_start` with no matching `tool_done`. The server is still executing it,
@@ -479,6 +523,17 @@ function stableJson(value) {
         return String(value ?? "");
     }
 }
+// Bounded signature of an in-flight tool call's input, used by the stall guard
+// to tell a genuinely-stuck retry (same tool, same payload, connection keeps
+// dropping) apart from a legitimate retry with a CHANGED payload (e.g. the
+// `create-extension` cutoff nudge tells the model to re-send a smaller body).
+// A changed payload yields a different signature, so the guard resets that
+// tool's stall budget instead of aborting the new attempt as a repeat. Bounded
+// to length + head so we never retain a large pasted payload across rounds.
+function inFlightToolInputSignature(part) {
+    const raw = part.argsText ?? stableJson(part.args);
+    return `${raw.length}${raw.slice(0, 256)}`;
+}
 function toolContinuationKey(part) {
     return [
         part.toolCallId,
@@ -535,8 +590,13 @@ function autoContinueMessage(signal) {
                 : signal.reason === "stream_ended"
                     ? "The previous stream ended before the agent sent a final completion signal."
                     : "The previous run reached an internal execution budget.";
-    const actionInputNote = signal.reason === "run_timeout" && tool
-        ? `\n\nThe previous run timed out while preparing the \`${tool}\` action input before the action could run. Avoid spending another whole run assembling one large tool payload. If this is \`create-extension\`, create a compact working v1 first, then use focused \`update-extension\` edits for refinements.`
+    // A run_timeout or a mid-stream cutoff while assembling one large action
+    // payload (e.g. inlining a big pasted HTML file into `create-extension`) is
+    // the classic trigger for the repetition/cutoff loop. Nudge the model toward
+    // a compact first version it can actually finish in a single run.
+    const cutoffPreparingAction = signal.reason === "run_timeout" || signal.reason === "stream_ended";
+    const actionInputNote = cutoffPreparingAction && tool
+        ? `\n\nThe previous run was cut off while preparing the \`${tool}\` action input before the action could finish. Avoid spending another whole run assembling one large tool payload. If this is \`create-extension\`, create a compact working v1 first, then use focused \`update-extension\` edits for refinements.`
         : "";
     return `${AUTO_CONTINUE_PROMPT}\n\nInternal note: ${reason}${actionInputNote}`;
 }
@@ -841,6 +901,22 @@ export function createAgentChatAdapter(options) {
             let stalledTransientContinuationAttempts = 0;
             let emptyTransientContinuationAttempts = 0;
             let totalTransientContinuationAttempts = 0;
+            let repeatedTransientContinuationAttempts = 0;
+            let lastContinuationRepeatSignature = null;
+            let recoveryGaveUpOnRepetition = false;
+            // Track when the same write tool is stuck in-flight across consecutive
+            // continuations (connection keeps dropping mid-execution). This is
+            // orthogonal to the text-repeat guard — in-flight tools reset
+            // madeProgress=true so the stalled/empty budgets never fire, but the tool
+            // never actually completes. After MAX_REPEATED_INFLIGHT_TOOL_STALLS
+            // consecutive interruptions of the same tool, bail with a clear message.
+            let lastInFlightToolName;
+            // Signature of the stuck tool's input. A retry with a changed payload
+            // (different signature) resets the stall count so the new attempt gets
+            // its own budget rather than inheriting the prior payload's.
+            let lastInFlightToolSignature;
+            let repeatedInFlightToolCount = 0;
+            const MAX_REPEATED_INFLIGHT_TOOL_STALLS = 3;
             const continuationHistoryFragments = [];
             const structuredContinuationFragments = [];
             let visibleContinuationPrefix = [];
@@ -857,6 +933,11 @@ export function createAgentChatAdapter(options) {
                     `stale_run_continuations: ${staleRunContinuationAttempts}`,
                     `stalled_transient_continuations: ${stalledTransientContinuationAttempts}`,
                     `empty_transient_continuations: ${emptyTransientContinuationAttempts}`,
+                    `repeated_transient_continuations: ${repeatedTransientContinuationAttempts}`,
+                    `repeated_inflight_tool_stalls: ${repeatedInFlightToolCount}`,
+                    lastInFlightToolName
+                        ? `last_inflight_tool: ${lastInFlightToolName}`
+                        : "",
                     `total_transient_continuations: ${totalTransientContinuationAttempts}`,
                     attemptedRunIds.length > 0
                         ? `attempted_runs: ${attemptedRunIds.join(", ")}`
@@ -866,6 +947,9 @@ export function createAgentChatAdapter(options) {
                     .join("\n");
             };
             const exhaustedRecoveryMessage = (reason) => {
+                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.";
+                }
                 if (content.length === 0 &&
                     (reason === "run_timeout" ||
                         reason === "no_progress" ||
@@ -927,6 +1011,9 @@ export function createAgentChatAdapter(options) {
                         staleRunContinuationAttempts,
                         stalledTransientContinuationAttempts,
                         emptyTransientContinuationAttempts,
+                        repeatedTransientContinuationAttempts,
+                        repeatedInFlightToolCount,
+                        lastInFlightToolName,
                         totalTransientContinuationAttempts,
                         ...extra,
                     },
@@ -941,6 +1028,9 @@ export function createAgentChatAdapter(options) {
                             staleRunContinuationAttempts,
                             stalledTransientContinuationAttempts,
                             emptyTransientContinuationAttempts,
+                            repeatedTransientContinuationAttempts,
+                            repeatedInFlightToolCount,
+                            lastInFlightToolName,
                             totalTransientContinuationAttempts,
                         },
                     },
@@ -1104,12 +1194,89 @@ export function createAgentChatAdapter(options) {
                     // for the stalled/empty caps.
                     const madeProgress = madeContentProgress || hasInFlightTool;
                     const madeDurableToolProgress = visibleContent.some((part) => part.type === "tool-call" && part.result !== undefined);
+                    // In-flight tool stall guard. When the same write tool is stuck
+                    // in-flight because the connection keeps dropping (stream_ended),
+                    // hasInFlightTool=true keeps madeProgress=true and completely
+                    // bypasses the stalled/empty budgets. Track the last in-flight tool
+                    // name; when the same tool is still unresolved after
+                    // 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.
+                    const currentInFlightToolPart = visibleContent.find((p) => p.type === "tool-call" &&
+                        p.result === undefined &&
+                        p.activity !== true);
+                    const currentInFlightToolName = currentInFlightToolPart?.toolName;
+                    const currentInFlightToolSignature = currentInFlightToolPart
+                        ? inFlightToolInputSignature(currentInFlightToolPart)
+                        : undefined;
+                    const isConnectionDrop = signal.reason === "stream_ended";
+                    if (currentInFlightToolName && isConnectionDrop) {
+                        if (currentInFlightToolName === lastInFlightToolName &&
+                            currentInFlightToolSignature === lastInFlightToolSignature) {
+                            repeatedInFlightToolCount += 1;
+                        }
+                        else {
+                            // New tool, or the same tool retried with a CHANGED (e.g.
+                            // smaller) payload — give the changed input a fresh stall budget
+                            // instead of aborting it as a repeat of the prior payload.
+                            repeatedInFlightToolCount = 0;
+                            lastInFlightToolName = currentInFlightToolName;
+                            lastInFlightToolSignature = currentInFlightToolSignature;
+                        }
+                    }
+                    else if (!currentInFlightToolName) {
+                        repeatedInFlightToolCount = 0;
+                    }
+                    // Degenerate repetition guard. When the model gets stuck re-streaming
+                    // the SAME narration every continuation without ever starting or
+                    // finishing a tool, each round is "new" text — so madeProgress stays
+                    // true and the stalled/empty budgets never trip. Compare this round's
+                    // unique-sentence signature to the previous round's; a match with no
+                    // tool progress is a non-advancing loop. Tracked by its own counter
+                    // so it bails after a few rounds instead of the full transient budget,
+                    // without perturbing the stalled/empty/stale accounting.
+                    const repeatSignature = continuationRepeatSignature(visibleContent);
+                    const isNonAdvancingRepeat = signal.reason !== "loop_limit" &&
+                        repeatSignature !== "" &&
+                        repeatSignature === lastContinuationRepeatSignature &&
+                        !hasInFlightTool &&
+                        !madeDurableToolProgress;
                     if (signal.reason === "loop_limit") {
                         stalledTransientContinuationAttempts = 0;
                         emptyTransientContinuationAttempts = 0;
                     }
                     else {
                         totalTransientContinuationAttempts += 1;
+                        // 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;
+                            return { ok: false, resetVisibleContent: false };
+                        }
+                        // Bail fast on a non-advancing repetition loop, well before the
+                        // stalled/empty/total budgets would (each round otherwise re-sends
+                        // the whole pasted payload). Tracked separately so it never trips
+                        // on legitimately-progressing runs that happen to be slow.
+                        if (isNonAdvancingRepeat) {
+                            repeatedTransientContinuationAttempts += 1;
+                            if (repeatedTransientContinuationAttempts >
+                                MAX_REPEATED_TRANSIENT_CONTINUATIONS) {
+                                recoveryGaveUpOnRepetition = true;
+                                return { ok: false, resetVisibleContent: false };
+                            }
+                        }
+                        else {
+                            repeatedTransientContinuationAttempts = 0;
+                        }
+                        if (repeatSignature) {
+                            lastContinuationRepeatSignature = repeatSignature;
+                        }
                         // A run_timeout that produced nothing visible and no activity (the
                         // model spent the whole soft-timeout window thinking before its
                         // first output) is NOT an immediate give-up: a transient slow start