@juspay/neurolink 9.80.1 → 9.80.3

package/dist/lib/providers/googleVertex.js

@@ -5,7 +5,7 @@ import path from "path";
 import os from "os";
 import { AIProviderName, ErrorCategory, ErrorSeverity, } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
-import { DEFAULT_MAX_STEPS, DEFAULT_TOOL_MAX_RETRIES, GLOBAL_LOCATION_MODELS, IMAGE_GENERATION_MODELS, TOOL_STORAGE_TIMEOUT_MS, } from "../core/constants.js";
+import { DEFAULT_GEMINI_STREAM_TIMEOUT_MS, DEFAULT_MAX_STEPS, DEFAULT_TOOL_MAX_RETRIES, GLOBAL_LOCATION_MODELS, IMAGE_GENERATION_MODELS, TOOL_STORAGE_TIMEOUT_MS, } from "../core/constants.js";
 import { ModelConfigurationManager } from "../core/modelConfiguration.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
 import { AuthenticationError, InvalidModelError, NetworkError, ProviderError, RateLimitError, } from "../types/index.js";
@@ -22,7 +22,7 @@ import { convertZodToJsonSchema, inlineJsonSchema, ensureNestedSchemaTypes, } fr
 import { createNativeThinkingConfig } from "../utils/thinkingConfig.js";
 import { TimeoutError, withTimeout } from "../utils/async/index.js";
 import { parseTimeout } from "../utils/timeout.js";
-import { appendStepText, createTextChannel, extractThoughtSignature, mapGeminiFinishReason, prependConversationMessages, } from "./googleNativeGemini3.js";
+import { appendStepText, buildToolLoopCapMessage, createTextChannel, extractThoughtSignature, isAbortError, mapGeminiFinishReason, prependConversationMessages, } from "./googleNativeGemini3.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";
@@ -932,7 +932,10 @@ export class GoogleVertexProvider extends BaseProvider {
                 this.emitStreamEnd(modelName, streamStartTime, false, error);
                 throw error;
             }
