@juspay/neurolink 9.81.2 → 9.81.3

package/dist/lib/providers/googleVertex.js

@@ -22,15 +22,16 @@ import { resolveClaudeMaxTokens } from "../utils/tokenLimits.js";
 import { validateApiKey, createVertexProjectConfig, createGoogleAuthConfig, } from "../utils/providerConfig.js";
 import { convertZodToJsonSchema, inlineJsonSchema, ensureNestedSchemaTypes, } from "../utils/schemaConversion.js";
 import { createNativeThinkingConfig } from "../utils/thinkingConfig.js";
-import { TimeoutError, withTimeout } from "../utils/async/index.js";
+import { TimeoutError, raceWithAbort, withTimeout, } from "../utils/async/index.js";
 import { parseTimeout } from "../utils/timeout.js";
-import { appendStepText, buildAbortedTurnMessage, buildToolLoopCapMessage, buildTurnStalledMessage, buildTurnTimeoutMessage, buildWrapupNudgeText, createTextChannel, createTurnClock, extractThoughtSignature, isAbortError, mapGeminiFinishReason, prependConversationMessages, resolveTurnStopReason, } from "./googleNativeGemini3.js";
+import { appendStepText, buildAbortedTurnMessage, buildContextCapMessage, buildToolLoopCapMessage, buildTurnStalledMessage, buildTurnTimeoutMessage, buildWrapupNudgeText, createContextGuard, createTextChannel, createTurnClock, extractThoughtSignature, isAbortError, mapGeminiFinishReason, prependConversationMessages, resolveTurnStopReason, } from "./googleNativeGemini3.js";
+import { getContextWindowSize } from "../constants/contextWindows.js";
 import { ATTR, LANGFUSE_ATTR, spanJsonAttribute, tracers, withClientSpan, withClientStreamSpan, withSpan, } from "../telemetry/index.js";
 import { SpanKind, SpanStatusCode, context as otelContext, trace as otelTrace, } from "@opentelemetry/api";
 import { calculateCost } from "../utils/pricing.js";
 import { transformToolExecutions } from "../utils/transformationUtils.js";
 import { sanitizeAnthropicMessagesForTrace } from "../utils/anthropicTraceSanitizer.js";
-import { extractMcpToolErrorMessage } from "../utils/mcpErrorText.js";
+import { extractMcpToolErrorMessage, extractToolFailureText, } from "../utils/mcpErrorText.js";
 // Import proper types for multimodal message handling
 // Dynamic import helper for native Anthropic Vertex SDK
 let anthropicVertexModule = null;
@@ -1315,6 +1316,11 @@ export class GoogleVertexProvider extends BaseProvider {
         // Track failed tools to prevent infinite retry loops
         // Key: tool name, Value: { count: retry attempts, lastError: error message }
         const failedTools = new Map();
+        // In-loop context guard: stop calling tools when the accumulated
+        // conversation approaches the model's context window instead of stepping
+        // into a provider "prompt too long" rejection mid-loop.
+        const contextGuard = createContextGuard(getContextWindowSize("vertex", modelName));
+        let hitContextLimit = false;
         // Track token usage across all steps
         // promptTokenCount is typically in the final chunk, candidatesTokenCount accumulates
         let totalInputTokens = 0;
@@ -1371,6 +1377,16 @@ export class GoogleVertexProvider extends BaseProvider {
                     wasAborted = true;
                     break;
                 }
+                // Context guard: stop the tool loop before the accumulated
+                // conversation crosses the window threshold — synthesize from what
+                // we have instead of stepping into a provider rejection.
+                if (contextGuard.shouldStop()) {
+                    hitContextLimit = true;
+                    logger.warn(`[GoogleVertex] Gemini turn stopped by the context guard: ` +
+                        `projected prompt ~${contextGuard.projectedNextPromptTokens} tokens ` +
+                        `>= threshold ${contextGuard.thresholdTokens} (step ${step}) — synthesizing a final answer.`);
+                    break;
+                }
                 step++;
                 turnClock.noteProgress();
                 logger.debug(`[GoogleVertex] Native SDK step ${step}/${maxSteps}`);
@@ -1422,6 +1438,8 @@ export class GoogleVertexProvider extends BaseProvider {
                             if (usageMetadata.promptTokenCount !== undefined &&
                                 usageMetadata.promptTokenCount > 0) {
                                 totalInputTokens = usageMetadata.promptTokenCount;
+                                // Feed the context guard the REAL prompt size of this call.
+                                contextGuard.noteUsage(usageMetadata.promptTokenCount, usageMetadata.candidatesTokenCount ?? 0);
                             }
                             // Take the latest candidatesTokenCount (accumulates through chunks)
                             if (usageMetadata.candidatesTokenCount !== undefined &&
@@ -1506,6 +1524,14 @@ export class GoogleVertexProvider extends BaseProvider {
                     // Note: tool:start / tool:end events are emitted by ToolsManager's
                     // wrapped `execute` (see ToolsManager.ts:355) — no inline emit needed.
                     for (const call of stepFunctionCalls) {
+                        // Honor a deadline/stall/caller abort BETWEEN tool executions —
+                        // without this check a multi-tool step keeps executing its whole
+                        // batch (up to N × toolTimeoutMs past the deadline) before the
+                        // while-top check finally breaks.
+                        if (effectiveSignal.aborted) {
+                            wasAborted = true;
+                            break;
+                        }
                         allToolCalls.push({ toolName: call.name, args: call.args });
                         stepStorageCalls.push({ toolName: call.name, args: call.args });
                         // Check if this tool has already exceeded retry limit
@@ -1545,9 +1571,31 @@ export class GoogleVertexProvider extends BaseProvider {
                                 };
                                 turnClock.noteProgress();
                                 // Bound the execute() await — a wedged tool costs one step
-                                // (error tool_result), not the whole turn.
-                                const result = await withTimeout(Promise.resolve(execute(call.args, toolOptions)), toolExecTimeoutMs, `Tool "${call.name}" execution timed out after ${toolExecTimeoutMs}ms`);
+                                // (error tool_result), not the whole turn — and race it
+                                // against the turn's abort so a deadline/caller abort is
+                                // observed IMMEDIATELY instead of after the tool settles.
+                                const result = await withTimeout(raceWithAbort(Promise.resolve(execute(call.args, toolOptions)), effectiveSignal), toolExecTimeoutMs, `Tool "${call.name}" execution timed out after ${toolExecTimeoutMs}ms`);
                                 turnClock.noteProgress();
+                                // Error-shaped success (MCP isError / { error } payloads —
+                                // e.g. proxy-blocked tools) counts toward the breaker too:
+                                // these fail without throwing, and only counting throws lets
+                                // the model grind on a blocked tool for the whole budget.
+                                const resultErrorText = extractToolFailureText(result);
+                                if (resultErrorText) {
+                                    const info = failedTools.get(call.name) || {
+                                        count: 0,
+                                        lastError: "",
+                                    };
+                                    info.count++;
+                                    info.lastError = resultErrorText;
+                                    failedTools.set(call.name, info);
+                                }
+                                else {
+                                    // Genuinely consecutive: a success clears the strike count
+                                    // (argument-dependent soft errors — file-not-found on
+                                    // different paths — must not disable a working tool).
+                                    failedTools.delete(call.name);
+                                }
                                 toolExecutions.push({
                                     name: call.name,
                                     input: call.args,
@@ -1620,12 +1668,23 @@ export class GoogleVertexProvider extends BaseProvider {
                             }
                         }
                         else {
-                            // Tool not found is a permanent error
+                            // Tool not found is a permanent error. Count it toward the
+                            // breaker too (parity with the Anthropic loops) — a model that
+                            // ignores the do_not_retry hint and keeps calling a
+                            // hallucinated/stale tool name must not burn the whole step
+                            // budget on TOOL_NOT_FOUND round-trips.
                             const errorPayload = {
                                 error: `TOOL_NOT_FOUND: The tool "${call.name}" does not exist. Do not attempt to call this tool again.`,
                                 status: "permanently_failed",
                                 do_not_retry: true,
                             };
+                            const notFoundInfo = failedTools.get(call.name) || {
+                                count: 0,
+                                lastError: "",
+                            };
+                            notFoundInfo.count++;
+                            notFoundInfo.lastError = errorPayload.error;
+                            failedTools.set(call.name, notFoundInfo);
                             functionResponses.push({
                                 functionResponse: {
                                     name: call.name,
@@ -1689,6 +1748,15 @@ export class GoogleVertexProvider extends BaseProvider {
                         role: "user",
                         parts: functionResponses,
                     });
+                    // Project this step's growth for the context guard: the appended
+                    // tool results ride the next prompt (Gemini reports usage per call,
+                    // but only for content it has already seen).
+                    try {
+                        contextGuard.noteAppendedChars(JSON.stringify(functionResponses).length);
+                    }
+                    catch {
+                        /* estimation is best-effort — never break the loop */
+                    }
                 }
                 catch (error) {
                     // A mid-drain abort surfaces as an AbortError from the `for await`.
@@ -1709,7 +1777,7 @@ export class GoogleVertexProvider extends BaseProvider {
             // cap was reached (or the turn was aborted) while the model was still
             // calling tools. Surface a real answer instead of the canned placeholder
             // (Bug 1) and a meaningful finishReason (Bug 2).
-            if (!finalText && (step >= maxSteps || wasAborted)) {
+            if (!finalText && (step >= maxSteps || wasAborted || hitContextLimit)) {
                 hitStepLimit = step >= maxSteps && !wasAborted;
                 const toolCallCount = allToolCalls.filter((tc) => tc.toolName !== "final_result").length;
                 // The consumer receives text via `incrementalTextChunks`; any text the
@@ -1719,8 +1787,11 @@ export class GoogleVertexProvider extends BaseProvider {
                 // exist, leave `finalText` empty so `textPartsToYield` keeps replaying
                 // the gathered chunks instead of collapsing to a single one.
                 if (incrementalTextChunks.length > 0) {
-                    logger.warn(`[GoogleVertex] Tool call loop terminated after reaching maxSteps (${maxSteps}); ` +
-                        `returning text already gathered from prior steps.`);
+                    logger.warn(hitContextLimit
+                        ? `[GoogleVertex] Tool call loop stopped by the context guard; ` +
+                            `returning text already gathered from prior steps.`
+                        : `[GoogleVertex] Tool call loop terminated after reaching maxSteps (${maxSteps}); ` +
+                            `returning text already gathered from prior steps.`);
                 }
                 else if (wasAborted) {
                     // Turn ended on a time condition or caller abort — skip synth
@@ -1740,8 +1811,11 @@ export class GoogleVertexProvider extends BaseProvider {
                     });
                 }
                 else {
-                    logger.warn(`[GoogleVertex] Tool call loop terminated after reaching maxSteps (${maxSteps}) ` +
-                        `with no text; synthesizing a final answer with tools disabled.`);
+                    logger.warn(hitContextLimit
+                        ? `[GoogleVertex] Tool call loop stopped by the context guard ` +
+                            `with no text; synthesizing a final answer with tools disabled.`
+                        : `[GoogleVertex] Tool call loop terminated after reaching maxSteps (${maxSteps}) ` +
+                            `with no text; synthesizing a final answer with tools disabled.`);
                     // synth self-bounds its connect+drain via withTimeout(timeoutMs) and
                     // never throws (returns empty on timeout/error), so it needs no outer
                     // withTimeout wrapper — see synthesizeFinalAnswerWithoutTools.
@@ -1757,7 +1831,9 @@ export class GoogleVertexProvider extends BaseProvider {
                         }
                     }
                     else {
-                        finalText = buildToolLoopCapMessage(maxSteps, toolCallCount);
+                        finalText = hitContextLimit
+                            ? buildContextCapMessage(toolCallCount)
+                            : buildToolLoopCapMessage(maxSteps, toolCallCount);
                     }
                 }
             }
@@ -1781,6 +1857,7 @@ export class GoogleVertexProvider extends BaseProvider {
             stalled: turnClock.stalled,
             wasAborted,
             cappedWithoutAnswer: hitStepLimit && !synthesizedFinalAnswer,
+            contextCappedWithoutAnswer: hitContextLimit && !synthesizedFinalAnswer,
             finishReason: resolvedFinishReason,
         });
         if (stopReason !== "completed") {
@@ -2168,6 +2245,11 @@ export class GoogleVertexProvider extends BaseProvider {
         // Track failed tools to prevent infinite retry loops
         // Key: tool name, Value: { count: retry attempts, lastError: error message }
         const failedTools = new Map();
+        // In-loop context guard: stop calling tools when the accumulated
+        // conversation approaches the model's context window instead of stepping
+        // into a provider "prompt too long" rejection mid-loop.
+        const contextGuard = createContextGuard(getContextWindowSize("vertex", modelName));
+        let hitContextLimit = false;
         // Track token usage across all steps
         // promptTokenCount is typically in the final chunk, candidatesTokenCount accumulates
         let totalInputTokens = 0;
@@ -2217,6 +2299,16 @@ export class GoogleVertexProvider extends BaseProvider {
                     wasAborted = true;
                     break;
                 }
+                // Context guard: stop the tool loop before the accumulated
+                // conversation crosses the window threshold — synthesize from what
+                // we have instead of stepping into a provider rejection.
+                if (contextGuard.shouldStop()) {
+                    hitContextLimit = true;
+                    logger.warn(`[GoogleVertex] Gemini turn stopped by the context guard: ` +
+                        `projected prompt ~${contextGuard.projectedNextPromptTokens} tokens ` +
+                        `>= threshold ${contextGuard.thresholdTokens} (step ${step}) — synthesizing a final answer.`);
+                    break;
+                }
                 step++;
                 turnClock.noteProgress();
                 logger.debug(`[GoogleVertex] Native SDK generate step ${step}/${maxSteps}`);
@@ -2265,6 +2357,8 @@ export class GoogleVertexProvider extends BaseProvider {
                             if (usageMetadata.promptTokenCount !== undefined &&
                                 usageMetadata.promptTokenCount > 0) {
                                 totalInputTokens = usageMetadata.promptTokenCount;
+                                // Feed the context guard the REAL prompt size of this call.
+                                contextGuard.noteUsage(usageMetadata.promptTokenCount, usageMetadata.candidatesTokenCount ?? 0);
                             }
                             // Take the latest candidatesTokenCount (accumulates through chunks)
                             if (usageMetadata.candidatesTokenCount !== undefined &&
@@ -2353,6 +2447,14 @@ export class GoogleVertexProvider extends BaseProvider {
                     // Note: tool:start / tool:end events are emitted by ToolsManager's
                     // wrapped `execute` (see ToolsManager.ts:355) — no inline emit needed.
                     for (const call of stepFunctionCalls) {
+                        // Honor a deadline/stall/caller abort BETWEEN tool executions —
+                        // without this check a multi-tool step keeps executing its whole
+                        // batch (up to N × toolTimeoutMs past the deadline) before the
+                        // while-top check finally breaks.
+                        if (effectiveSignal.aborted) {
+                            wasAborted = true;
+                            break;
+                        }
                         allToolCalls.push({ toolName: call.name, args: call.args });
                         // Check if this tool has already exceeded retry limit
                         const failedInfo = failedTools.get(call.name);
@@ -2388,8 +2490,28 @@ export class GoogleVertexProvider extends BaseProvider {
                                 turnClock.noteProgress();
                                 // Bound the execute() await — a wedged tool costs one step
                                 // (error tool_result), not the whole turn.
-                                const execResult = await withTimeout(Promise.resolve(execute(call.args, toolOptions)), toolExecTimeoutMs, `Tool "${call.name}" execution timed out after ${toolExecTimeoutMs}ms`);
+                                const execResult = await withTimeout(raceWithAbort(Promise.resolve(execute(call.args, toolOptions)), effectiveSignal), toolExecTimeoutMs, `Tool "${call.name}" execution timed out after ${toolExecTimeoutMs}ms`);
                                 turnClock.noteProgress();
+                                // Error-shaped success (MCP isError / { error } payloads —
+                                // e.g. proxy-blocked tools) counts toward the breaker too:
+                                // these fail without throwing, and only counting throws lets
+                                // the model grind on a blocked tool for the whole budget.
+                                const resultErrorText = extractToolFailureText(execResult);
+                                if (resultErrorText) {
+                                    const info = failedTools.get(call.name) || {
+                                        count: 0,
+                                        lastError: "",
+                                    };
+                                    info.count++;
+                                    info.lastError = resultErrorText;
+                                    failedTools.set(call.name, info);
+                                }
+                                else {
+                                    // Genuinely consecutive: a success clears the strike count
+                                    // (argument-dependent soft errors — file-not-found on
+                                    // different paths — must not disable a working tool).
+                                    failedTools.delete(call.name);
+                                }
                                 // Track execution
                                 toolExecutions.push({
                                     name: call.name,
@@ -2526,6 +2648,15 @@ export class GoogleVertexProvider extends BaseProvider {
                         role: "user",
                         parts: functionResponses,
                     });
+                    // Project this step's growth for the context guard: the appended
+                    // tool results ride the next prompt (Gemini reports usage per call,
+                    // but only for content it has already seen).
+                    try {
+                        contextGuard.noteAppendedChars(JSON.stringify(functionResponses).length);
+                    }
+                    catch {
+                        /* estimation is best-effort — never break the loop */
+                    }
                 }
                 catch (error) {
                     // A mid-drain abort surfaces as an AbortError from the `for await`.
@@ -2564,13 +2695,16 @@ export class GoogleVertexProvider extends BaseProvider {
             // cap was reached (or the turn was aborted) while the model was still
             // calling tools. Surface a real answer instead of the canned placeholder
             // (Bug 1) and a meaningful finishReason (Bug 2).
-            if (!finalText && (step >= maxSteps || wasAborted)) {
+            if (!finalText && (step >= maxSteps || wasAborted || hitContextLimit)) {
                 hitStepLimit = step >= maxSteps && !wasAborted;
                 const toolCallCount = allToolCalls.filter((tc) => tc.toolName !== "final_result").length;
                 if (accumulatedText) {
                     // Prefer the prose the model already produced across steps.
-                    logger.warn(`[GoogleVertex] Generate tool call loop terminated after reaching maxSteps (${maxSteps}); ` +
-                        `returning text already gathered from prior steps.`);
+                    logger.warn(hitContextLimit
+                        ? `[GoogleVertex] Generate tool call loop stopped by the context guard; ` +
+                            `returning text already gathered from prior steps.`
+                        : `[GoogleVertex] Generate tool call loop terminated after reaching maxSteps (${maxSteps}); ` +
+                            `returning text already gathered from prior steps.`);
                     finalText = accumulatedText;
                 }
                 else if (wasAborted) {
@@ -2593,8 +2727,11 @@ export class GoogleVertexProvider extends BaseProvider {
                     // Pure functionCall turns leave no text — make one tools-disabled call
                     // so the model answers from the gathered tool results instead of the
                     // canned placeholder.
-                    logger.warn(`[GoogleVertex] Generate tool call loop terminated after reaching maxSteps (${maxSteps}) ` +
-                        `with no text; synthesizing a final answer with tools disabled.`);
+                    logger.warn(hitContextLimit
+                        ? `[GoogleVertex] Generate tool call loop stopped by the context guard ` +
+                            `with no text; synthesizing a final answer with tools disabled.`
+                        : `[GoogleVertex] Generate tool call loop terminated after reaching maxSteps (${maxSteps}) ` +
+                            `with no text; synthesizing a final answer with tools disabled.`);
                     // synth self-bounds its connect+drain via withTimeout(timeoutMs) and
                     // never throws (returns empty on timeout/error), so it needs no outer
                     // withTimeout wrapper — see synthesizeFinalAnswerWithoutTools.
@@ -2609,7 +2746,9 @@ export class GoogleVertexProvider extends BaseProvider {
                         }
                     }
                     else {
-                        finalText = buildToolLoopCapMessage(maxSteps, toolCallCount);
+                        finalText = hitContextLimit
+                            ? buildContextCapMessage(toolCallCount)
+                            : buildToolLoopCapMessage(maxSteps, toolCallCount);
                     }
                 }
             }
@@ -2633,6 +2772,7 @@ export class GoogleVertexProvider extends BaseProvider {
             stalled: turnClock.stalled,
             wasAborted,
             cappedWithoutAnswer: hitStepLimit && !synthesizedFinalAnswer,
+            contextCappedWithoutAnswer: hitContextLimit && !synthesizedFinalAnswer,
             finishReason: resolvedFinishReason,
         });
         if (stopReason !== "completed") {
@@ -3192,9 +3332,14 @@ export class GoogleVertexProvider extends BaseProvider {
             // mapping written into finishReasonRef.
             let wasAborted = false;
             let hitStepLimit = false;
+            let hitContextLimit = false;
             let synthesizedFinalAnswer = false;
             let modelFinished = false;
             let lastStopReason;
+            // In-loop context guard + consecutive-failure breaker — same rationale
+            // as the generate twin (see executeNativeAnthropicGenerate).
+            const contextGuard = createContextGuard(getContextWindowSize("vertex", modelName));
+            const failedTools = new Map();
             try {
                 while (step < agenticStepBudget) {
                     // Honor aborts BETWEEN steps (caller signal OR the turn clock's
@@ -3206,6 +3351,15 @@ export class GoogleVertexProvider extends BaseProvider {
                         wasAborted = true;
                         break;
                     }
+                    // Context guard: stop the tool loop before the accumulated
+                    // conversation crosses the window threshold (see generate twin).
+                    if (contextGuard.shouldStop()) {
+                        hitContextLimit = true;
+                        logger.warn(`[GoogleVertex] Anthropic stream turn stopped by the context guard: ` +
+                            `projected prompt ~${contextGuard.projectedNextPromptTokens} tokens ` +
+                            `>= threshold ${contextGuard.thresholdTokens} (step ${step}) — synthesizing a final answer.`);
+                        break;
+                    }
                     step++;
                     turnClock.noteProgress();
                     // One generation observation per API call: request in, content + usage out.
@@ -3318,6 +3472,11 @@ export class GoogleVertexProvider extends BaseProvider {
                         usage.output += response.usage?.output_tokens || 0;
                         usage.total = usage.input + usage.output;
                         lastStopReason = response.stop_reason;
+                        // Feed the context guard the FULL prompt size of this call
+                        // (uncached input + cache reads/writes).
+                        contextGuard.noteUsage((response.usage?.input_tokens || 0) +
+                            stepCacheRead +
+                            stepCacheCreation, response.usage?.output_tokens || 0);
                         for (const block of response.content) {
                             if (block.type === "text" && typeof block.text === "string") {
                                 aggregatedTurnText += block.text;
@@ -3382,6 +3541,15 @@ export class GoogleVertexProvider extends BaseProvider {
                     // Note: tool:start / tool:end events are emitted by ToolsManager's
                     // wrapped `execute` (see ToolsManager.ts:355) — no inline emit needed.
                     for (const toolUse of toolUseBlocks) {
+                        // Honor a deadline/stall/caller abort BETWEEN tool executions —
+                        // without this check a multi-tool step keeps executing its whole
+                        // batch (up to N × toolTimeoutMs past the deadline) before the
+                        // while-top check finally breaks. Skipped tools get neither a
+                        // call row nor a result row, so persisted history stays paired.
+                        if (internalAbort.signal.aborted) {
+                            wasAborted = true;
+                            break;
+                        }
                         allToolCalls.push({
                             toolName: toolUse.name,
                             args: toolUse.input,
@@ -3392,6 +3560,31 @@ export class GoogleVertexProvider extends BaseProvider {
                             toolName: toolUse.name,
                             args: toolUse.input,
                         });
+                        // Consecutive-failure breaker (ports the Gemini loops' failedTools
+                        // map): a tool that has already failed DEFAULT_TOOL_MAX_RETRIES
+                        // times this turn is short-circuited instead of re-executed.
+                        const failedInfo = failedTools.get(toolUse.name);
+                        if (failedInfo && failedInfo.count >= DEFAULT_TOOL_MAX_RETRIES) {
+                            logger.warn(`[GoogleVertex] Tool "${toolUse.name}" has exceeded retry limit (${DEFAULT_TOOL_MAX_RETRIES}), skipping execution`);
+                            const errMsg = `TOOL_PERMANENTLY_FAILED: The tool "${toolUse.name}" has failed ${failedInfo.count} times and will not be retried. Last error: ${failedInfo.lastError}. Please proceed without using this tool or inform the user that this functionality is unavailable.`;
+                            const errorPayload = { error: errMsg };
+                            toolExecutions.push({
+                                name: toolUse.name,
+                                input: toolUse.input,
+                                output: errorPayload,
+                            });
+                            toolResults.push({
+                                type: "tool_result",
+                                tool_use_id: toolUse.id,
+                                content: errMsg,
+                            });
+                            stepStorageResults.push({
+                                toolCallId: toolUse.id,
+                                toolName: toolUse.name,
+                                output: errorPayload,
+                            });
+                            continue;
+                        }
                         // One tool observation per execution. ai.toolCall.* names follow the
                         // Vercel AI SDK convention so existing tooling keeps working.
                         const toolSpan = tracers.mcp.startSpan("ai.toolCall", {
@@ -3437,12 +3630,32 @@ export class GoogleVertexProvider extends BaseProvider {
                                 // (neurolink.tool.execute) nest under this observation instead
                                 // of becoming disconnected siblings. Bound the await — a
                                 // wedged tool costs one step (error tool_result), not the
-                                // whole turn.
-                                const result = await withTimeout(otelContext.with(otelTrace.setSpan(turnContext, toolSpan), () => Promise.resolve(execute(toolUse.input, toolOptions))), toolExecTimeoutMs, `Tool "${toolUse.name}" execution timed out after ${toolExecTimeoutMs}ms`);
+                                // whole turn — and race it against the turn's abort so a
+                                // deadline/caller abort is observed IMMEDIATELY instead of
+                                // after the tool settles.
+                                const result = await withTimeout(raceWithAbort(otelContext.with(otelTrace.setSpan(turnContext, toolSpan), () => Promise.resolve(execute(toolUse.input, toolOptions))), internalAbort.signal), toolExecTimeoutMs, `Tool "${toolUse.name}" execution timed out after ${toolExecTimeoutMs}ms`);
                                 turnClock.noteProgress();
                                 // MCP failures are returned, not thrown — surface them on
                                 // the span so failed calls show as ERROR in Langfuse.
                                 endToolSpan(result, extractMcpToolErrorMessage(result));
+                                // Error-shaped success (MCP isError / { error } payloads)
+                                // counts toward the breaker too — see the generate twin.
+                                const resultErrorText = extractToolFailureText(result);
+                                if (resultErrorText) {
+                                    const info = failedTools.get(toolUse.name) || {
+                                        count: 0,
+                                        lastError: "",
+                                    };
+                                    info.count++;
+                                    info.lastError = resultErrorText;
+                                    failedTools.set(toolUse.name, info);
+                                }
+                                else {
+                                    // Genuinely consecutive: a success clears the strike count
+                                    // (argument-dependent soft errors — file-not-found on
+                                    // different paths — must not disable a working tool).
+                                    failedTools.delete(toolUse.name);
+                                }
                                 toolExecutions.push({
                                     name: toolUse.name,
                                     input: toolUse.input,
@@ -3492,7 +3705,17 @@ export class GoogleVertexProvider extends BaseProvider {
                                         toolName: toolUse.name,
                                     });
                                 }
-                                const errMsg = `Error executing tool "${toolUse.name}": ${err instanceof Error ? err.message : String(err)}`;
+                                // Count the failure toward the consecutive-failure breaker.
+                                const thrownErrorText = err instanceof Error ? err.message : String(err);
+                                const info = failedTools.get(toolUse.name) || {
+                                    count: 0,
+                                    lastError: "",
+                                };
+                                info.count++;
+                                info.lastError = thrownErrorText;
+                                failedTools.set(toolUse.name, info);
+                                logger.warn(`[GoogleVertex] Tool "${toolUse.name}" failed (attempt ${info.count}/${DEFAULT_TOOL_MAX_RETRIES}): ${thrownErrorText}`);
+                                const errMsg = `Error executing tool "${toolUse.name}": ${thrownErrorText}`;
                                 const errorPayload = { error: errMsg };
                                 endToolSpan(errorPayload, errMsg);
                                 toolExecutions.push({
@@ -3515,6 +3738,16 @@ export class GoogleVertexProvider extends BaseProvider {
                         else {
                             const errMsg = `TOOL_NOT_FOUND: The tool "${toolUse.name}" does not exist.`;
                             const errorPayload = { error: errMsg };
+                            // A missing tool counts toward the breaker too — a model
+                            // grinding on a hallucinated/stale tool name must not burn the
+                            // whole step budget on TOOL_NOT_FOUND round-trips.
+                            const notFoundInfo = failedTools.get(toolUse.name) || {
+                                count: 0,
+                                lastError: "",
+                            };
+                            notFoundInfo.count++;
+                            notFoundInfo.lastError = errMsg;
+                            failedTools.set(toolUse.name, notFoundInfo);
                             endToolSpan(errorPayload, errMsg);
                             toolExecutions.push({
                                 name: toolUse.name,
@@ -3585,6 +3818,12 @@ export class GoogleVertexProvider extends BaseProvider {
                         role: "user",
                         content: toolResults,
                     });
+                    // Project this step's growth for the context guard: everything
+                    // just appended (tool results + nudge text) rides the next prompt.
+                    contextGuard.noteAppendedChars(toolResults.reduce((sum, block) => sum +
+                        ("content" in block
+                            ? block.content.length
+                            : block.text.length), 0));
                 }
                 // Terminal handling — the loop exited without a model-initiated
                 // finish (step budget exhausted, or the turn was aborted). Never end
@@ -3603,6 +3842,15 @@ export class GoogleVertexProvider extends BaseProvider {
                         wasAborted = true;
                     }
                     const externalToolCallCount = allToolCalls.filter((tc) => tc.toolName !== "final_result").length;
+                    // Clamp the terminal calls' max_tokens so prompt + output stays
+                    // inside the model window: pre-4.5 Claude models 400 on
+                    // input + max_tokens > window, which would defeat the very
+                    // synthesis these calls exist for on context-capped turns. Only
+                    // bites when the prompt is near the window (min() is a no-op on
+                    // ordinary step-cap turns).
+                    const terminalMaxTokens = Math.max(1024, Math.min(requestParams.max_tokens, getContextWindowSize("vertex", modelName) -
+                        contextGuard.projectedNextPromptTokens -
+                        4_000));
                     if (wasAborted) {
                         // Budget already blown — never issue another model call. Deliver
                         // exactly one HONEST terminal chunk matching the actual exit
@@ -3627,8 +3875,12 @@ export class GoogleVertexProvider extends BaseProvider {
                         }
                     }
                     else if (useFinalResultTool) {
-                        hitStepLimit = true;
-                        logger.warn(`[GoogleVertex] Native Anthropic stream loop reached maxSteps (${maxSteps}) without final_result; forcing a finalization call.`);
+                        if (!hitContextLimit) {
+                            hitStepLimit = true;
+                        }
+                        logger.warn(hitContextLimit
+                            ? `[GoogleVertex] Native Anthropic stream loop stopped by the context guard without final_result; forcing a finalization call.`
+                            : `[GoogleVertex] Native Anthropic stream loop reached maxSteps (${maxSteps}) without final_result; forcing a finalization call.`);
                         try {
                             // Reserved finalization step: identical request except
                             // tool_choice pins final_result — Anthropic guarantees a
@@ -3642,6 +3894,7 @@ export class GoogleVertexProvider extends BaseProvider {
                             });
                             const finalizationStream = await client.messages.stream({
                                 ...requestParams,
+                                max_tokens: terminalMaxTokens,
                                 tool_choice: {
                                     type: "tool",
                                     name: "final_result",
@@ -3681,7 +3934,9 @@ export class GoogleVertexProvider extends BaseProvider {
                                 logger.debug("[GoogleVertex] Forced finalization returned structured output (stream)", { keys: Object.keys(forcedFinalResult.input) });
                             }
                             else {
-                                const capMessage = buildToolLoopCapMessage(maxSteps, externalToolCallCount);
+                                const capMessage = hitContextLimit
+                                    ? buildContextCapMessage(externalToolCallCount)
+                                    : buildToolLoopCapMessage(maxSteps, externalToolCallCount);
                                 channel.push(capMessage);
                                 aggregatedTurnText += capMessage;
                             }
@@ -3699,19 +3954,23 @@ export class GoogleVertexProvider extends BaseProvider {
                             logger.warn("[GoogleVertex] Forced finalization call failed; falling back to a terminal message", {
                                 error: error instanceof Error ? error.message : String(error),
                             });
-                            const exitMessage = this.buildLoopExitMessage({
-                                turnClock,
-                                wasAborted,
-                                stallTimeoutMs: options.stallTimeoutMs,
-                                maxSteps,
-                                toolCallCount: externalToolCallCount,
-                            });
+                            const exitMessage = hitContextLimit && !wasAborted
+                                ? buildContextCapMessage(externalToolCallCount)
+                                : this.buildLoopExitMessage({
+                                    turnClock,
+                                    wasAborted,
+                                    stallTimeoutMs: options.stallTimeoutMs,
+                                    maxSteps,
+                                    toolCallCount: externalToolCallCount,
+                                });
                             channel.push(exitMessage);
                             aggregatedTurnText += exitMessage;
                         }
                     }
                     else {
-                        hitStepLimit = true;
+                        if (!hitContextLimit) {
+                            hitStepLimit = true;
+                        }
                         if (aggregatedTurnText.length === 0) {
                             // Pure tool-loop with no streamed text: one tools-disabled call
                             // so the model answers from the gathered tool results, pushed
@@ -3720,7 +3979,9 @@ export class GoogleVertexProvider extends BaseProvider {
                             // histories containing tool_use/tool_result blocks without a
                             // tools param — so "tools disabled" is tool_choice:"none",
                             // which also keeps the cached tools prefix byte-identical.
-                            logger.warn(`[GoogleVertex] Native Anthropic stream loop reached maxSteps (${maxSteps}) with no text; synthesizing a final answer with tools disabled.`);
+                            logger.warn(hitContextLimit
+                                ? `[GoogleVertex] Native Anthropic stream loop stopped by the context guard with no text; synthesizing a final answer with tools disabled.`
+                                : `[GoogleVertex] Native Anthropic stream loop reached maxSteps (${maxSteps}) with no text; synthesizing a final answer with tools disabled.`);
                             try {
                                 const backstopSystem = (systemPromptWithSchema
                                     ? systemPromptWithSchema + "\n\n"
@@ -3735,6 +3996,7 @@ export class GoogleVertexProvider extends BaseProvider {
                                 });
                                 const backstopStream = await client.messages.stream({
                                     ...requestParams,
+                                    max_tokens: terminalMaxTokens,
                                     tool_choice: { type: "none" },
                                     system: cachedBackstop.system,
                                     ...(cachedBackstop.tools &&
@@ -3770,7 +4032,9 @@ export class GoogleVertexProvider extends BaseProvider {
                                     aggregatedTurnText = backstopText;
                                 }
                                 else {
-                                    const capMessage = buildToolLoopCapMessage(maxSteps, externalToolCallCount);
+                                    const capMessage = hitContextLimit
+                                        ? buildContextCapMessage(externalToolCallCount)
+                                        : buildToolLoopCapMessage(maxSteps, externalToolCallCount);
                                     channel.push(capMessage);
                                     aggregatedTurnText = capMessage;
                                 }
@@ -3788,13 +4052,15 @@ export class GoogleVertexProvider extends BaseProvider {
                                 logger.warn("[GoogleVertex] Tools-disabled backstop call failed; falling back to a terminal message", {
                                     error: error instanceof Error ? error.message : String(error),
                                 });
-                                const exitMessage = this.buildLoopExitMessage({
-                                    turnClock,
-                                    wasAborted,
-                                    stallTimeoutMs: options.stallTimeoutMs,
-                                    maxSteps,
-                                    toolCallCount: externalToolCallCount,
-                                });
+                                const exitMessage = hitContextLimit && !wasAborted
+                                    ? buildContextCapMessage(externalToolCallCount)
+                                    : this.buildLoopExitMessage({
+                                        turnClock,
+                                        wasAborted,
+                                        stallTimeoutMs: options.stallTimeoutMs,
+                                        maxSteps,
+                                        toolCallCount: externalToolCallCount,
+                                    });
                                 channel.push(exitMessage);
                                 aggregatedTurnText = exitMessage;
                             }
@@ -3812,13 +4078,15 @@ export class GoogleVertexProvider extends BaseProvider {
                     !structuredOutputRef.value;
                 const externalToolCallTotal = allToolCalls.filter((tc) => tc.toolName !== "final_result").length;
                 if (deliveredNothing && externalToolCallTotal > 0) {
-                    const exitMessage = this.buildLoopExitMessage({
-                        turnClock,
-                        wasAborted,
-                        stallTimeoutMs: options.stallTimeoutMs,
-                        maxSteps,
-                        toolCallCount: externalToolCallTotal,
-                    });
+                    const exitMessage = hitContextLimit && !wasAborted
+                        ? buildContextCapMessage(externalToolCallTotal)
+                        : this.buildLoopExitMessage({
+                            turnClock,
+                            wasAborted,
+                            stallTimeoutMs: options.stallTimeoutMs,
+                            maxSteps,
+                            toolCallCount: externalToolCallTotal,
+                        });
                     channel.push(exitMessage);
                     aggregatedTurnText = exitMessage;
                 }
@@ -3844,6 +4112,7 @@ export class GoogleVertexProvider extends BaseProvider {
                     stalled: turnClock.stalled,
                     wasAborted,
                     cappedWithoutAnswer: hitStepLimit && !synthesizedFinalAnswer,
+                    contextCappedWithoutAnswer: hitContextLimit && !synthesizedFinalAnswer,
                     finishReason: finishReasonRef.value,
                 });
                 stopReasonRef.value = resolvedStopReason;
@@ -4266,9 +4535,21 @@ export class GoogleVertexProvider extends BaseProvider {
         // these to distinguish clean finishes, capped turns, and aborted turns.
         let wasAborted = false;
         let hitStepLimit = false;
+        let hitContextLimit = false;
         let synthesizedFinalAnswer = false;
         let modelFinished = false;
         const currentMessages = [...messages];
+        // In-loop context guard: stop calling tools when the accumulated
+        // conversation approaches the model's real context window, instead of
+        // stepping into an Anthropic 400 "prompt is too long" at step N that
+        // destroys the whole turn's work (claude-sonnet-5 1,005,647-token RCA).
+        const contextGuard = createContextGuard(getContextWindowSize("vertex", modelName));
+        // Consecutive-failure breaker (ports the Gemini loops' failedTools map):
+        // a tool that keeps failing — thrown errors, timeouts, or error-shaped
+        // results like mcp-proxy blocks — is short-circuited after
+        // DEFAULT_TOOL_MAX_RETRIES instead of being retried for the remaining
+        // step budget.
+        const failedTools = new Map();
         // Internal abort fan-in: the caller's signal and the turn clock's
         // watchdogs all trip it; it rides every SDK request and tool execution.
         const internalAbort = new AbortController();
@@ -4309,6 +4590,16 @@ export class GoogleVertexProvider extends BaseProvider {
                 wasAborted = true;
                 break;
             }
+            // Context guard: the projected next prompt (last call's REAL usage +
+            // this step's appended tool results/output) would cross the window
+            // threshold — stop the tool loop and synthesize from what we have.
+            if (contextGuard.shouldStop()) {
+                hitContextLimit = true;
+                logger.warn(`[GoogleVertex] Anthropic generate turn stopped by the context guard: ` +
+                    `projected prompt ~${contextGuard.projectedNextPromptTokens} tokens ` +
+                    `>= threshold ${contextGuard.thresholdTokens} (step ${step}) — synthesizing a final answer.`);
+                break;
+            }
             step++;
             turnClock.noteProgress();
             try {
@@ -4349,6 +4640,11 @@ export class GoogleVertexProvider extends BaseProvider {
                 totalCacheCreationTokens +=
                     response.usage?.cache_creation_input_tokens || 0;
                 lastStopReason = response.stop_reason;
+                // Feed the context guard the FULL prompt size of this call (uncached
+                // input + cache reads/writes) — the API reports it every step.
+                contextGuard.noteUsage((response.usage?.input_tokens || 0) +
+                    (response.usage?.cache_read_input_tokens || 0) +
+                    (response.usage?.cache_creation_input_tokens || 0), response.usage?.output_tokens || 0);
                 // Check if we need to handle tool use
                 const toolUseBlocks = response.content.filter((block) => block.type === "tool_use");
                 // Check for final_result tool call (for structured output)
@@ -4384,6 +4680,15 @@ export class GoogleVertexProvider extends BaseProvider {
                 // Note: tool:start / tool:end events are emitted by ToolsManager's
                 // wrapped `execute` (see ToolsManager.ts:355) — no inline emit needed.
                 for (const toolUse of toolUseBlocks) {
+                    // Honor a deadline/stall/caller abort BETWEEN tool executions —
+                    // without this check a multi-tool step keeps executing its whole
+                    // batch (up to N × toolTimeoutMs past the deadline) before the
+                    // while-top check finally breaks. Skipped tools get neither a call
+                    // row nor a result row, so persisted history stays paired.
+                    if (internalAbort.signal.aborted) {
+                        wasAborted = true;
+                        break;
+                    }
                     allToolCalls.push({
                         toolName: toolUse.name,
                         args: toolUse.input,
@@ -4393,6 +4698,32 @@ export class GoogleVertexProvider extends BaseProvider {
                         toolName: toolUse.name,
                         args: toolUse.input,
                     });
+                    // Consecutive-failure breaker: stop re-executing a tool that has
+                    // already failed DEFAULT_TOOL_MAX_RETRIES times this turn (ports
+                    // the Gemini loops' failedTools map — the Anthropic loops let a
+                    // blocked tool be retried for the entire remaining step budget).
+                    const failedInfo = failedTools.get(toolUse.name);
+                    if (failedInfo && failedInfo.count >= DEFAULT_TOOL_MAX_RETRIES) {
+                        logger.warn(`[GoogleVertex] Tool "${toolUse.name}" has exceeded retry limit (${DEFAULT_TOOL_MAX_RETRIES}), skipping execution`);
+                        const errMsg = `TOOL_PERMANENTLY_FAILED: The tool "${toolUse.name}" has failed ${failedInfo.count} times and will not be retried. Last error: ${failedInfo.lastError}. Please proceed without using this tool or inform the user that this functionality is unavailable.`;
+                        const errorPayload = { error: errMsg };
+                        toolExecutions.push({
+                            name: toolUse.name,
+                            input: toolUse.input,
+                            output: errorPayload,
+                        });
+                        toolResults.push({
+                            type: "tool_result",
+                            tool_use_id: toolUse.id,
+                            content: errMsg,
+                        });
+                        stepStorageResults.push({
+                            toolCallId: toolUse.id,
+                            toolName: toolUse.name,
+                            output: errorPayload,
+                        });
+                        continue;
+                    }
                     const execute = executeMap.get(toolUse.name);
                     if (execute) {
                         try {
@@ -4403,9 +4734,32 @@ export class GoogleVertexProvider extends BaseProvider {
                             };
                             turnClock.noteProgress();
                             // Bound the execute() await — a wedged tool costs one step
-                            // (error tool_result), not the whole turn.
-                            const result = await withTimeout(Promise.resolve(execute(toolUse.input, toolOptions)), toolExecTimeoutMs, `Tool "${toolUse.name}" execution timed out after ${toolExecTimeoutMs}ms`);
+                            // (error tool_result), not the whole turn — and race it against
+                            // the turn's abort so a deadline/caller abort is observed
+                            // IMMEDIATELY instead of after the tool settles (live-verified:
+                            // an 8s deadline previously waited out a 60s tool).
+                            const result = await withTimeout(raceWithAbort(Promise.resolve(execute(toolUse.input, toolOptions)), internalAbort.signal), toolExecTimeoutMs, `Tool "${toolUse.name}" execution timed out after ${toolExecTimeoutMs}ms`);
                             turnClock.noteProgress();
+                            // Error-shaped success (MCP isError / { error } payloads —
+                            // e.g. proxy-blocked tools) counts toward the breaker too:
+                            // these fail without throwing, and only counting throws lets
+                            // the model grind on a blocked tool for the whole budget.
+                            const resultErrorText = extractToolFailureText(result);
+                            if (resultErrorText) {
+                                const info = failedTools.get(toolUse.name) || {
+                                    count: 0,
+                                    lastError: "",
+                                };
+                                info.count++;
+                                info.lastError = resultErrorText;
+                                failedTools.set(toolUse.name, info);
+                            }
+                            else {
+                                // Genuinely consecutive: a success clears the strike count
+                                // (argument-dependent soft errors — file-not-found on
+                                // different paths — must not disable a working tool).
+                                failedTools.delete(toolUse.name);
+                            }
                             toolExecutions.push({
                                 name: toolUse.name,
                                 input: toolUse.input,
@@ -4453,7 +4807,17 @@ export class GoogleVertexProvider extends BaseProvider {
                                     toolName: toolUse.name,
                                 });
                             }
-                            const errMsg = `Error executing tool "${toolUse.name}": ${err instanceof Error ? err.message : String(err)}`;
+                            // Count the failure toward the consecutive-failure breaker.
+                            const thrownErrorText = err instanceof Error ? err.message : String(err);
+                            const info = failedTools.get(toolUse.name) || {
+                                count: 0,
+                                lastError: "",
+                            };
+                            info.count++;
+                            info.lastError = thrownErrorText;
+                            failedTools.set(toolUse.name, info);
+                            logger.warn(`[GoogleVertex] Tool "${toolUse.name}" failed (attempt ${info.count}/${DEFAULT_TOOL_MAX_RETRIES}): ${thrownErrorText}`);
+                            const errMsg = `Error executing tool "${toolUse.name}": ${thrownErrorText}`;
                             const errorPayload = { error: errMsg };
                             toolExecutions.push({
                                 name: toolUse.name,
@@ -4475,6 +4839,16 @@ export class GoogleVertexProvider extends BaseProvider {
                     else {
                         const errMsg = `TOOL_NOT_FOUND: The tool "${toolUse.name}" does not exist.`;
                         const errorPayload = { error: errMsg };
+                        // A missing tool counts toward the breaker too — a model
+                        // grinding on a hallucinated/stale tool name must not burn the
+                        // whole step budget on TOOL_NOT_FOUND round-trips.
+                        const notFoundInfo = failedTools.get(toolUse.name) || {
+                            count: 0,
+                            lastError: "",
+                        };
+                        notFoundInfo.count++;
+                        notFoundInfo.lastError = errMsg;
+                        failedTools.set(toolUse.name, notFoundInfo);
                         toolExecutions.push({
                             name: toolUse.name,
                             input: toolUse.input,
@@ -4544,6 +4918,13 @@ export class GoogleVertexProvider extends BaseProvider {
                     role: "user",
                     content: toolResults,
                 });
+                // Project this step's growth for the context guard: everything just
+                // appended (tool results + nudge text) rides the next prompt. The
+                // assistant output was already counted via noteUsage.
+                contextGuard.noteAppendedChars(toolResults.reduce((sum, block) => sum +
+                    ("content" in block
+                        ? block.content.length
+                        : block.text.length), 0));
                 // Accumulate the step's prose so a capped turn can still surface it —
                 // finalText is reserved for model-initiated finishes.
                 accumulatedStepText = appendStepText(accumulatedStepText, responseText);
@@ -4593,6 +4974,14 @@ export class GoogleVertexProvider extends BaseProvider {
                 wasAborted = true;
             }
             const externalToolCallCount = allToolCalls.filter((tc) => tc.toolName !== "final_result").length;
+            // Clamp the terminal calls' max_tokens so prompt + output stays inside
+            // the model window: pre-4.5 Claude models 400 on input + max_tokens >
+            // window, which would defeat the very synthesis these calls exist for
+            // on context-capped turns. Only bites when the prompt is near the
+            // window (min() is a no-op on ordinary step-cap turns).
+            const terminalMaxTokens = Math.max(1024, Math.min(requestParams.max_tokens, getContextWindowSize("vertex", modelName) -
+                contextGuard.projectedNextPromptTokens -
+                4_000));
             if (wasAborted) {
                 // Budget already blown — never issue another model call; prefer the
                 // prose the model already produced (mirrors the Gemini abort path),
@@ -4614,8 +5003,12 @@ export class GoogleVertexProvider extends BaseProvider {
                         });
             }
             else if (useFinalResultTool) {
-                hitStepLimit = true;
-                logger.warn(`[GoogleVertex] Native Anthropic generate loop reached maxSteps (${maxSteps}) without final_result; forcing a finalization call.`);
+                if (!hitContextLimit) {
+                    hitStepLimit = true;
+                }
+                logger.warn(hitContextLimit
+                    ? `[GoogleVertex] Native Anthropic generate loop stopped by the context guard without final_result; forcing a finalization call.`
+                    : `[GoogleVertex] Native Anthropic generate loop reached maxSteps (${maxSteps}) without final_result; forcing a finalization call.`);
                 try {
                     // Reserved finalization step: identical request except tool_choice
                     // pins final_result, so Anthropic guarantees the response is a
@@ -4629,6 +5022,7 @@ export class GoogleVertexProvider extends BaseProvider {
                     });
                     const response = await withTimeout(client.messages.create({
                         ...requestParams,
+                        max_tokens: terminalMaxTokens,
                         tool_choice: {
                             type: "tool",
                             name: "final_result",
@@ -4656,7 +5050,9 @@ export class GoogleVertexProvider extends BaseProvider {
                         logger.debug("[GoogleVertex] Forced finalization returned structured output (generate)", { keys: Object.keys(structuredOutput) });
                     }
                     else {
-                        finalText = buildToolLoopCapMessage(maxSteps, externalToolCallCount);
+                        finalText = hitContextLimit
+                            ? buildContextCapMessage(externalToolCallCount)
+                            : buildToolLoopCapMessage(maxSteps, externalToolCallCount);
                     }
                 }
                 catch (error) {
@@ -4669,20 +5065,27 @@ export class GoogleVertexProvider extends BaseProvider {
                         wasAborted = true;
                     }
                     logger.warn("[GoogleVertex] Forced finalization call failed; falling back to a terminal message", { error: error instanceof Error ? error.message : String(error) });
-                    finalText = this.buildLoopExitMessage({
-                        turnClock,
-                        wasAborted,
-                        stallTimeoutMs: options.stallTimeoutMs,
-                        maxSteps,
-                        toolCallCount: externalToolCallCount,
-                    });
+                    finalText =
+                        hitContextLimit && !wasAborted
+                            ? buildContextCapMessage(externalToolCallCount)
+                            : this.buildLoopExitMessage({
+                                turnClock,
+                                wasAborted,
+                                stallTimeoutMs: options.stallTimeoutMs,
+                                maxSteps,
+                                toolCallCount: externalToolCallCount,
+                            });
                 }
             }
             else {
-                hitStepLimit = true;
+                if (!hitContextLimit) {
+                    hitStepLimit = true;
+                }
                 if (accumulatedStepText) {
                     // Prefer the prose the model already produced across steps.
-                    logger.warn(`[GoogleVertex] Native Anthropic generate loop reached maxSteps (${maxSteps}); returning text already gathered from prior steps.`);
+                    logger.warn(hitContextLimit
+                        ? `[GoogleVertex] Native Anthropic generate loop stopped by the context guard; returning text already gathered from prior steps.`
+                        : `[GoogleVertex] Native Anthropic generate loop reached maxSteps (${maxSteps}); returning text already gathered from prior steps.`);
                     finalText = accumulatedStepText;
                 }
                 else {
@@ -4693,7 +5096,9 @@ export class GoogleVertexProvider extends BaseProvider {
                     // history contains tool_use/tool_result blocks without a tools
                     // param — so "tools disabled" is expressed as tool_choice:"none",
                     // which also keeps the cached tools prefix byte-identical.
-                    logger.warn(`[GoogleVertex] Native Anthropic generate loop reached maxSteps (${maxSteps}) with no text; synthesizing a final answer with tools disabled.`);
+                    logger.warn(hitContextLimit
+                        ? `[GoogleVertex] Native Anthropic generate loop stopped by the context guard with no text; synthesizing a final answer with tools disabled.`
+                        : `[GoogleVertex] Native Anthropic generate loop reached maxSteps (${maxSteps}) with no text; synthesizing a final answer with tools disabled.`);
                     try {
                         const backstopSystem = (systemPromptWithSchema ? systemPromptWithSchema + "\n\n" : "") +
                             "Tool calling is no longer available for this turn. Provide " +
@@ -4706,6 +5111,7 @@ export class GoogleVertexProvider extends BaseProvider {
                         });
                         const response = await withTimeout(client.messages.create({
                             ...requestParams,
+                            max_tokens: terminalMaxTokens,
                             tool_choice: { type: "none" },
                             system: cachedBackstop.system,
                             ...(cachedBackstop.tools &&
@@ -4730,7 +5136,9 @@ export class GoogleVertexProvider extends BaseProvider {
                             finalText = backstopText;
                         }
                         else {
-                            finalText = buildToolLoopCapMessage(maxSteps, externalToolCallCount);
+                            finalText = hitContextLimit
+                                ? buildContextCapMessage(externalToolCallCount)
+                                : buildToolLoopCapMessage(maxSteps, externalToolCallCount);
                         }
                     }
                     catch (error) {
@@ -4745,13 +5153,16 @@ export class GoogleVertexProvider extends BaseProvider {
                         logger.warn("[GoogleVertex] Tools-disabled backstop call failed; falling back to a terminal message", {
                             error: error instanceof Error ? error.message : String(error),
                         });
-                        finalText = this.buildLoopExitMessage({
-                            turnClock,
-                            wasAborted,
-                            stallTimeoutMs: options.stallTimeoutMs,
-                            maxSteps,
-                            toolCallCount: externalToolCallCount,
-                        });
+                        finalText =
+                            hitContextLimit && !wasAborted
+                                ? buildContextCapMessage(externalToolCallCount)
+                                : this.buildLoopExitMessage({
+                                    turnClock,
+                                    wasAborted,
+                                    stallTimeoutMs: options.stallTimeoutMs,
+                                    maxSteps,
+                                    toolCallCount: externalToolCallCount,
+                                });
                     }
                 }
             }
@@ -4765,13 +5176,16 @@ export class GoogleVertexProvider extends BaseProvider {
         // Cause-aware: an aborted/timed-out turn gets the honest exit message,
         // a genuine budget exhaustion gets the step-cap message.
         if (!finalText && externalToolCalls.length > 0) {
-            finalText = this.buildLoopExitMessage({
-                turnClock,
-                wasAborted,
-                stallTimeoutMs: options.stallTimeoutMs,
-                maxSteps,
-                toolCallCount: externalToolCalls.length,
-            });
+            finalText =
+                hitContextLimit && !wasAborted
+                    ? buildContextCapMessage(externalToolCalls.length)
+                    : this.buildLoopExitMessage({
+                        turnClock,
+                        wasAborted,
+                        stallTimeoutMs: options.stallTimeoutMs,
+                        maxSteps,
+                        toolCallCount: externalToolCalls.length,
+                    });
         }
         // Honest finish reason. "length" (token truncation) takes precedence; a
         // step-cap exhaustion without a clean/forced answer surfaces as
@@ -4790,6 +5204,7 @@ export class GoogleVertexProvider extends BaseProvider {
             stalled: turnClock.stalled,
             wasAborted,
             cappedWithoutAnswer: hitStepLimit && !synthesizedFinalAnswer,
+            contextCappedWithoutAnswer: hitContextLimit && !synthesizedFinalAnswer,
             finishReason: resolvedFinishReason,
         });
         if (stopReason !== "completed") {