-        }, (r) => r.stream, (r, wrapped) => ({ ...r, stream: wrapped }));
+        }, (r) => r.stream, 
+        // Preserve live getters (finishReason/structuredOutput/…) that the
+        // spread would otherwise snapshot before the background loop resolves.
+        (r, wrapped) => this.preserveStreamResultAccessors(r, { ...r, stream: wrapped }));
     }
     /**
      * Emit `stream:end` so the Pipeline B observability listener creates a
@@ -1321,177 +1324,238 @@ export class GoogleVertexProvider extends BaseProvider {
         // yielding it once breaks that signal even though the underlying
         // network stream is genuinely incremental.
         const incrementalTextChunks = [];
-        // Agentic loop for tool calling
-        while (step < maxSteps) {
-            step++;
-            logger.debug(`[GoogleVertex] Native SDK step ${step}/${maxSteps}`);
-            try {
-                const stream = await client.models.generateContentStream({
-                    model: modelName,
-                    contents: currentContents,
-                    config,
-                });
-                const stepFunctionCalls = [];
-                // Capture raw response parts including thoughtSignature
-                const rawResponseParts = [];
-                for await (const chunk of stream) {
-                    // Extract raw parts from candidates FIRST
-                    // This avoids using chunk.text which triggers SDK warning when
-                    // non-text parts (thoughtSignature, functionCall) are present
-                    const chunkRecord = chunk;
-                    const candidates = chunkRecord.candidates;
-                    const firstCandidate = candidates?.[0];
-                    // Capture the SDK finish reason (Bug 2: previously dropped). Last
-                    // non-empty value across chunks wins.
-                    const chunkFinishReason = firstCandidate?.finishReason;
-                    if (typeof chunkFinishReason === "string" && chunkFinishReason) {
-                        lastFinishReason = chunkFinishReason;
-                    }
-                    const chunkContent = firstCandidate?.content;
-                    if (chunkContent && Array.isArray(chunkContent.parts)) {
-                        for (const part of chunkContent.parts) {
-                            rawResponseParts.push(part);
-                            if (typeof part.text === "string" && part.text.length > 0) {
-                                incrementalTextChunks.push(part.text);
+        // Abort scaffolding (mirrors executeNativeAnthropicStream). The native
+        // Gemini SDK cancels via config.abortSignal, so drive an internal
+        // AbortController: the caller's signal and a defensive wall-clock timer
+        // both trip it, and every request/tool-exec receives effectiveSignal.
+        const streamTimeoutMs = parseTimeout(options.timeout) ?? DEFAULT_GEMINI_STREAM_TIMEOUT_MS;
+        const internalAbort = new AbortController();
+        const onCallerAbort = () => internalAbort.abort();
+        options.abortSignal?.addEventListener("abort", onCallerAbort);
+        const defensiveTimer = setTimeout(() => {
+            logger.warn(`[GoogleVertex] Native Gemini turn exceeded ${streamTimeoutMs}ms — aborting`);
+            internalAbort.abort();
+        }, streamTimeoutMs);
+        const effectiveSignal = internalAbort.signal;
+        if (options.abortSignal?.aborted) {
+            internalAbort.abort();
+        }
+        let wasAborted = false;
+        // Step-cap flags declared in the outer scope so the terminal block (also
+        // inside the try) and the finishReason mapping (after the finally) can
+        // both read them.
+        let hitStepLimit = false;
+        let synthesizedFinalAnswer = false;
+        try {
+            // Agentic loop for tool calling
+            while (step < maxSteps) {
+                if (effectiveSignal.aborted) {
+                    wasAborted = true;
+                    break;
+                }
+                step++;
+                logger.debug(`[GoogleVertex] Native SDK step ${step}/${maxSteps}`);
+                try {
+                    const stream = await client.models.generateContentStream({
+                        model: modelName,
+                        contents: currentContents,
+                        config: { ...config, abortSignal: effectiveSignal },
+                    });
+                    const stepFunctionCalls = [];
+                    // Capture raw response parts including thoughtSignature
+                    const rawResponseParts = [];
+                    for await (const chunk of stream) {
+                        // Extract raw parts from candidates FIRST
+                        // This avoids using chunk.text which triggers SDK warning when
+                        // non-text parts (thoughtSignature, functionCall) are present
+                        const chunkRecord = chunk;
+                        const candidates = chunkRecord.candidates;
+                        const firstCandidate = candidates?.[0];
+                        // Capture the SDK finish reason (Bug 2: previously dropped). Last
+                        // non-empty value across chunks wins.
+                        const chunkFinishReason = firstCandidate?.finishReason;
+                        if (typeof chunkFinishReason === "string" && chunkFinishReason) {
+                            lastFinishReason = chunkFinishReason;
+                        }
+                        const chunkContent = firstCandidate?.content;
+                        if (chunkContent && Array.isArray(chunkContent.parts)) {
+                            for (const part of chunkContent.parts) {
+                                rawResponseParts.push(part);
+                                if (typeof part.text === "string" && part.text.length > 0) {
+                                    incrementalTextChunks.push(part.text);
+                                }
                             }
                         }
-                    }
-                    if (chunk.functionCalls) {
-                        stepFunctionCalls.push(...chunk.functionCalls);
-                    }
-                    // Extract usage metadata from chunk
-                    // promptTokenCount is typically in the final chunk, candidatesTokenCount accumulates
-                    const usageMetadata = chunkRecord.usageMetadata;
-                    if (usageMetadata) {
-                        // Take the latest promptTokenCount (usually only in final chunk)
-                        if (usageMetadata.promptTokenCount !== undefined &&
-                            usageMetadata.promptTokenCount > 0) {
-                            totalInputTokens = usageMetadata.promptTokenCount;
+                        if (chunk.functionCalls) {
+                            stepFunctionCalls.push(...chunk.functionCalls);
                         }
-                        // Take the latest candidatesTokenCount (accumulates through chunks)
-                        if (usageMetadata.candidatesTokenCount !== undefined &&
-                            usageMetadata.candidatesTokenCount > 0) {
-                            totalOutputTokens = usageMetadata.candidatesTokenCount;
+                        // Extract usage metadata from chunk
+                        // promptTokenCount is typically in the final chunk, candidatesTokenCount accumulates
+                        const usageMetadata = chunkRecord.usageMetadata;
+                        if (usageMetadata) {
+                            // Take the latest promptTokenCount (usually only in final chunk)
+                            if (usageMetadata.promptTokenCount !== undefined &&
+                                usageMetadata.promptTokenCount > 0) {
+                                totalInputTokens = usageMetadata.promptTokenCount;
+                            }
+                            // Take the latest candidatesTokenCount (accumulates through chunks)
+                            if (usageMetadata.candidatesTokenCount !== undefined &&
+                                usageMetadata.candidatesTokenCount > 0) {
+                                totalOutputTokens = usageMetadata.candidatesTokenCount;
+                            }
                         }
                     }
-                }
-                // Extract text from raw parts after stream completes
-                // This avoids SDK warning about non-text parts (thoughtSignature, functionCall)
-                const stepText = rawResponseParts
-                    .filter((part) => typeof part.text === "string")
-                    .map((part) => part.text)
-                    .join("");
-                // If no function calls, we're done
-                if (stepFunctionCalls.length === 0) {
-                    finalText = stepText;
-                    break;
-                }
-                // Check for final_result tool call - this is our structured output pattern
-                if (useFinalResultTool) {
-                    const finalResultCall = stepFunctionCalls.find((call) => call.name === "final_result");
-                    if (finalResultCall) {
-                        // Extract the structured output from final_result arguments
-                        finalResultStructuredOutput = finalResultCall.args;
-                        logger.debug("[GoogleVertex] Received final_result tool call with structured output (stream)", {
-                            outputKeys: Object.keys(finalResultStructuredOutput),
-                        });
-                        // Return the structured output as JSON text
-                        finalText = JSON.stringify(finalResultStructuredOutput);
+                    // Extract text from raw parts after stream completes
+                    // This avoids SDK warning about non-text parts (thoughtSignature, functionCall)
+                    const stepText = rawResponseParts
+                        .filter((part) => typeof part.text === "string")
+                        .map((part) => part.text)
+                        .join("");
+                    // If no function calls, we're done
+                    if (stepFunctionCalls.length === 0) {
+                        finalText = stepText;
                         break;
                     }
-                }
-                // Execute function calls
-                logger.debug(`[GoogleVertex] Executing ${stepFunctionCalls.length} function calls`);
-                // Add model response with ALL parts (including thoughtSignature) to history
-                // This preserves the thought_signature which is required for Gemini 3 multi-turn tool calling
-                currentContents.push({
-                    role: "model",
-                    parts: rawResponseParts.length > 0
-                        ? rawResponseParts
-                        : stepFunctionCalls.map((fc) => ({
-                            functionCall: fc,
-                        })),
-                });
-                // Execute each function and collect responses
-                const functionResponses = [];
-                // Per-step bookkeeping for conversation-memory storage.
-                const stepStorageCalls = [];
-                const stepStorageResults = [];
-                // 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) {
-                    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
-                    const failedInfo = failedTools.get(call.name);
-                    if (failedInfo && failedInfo.count >= DEFAULT_TOOL_MAX_RETRIES) {
-                        logger.warn(`[GoogleVertex] Tool "${call.name}" has exceeded retry limit (${DEFAULT_TOOL_MAX_RETRIES}), skipping execution`);
-                        const errorPayload = {
-                            error: `TOOL_PERMANENTLY_FAILED: The tool "${call.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.`,
-                            status: "permanently_failed",
-                            do_not_retry: true,
-                        };
-                        functionResponses.push({
-                            functionResponse: {
-                                name: call.name,
-                                response: errorPayload,
-                            },
-                        });
-                        toolExecutions.push({
-                            name: call.name,
-                            input: call.args,
-                            output: errorPayload,
-                        });
-                        stepStorageResults.push({
-                            toolName: call.name,
-                            output: errorPayload,
-                        });
-                        continue;
+                    // Check for final_result tool call - this is our structured output pattern
+                    if (useFinalResultTool) {
+                        const finalResultCall = stepFunctionCalls.find((call) => call.name === "final_result");
+                        if (finalResultCall) {
+                            // Extract the structured output from final_result arguments
+                            finalResultStructuredOutput = finalResultCall.args;
+                            logger.debug("[GoogleVertex] Received final_result tool call with structured output (stream)", {
+                                outputKeys: Object.keys(finalResultStructuredOutput),
+                            });
+                            // Return the structured output as JSON text
+                            finalText = JSON.stringify(finalResultStructuredOutput);
+                            break;
+                        }
                     }
-                    const execute = executeMap.get(call.name);
-                    if (execute) {
-                        try {
-                            // AI SDK Tool execute requires (args, options) - provide minimal options
-                            const toolOptions = {
-                                toolCallId: `${call.name}-${Date.now()}`,
-                                messages: [],
-                                abortSignal: undefined,
+                    // Execute function calls
+                    logger.debug(`[GoogleVertex] Executing ${stepFunctionCalls.length} function calls`);
+                    // Add model response with ALL parts (including thoughtSignature) to history
+                    // This preserves the thought_signature which is required for Gemini 3 multi-turn tool calling
+                    currentContents.push({
+                        role: "model",
+                        parts: rawResponseParts.length > 0
+                            ? rawResponseParts
+                            : stepFunctionCalls.map((fc) => ({
+                                functionCall: fc,
+                            })),
+                    });
+                    // Execute each function and collect responses
+                    const functionResponses = [];
+                    // Per-step bookkeeping for conversation-memory storage.
+                    const stepStorageCalls = [];
+                    const stepStorageResults = [];
+                    // 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) {
+                        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
+                        const failedInfo = failedTools.get(call.name);
+                        if (failedInfo && failedInfo.count >= DEFAULT_TOOL_MAX_RETRIES) {
+                            logger.warn(`[GoogleVertex] Tool "${call.name}" has exceeded retry limit (${DEFAULT_TOOL_MAX_RETRIES}), skipping execution`);
+                            const errorPayload = {
+                                error: `TOOL_PERMANENTLY_FAILED: The tool "${call.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.`,
+                                status: "permanently_failed",
+                                do_not_retry: true,
                             };
-                            const result = await execute(call.args, toolOptions);
+                            functionResponses.push({
+                                functionResponse: {
+                                    name: call.name,
+                                    response: errorPayload,
+                                },
+                            });
                             toolExecutions.push({
                                 name: call.name,
                                 input: call.args,
-                                output: result,
-                            });
-                            functionResponses.push({
-                                functionResponse: { name: call.name, response: { result } },
+                                output: errorPayload,
                             });
                             stepStorageResults.push({
                                 toolName: call.name,
-                                output: result,
+                                output: errorPayload,
                             });
+                            continue;
                         }
-                        catch (error) {
-                            const errorMessage = error instanceof Error ? error.message : "Unknown error";
-                            // Track this failure
-                            const currentFailInfo = failedTools.get(call.name) || {
-                                count: 0,
-                                lastError: "",
-                            };
-                            currentFailInfo.count++;
-                            currentFailInfo.lastError = errorMessage;
-                            failedTools.set(call.name, currentFailInfo);
-                            logger.warn(`[GoogleVertex] Tool "${call.name}" failed (attempt ${currentFailInfo.count}/${DEFAULT_TOOL_MAX_RETRIES}): ${errorMessage}`);
-                            // Determine if this is a permanent failure
-                            const isPermanentFailure = currentFailInfo.count >= DEFAULT_TOOL_MAX_RETRIES;
+                        const execute = executeMap.get(call.name);
+                        if (execute) {
+                            try {
+                                // AI SDK Tool execute requires (args, options) - provide minimal options
+                                const toolOptions = {
+                                    toolCallId: `${call.name}-${Date.now()}`,
+                                    messages: [],
+                                    abortSignal: effectiveSignal,
+                                };
+                                const result = await execute(call.args, toolOptions);
+                                toolExecutions.push({
+                                    name: call.name,
+                                    input: call.args,
+                                    output: result,
+                                });
+                                functionResponses.push({
+                                    functionResponse: { name: call.name, response: { result } },
+                                });
+                                stepStorageResults.push({
+                                    toolName: call.name,
+                                    output: result,
+                                });
+                            }
+                            catch (error) {
+                                // An abort during tool execution ends the turn gracefully — it
+                                // must NOT be recorded as a spurious tool failure. Both checks
+                                // matter: effectiveSignal.aborted catches an abort WE triggered
+                                // (even if the throw isn't abort-shaped); isAbortError(error)
+                                // catches an abort-shaped throw (e.g. a tool raising AbortError)
+                                // even when the signal itself never fired.
+                                if (effectiveSignal.aborted || isAbortError(error)) {
+                                    wasAborted = true;
+                                    break;
+                                }
+                                const errorMessage = error instanceof Error ? error.message : "Unknown error";
+                                // Track this failure
+                                const currentFailInfo = failedTools.get(call.name) || {
+                                    count: 0,
+                                    lastError: "",
+                                };
+                                currentFailInfo.count++;
+                                currentFailInfo.lastError = errorMessage;
+                                failedTools.set(call.name, currentFailInfo);
+                                logger.warn(`[GoogleVertex] Tool "${call.name}" failed (attempt ${currentFailInfo.count}/${DEFAULT_TOOL_MAX_RETRIES}): ${errorMessage}`);
+                                // Determine if this is a permanent failure
+                                const isPermanentFailure = currentFailInfo.count >= DEFAULT_TOOL_MAX_RETRIES;
+                                const errorPayload = {
+                                    error: isPermanentFailure
+                                        ? `TOOL_PERMANENTLY_FAILED: The tool "${call.name}" has failed ${currentFailInfo.count} times with error: ${errorMessage}. This tool will not be retried. Please proceed without using this tool or inform the user that this functionality is unavailable.`
+                                        : `TOOL_EXECUTION_ERROR: ${errorMessage}. Retry attempt ${currentFailInfo.count}/${DEFAULT_TOOL_MAX_RETRIES}.`,
+                                    status: isPermanentFailure ? "permanently_failed" : "failed",
+                                    do_not_retry: isPermanentFailure,
+                                    retry_count: currentFailInfo.count,
+                                    max_retries: DEFAULT_TOOL_MAX_RETRIES,
+                                };
+                                functionResponses.push({
+                                    functionResponse: {
+                                        name: call.name,
+                                        response: errorPayload,
+                                    },
+                                });
+                                toolExecutions.push({
+                                    name: call.name,
+                                    input: call.args,
+                                    output: errorPayload,
+                                });
+                                stepStorageResults.push({
+                                    toolName: call.name,
+                                    output: errorPayload,
+                                });
+                            }
+                        }
+                        else {
+                            // Tool not found is a permanent error
                             const errorPayload = {
-                                error: isPermanentFailure
-                                    ? `TOOL_PERMANENTLY_FAILED: The tool "${call.name}" has failed ${currentFailInfo.count} times with error: ${errorMessage}. This tool will not be retried. Please proceed without using this tool or inform the user that this functionality is unavailable.`
-                                    : `TOOL_EXECUTION_ERROR: ${errorMessage}. Retry attempt ${currentFailInfo.count}/${DEFAULT_TOOL_MAX_RETRIES}.`,
-                                status: isPermanentFailure ? "permanently_failed" : "failed",
-                                do_not_retry: isPermanentFailure,
-                                retry_count: currentFailInfo.count,
-                                max_retries: DEFAULT_TOOL_MAX_RETRIES,
+                                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,
                             };
                             functionResponses.push({
                                 functionResponse: {
@@ -1510,102 +1574,109 @@ export class GoogleVertexProvider extends BaseProvider {
                             });
                         }
                     }
-                    else {
-                        // Tool not found is a permanent error
-                        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,
-                        };
-                        functionResponses.push({
-                            functionResponse: {
-                                name: call.name,
-                                response: errorPayload,
-                            },
-                        });
-                        toolExecutions.push({
-                            name: call.name,
-                            input: call.args,
-                            output: errorPayload,
-                        });
-                        stepStorageResults.push({
-                            toolName: call.name,
-                            output: errorPayload,
-                        });
+                    // An abort inside the tool-exec loop only breaks that inner for-loop.
+                    // Break the while too so no further model call is issued and control
+                    // reaches the terminal step-cap handling below.
+                    if (wasAborted) {
+                        break;
                     }
-                }
-                // Persist this step's tool calls/results into conversation memory.
-                // Without this, tool_call / tool_result rows never reach Redis and
-                // the chat-history UI loses every tool invocation.
-                //
-                // `thoughtSignature` rides as a sibling on the first call of the
-                // step — Gemini 3 needs it to match thinking patterns when the
-                // conversation is replayed on the next turn.
-                if (stepStorageCalls.length > 0 || stepStorageResults.length > 0) {
-                    const stepThoughtSig = extractThoughtSignature(rawResponseParts);
-                    withTimeout(this.handleToolExecutionStorage(stepStorageCalls.map((c, i) => ({
-                        ...c,
-                        ...(i === 0 && stepThoughtSig
-                            ? { thoughtSignature: stepThoughtSig }
-                            : {}),
-                        stepIndex: step,
-                    })), stepStorageResults.map((r) => ({ ...r, stepIndex: step })), options, new Date()), TOOL_STORAGE_TIMEOUT_MS, "tool storage write timed out").catch((error) => {
-                        logger.warn("[GoogleVertex] Failed to store native Gemini stream tool executions", {
-                            error: error instanceof Error ? error.message : String(error),
+                    // Persist this step's tool calls/results into conversation memory.
+                    // Without this, tool_call / tool_result rows never reach Redis and
+                    // the chat-history UI loses every tool invocation.
+                    //
+                    // `thoughtSignature` rides as a sibling on the first call of the
+                    // step — Gemini 3 needs it to match thinking patterns when the
+                    // conversation is replayed on the next turn.
+                    if (stepStorageCalls.length > 0 || stepStorageResults.length > 0) {
+                        const stepThoughtSig = extractThoughtSignature(rawResponseParts);
+                        withTimeout(this.handleToolExecutionStorage(stepStorageCalls.map((c, i) => ({
+                            ...c,
+                            ...(i === 0 && stepThoughtSig
+                                ? { thoughtSignature: stepThoughtSig }
+                                : {}),
+                            stepIndex: step,
+                        })), stepStorageResults.map((r) => ({ ...r, stepIndex: step })), options, new Date()), TOOL_STORAGE_TIMEOUT_MS, "tool storage write timed out").catch((error) => {
+                            logger.warn("[GoogleVertex] Failed to store native Gemini stream tool executions", {
+                                error: error instanceof Error ? error.message : String(error),
+                            });
                         });
+                    }
+                    // The @google/genai SDK only accepts "user" and "model" as valid
+                    // roles in contents — function/tool responses must use role: "user"
+                    // (matching the SDK's automaticFunctionCalling implementation and
+                    // the Google AI Studio path). Sending role: "function" was causing
+                    // native Vertex Gemini tool loops to be silently rejected by the
+                    // request validator.
+                    currentContents.push({
+                        role: "user",
+                        parts: functionResponses,
                     });
                 }
-                // The @google/genai SDK only accepts "user" and "model" as valid
-                // roles in contents — function/tool responses must use role: "user"
-                // (matching the SDK's automaticFunctionCalling implementation and
-                // the Google AI Studio path). Sending role: "function" was causing
-                // native Vertex Gemini tool loops to be silently rejected by the
-                // request validator.
-                currentContents.push({
-                    role: "user",
-                    parts: functionResponses,
-                });
-            }
-            catch (error) {
-                logger.error("[GoogleVertex] Native SDK error", error);
-                throw this.handleProviderError(error);
-            }
-        }
-        // Handle maxSteps termination — the loop exited because the step cap was
-        // reached while the model was still calling tools. Surface a real answer
-        // instead of the canned placeholder (Bug 1) and a meaningful finishReason
-        // (Bug 2).
-        let hitStepLimit = false;
-        let synthesizedFinalAnswer = false;
-        if (step >= maxSteps && !finalText) {
-            hitStepLimit = true;
-            // The consumer receives text via `incrementalTextChunks`; any text the
-            // model emitted across steps is already preserved there. Only synthesize
-            // when NOTHING was produced (the pure-functionCall case that otherwise
-            // surfaces the placeholder) so we never waste a round-trip whose output
-            // the stream would ignore.
-            if (incrementalTextChunks.length === 0) {
-                logger.warn(`[GoogleVertex] Tool call loop terminated after reaching maxSteps (${maxSteps}) ` +
-                    `with no text; synthesizing a final answer with tools disabled.`);
-                const synth = await this.synthesizeFinalAnswerWithoutTools(client, modelName, config, currentContents, useFinalResultTool, parseTimeout(options.timeout) ?? 300_000);
-                if (synth.text) {
-                    synthesizedFinalAnswer = true;
-                    finalText = synth.text;
-                    incrementalTextChunks.push(synth.text);
-                    totalInputTokens += synth.inputTokens;
-                    totalOutputTokens += synth.outputTokens;
-                    if (synth.finishReason) {
-                        lastFinishReason = synth.finishReason;
+                catch (error) {
+                    // A mid-drain abort surfaces as an AbortError from the `for await`.
+                    // Break gracefully into the terminal block instead of re-throwing
+                    // (a re-throw would route the caller's abort into a second unbounded
+                    // fallback stream()). Dual check as with the inner catch:
+                    // effectiveSignal.aborted (a signal we tripped) OR isAbortError(error)
+                    // (an abort-shaped throw) — either means "stop", not a real failure.
+                    if (effectiveSignal.aborted || isAbortError(error)) {
+                        wasAborted = true;
+                        break;
                     }
+                    logger.error("[GoogleVertex] Native SDK error", error);
+                    throw this.handleProviderError(error);
+                }
+            }
+            // Handle maxSteps termination / abort — the loop exited because the step
+            // 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)) {
+                hitStepLimit = step >= maxSteps && !wasAborted;
+                const toolCallCount = allToolCalls.filter((tc) => tc.toolName !== "final_result").length;
+                // The consumer receives text via `incrementalTextChunks`; any text the
+                // model emitted across steps is already preserved there. Only produce a
+                // terminal message when NOTHING was produced (the pure-functionCall /
+                // abort case that otherwise surfaces the placeholder). When chunks
+                // 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.`);
+                }
+                else if (wasAborted) {
+                    // Aborted turn — skip synth entirely so it can never add +300s after
+                    // a blown budget. Deliver exactly one graceful cap chunk.
+                    logger.warn(`[GoogleVertex] Tool call loop aborted mid-turn; ` +
+                        `returning a graceful cap message.`);
+                    finalText = buildToolLoopCapMessage(maxSteps, toolCallCount);
                 }
                 else {
-                    finalText = `[Tool execution limit reached after ${maxSteps} steps. The model continued requesting tool calls beyond the limit.]`;
+                    logger.warn(`[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.
+                    const synth = await this.synthesizeFinalAnswerWithoutTools(client, modelName, config, currentContents, useFinalResultTool, parseTimeout(options.timeout) ?? DEFAULT_GEMINI_STREAM_TIMEOUT_MS, effectiveSignal);
+                    if (synth.text) {
+                        synthesizedFinalAnswer = true;
+                        finalText = synth.text;
+                        incrementalTextChunks.push(synth.text);
+                        totalInputTokens += synth.inputTokens;
+                        totalOutputTokens += synth.outputTokens;
+                        if (synth.finishReason) {
+                            lastFinishReason = synth.finishReason;
+                        }
+                    }
+                    else {
+                        finalText = buildToolLoopCapMessage(maxSteps, toolCallCount);
+                    }
                 }
             }
-            else {
-                logger.warn(`[GoogleVertex] Tool call loop terminated after reaching maxSteps (${maxSteps}); ` +
-                    `returning text already gathered from prior steps.`);
-            }
+        }
+        finally {
+            clearTimeout(defensiveTimer);
+            options.abortSignal?.removeEventListener("abort", onCallerAbort);
         }
         // Unified finish reason: a step-cap exhaustion that did NOT end in a clean
         // synthesized answer is reported as "tool-calls" (the model still wanted
@@ -1990,173 +2061,230 @@ export class GoogleVertexProvider extends BaseProvider {
         // promptTokenCount is typically in the final chunk, candidatesTokenCount accumulates
         let totalInputTokens = 0;
         let totalOutputTokens = 0;
-        // Agentic loop for tool calling
-        while (step < maxSteps) {
-            step++;
-            logger.debug(`[GoogleVertex] Native SDK generate step ${step}/${maxSteps}`);
-            try {
-                // Use generateContentStream and collect all chunks (same as GoogleAIStudio)
-                const stream = await client.models.generateContentStream({
-                    model: modelName,
-                    contents: currentContents,
-                    config,
-                });
-                const stepFunctionCalls = [];
-                // Capture raw response parts including thoughtSignature
-                const rawResponseParts = [];
-                // Collect all chunks from stream
-                for await (const chunk of stream) {
-                    // Extract raw parts from candidates FIRST
-                    // This avoids using chunk.text which triggers SDK warning when
-                    // non-text parts (thoughtSignature, functionCall) are present
-                    const chunkRecord = chunk;
-                    const candidates = chunkRecord.candidates;
-                    const firstCandidate = candidates?.[0];
-                    // Capture the SDK finish reason (Bug 2: previously dropped). Last
-                    // non-empty value across chunks wins.
-                    const chunkFinishReason = firstCandidate?.finishReason;
-                    if (typeof chunkFinishReason === "string" && chunkFinishReason) {
-                        lastFinishReason = chunkFinishReason;
-                    }
-                    const chunkContent = firstCandidate?.content;
-                    if (chunkContent && Array.isArray(chunkContent.parts)) {
-                        rawResponseParts.push(...chunkContent.parts);
-                    }
-                    if (chunk.functionCalls) {
-                        stepFunctionCalls.push(...chunk.functionCalls);
-                    }
-                    // Extract usage metadata from chunk
-                    // promptTokenCount is typically in the final chunk, candidatesTokenCount accumulates
-                    const usageMetadata = chunkRecord.usageMetadata;
-                    if (usageMetadata) {
-                        // Take the latest promptTokenCount (usually only in final chunk)
-                        if (usageMetadata.promptTokenCount !== undefined &&
-                            usageMetadata.promptTokenCount > 0) {
-                            totalInputTokens = usageMetadata.promptTokenCount;
+        // Abort scaffolding (mirrors executeNativeAnthropicStream). The native
+        // Gemini SDK cancels via config.abortSignal, so drive an internal
+        // AbortController: the caller's signal and a defensive wall-clock timer
+        // both trip it, and every request/tool-exec receives effectiveSignal.
+        const streamTimeoutMs = parseTimeout(options.timeout) ?? DEFAULT_GEMINI_STREAM_TIMEOUT_MS;
+        const internalAbort = new AbortController();
+        const onCallerAbort = () => internalAbort.abort();
+        options.abortSignal?.addEventListener("abort", onCallerAbort);
+        const defensiveTimer = setTimeout(() => {
+            logger.warn(`[GoogleVertex] Native Gemini turn exceeded ${streamTimeoutMs}ms — aborting`);
+            internalAbort.abort();
+        }, streamTimeoutMs);
+        const effectiveSignal = internalAbort.signal;
+        if (options.abortSignal?.aborted) {
+            internalAbort.abort();
+        }
+        let wasAborted = false;
+        // Step-cap flags declared in the outer scope so the terminal block (also
+        // inside the try) and the finishReason mapping (after the finally) can
+        // both read them.
+        let hitStepLimit = false;
+        let synthesizedFinalAnswer = false;
+        try {
+            // Agentic loop for tool calling
+            while (step < maxSteps) {
+                if (effectiveSignal.aborted) {
+                    wasAborted = true;
+                    break;
+                }
+                step++;
+                logger.debug(`[GoogleVertex] Native SDK generate step ${step}/${maxSteps}`);
+                try {
+                    // Use generateContentStream and collect all chunks (same as GoogleAIStudio)
+                    const stream = await client.models.generateContentStream({
+                        model: modelName,
+                        contents: currentContents,
+                        config: { ...config, abortSignal: effectiveSignal },
+                    });
+                    const stepFunctionCalls = [];
+                    // Capture raw response parts including thoughtSignature
+                    const rawResponseParts = [];
+                    // Collect all chunks from stream
+                    for await (const chunk of stream) {
+                        // Extract raw parts from candidates FIRST
+                        // This avoids using chunk.text which triggers SDK warning when
+                        // non-text parts (thoughtSignature, functionCall) are present
+                        const chunkRecord = chunk;
+                        const candidates = chunkRecord.candidates;
+                        const firstCandidate = candidates?.[0];
+                        // Capture the SDK finish reason (Bug 2: previously dropped). Last
+                        // non-empty value across chunks wins.
+                        const chunkFinishReason = firstCandidate?.finishReason;
+                        if (typeof chunkFinishReason === "string" && chunkFinishReason) {
+                            lastFinishReason = chunkFinishReason;
                         }
-                        // Take the latest candidatesTokenCount (accumulates through chunks)
-                        if (usageMetadata.candidatesTokenCount !== undefined &&
-                            usageMetadata.candidatesTokenCount > 0) {
-                            totalOutputTokens = usageMetadata.candidatesTokenCount;
+                        const chunkContent = firstCandidate?.content;
+                        if (chunkContent && Array.isArray(chunkContent.parts)) {
+                            rawResponseParts.push(...chunkContent.parts);
+                        }
+                        if (chunk.functionCalls) {
+                            stepFunctionCalls.push(...chunk.functionCalls);
+                        }
+                        // Extract usage metadata from chunk
+                        // promptTokenCount is typically in the final chunk, candidatesTokenCount accumulates
+                        const usageMetadata = chunkRecord.usageMetadata;
+                        if (usageMetadata) {
+                            // Take the latest promptTokenCount (usually only in final chunk)
+                            if (usageMetadata.promptTokenCount !== undefined &&
+                                usageMetadata.promptTokenCount > 0) {
+                                totalInputTokens = usageMetadata.promptTokenCount;
+                            }
+                            // Take the latest candidatesTokenCount (accumulates through chunks)
+                            if (usageMetadata.candidatesTokenCount !== undefined &&
+                                usageMetadata.candidatesTokenCount > 0) {
+                                totalOutputTokens = usageMetadata.candidatesTokenCount;
+                            }
                         }
                     }
-                }
-                // Extract text from raw parts after stream completes
-                // This avoids SDK warning about non-text parts (thoughtSignature, functionCall)
-                const stepText = rawResponseParts
-                    .filter((part) => typeof part.text === "string")
-                    .map((part) => part.text)
-                    .join("");
-                // If no function calls, we're done
-                if (stepFunctionCalls.length === 0) {
-                    finalText = stepText;
-                    break;
-                }
-                // Check for final_result tool call - this is our structured output pattern
-                if (useFinalResultTool) {
-                    const finalResultCall = stepFunctionCalls.find((call) => call.name === "final_result");
-                    if (finalResultCall) {
-                        // Extract the structured output from final_result arguments
-                        finalResultStructuredOutput = finalResultCall.args;
-                        logger.debug("[GoogleVertex] Received final_result tool call with structured output (generate)", {
-                            outputKeys: Object.keys(finalResultStructuredOutput),
-                        });
-                        // Return the structured output as JSON text
-                        finalText = JSON.stringify(finalResultStructuredOutput);
+                    // Extract text from raw parts after stream completes
+                    // This avoids SDK warning about non-text parts (thoughtSignature, functionCall)
+                    const stepText = rawResponseParts
+                        .filter((part) => typeof part.text === "string")
+                        .map((part) => part.text)
+                        .join("");
+                    // If no function calls, we're done
+                    if (stepFunctionCalls.length === 0) {
+                        finalText = stepText;
                         break;
                     }
-                }
-                // Accumulate non-empty step text across steps so the
-                // maxSteps-exhaustion exit can surface the prose the model produced
-                // instead of a canned placeholder (Bug 1). Mirrors the Vertex-Claude
-                // loop's text accumulation.
-                accumulatedText = appendStepText(accumulatedText, stepText);
-                // Execute function calls
-                logger.debug(`[GoogleVertex] Generate executing ${stepFunctionCalls.length} function calls`);
-                // Add model response with ALL parts (including thoughtSignature) to history
-                // This preserves the thought_signature which is required for Gemini 3 multi-turn tool calling
-                currentContents.push({
-                    role: "model",
-                    parts: rawResponseParts.length > 0
-                        ? rawResponseParts
-                        : stepFunctionCalls.map((fc) => ({
-                            functionCall: fc,
-                        })),
-                });
-                // Execute each function and collect responses
-                const functionResponses = [];
-                const toolCallsBefore = allToolCalls.length;
-                const toolExecsBefore = toolExecutions.length;
-                // 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) {
-                    allToolCalls.push({ toolName: call.name, args: call.args });
-                    // Check if this tool has already exceeded retry limit
-                    const failedInfo = failedTools.get(call.name);
-                    if (failedInfo && failedInfo.count >= DEFAULT_TOOL_MAX_RETRIES) {
-                        logger.warn(`[GoogleVertex] Tool "${call.name}" has exceeded retry limit (${DEFAULT_TOOL_MAX_RETRIES}), skipping execution`);
-                        const errorOutput = {
-                            error: `TOOL_PERMANENTLY_FAILED: The tool "${call.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.`,
-                            status: "permanently_failed",
-                            do_not_retry: true,
-                        };
-                        toolExecutions.push({
-                            name: call.name,
-                            input: call.args,
-                            output: errorOutput,
-                        });
-                        functionResponses.push({
-                            functionResponse: {
-                                name: call.name,
-                                response: errorOutput,
-                            },
-                        });
-                        continue;
+                    // Check for final_result tool call - this is our structured output pattern
+                    if (useFinalResultTool) {
+                        const finalResultCall = stepFunctionCalls.find((call) => call.name === "final_result");
+                        if (finalResultCall) {
+                            // Extract the structured output from final_result arguments
+                            finalResultStructuredOutput = finalResultCall.args;
+                            logger.debug("[GoogleVertex] Received final_result tool call with structured output (generate)", {
+                                outputKeys: Object.keys(finalResultStructuredOutput),
+                            });
+                            // Return the structured output as JSON text
+                            finalText = JSON.stringify(finalResultStructuredOutput);
+                            break;
+                        }
                     }
-                    const execute = executeMap.get(call.name);
-                    if (execute) {
-                        try {
-                            // AI SDK Tool execute requires (args, options) - provide minimal options
-                            const toolOptions = {
-                                toolCallId: `${call.name}-${Date.now()}`,
-                                messages: [],
-                                abortSignal: undefined,
+                    // Accumulate non-empty step text across steps so the
+                    // maxSteps-exhaustion exit can surface the prose the model produced
+                    // instead of a canned placeholder (Bug 1). Mirrors the Vertex-Claude
+                    // loop's text accumulation.
+                    accumulatedText = appendStepText(accumulatedText, stepText);
+                    // Execute function calls
+                    logger.debug(`[GoogleVertex] Generate executing ${stepFunctionCalls.length} function calls`);
+                    // Add model response with ALL parts (including thoughtSignature) to history
+                    // This preserves the thought_signature which is required for Gemini 3 multi-turn tool calling
+                    currentContents.push({
+                        role: "model",
+                        parts: rawResponseParts.length > 0
+                            ? rawResponseParts
+                            : stepFunctionCalls.map((fc) => ({
+                                functionCall: fc,
+                            })),
+                    });
+                    // Execute each function and collect responses
+                    const functionResponses = [];
+                    const toolCallsBefore = allToolCalls.length;
+                    const toolExecsBefore = toolExecutions.length;
+                    // 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) {
+                        allToolCalls.push({ toolName: call.name, args: call.args });
+                        // Check if this tool has already exceeded retry limit
+                        const failedInfo = failedTools.get(call.name);
+                        if (failedInfo && failedInfo.count >= DEFAULT_TOOL_MAX_RETRIES) {
+                            logger.warn(`[GoogleVertex] Tool "${call.name}" has exceeded retry limit (${DEFAULT_TOOL_MAX_RETRIES}), skipping execution`);
+                            const errorOutput = {
+                                error: `TOOL_PERMANENTLY_FAILED: The tool "${call.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.`,
+                                status: "permanently_failed",
+                                do_not_retry: true,
                             };
-                            const execResult = await execute(call.args, toolOptions);
-                            // Track execution
                             toolExecutions.push({
                                 name: call.name,
                                 input: call.args,
-                                output: execResult,
+                                output: errorOutput,
                             });
                             functionResponses.push({
                                 functionResponse: {
                                     name: call.name,
-                                    response: { result: execResult },
+                                    response: errorOutput,
                                 },
                             });
+                            continue;
                         }
-                        catch (error) {
-                            const errorMessage = error instanceof Error ? error.message : "Unknown error";
-                            // Track this failure
-                            const currentFailInfo = failedTools.get(call.name) || {
-                                count: 0,
-                                lastError: "",
-                            };
-                            currentFailInfo.count++;
-                            currentFailInfo.lastError = errorMessage;
-                            failedTools.set(call.name, currentFailInfo);
-                            logger.warn(`[GoogleVertex] Tool "${call.name}" failed (attempt ${currentFailInfo.count}/${DEFAULT_TOOL_MAX_RETRIES}): ${errorMessage}`);
-                            // Determine if this is a permanent failure
-                            const isPermanentFailure = currentFailInfo.count >= DEFAULT_TOOL_MAX_RETRIES;
+                        const execute = executeMap.get(call.name);
+                        if (execute) {
+                            try {
+                                // AI SDK Tool execute requires (args, options) - provide minimal options
+                                const toolOptions = {
+                                    toolCallId: `${call.name}-${Date.now()}`,
+                                    messages: [],
+                                    abortSignal: effectiveSignal,
+                                };
+                                const execResult = await execute(call.args, toolOptions);
+                                // Track execution
+                                toolExecutions.push({
+                                    name: call.name,
+                                    input: call.args,
+                                    output: execResult,
+                                });
+                                functionResponses.push({
+                                    functionResponse: {
+                                        name: call.name,
+                                        response: { result: execResult },
+                                    },
+                                });
+                            }
+                            catch (error) {
+                                // An abort during tool execution ends the turn gracefully — it
+                                // must NOT be recorded as a spurious tool failure. Both checks
+                                // matter: effectiveSignal.aborted catches an abort WE triggered
+                                // (even if the throw isn't abort-shaped); isAbortError(error)
+                                // catches an abort-shaped throw (e.g. a tool raising AbortError)
+                                // even when the signal itself never fired.
+                                if (effectiveSignal.aborted || isAbortError(error)) {
+                                    wasAborted = true;
+                                    break;
+                                }
+                                const errorMessage = error instanceof Error ? error.message : "Unknown error";
+                                // Track this failure
+                                const currentFailInfo = failedTools.get(call.name) || {
+                                    count: 0,
+                                    lastError: "",
+                                };
+                                currentFailInfo.count++;
+                                currentFailInfo.lastError = errorMessage;
+                                failedTools.set(call.name, currentFailInfo);
+                                logger.warn(`[GoogleVertex] Tool "${call.name}" failed (attempt ${currentFailInfo.count}/${DEFAULT_TOOL_MAX_RETRIES}): ${errorMessage}`);
+                                // Determine if this is a permanent failure
+                                const isPermanentFailure = currentFailInfo.count >= DEFAULT_TOOL_MAX_RETRIES;
+                                const errorOutput = {
+                                    error: isPermanentFailure
+                                        ? `TOOL_PERMANENTLY_FAILED: The tool "${call.name}" has failed ${currentFailInfo.count} times with error: ${errorMessage}. This tool will not be retried. Please proceed without using this tool or inform the user that this functionality is unavailable.`
+                                        : `TOOL_EXECUTION_ERROR: ${errorMessage}. Retry attempt ${currentFailInfo.count}/${DEFAULT_TOOL_MAX_RETRIES}.`,
+                                    status: isPermanentFailure ? "permanently_failed" : "failed",
+                                    do_not_retry: isPermanentFailure,
+                                    retry_count: currentFailInfo.count,
+                                    max_retries: DEFAULT_TOOL_MAX_RETRIES,
+                                };
+                                toolExecutions.push({
+                                    name: call.name,
+                                    input: call.args,
+                                    output: errorOutput,
+                                });
+                                functionResponses.push({
+                                    functionResponse: {
+                                        name: call.name,
+                                        response: errorOutput,
+                                    },
+                                });
+                            }
+                        }
+                        else {
+                            // Tool not found is a permanent error
                             const errorOutput = {
-                                error: isPermanentFailure
-                                    ? `TOOL_PERMANENTLY_FAILED: The tool "${call.name}" has failed ${currentFailInfo.count} times with error: ${errorMessage}. This tool will not be retried. Please proceed without using this tool or inform the user that this functionality is unavailable.`
-                                    : `TOOL_EXECUTION_ERROR: ${errorMessage}. Retry attempt ${currentFailInfo.count}/${DEFAULT_TOOL_MAX_RETRIES}.`,
-                                status: isPermanentFailure ? "permanently_failed" : "failed",
-                                do_not_retry: isPermanentFailure,
-                                retry_count: currentFailInfo.count,
-                                max_retries: DEFAULT_TOOL_MAX_RETRIES,
+                                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,
                             };
                             toolExecutions.push({
                                 name: call.name,
@@ -2171,101 +2299,111 @@ export class GoogleVertexProvider extends BaseProvider {
                             });
                         }
                     }
-                    else {
-                        // Tool not found is a permanent error
-                        const errorOutput = {
-                            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,
-                        };
-                        toolExecutions.push({
-                            name: call.name,
-                            input: call.args,
-                            output: errorOutput,
-                        });
-                        functionResponses.push({
-                            functionResponse: {
-                                name: call.name,
-                                response: errorOutput,
-                            },
-                        });
+                    // An abort inside the tool-exec loop only breaks that inner for-loop.
+                    // Break the while too so no further model call is issued and control
+                    // reaches the terminal step-cap handling below.
+                    if (wasAborted) {
+                        break;
                     }
-                }
-                // Persist this step's tool calls/results into conversation memory.
-                // Without this, tool_call / tool_result rows never reach Redis and
-                // the chat-history UI loses every tool invocation. The first call
-                // of the step carries the step's `thoughtSignature` so Gemini 3 can
-                // match thinking patterns on replay.
-                const stepToolCalls = allToolCalls.slice(toolCallsBefore);
-                const stepToolExecs = toolExecutions.slice(toolExecsBefore);
-                if (stepToolCalls.length > 0 || stepToolExecs.length > 0) {
-                    const stepThoughtSig = extractThoughtSignature(rawResponseParts);
-                    withTimeout(this.handleToolExecutionStorage(stepToolCalls.map((tc, i) => ({
-                        toolName: tc.toolName,
-                        args: tc.args,
-                        ...(i === 0 && stepThoughtSig
-                            ? { thoughtSignature: stepThoughtSig }
-                            : {}),
-                        stepIndex: step,
-                    })), stepToolExecs.map((te) => ({
-                        toolName: te.name,
-                        output: te.output,
-                        stepIndex: step,
-                    })), options, new Date()), TOOL_STORAGE_TIMEOUT_MS, "tool storage write timed out").catch((error) => {
-                        logger.warn("[GoogleVertex] Failed to store native Gemini generate tool executions", {
-                            error: error instanceof Error ? error.message : String(error),
+                    // Persist this step's tool calls/results into conversation memory.
+                    // Without this, tool_call / tool_result rows never reach Redis and
+                    // the chat-history UI loses every tool invocation. The first call
+                    // of the step carries the step's `thoughtSignature` so Gemini 3 can
+                    // match thinking patterns on replay.
+                    const stepToolCalls = allToolCalls.slice(toolCallsBefore);
+                    const stepToolExecs = toolExecutions.slice(toolExecsBefore);
+                    if (stepToolCalls.length > 0 || stepToolExecs.length > 0) {
+                        const stepThoughtSig = extractThoughtSignature(rawResponseParts);
+                        withTimeout(this.handleToolExecutionStorage(stepToolCalls.map((tc, i) => ({
+                            toolName: tc.toolName,
+                            args: tc.args,
+                            ...(i === 0 && stepThoughtSig
+                                ? { thoughtSignature: stepThoughtSig }
+                                : {}),
+                            stepIndex: step,
+                        })), stepToolExecs.map((te) => ({
+                            toolName: te.name,
+                            output: te.output,
+                            stepIndex: step,
+                        })), options, new Date()), TOOL_STORAGE_TIMEOUT_MS, "tool storage write timed out").catch((error) => {
+                            logger.warn("[GoogleVertex] Failed to store native Gemini generate tool executions", {
+                                error: error instanceof Error ? error.message : String(error),
+                            });
                         });
+                    }
+                    // The @google/genai SDK only accepts "user" and "model" as valid
+                    // roles in contents — function/tool responses must use role: "user"
+                    // (matching the SDK's automaticFunctionCalling implementation and
+                    // the Google AI Studio path). See note in executeNativeGemini3Stream.
+                    currentContents.push({
+                        role: "user",
+                        parts: functionResponses,
                     });
                 }
-                // The @google/genai SDK only accepts "user" and "model" as valid
-                // roles in contents — function/tool responses must use role: "user"
-                // (matching the SDK's automaticFunctionCalling implementation and
-                // the Google AI Studio path). See note in executeNativeGemini3Stream.
-                currentContents.push({
-                    role: "user",
-                    parts: functionResponses,
-                });
-            }
-            catch (error) {
-                logger.error("[GoogleVertex] Native SDK generate error", error);
-                throw this.handleProviderError(error);
-            }
-        }
-        // Handle maxSteps termination — the loop exited because the step cap was
-        // reached while the model was still calling tools. Surface a real answer
-        // instead of the canned placeholder (Bug 1) and a meaningful finishReason
-        // (Bug 2).
-        let hitStepLimit = false;
-        let synthesizedFinalAnswer = false;
-        if (step >= maxSteps && !finalText) {
-            hitStepLimit = true;
-            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.`);
-                finalText = accumulatedText;
-            }
-            else {
-                // 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.`);
-                const synth = await this.synthesizeFinalAnswerWithoutTools(client, modelName, config, currentContents, useFinalResultTool, parseTimeout(options.timeout) ?? 300_000);
-                if (synth.text) {
-                    synthesizedFinalAnswer = true;
-                    finalText = synth.text;
-                    totalInputTokens += synth.inputTokens;
-                    totalOutputTokens += synth.outputTokens;
-                    if (synth.finishReason) {
-                        lastFinishReason = synth.finishReason;
+                catch (error) {
+                    // A mid-drain abort surfaces as an AbortError from the `for await`.
+                    // Break gracefully into the terminal block instead of re-throwing
+                    // (a re-throw would route the caller's abort into a second unbounded
+                    // fallback generate()). Dual check as with the inner catch:
+                    // effectiveSignal.aborted (a signal we tripped) OR isAbortError(error)
+                    // (an abort-shaped throw) — either means "stop", not a real failure.
+                    if (effectiveSignal.aborted || isAbortError(error)) {
+                        wasAborted = true;
+                        break;
                     }
+                    logger.error("[GoogleVertex] Native SDK generate error", error);
+                    throw this.handleProviderError(error);
+                }
+            }
+            // Handle maxSteps termination / abort — the loop exited because the step
+            // 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)) {
+                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.`);
+                    finalText = accumulatedText;
+                }
+                else if (wasAborted) {
+                    // Aborted turn — skip synth entirely so it can never add +300s after
+                    // a blown budget. Deliver a graceful cap message as ordinary prose.
+                    logger.warn(`[GoogleVertex] Generate tool call loop aborted mid-turn; ` +
+                        `returning a graceful cap message.`);
+                    finalText = buildToolLoopCapMessage(maxSteps, toolCallCount);
                 }
                 else {
-                    finalText = `[Tool execution limit reached after ${maxSteps} steps. The model continued requesting tool calls beyond the limit.]`;
+                    // 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.`);
+                    // 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.
+                    const synth = await this.synthesizeFinalAnswerWithoutTools(client, modelName, config, currentContents, useFinalResultTool, parseTimeout(options.timeout) ?? DEFAULT_GEMINI_STREAM_TIMEOUT_MS, effectiveSignal);
+                    if (synth.text) {
+                        synthesizedFinalAnswer = true;
+                        finalText = synth.text;
+                        totalInputTokens += synth.inputTokens;
+                        totalOutputTokens += synth.outputTokens;
+                        if (synth.finishReason) {
+                            lastFinishReason = synth.finishReason;
+                        }
+                    }
+                    else {
+                        finalText = buildToolLoopCapMessage(maxSteps, toolCallCount);
+                    }
                 }
             }
         }
+        finally {
+            clearTimeout(defensiveTimer);
+            options.abortSignal?.removeEventListener("abort", onCallerAbort);
+        }
         // Unified finish reason: a step-cap exhaustion that did NOT end in a clean
         // synthesized answer is reported as "tool-calls" (the model still wanted
         // tools) — NOT "length", which neurolink.ts treats as token truncation
@@ -2317,14 +2455,25 @@ export class GoogleVertexProvider extends BaseProvider {
      * (`final_result`) pattern was active, a trailing instruction countermands the
      * earlier "you MUST call final_result" directive so the model answers in plain
      * text. Never throws — returns empty text so the caller falls back to the
-     * placeholder, guaranteeing no new failure path.
+     * graceful cap message (buildToolLoopCapMessage), guaranteeing no new failure
+     * path.
      */
-    async synthesizeFinalAnswerWithoutTools(client, modelName, config, contents, useFinalResultTool, timeoutMs) {
+    // eslint-disable-next-line max-params -- trailing optional abortSignal keeps the positional call sites stable
+    async synthesizeFinalAnswerWithoutTools(client, modelName, config, contents, useFinalResultTool, timeoutMs, abortSignal) {
+        // Already aborted — never issue the synth request (would add +300s after a
+        // blown budget). Return empty so the caller maps to the graceful message.
+        if (abortSignal?.aborted) {
+            return { text: "", inputTokens: 0, outputTokens: 0 };
+        }
         try {
             // Shallow clone so the loop's config is never mutated; dropping the
             // top-level `tools` key is sufficient (nested thinkingConfig /
-            // systemInstruction are intentionally preserved).
-            const synthConfig = { ...config };
+            // systemInstruction are intentionally preserved). Fold in the abort
+            // signal so the synth request is cancellable too.
+            const synthConfig = {
+                ...config,
+                ...(abortSignal ? { abortSignal } : {}),
+            };
             delete synthConfig.tools;
             if (useFinalResultTool) {
                 const baseSystemInstruction = typeof synthConfig.systemInstruction === "string"
@@ -2686,6 +2835,13 @@ export class GoogleVertexProvider extends BaseProvider {
         // while generation is still in progress. Mirrors the executeStream
         // pattern in googleAiStudio.ts.
         const maxSteps = options.maxSteps || DEFAULT_MAX_STEPS;
+        // Reserve the LAST step of the budget for a forced final_result call when
+        // structured output is active — see the generate twin for the full
+        // rationale (tool_choice:"any" makes the text exit unreachable, so an
+        // un-reserved budget deadlocks into an empty stream).
+        const agenticStepBudget = useFinalResultTool
+            ? Math.max(maxSteps - 1, 0)
+            : maxSteps;
         const allToolCalls = [];
         const toolExecutions = [];
         const channel = createTextChannel();
@@ -2701,6 +2857,10 @@ export class GoogleVertexProvider extends BaseProvider {
         };
         const toolsUsedRef = [];
         const structuredOutputRef = {};
+        // Resolved after the background loop finishes; the StreamResult exposes it
+        // via a getter (consumers read it after draining the stream), mirroring
+        // the Gemini stream path's finishReason field.
+        const finishReasonRef = {};
         // Langfuse/OTel: the native SDK bypasses the Vercel AI SDK's
         // experimental_telemetry, so emit spans manually — one turn span, one
         // generation span per API call, one tool span per execution — all carrying
@@ -2737,6 +2897,11 @@ export class GoogleVertexProvider extends BaseProvider {
         });
         const turnContext = otelTrace.setSpan(otelContext.active(), turnSpan);
         let aggregatedTurnText = "";
+        // Count of characters ALREADY delivered to the consumer via live text
+        // deltas. aggregatedTurnText only reflects completed finalMessage()
+        // responses, so an aborted mid-answer call would otherwise look "empty"
+        // to the terminal handling even though the consumer saw partial prose.
+        let liveTextPushedLength = 0;
         // Anthropic prompt-cache token accounting, aggregated across loop steps.
         const turnCacheUsage = {
             read: 0,
@@ -2767,10 +2932,23 @@ export class GoogleVertexProvider extends BaseProvider {
         const loopPromise = (async () => {
             let step = 0;
             const currentMessages = [...messages];
+            // Step-cap / abort bookkeeping (mirrors the generate twin): read by the
+            // terminal recovery block after the loop and by the finishReason
+            // mapping written into finishReasonRef.
+            let wasAborted = false;
+            let hitStepLimit = false;
+            let synthesizedFinalAnswer = false;
+            let modelFinished = false;
+            let lastStopReason;
             try {
-                while (step < maxSteps) {
+                while (step < agenticStepBudget) {
+                    // Honor caller aborts BETWEEN steps: break into terminal handling
+                    // (one graceful cap chunk, clean close) instead of throwing —
+                    // channel.error would surface the caller's own abort as a stream
+                    // failure and route consumers into fallback retries.
                     if (options.abortSignal?.aborted) {
-                        throw new Error("Stream aborted by caller");
+                        wasAborted = true;
+                        break;
                     }
                     step++;
                     // One generation observation per API call: request in, content + usage out.
@@ -2834,6 +3012,7 @@ export class GoogleVertexProvider extends BaseProvider {
                                     generationSpan.setAttribute(LANGFUSE_ATTR.OBSERVATION_COMPLETION_START_TIME, new Date().toISOString());
                                 }
                                 channel.push(delta);
+                                liveTextPushedLength += delta.length;
                             }
                         });
                         // finalMessage() resolves AFTER message_stop. By then the listener
@@ -2853,6 +3032,15 @@ export class GoogleVertexProvider extends BaseProvider {
                             generationSpan.recordException(modelCallError);
                         }
                         generationSpan.end();
+                        // A mid-flight abort (caller signal or the defensive timer
+                        // tripping abortHandler) rejects finalMessage() with an
+                        // abort-shaped error. Break gracefully into the terminal handling
+                        // instead of routing it through channel.error as a failure.
+                        if (options.abortSignal?.aborted || isAbortError(modelCallError)) {
+                            activeStream = undefined;
+                            wasAborted = true;
+                            break;
+                        }
                         throw modelCallError;
                     }
                     activeStream = undefined;
@@ -2870,6 +3058,7 @@ export class GoogleVertexProvider extends BaseProvider {
                         usage.input += response.usage?.input_tokens || 0;
                         usage.output += response.usage?.output_tokens || 0;
                         usage.total = usage.input + usage.output;
+                        lastStopReason = response.stop_reason;
                         for (const block of response.content) {
                             if (block.type === "text" && typeof block.text === "string") {
                                 aggregatedTurnText += block.text;
@@ -2911,6 +3100,7 @@ export class GoogleVertexProvider extends BaseProvider {
                         if (finalResultCall) {
                             structuredOutputRef.value = finalResultCall.input;
                             channel.push(JSON.stringify(finalResultCall.input));
+                            modelFinished = true;
                             logger.debug("[GoogleVertex] Extracted structured output from final_result tool (stream)", { keys: Object.keys(finalResultCall.input) });
                             break;
                         }
@@ -2918,11 +3108,14 @@ export class GoogleVertexProvider extends BaseProvider {
                     // No tools — pure text turn. Listener already pushed all deltas;
                     // loop terminates and channel.close() flushes the consumer.
                     if (toolUseBlocks.length === 0) {
+                        modelFinished = true;
                         break;
                     }
                     // Tool execution loop. tool:start / tool:end events fire from
                     // ToolsManager's wrapped execute (ToolsManager.ts:355) — no inline
-                    // emit needed.
+                    // emit needed. The array also carries the trailing soft-budget
+                    // nudge text block appended below (tool_result blocks stay first,
+                    // as the Anthropic API requires).
                     const toolResults = [];
                     // Per-step bookkeeping for conversation-memory storage.
                     const stepStorageCalls = [];
@@ -3010,6 +3203,23 @@ export class GoogleVertexProvider extends BaseProvider {
                                 });
                             }
                             catch (err) {
+                                // An aborted tool call is a cancellation, not a tool failure —
+                                // end the span without recording an error execution/result and
+                                // break the turn.
+                                if (options.abortSignal?.aborted || isAbortError(err)) {
+                                    endToolSpan({ aborted: true });
+                                    // Keep persisted tool history paired: the call row was
+                                    // already pushed above, so record a neutral cancellation
+                                    // result (NOT an error) — an unpaired tool_use replayed on
+                                    // the next turn would be rejected by the Anthropic API.
+                                    stepStorageResults.push({
+                                        toolCallId: toolUse.id,
+                                        toolName: toolUse.name,
+                                        output: { aborted: true },
+                                    });
+                                    wasAborted = true;
+                                    break;
+                                }
                                 const errMsg = `Error executing tool "${toolUse.name}": ${err instanceof Error ? err.message : String(err)}`;
                                 const errorPayload = { error: errMsg };
                                 endToolSpan(errorPayload, errMsg);
@@ -3053,7 +3263,9 @@ export class GoogleVertexProvider extends BaseProvider {
                     }
                     // Persist this step's tool calls/results into conversation memory.
                     // Without this hook, tool rows never land in Redis and the
-                    // chat-history UI loses every tool invocation.
+                    // chat-history UI loses every tool invocation. Runs BEFORE the
+                    // abort break below so tools that DID complete in an aborted step
+                    // (real side effects) still reach the chat history.
                     if (stepStorageCalls.length > 0 || stepStorageResults.length > 0) {
                         withTimeout(this.handleToolExecutionStorage(stepStorageCalls.map((c) => ({ ...c, stepIndex: step })), stepStorageResults.map((r) => ({ ...r, stepIndex: step })), options, new Date()), TOOL_STORAGE_TIMEOUT_MS, "tool storage write timed out").catch((error) => {
                             logger.warn("[GoogleVertex] Failed to store native Anthropic stream tool executions", {
@@ -3061,6 +3273,26 @@ export class GoogleVertexProvider extends BaseProvider {
                             });
                         });
                     }
+                    // An abort inside the tool-exec loop only breaks that inner
+                    // for-loop. Break the while too so no further model call is issued
+                    // and control reaches the terminal step-cap handling below.
+                    if (wasAborted) {
+                        break;
+                    }
+                    // Soft budget nudge: with the step cap approaching, tell the model
+                    // to wrap up so the reserved forced-finalization call below stays a
+                    // fallback, not the norm. Rides as a trailing text block on the
+                    // tool_result user turn (cache-safe: it lives in the growing tail).
+                    const stepsRemaining = agenticStepBudget - step;
+                    if (stepsRemaining > 0 && stepsRemaining <= 3) {
+                        toolResults.push({
+                            type: "text",
+                            text: `NOTE: Only ${stepsRemaining} tool step(s) remain. Consolidate what you have and ` +
+                                (useFinalResultTool
+                                    ? "call final_result with your best answer."
+                                    : "provide your final answer."),
+                        });
+                    }
                     // Continue the loop: assistant turn + tool_result user turn.
                     // Filter server_tool_use blocks (Anthropic API rejects them in
                     // subsequent message turns).
@@ -3074,6 +3306,220 @@ export class GoogleVertexProvider extends BaseProvider {
                         content: toolResults,
                     });
                 }
+                // Terminal handling — the loop exited without a model-initiated
+                // finish (step budget exhausted, or the turn was aborted). Never end
+                // the stream empty: force the reserved final_result step on
+                // structured-output turns, synthesize a plain-text answer on tool
+                // turns, or push one graceful cap chunk. Mirrors the generate twin
+                // and the Gemini paths (ed289b7 / PR #1123). The finalization and
+                // backstop calls emit no per-call generation span (matching the
+                // Gemini synthesizeFinalAnswerWithoutTools precedent); their tokens
+                // still land in `usage` and the turn-span metadata.
+                if (!modelFinished) {
+                    // A caller abort that landed during the FINAL budgeted step's tool
+                    // execution leaves wasAborted=false (no loop-entry check runs after
+                    // a budget exit) — re-check before issuing any terminal model call.
+                    if (options.abortSignal?.aborted) {
+                        wasAborted = true;
+                    }
+                    const externalToolCallCount = allToolCalls.filter((tc) => tc.toolName !== "final_result").length;
+                    if (wasAborted) {
+                        // Budget already blown — never issue another model call. Deliver
+                        // exactly one graceful cap chunk if nothing reached the consumer
+                        // (live deltas already delivered count as "something reached").
+                        logger.warn("[GoogleVertex] Native Anthropic stream loop aborted mid-turn; returning a graceful cap message.");
+                        if (aggregatedTurnText.length === 0 &&
+                            liveTextPushedLength === 0 &&
+                            !structuredOutputRef.value) {
+                            const capMessage = buildToolLoopCapMessage(maxSteps, externalToolCallCount);
+                            channel.push(capMessage);
+                            aggregatedTurnText = capMessage;
+                        }
+                    }
+                    else if (useFinalResultTool) {
+                        hitStepLimit = true;
+                        logger.warn(`[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
+                            // final_result tool_use. Cache treatment is byte-identical to
+                            // loop steps. No text listener: forced tool calls stream no
+                            // text deltas, and the structured JSON is pushed once below.
+                            const cachedFinal = applyVertexAnthropicCacheBreakpoints({
+                                system: systemPromptWithSchema,
+                                tools,
+                                messages: currentMessages,
+                            });
+                            const finalizationStream = await client.messages.stream({
+                                ...requestParams,
+                                tool_choice: {
+                                    type: "tool",
+                                    name: "final_result",
+                                },
+                                ...(cachedFinal.system !== undefined && {
+                                    system: cachedFinal.system,
+                                }),
+                                ...(cachedFinal.tools &&
+                                    cachedFinal.tools.length > 0 && {
+                                    tools: cachedFinal.tools,
+                                }),
+                                messages: cachedFinal.messages,
+                            });
+                            // Mid-flight aborts are covered by the shared abortHandler via
+                            // activeStream; already-fired aborts were handled by the
+                            // terminal-entry re-check above.
+                            activeStream = finalizationStream;
+                            const response = await finalizationStream.finalMessage();
+                            activeStream = undefined;
+                            usage.input += response.usage?.input_tokens || 0;
+                            usage.output += response.usage?.output_tokens || 0;
+                            usage.total = usage.input + usage.output;
+                            turnCacheUsage.read +=
+                                response.usage?.cache_read_input_tokens ?? 0;
+                            turnCacheUsage.creation +=
+                                response.usage?.cache_creation_input_tokens ?? 0;
+                            turnCacheUsage.creation5m +=
+                                response.usage?.cache_creation?.ephemeral_5m_input_tokens ?? 0;
+                            turnCacheUsage.creation1h +=
+                                response.usage?.cache_creation?.ephemeral_1h_input_tokens ?? 0;
+                            lastStopReason = response.stop_reason;
+                            const forcedFinalResult = response.content.find((block) => block.type === "tool_use" && block.name === "final_result");
+                            if (forcedFinalResult) {
+                                structuredOutputRef.value = forcedFinalResult.input;
+                                channel.push(JSON.stringify(forcedFinalResult.input));
+                                synthesizedFinalAnswer = true;
+                                logger.debug("[GoogleVertex] Forced finalization returned structured output (stream)", { keys: Object.keys(forcedFinalResult.input) });
+                            }
+                            else {
+                                const capMessage = buildToolLoopCapMessage(maxSteps, externalToolCallCount);
+                                channel.push(capMessage);
+                                aggregatedTurnText += capMessage;
+                            }
+                        }
+                        catch (error) {
+                            activeStream = undefined;
+                            // An aborted finalization is a cancellation, not a step-cap
+                            // turn — keep finishReason mapping from lastStopReason.
+                            if (options.abortSignal?.aborted || isAbortError(error)) {
+                                hitStepLimit = false;
+                            }
+                            logger.warn("[GoogleVertex] Forced finalization call failed; falling back to cap message", {
+                                error: error instanceof Error ? error.message : String(error),
+                            });
+                            const capMessage = buildToolLoopCapMessage(maxSteps, externalToolCallCount);
+                            channel.push(capMessage);
+                            aggregatedTurnText += capMessage;
+                        }
+                    }
+                    else {
+                        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
+                            // as a single chunk (matching the Gemini stream synth). NOTE:
+                            // the tools array must stay in the request — Anthropic rejects
+                            // 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.`);
+                            try {
+                                const backstopSystem = (systemPromptWithSchema
+                                    ? systemPromptWithSchema + "\n\n"
+                                    : "") +
+                                    "Tool calling is no longer available for this turn. " +
+                                    "Provide your final answer directly as plain text now, " +
+                                    "using the information gathered so far.";
+                                const cachedBackstop = applyVertexAnthropicCacheBreakpoints({
+                                    system: backstopSystem,
+                                    tools,
+                                    messages: currentMessages,
+                                });
+                                const backstopStream = await client.messages.stream({
+                                    ...requestParams,
+                                    tool_choice: { type: "none" },
+                                    system: cachedBackstop.system,
+                                    ...(cachedBackstop.tools &&
+                                        cachedBackstop.tools.length > 0 && {
+                                        tools: cachedBackstop.tools,
+                                    }),
+                                    messages: cachedBackstop.messages,
+                                });
+                                activeStream = backstopStream;
+                                const response = await backstopStream.finalMessage();
+                                activeStream = undefined;
+                                usage.input += response.usage?.input_tokens || 0;
+                                usage.output += response.usage?.output_tokens || 0;
+                                usage.total = usage.input + usage.output;
+                                turnCacheUsage.read +=
+                                    response.usage?.cache_read_input_tokens ?? 0;
+                                turnCacheUsage.creation +=
+                                    response.usage?.cache_creation_input_tokens ?? 0;
+                                turnCacheUsage.creation5m +=
+                                    response.usage?.cache_creation?.ephemeral_5m_input_tokens ??
+                                        0;
+                                turnCacheUsage.creation1h +=
+                                    response.usage?.cache_creation?.ephemeral_1h_input_tokens ??
+                                        0;
+                                lastStopReason = response.stop_reason;
+                                const backstopText = response.content
+                                    .filter((block) => block.type === "text")
+                                    .map((b) => b.text)
+                                    .join("");
+                                if (backstopText) {
+                                    synthesizedFinalAnswer = true;
+                                    channel.push(backstopText);
+                                    aggregatedTurnText = backstopText;
+                                }
+                                else {
+                                    const capMessage = buildToolLoopCapMessage(maxSteps, externalToolCallCount);
+                                    channel.push(capMessage);
+                                    aggregatedTurnText = capMessage;
+                                }
+                            }
+                            catch (error) {
+                                activeStream = undefined;
+                                // An aborted backstop is a cancellation, not a step-cap
+                                // turn — keep finishReason mapping from lastStopReason.
+                                if (options.abortSignal?.aborted || isAbortError(error)) {
+                                    hitStepLimit = false;
+                                }
+                                logger.warn("[GoogleVertex] Tools-disabled backstop call failed; falling back to cap message", {
+                                    error: error instanceof Error ? error.message : String(error),
+                                });
+                                const capMessage = buildToolLoopCapMessage(maxSteps, externalToolCallCount);
+                                channel.push(capMessage);
+                                aggregatedTurnText = capMessage;
+                            }
+                        }
+                        // else: prose already streamed to the consumer across steps —
+                        // add nothing; finishReason "tool-calls" flags the capped turn.
+                    }
+                }
+                // Absolute backstop — never close the stream empty on a turn that
+                // ran tools (mirrors the generate twin's guard). Catches the
+                // model-finished-with-empty-content exit, which skips the terminal
+                // recovery above.
+                const deliveredNothing = aggregatedTurnText.length === 0 &&
+                    liveTextPushedLength === 0 &&
+                    !structuredOutputRef.value;
+                const externalToolCallTotal = allToolCalls.filter((tc) => tc.toolName !== "final_result").length;
+                if (deliveredNothing && externalToolCallTotal > 0) {
+                    const capMessage = buildToolLoopCapMessage(maxSteps, externalToolCallTotal);
+                    channel.push(capMessage);
+                    aggregatedTurnText = capMessage;
+                }
+                // Honest finish reason (same mapping as the generate twin): "length"
+                // takes precedence, a capped turn without a clean/forced answer is
+                // "tool-calls", everything else is "stop". Mirrored onto metadata
+                // (a mutable reference) because wrapper spreads snapshot the
+                // top-level getter before this line runs.
+                finishReasonRef.value =
+                    lastStopReason === "max_tokens"
+                        ? "length"
+                        : hitStepLimit && !synthesizedFinalAnswer
+                            ? "tool-calls"
+                            : "stop";
+                metadata.finishReason = finishReasonRef.value;
                 metadata.responseTime = Date.now() - startTime;
                 metadata.totalToolExecutions = allToolCalls.filter((tc) => tc.toolName !== "final_result").length;
                 // Surface cache metrics once, after the agentic loop, from the
@@ -3169,6 +3615,13 @@ export class GoogleVertexProvider extends BaseProvider {
             configurable: true,
             get: () => structuredOutputRef.value,
         });
+        // Resolved by the background loop right before channel.close(); consumers
+        // read it after draining the stream (same contract as usage/metadata).
+        Object.defineProperty(result, "finishReason", {
+            enumerable: true,
+            configurable: true,
+            get: () => finishReasonRef.value,
+        });
         return result;
     }
     /**
@@ -3432,8 +3885,21 @@ export class GoogleVertexProvider extends BaseProvider {
         };
         // Handle tool calling loop with max steps
         const maxSteps = options.maxSteps || DEFAULT_MAX_STEPS;
+        // Reserve the LAST step of the budget for a forced final_result call when
+        // structured output is active. tool_choice:"any" (set above) forces a tool
+        // call on every assistant turn, so the toolUseBlocks.length===0 text exit
+        // is structurally unreachable — without a reserved finalization step, a
+        // turn whose budget is consumed by other tool calls (runaway loop, or all
+        // tools failing) ends with content:"" and a masking finishReason "stop".
+        const agenticStepBudget = useFinalResultTool
+            ? Math.max(maxSteps - 1, 0)
+            : maxSteps;
         let step = 0;
         let finalText = "";
+        // Prose produced mid-loop alongside tool calls, accumulated across steps
+        // via appendStepText — surfaced if the step budget runs out (mirrors the
+        // Gemini paths' accumulatedText; last-step-only would drop earlier prose).
+        let accumulatedStepText = "";
         let structuredOutput;
         const allToolCalls = [];
         let totalInputTokens = 0;
@@ -3448,8 +3914,22 @@ export class GoogleVertexProvider extends BaseProvider {
         // (notably "length" on token truncation) — the legacy native path always
         // reported "stop", hiding truncation from callers.
         let lastStopReason;
+        // Step-cap / abort bookkeeping (mirrors the native Gemini loops): the
+        // terminal recovery block below and the finishReason mapping both read
+        // these to distinguish clean finishes, capped turns, and aborted turns.
+        let wasAborted = false;
+        let hitStepLimit = false;
+        let synthesizedFinalAnswer = false;
+        let modelFinished = false;
         const currentMessages = [...messages];
-        while (step < maxSteps) {
+        while (step < agenticStepBudget) {
+            // Honor caller aborts BETWEEN steps: break into terminal handling
+            // instead of throwing (a throw routes consumers into abortSignal-less
+            // fallback retries — observed in production as a 600s abort no-op).
+            if (options.abortSignal?.aborted) {
+                wasAborted = true;
+                break;
+            }
             step++;
             try {
                 // Bound the SDK wait so a stalled Vertex/Anthropic call can't hang
@@ -3466,6 +3946,9 @@ export class GoogleVertexProvider extends BaseProvider {
                     tools,
                     messages: currentMessages,
                 });
+                // The caller's abortSignal rides as an SDK request option so a
+                // mid-flight abort cancels the HTTP call itself (the SDK rejects with
+                // an abort-shaped error the per-step catch below turns into a break).
                 const response = await withTimeout(client.messages.create({
                     ...requestParams,
                     ...(cachedGenerate.system !== undefined && {
@@ -3476,7 +3959,7 @@ export class GoogleVertexProvider extends BaseProvider {
                         tools: cachedGenerate.tools,
                     }),
                     messages: cachedGenerate.messages,
-                }), generateTimeoutMs, "Anthropic generate timed out");
+                }, { signal: options.abortSignal }), generateTimeoutMs, "Anthropic generate timed out");
                 // Update token counts. input_tokens is the uncached remainder; cache
                 // reads/writes are reported separately and accumulated here so the
                 // result reflects the full picture.
@@ -3495,6 +3978,7 @@ export class GoogleVertexProvider extends BaseProvider {
                         // Extract structured output and convert to JSON string for finalText
                         structuredOutput = finalResultCall.input;
                         finalText = JSON.stringify(structuredOutput);
+                        modelFinished = true;
                         logger.debug("[GoogleVertex] Extracted structured output from final_result tool (generate)", { keys: Object.keys(structuredOutput) });
                         break; // We have the structured output, we're done
                     }
@@ -3504,10 +3988,13 @@ export class GoogleVertexProvider extends BaseProvider {
                 const responseText = textBlocks.map((b) => b.text).join("");
                 if (toolUseBlocks.length === 0) {
                     // No tool calls, we're done
-                    finalText = responseText || finalText;
+                    finalText = responseText || accumulatedStepText;
+                    modelFinished = true;
                     break;
                 }
-                // Handle tool calls
+                // Handle tool calls. The array also carries the trailing soft-budget
+                // nudge text block appended below (tool_result blocks stay first, as
+                // the Anthropic API requires).
                 const toolResults = [];
                 // Per-step bookkeeping for conversation-memory storage. Tracks calls
                 // and results for ONLY the tools fired in this step so the storage
@@ -3558,6 +4045,21 @@ export class GoogleVertexProvider extends BaseProvider {
                             });
                         }
                         catch (err) {
+                            // An aborted tool call is a cancellation, not a tool failure —
+                            // break the turn without recording an error execution/result.
+                            if (options.abortSignal?.aborted || isAbortError(err)) {
+                                // Keep persisted tool history paired: the call row was
+                                // already pushed above, so record a neutral cancellation
+                                // result (NOT an error) — an unpaired tool_use replayed on
+                                // the next turn would be rejected by the Anthropic API.
+                                stepStorageResults.push({
+                                    toolCallId: toolUse.id,
+                                    toolName: toolUse.name,
+                                    output: { aborted: true },
+                                });
+                                wasAborted = true;
+                                break;
+                            }
                             const errMsg = `Error executing tool "${toolUse.name}": ${err instanceof Error ? err.message : String(err)}`;
                             const errorPayload = { error: errMsg };
                             toolExecutions.push({
@@ -3601,6 +4103,8 @@ export class GoogleVertexProvider extends BaseProvider {
                 // Without this, tool_call / tool_result rows never reach Redis and
                 // the chat-history UI loses every tool invocation.
                 // Fire-and-forget — storage failures must not break generation.
+                // Runs BEFORE the abort break below so tools that DID complete in an
+                // aborted step (real side effects) still reach the chat history.
                 if (stepStorageCalls.length > 0 || stepStorageResults.length > 0) {
                     withTimeout(this.handleToolExecutionStorage(stepStorageCalls.map((c) => ({ ...c, stepIndex: step })), stepStorageResults.map((r) => ({ ...r, stepIndex: step })), options, new Date()), TOOL_STORAGE_TIMEOUT_MS, "tool storage write timed out").catch((error) => {
                         logger.warn("[GoogleVertex] Failed to store native Anthropic generate tool executions", {
@@ -3608,6 +4112,26 @@ export class GoogleVertexProvider extends BaseProvider {
                         });
                     });
                 }
+                // An abort inside the tool-exec loop only breaks that inner for-loop.
+                // Break the while too so no further model call is issued and control
+                // reaches the terminal step-cap handling below.
+                if (wasAborted) {
+                    break;
+                }
+                // Soft budget nudge: with the step cap approaching, tell the model to
+                // wrap up so the reserved forced-finalization call below stays a
+                // fallback, not the norm. Rides as a trailing text block on the
+                // tool_result user turn (cache-safe: it lives in the growing tail).
+                const stepsRemaining = agenticStepBudget - step;
+                if (stepsRemaining > 0 && stepsRemaining <= 3) {
+                    toolResults.push({
+                        type: "text",
+                        text: `NOTE: Only ${stepsRemaining} tool step(s) remain. Consolidate what you have and ` +
+                            (useFinalResultTool
+                                ? "call final_result with your best answer."
+                                : "provide your final answer."),
+                    });
+                }
                 // Add assistant message and tool results to continue the loop
                 // Filter out server_tool_use blocks that the Anthropic API doesn't accept in messages
                 const assistantContent = response.content.filter((block) => block.type !== "server_tool_use");
@@ -3619,25 +4143,193 @@ export class GoogleVertexProvider extends BaseProvider {
                     role: "user",
                     content: toolResults,
                 });
-                // Store last text in case we hit max steps
-                if (responseText) {
-                    finalText = responseText;
-                }
+                // Accumulate the step's prose so a capped turn can still surface it —
+                // finalText is reserved for model-initiated finishes.
+                accumulatedStepText = appendStepText(accumulatedStepText, responseText);
             }
             catch (error) {
+                // A mid-request abort surfaces as an abort-shaped SDK rejection (we
+                // pass options.abortSignal as the request signal above). Break
+                // gracefully into the terminal handling instead of re-throwing — a
+                // re-throw routes the caller's abort into abortSignal-less fallback
+                // retries. Dual check as in the Gemini loops: the caller's signal OR
+                // an abort-shaped error either way means "stop", not a real failure.
+                if (options.abortSignal?.aborted || isAbortError(error)) {
+                    wasAborted = true;
+                    break;
+                }
                 logger.error("[GoogleVertex] Native Anthropic SDK generate error", error);
                 throw this.handleProviderError(error);
             }
         }
+        // Terminal handling — the loop exited without a model-initiated finish
+        // (step budget exhausted, or the turn was aborted). Never return "":
+        // force the reserved final_result step on structured-output turns,
+        // synthesize a plain-text answer on tool turns, or fall back to a
+        // graceful cap message. Mirrors the Gemini paths (ed289b7 / PR #1123).
+        if (!modelFinished && !finalText) {
+            // A caller abort that landed during the FINAL budgeted step's tool
+            // execution leaves wasAborted=false (no loop-entry check runs after a
+            // budget exit) — re-check before issuing any terminal model call.
+            if (options.abortSignal?.aborted) {
+                wasAborted = true;
+            }
+            const externalToolCallCount = allToolCalls.filter((tc) => tc.toolName !== "final_result").length;
+            if (wasAborted) {
+                // Budget already blown — never issue another model call; prefer the
+                // prose the model already produced (mirrors the Gemini abort path),
+                // else answer with a graceful cap message. finishReason keeps mapping
+                // from lastStopReason (an aborted turn is not a step-cap turn).
+                logger.warn("[GoogleVertex] Native Anthropic generate loop aborted mid-turn; returning gathered text or a graceful cap message.");
+                finalText =
+                    accumulatedStepText ||
+                        buildToolLoopCapMessage(maxSteps, externalToolCallCount);
+            }
+            else if (useFinalResultTool) {
+                hitStepLimit = true;
+                logger.warn(`[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
+                    // final_result tool_use. Cache treatment is byte-identical to loop
+                    // steps (same applyVertexAnthropicCacheBreakpoints on the same
+                    // stable system/tools prefix), so caching is unaffected.
+                    const cachedFinal = applyVertexAnthropicCacheBreakpoints({
+                        system: systemPromptWithSchema,
+                        tools,
+                        messages: currentMessages,
+                    });
+                    const response = await withTimeout(client.messages.create({
+                        ...requestParams,
+                        tool_choice: {
+                            type: "tool",
+                            name: "final_result",
+                        },
+                        ...(cachedFinal.system !== undefined && {
+                            system: cachedFinal.system,
+                        }),
+                        ...(cachedFinal.tools &&
+                            cachedFinal.tools.length > 0 && {
+                            tools: cachedFinal.tools,
+                        }),
+                        messages: cachedFinal.messages,
+                    }, { signal: options.abortSignal }), generateTimeoutMs, "Anthropic finalization call timed out");
+                    totalInputTokens += response.usage?.input_tokens || 0;
+                    totalOutputTokens += response.usage?.output_tokens || 0;
+                    totalCacheReadTokens += response.usage?.cache_read_input_tokens || 0;
+                    totalCacheCreationTokens +=
+                        response.usage?.cache_creation_input_tokens || 0;
+                    lastStopReason = response.stop_reason;
+                    const forcedFinalResult = response.content.find((block) => block.type === "tool_use" && block.name === "final_result");
+                    if (forcedFinalResult) {
+                        structuredOutput = forcedFinalResult.input;
+                        finalText = JSON.stringify(structuredOutput);
+                        synthesizedFinalAnswer = true;
+                        logger.debug("[GoogleVertex] Forced finalization returned structured output (generate)", { keys: Object.keys(structuredOutput) });
+                    }
+                    else {
+                        finalText = buildToolLoopCapMessage(maxSteps, externalToolCallCount);
+                    }
+                }
+                catch (error) {
+                    // An aborted finalization is a cancellation, not a step-cap turn —
+                    // keep finishReason mapping from lastStopReason, not "tool-calls".
+                    if (options.abortSignal?.aborted || isAbortError(error)) {
+                        hitStepLimit = false;
+                    }
+                    logger.warn("[GoogleVertex] Forced finalization call failed; falling back to cap message", { error: error instanceof Error ? error.message : String(error) });
+                    finalText = buildToolLoopCapMessage(maxSteps, externalToolCallCount);
+                }
+            }
+            else {
+                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.`);
+                    finalText = accumulatedStepText;
+                }
+                else {
+                    // Pure tool-loop with no text: one tools-disabled call so the model
+                    // answers from the gathered tool results (Anthropic twin of the
+                    // Gemini synthesizeFinalAnswerWithoutTools). NOTE: the tools array
+                    // must stay in the request — Anthropic rejects requests whose
+                    // 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.`);
+                    try {
+                        const backstopSystem = (systemPromptWithSchema ? systemPromptWithSchema + "\n\n" : "") +
+                            "Tool calling is no longer available for this turn. Provide " +
+                            "your final answer directly as plain text now, using the " +
+                            "information gathered so far.";
+                        const cachedBackstop = applyVertexAnthropicCacheBreakpoints({
+                            system: backstopSystem,
+                            tools,
+                            messages: currentMessages,
+                        });
+                        const response = await withTimeout(client.messages.create({
+                            ...requestParams,
+                            tool_choice: { type: "none" },
+                            system: cachedBackstop.system,
+                            ...(cachedBackstop.tools &&
+                                cachedBackstop.tools.length > 0 && {
+                                tools: cachedBackstop.tools,
+                            }),
+                            messages: cachedBackstop.messages,
+                        }, { signal: options.abortSignal }), generateTimeoutMs, "Anthropic backstop call timed out");
+                        totalInputTokens += response.usage?.input_tokens || 0;
+                        totalOutputTokens += response.usage?.output_tokens || 0;
+                        totalCacheReadTokens +=
+                            response.usage?.cache_read_input_tokens || 0;
+                        totalCacheCreationTokens +=
+                            response.usage?.cache_creation_input_tokens || 0;
+                        lastStopReason = response.stop_reason;
+                        const backstopText = response.content
+                            .filter((block) => block.type === "text")
+                            .map((b) => b.text)
+                            .join("");
+                        if (backstopText) {
+                            synthesizedFinalAnswer = true;
+                            finalText = backstopText;
+                        }
+                        else {
+                            finalText = buildToolLoopCapMessage(maxSteps, externalToolCallCount);
+                        }
+                    }
+                    catch (error) {
+                        // An aborted backstop is a cancellation, not a step-cap turn —
+                        // keep finishReason mapping from lastStopReason, not "tool-calls".
+                        if (options.abortSignal?.aborted || isAbortError(error)) {
+                            hitStepLimit = false;
+                        }
+                        logger.warn("[GoogleVertex] Tools-disabled backstop call failed; falling back to cap message", {
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                        finalText = buildToolLoopCapMessage(maxSteps, externalToolCallCount);
+                    }
+                }
+            }
+        }
         const responseTime = Date.now() - startTime;
         const externalToolCalls = allToolCalls.filter((tc) => tc.toolName !== "final_result");
         const externalToolExecutions = toolExecutions.filter((te) => te.name !== "final_result");
+        // Absolute backstop — no code path may surface empty content on a turn
+        // that ran tools (the consumer-facing "empty response" incident shape).
+        if (!finalText && externalToolCalls.length > 0) {
+            finalText = buildToolLoopCapMessage(maxSteps, externalToolCalls.length);
+        }
         const result = {
             content: finalText,
-            // Surface truncation: Anthropic "max_tokens" → unified "length" so the
-            // SDK boundary can flag/observe incomplete structured output. Anything
-            // else (end_turn / stop_sequence / tool_use) is a normal stop.
-            finishReason: lastStopReason === "max_tokens" ? "length" : "stop",
+            // Honest finish reason. "length" (token truncation) takes precedence; a
+            // step-cap exhaustion without a clean/forced answer surfaces as
+            // "tool-calls" (aligned with the Gemini paths, so consumers detect
+            // capped turns uniformly); everything else — including a successful
+            // forced finalization or backstop synthesis — is a normal "stop".
+            finishReason: lastStopReason === "max_tokens"
+                ? "length"
+                : hitStepLimit && !synthesizedFinalAnswer
+                    ? "tool-calls"
+                    : "stop",
             provider: this.providerName,
             model: modelName,
             usage: {
@@ -4106,10 +4798,35 @@ export class GoogleVertexProvider extends BaseProvider {
                 }
             },
         };
-        return {
+        return this.preserveStreamResultAccessors(result, {
             ...result,
             stream: wrappedIterable,
-        };
+        });
+    }
+    /**
+     * Re-apply getter-based accessor properties from a source StreamResult onto
+     * a wrapper copy. Wrapper spreads (`{ ...result }`) invoke and SNAPSHOT
+     * enumerable getters at wrap time — for background-loop streams (the native
+     * Anthropic path) that resolve finishReason / structuredOutput / toolCalls
+     * only as the consumer drains, the snapshot is permanently undefined/empty.
+     * Copying the accessor descriptors keeps the wrapped result live. Results
+     * built from plain data properties (the buffered Gemini paths) have no
+     * getters and pass through untouched.
+     */
+    preserveStreamResultAccessors(source, wrapped) {
+        for (const key of [
+            "finishReason",
+            "structuredOutput",
+            "toolCalls",
+            "toolsUsed",
+            "toolExecutions",
+        ]) {
+            const descriptor = Object.getOwnPropertyDescriptor(source, key);
+            if (descriptor?.get) {
+                Object.defineProperty(wrapped, key, descriptor);
+            }
+        }
+        return wrapped;
     }
     /**
      * Attach `gen_ai.usage.*` and `neurolink.cost` attributes to a span.