@juspay/neurolink 10.10.6 → 10.10.7

package/dist/lib/providers/googleAiStudio/client.d.ts

@@ -2,37 +2,6 @@ import { type AIProviderName } from "../../constants/enums.js";
 import { BaseProvider } from "../../core/baseProvider.js";
 import type { ZodUnknownSchema, EnhancedGenerateResult, TextGenerationOptions, StreamOptions, StreamResult } from "../../types/index.js";
 import type { LanguageModel, Schema } from "../../types/index.js";
-/**
- * Google AI Studio provider implementation using BaseProvider
- * Migrated from original GoogleAIStudio class to new factory pattern
- *
- * @important Structured Output Limitation
- * Google Gemini models cannot combine function calling (tools) with structured
- * output (JSON schema). When using schemas with output.format: "json", you MUST
- * set disableTools: true.
- *
- * Error without disableTools:
- * "Function calling with a response mime type: 'application/json' is unsupported"
- *
- * This is a Google API limitation documented at:
- * https://ai.google.dev/gemini-api/docs/function-calling
- *
- * @example
- * ```typescript
- * // ✅ Correct usage with schemas
- * const provider = new GoogleAIStudioProvider("gemini-2.5-flash");
- * const result = await provider.generate({
- *   input: { text: "Analyze data" },
- *   schema: MySchema,
- *   output: { format: "json" },
- *   disableTools: true  // Required
- * });
- * ```
- *
- * @note Gemini 3 Pro Preview (November 2025) will support combining tools + schemas
- * @note "Too many states for serving" errors can occur with complex schemas + tools.
- *       Solution: Simplify schema or use disableTools: true
- */
 export declare class GoogleAIStudioProvider extends BaseProvider {
     private credentials?;
     constructor(modelName?: string, sdk?: unknown, credentials?: {

package/dist/lib/providers/googleAiStudio/client.js

@@ -6,12 +6,14 @@ import { ATTR, tracers, withClientSpan, withClientStreamSpan, withSpan, } from "
 import { AuthenticationError, InvalidModelError, NetworkError, ProviderError, RateLimitError, } from "../../types/index.js";
 import { ERROR_CODES, NeuroLinkError } from "../../utils/errorHandling.js";
 import { logger } from "../../utils/logger.js";
+import { GEMINI_ELISION_NOTE, planGeminiLoopReclaim, previewGeminiToolResponseText, } from "../../context/geminiLoopGuard.js";
+import { getAvailableInputTokens, getContextWindowSize, } from "../../constants/contextWindows.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../../utils/timeout.js";
 import { withTimeout } from "../../utils/async/index.js";
 import { estimateTokens } from "../../utils/tokenEstimation.js";
 import { transformToolExecutions } from "../../utils/transformationUtils.js";
 import { resolveToolExecutionRecords } from "../../core/toolExecutionRecorder.js";
-import { buildGeminiResponseSchema, buildNativeConfig, buildNativeToolDeclarations, collectStreamChunks, collectStreamChunksIncremental, computeMaxSteps, createTextChannel, buildUserPartsWithMultimodal, executeNativeToolCalls, extractTextFromParts, extractThoughtSignature, handleMaxStepsTermination, prependConversationMessages, pushModelResponseToHistory, refreshNativeToolDeclarations, DedupExecuteMap, } from "../googleNativeGemini3/index.js";
+import { buildGeminiResponseSchema, buildNativeConfig, buildNativeToolDeclarations, collectStreamChunks, collectStreamChunksIncremental, computeMaxSteps, createContextGuard, createTextChannel, buildUserPartsWithMultimodal, executeNativeToolCalls, extractTextFromParts, extractThoughtSignature, handleMaxStepsTermination, prependConversationMessages, pushModelResponseToHistory, refreshNativeToolDeclarations, DedupExecuteMap, } from "../googleNativeGemini3/index.js";
 import { createProxyFetch } from "../../proxy/proxyFetch.js";
 // Google AI Live API types now imported from ../types/providerSpecific.js
 // Import proper types for multimodal message handling
@@ -69,6 +71,74 @@ async function createGoogleGenAIClient(apiKey) {
  * @note "Too many states for serving" errors can occur with complex schemas + tools.
  *       Solution: Simplify schema or use disableTools: true
  */
+/**
+ * Reclaim context from an AI Studio loop history IN PLACE.
+ *
+ * This loop had NO in-turn guard at all — it appended a model turn plus a tool
+ * turn every step with nothing bounding growth, so a long agentic run walked
+ * into a provider "context length exceeded" and lost every completed step.
+ * Shares its reclaim policy with the other provider loops via loopGuardCore.
+ *
+ * Returns true when something was reclaimed.
+ */
+function reclaimAiStudioContext(contents, modelName, observedPromptTokens) {
+    const plan = planGeminiLoopReclaim({
+        contents,
+        availableInputTokens: getAvailableInputTokens("googleAiStudio", modelName),
+        provider: "googleAiStudio",
+        ...(observedPromptTokens ? { observedPromptTokens } : {}),
+    });
+    if (!plan) {
+        return false;
+    }
+    const dropSet = new Set(plan.drop);
+    const truncateSet = new Set(plan.truncate);
+    const rebuilt = [];
+    for (let i = 0; i < contents.length; i++) {
+        if (dropSet.has(i)) {
+            continue;
+        }
+        const content = contents[i];
+        if (truncateSet.has(i) && Array.isArray(content.parts)) {
+            rebuilt.push({
+                ...content,
+                parts: content.parts.map((part) => {
+                    const record = part;
+                    if (!record.functionResponse) {
+                        return part;
+                    }
+                    const text = JSON.stringify(record.functionResponse.response) ?? "";
+                    if (text.length <= 2048) {
+                        return part;
+                    }
+                    return {
+                        functionResponse: {
+                            name: record.functionResponse.name,
+                            response: { result: previewGeminiToolResponseText(text) },
+                        },
+                    };
+                }),
+            });
+            continue;
+        }
+        rebuilt.push(content);
+    }
+    if (dropSet.size > 0) {
+        let noteIndex = rebuilt.findIndex((c) => Array.isArray(c.parts) &&
+            c.parts.some((part) => !!part.functionCall ||
+                !!part.functionResponse));
+        if (noteIndex < 0) {
+            noteIndex = Math.min(1, rebuilt.length);
+        }
+        rebuilt.splice(noteIndex, 0, {
+            role: "user",
+            parts: [{ text: GEMINI_ELISION_NOTE }],
+        });
+    }
+    contents.length = 0;
+    contents.push(...rebuilt);
+    return true;
+}
 export class GoogleAIStudioProvider extends BaseProvider {
     credentials;
     constructor(modelName, sdk, credentials) {
@@ -595,9 +665,27 @@ export class GoogleAIStudioProvider extends BaseProvider {
                     let step = 0;
                     let completedWithFinalAnswer = false;
                     const failedTools = new Map();
+                    // Cheap trigger for the in-turn reclaim, mirroring the Vertex twin.
+                    // Planning serializes the WHOLE accumulated history to estimate it,
+                    // so running it unconditionally charges that once per step for the
+                    // life of the turn; the guard tracks real prompt counts plus
+                    // measured growth instead, and it supplies the observed count that
+                    // calibrates the planner's char estimate.
+                    const contextGuard = createContextGuard(getContextWindowSize("googleAiStudio", modelName));
                     try {
                         // Agentic loop for tool calling
                         while (step < maxSteps) {
+                            // In-turn context guard: this loop appends a model turn plus a
+                            // tool turn every step with nothing bounding growth. No-op
+                            // while the request still fits, so a loop that fits never pays
+                            // a cache invalidation. Step 0 still plans unconditionally —
+                            // the guard has no usage to go on yet, and the incoming history
+                            // can already be oversized before the first call.
+                            if (step === 0 || contextGuard.shouldStop()) {
+                                if (reclaimAiStudioContext(currentContents, modelName, contextGuard.projectedNextPromptTokens)) {
+                                    contextGuard.resetAfterReclaim();
+                                }
+                            }
                             if (composedSignal?.aborted) {
                                 throw composedSignal.reason instanceof Error
                                     ? composedSignal.reason
@@ -629,6 +717,10 @@ export class GoogleAIStudioProvider extends BaseProvider {
                                 totalOutputTokens += chunkResult.outputTokens;
                                 totalCacheReadTokens += chunkResult.cacheReadTokens ?? 0;
                                 totalReasoningTokens += chunkResult.reasoningTokens ?? 0;
+                                // `inputTokens` is this step's promptTokenCount — the FULL
+                                // prompt size for the request just made, which is what the
+                                // guard projects the next request from.
+                                contextGuard.noteUsage(chunkResult.inputTokens, chunkResult.outputTokens);
                                 const stepText = extractTextFromParts(chunkResult.rawResponseParts);
                                 // If no function calls, this was the final step — channel
                                 // already received all text parts incrementally.
@@ -691,6 +783,14 @@ export class GoogleAIStudioProvider extends BaseProvider {
                                     role: "user",
                                     parts: functionResponses,
                                 });
+                                // Project this step's growth: the appended tool results ride
+                                // the next prompt, which the provider has not reported on yet.
+                                try {
+                                    contextGuard.noteAppendedChars(JSON.stringify(functionResponses).length);
+                                }
+                                catch {
+                                    /* estimation is best-effort — never break the loop */
+                                }
                             }
                             catch (error) {
                                 logger.error("[GoogleAIStudio] Native SDK error", error);
@@ -877,8 +977,16 @@ export class GoogleAIStudioProvider extends BaseProvider {
                 const toolExecutions = [];
                 let step = 0;
                 const failedTools = new Map();
+                // Cheap reclaim trigger — see the stream twin.
+                const contextGuard = createContextGuard(getContextWindowSize("googleAiStudio", modelName));
                 // Agentic loop for tool calling
                 while (step < maxSteps) {
+                    // In-turn context guard — see the stream twin.
+                    if (step === 0 || contextGuard.shouldStop()) {
+                        if (reclaimAiStudioContext(currentContents, modelName, contextGuard.projectedNextPromptTokens)) {
+                            contextGuard.resetAfterReclaim();
+                        }
+                    }
                     if (composedSignal?.aborted) {
                         throw composedSignal.reason instanceof Error
                             ? composedSignal.reason
@@ -904,6 +1012,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
                         totalOutputTokens += chunkResult.outputTokens;
                         totalCacheReadTokens += chunkResult.cacheReadTokens ?? 0;
                         totalReasoningTokens += chunkResult.reasoningTokens ?? 0;
+                        contextGuard.noteUsage(chunkResult.inputTokens, chunkResult.outputTokens);
                         const stepText = extractTextFromParts(chunkResult.rawResponseParts);
                         // If no function calls, we're done
                         if (chunkResult.stepFunctionCalls.length === 0) {
@@ -961,6 +1070,14 @@ export class GoogleAIStudioProvider extends BaseProvider {
                             role: "user",
                             parts: functionResponses,
                         });
+                        // Project this step's growth: the appended tool results ride
+                        // the next prompt, which the provider has not reported on yet.
+                        try {
+                            contextGuard.noteAppendedChars(JSON.stringify(functionResponses).length);
+                        }
+                        catch {
+                            /* estimation is best-effort — never break the loop */
+                        }
                     }
                     catch (error) {
                         logger.error("[GoogleAIStudio] Native SDK generate error", error);

package/dist/lib/providers/googleNativeGemini3/utils.d.ts

@@ -385,6 +385,15 @@ export declare function createContextGuard(contextWindowTokens: number, threshol
      * results, nudge text) using the ~4 chars/token heuristic.
      */
     noteAppendedChars(chars: number): void;
+    /**
+     * Clear the projection after the caller has reclaimed context.
+     *
+     * The observed prompt size reflects the pre-reclaim conversation, so
+     * leaving it in place would keep `shouldStop()` true forever and defeat
+     * the reclaim. Resetting to the fail-open state means the guard stays
+     * quiet until the next real usage report re-establishes the truth.
+     */
+    resetAfterReclaim(): void;
     /** True when issuing another model call risks crossing the threshold. */
     shouldStop(): boolean;
 };

package/dist/lib/providers/googleNativeGemini3/utils.js

@@ -1229,6 +1229,18 @@ export function createContextGuard(contextWindowTokens, thresholdRatio = DEFAULT
                 projectedGrowthTokens += Math.ceil(chars / 4);
             }
         },
+        /**
+         * Clear the projection after the caller has reclaimed context.
+         *
+         * The observed prompt size reflects the pre-reclaim conversation, so
+         * leaving it in place would keep `shouldStop()` true forever and defeat
+         * the reclaim. Resetting to the fail-open state means the guard stays
+         * quiet until the next real usage report re-establishes the truth.
+         */
+        resetAfterReclaim() {
+            observedPromptTokens = 0;
+            projectedGrowthTokens = 0;
+        },
         /** True when issuing another model call risks crossing the threshold. */
         shouldStop() {
             return (observedPromptTokens > 0 &&

package/dist/lib/providers/googleVertex/client.d.ts

@@ -51,51 +51,6 @@ export declare function stripAdditionalPropertiesDeep(schema: Record<string, unk
  * @returns The region string to pass to the @google/genai client.
  */
 export declare const resolveVertexLocation: (modelName: string | undefined, configuredLocation?: string) => string;
-/**
- * Google Vertex AI Provider v2 - BaseProvider Implementation
- *
- * Features:
- * - Extends BaseProvider for shared functionality
- * - Preserves existing Google Cloud authentication
- * - Maintains Anthropic model support via dynamic imports
- * - Fresh model creation for each request
- * - Enhanced error handling with setup guidance
- * - Tool registration and context management
- *
- * @important Tools + Schema Support (Fixed)
- * Gemini models on Vertex AI now support combining function calling (tools) with
- * structured output (JSON schema) simultaneously. The fix works by NOT setting
- * `responseMimeType: "application/json"` when tools are present, which was
- * causing the Google API error.
- *
- * The `responseSchema` is still set to guide the output structure, allowing
- * tools to execute AND the final output to follow the schema format.
- *
- * @example Gemini models with tools + schemas
- * ```typescript
- * const provider = new GoogleVertexProvider("gemini-2.5-flash");
- * const result = await provider.generate({
- *   input: { text: "Analyze data using tools" },
- *   schema: MySchema,
- *   output: { format: "json" },
- *   // No need for disableTools: true anymore!
- * });
- * ```
- *
- * @example Claude models (always supported both)
- * ```typescript
- * const provider = new GoogleVertexProvider("claude-3-5-sonnet-20241022");
- * const result = await provider.generate({
- *   input: { text: "Analyze data" },
- *   schema: MySchema,
- *   output: { format: "json" }
- * });
- * ```
- *
- * @note "Too many states for serving" errors can still occur with very complex schemas + tools.
- *       Solution: Simplify schema or reduce number of tools if this occurs.
- * @see https://cloud.google.com/vertex-ai/docs/generative-ai/learn/models
- */
 export declare class GoogleVertexProvider extends BaseProvider {
     private projectId;
     private location;

package/dist/lib/providers/googleVertex/client.js

@@ -16,6 +16,8 @@ import { applyVertexAnthropicCacheBreakpoints } from "../../utils/anthropicCache
 import { FileDetector } from "../../utils/fileDetector.js";
 import { mergeMediaFileAliases, processUnifiedFilesArray, } from "../../utils/messageBuilder.js";
 import { logger } from "../../utils/logger.js";
+import { GEMINI_ELISION_NOTE, planGeminiLoopReclaim, previewGeminiToolResponseText, } from "../../context/geminiLoopGuard.js";
+import { ANTHROPIC_ELISION_NOTE, planAnthropicLoopReclaim, previewAnthropicToolResultText, } from "../../context/anthropicLoopGuard.js";
 import { hasRestrictedOutputLimit, RESTRICTED_OUTPUT_TOKEN_LIMIT, toVertexAnthropicModelId, } from "../../utils/modelDetection.js";
 import { detectImageMimeType } from "../../utils/imageDetection.js";
 import { resolveClaudeMaxTokens } from "../../utils/tokenLimits.js";
@@ -25,7 +27,7 @@ import { createNativeThinkingConfig } from "../../utils/thinkingConfig.js";
 import { TimeoutError, raceWithAbort, withTimeout, } from "../../utils/async/index.js";
 import { parseTimeout } from "../../utils/timeout.js";
 import { appendStepText, buildAbortedTurnMessage, buildContextCapMessage, buildToolLoopCapMessage, buildTurnStalledMessage, buildTurnTimeoutMessage, buildWrapupNudgeText, createContextGuard, createTextChannel, createTurnClock, extractThoughtSignature, isAbortError, mapGeminiFinishReason, prependConversationMessages, resolveTurnStopReason, DedupExecuteMap, } from "../googleNativeGemini3/index.js";
-import { getContextWindowSize } from "../../constants/contextWindows.js";
+import { getAvailableInputTokens, getContextWindowSize, } from "../../constants/contextWindows.js";
 import { resolveLiveTool } from "../../tools/toolDiscovery.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";
@@ -587,6 +589,148 @@ const isAnthropicModel = (modelName) => {
  *       Solution: Simplify schema or reduce number of tools if this occurs.
  * @see https://cloud.google.com/vertex-ai/docs/generative-ai/learn/models
  */
+/** Byte budget above which an old tool response is previewed, not kept whole. */
+const TOOL_RESPONSE_PREVIEW_BYTES = 2048;
+/**
+ * Reclaim context from a Gemini-shaped loop history IN PLACE.
+ *
+ * Returns true when something was actually reclaimed, which tells the caller
+ * it is safe to continue the loop instead of stopping. Mutates `contents` so
+ * the caller's array identity (captured by the request builder) stays valid.
+ */
+function reclaimVertexLoopContext(contents, modelName, observedPromptTokens) {
+    const plan = planGeminiLoopReclaim({
+        contents,
+        // The usable INPUT budget, not the whole window: the window has to hold the
+        // model's output too, and the AI Studio twin already reclaims against this
+        // same definition.
+        availableInputTokens: getAvailableInputTokens("vertex", modelName),
+        provider: "vertex",
+        observedPromptTokens,
+    });
+    if (!plan) {
+        return false;
+    }
+    const dropSet = new Set(plan.drop);
+    const truncateSet = new Set(plan.truncate);
+    const rebuilt = [];
+    for (let i = 0; i < contents.length; i++) {
+        if (dropSet.has(i)) {
+            continue;
+        }
+        const content = contents[i];
+        if (truncateSet.has(i) && Array.isArray(content.parts)) {
+            rebuilt.push({
+                ...content,
+                parts: content.parts.map((part) => {
+                    if (!("functionResponse" in part)) {
+                        return part;
+                    }
+                    const fn = part.functionResponse;
+                    const text = JSON.stringify(fn.response) ?? "";
+                    if (text.length <= TOOL_RESPONSE_PREVIEW_BYTES) {
+                        return part;
+                    }
+                    // Rebuilt rather than cast: `functionResponse` requires `name`, and
+                    // Critical Rule 14 forbids casting through `unknown` to paper over it.
+                    return {
+                        functionResponse: {
+                            name: fn.name,
+                            response: { result: previewGeminiToolResponseText(text) },
+                        },
+                    };
+                }),
+            });
+            continue;
+        }
+        rebuilt.push(content);
+    }
+    if (dropSet.size > 0) {
+        // Gemini requires the history to start with a user turn; the note is
+        // inserted before the first surviving tool turn, never at the end where a
+        // "history was removed" cue would follow the content it refers to.
+        let noteIndex = rebuilt.findIndex((c) => Array.isArray(c.parts) &&
+            c.parts.some((part) => !!part.functionCall ||
+                !!part.functionResponse));
+        if (noteIndex < 0) {
+            noteIndex = Math.min(1, rebuilt.length);
+        }
+        rebuilt.splice(noteIndex, 0, {
+            role: "user",
+            parts: [{ text: GEMINI_ELISION_NOTE }],
+        });
+    }
+    contents.length = 0;
+    contents.push(...rebuilt);
+    return true;
+}
+/**
+ * Reclaim context from a Vertex+Claude loop history IN PLACE.
+ *
+ * Same parity upgrade as the Gemini path, but this loop carries Anthropic
+ * content blocks, so it reuses the Anthropic adapter. Returns true when
+ * something was reclaimed and the loop may continue.
+ */
+function reclaimVertexAnthropicContext(messages, modelName, observedPromptTokens) {
+    const plan = planAnthropicLoopReclaim({
+        conversation: messages,
+        // Usable input budget, matching the Gemini twin above.
+        availableInputTokens: getAvailableInputTokens("vertex", modelName),
+        fixedOverheadTokens: 0,
+        provider: "vertex",
+        observedPromptTokens,
+        // This loop plans only when its context guard trips, so the count it hands
+        // over is the guard's projection for the request about to be sent, not a
+        // previous request's total. Without saying so the planner has no
+        // denominator, calibration stays pinned at 1, and the reclaim is inert:
+        // the guard fires on real tokens at the same ratio the planner tests its
+        // smaller char estimate against, so the plan never fires and the turn stops
+        // instead of continuing.
+        observedDescribesCurrentPayload: true,
+    });
+    if (!plan) {
+        return false;
+    }
+    const dropSet = new Set(plan.drop);
+    const truncateSet = new Set(plan.truncate);
+    const rebuilt = [];
+    for (let i = 0; i < messages.length; i++) {
+        if (dropSet.has(i)) {
+            continue;
+        }
+        const message = messages[i];
+        if (truncateSet.has(i) && Array.isArray(message.content)) {
+            rebuilt.push({
+                ...message,
+                content: message.content.map((block) => {
+                    if (block.type !== "tool_result") {
+                        return block;
+                    }
+                    const text = typeof block.content === "string"
+                        ? block.content
+                        : (JSON.stringify(block.content) ?? "");
+                    return { ...block, content: previewAnthropicToolResultText(text) };
+                }),
+            });
+            continue;
+        }
+        rebuilt.push(message);
+    }
+    if (dropSet.size > 0) {
+        let noteIndex = rebuilt.findIndex((m) => Array.isArray(m.content) &&
+            m.content.some((b) => b.type === "tool_use" || b.type === "tool_result"));
+        if (noteIndex < 0) {
+            noteIndex = Math.min(1, rebuilt.length);
+        }
+        rebuilt.splice(noteIndex, 0, {
+            role: "user",
+            content: [{ type: "text", text: ANTHROPIC_ELISION_NOTE }],
+        });
+    }
+    messages.length = 0;
+    messages.push(...rebuilt);
+    return true;
+}
 export class GoogleVertexProvider extends BaseProvider {
     projectId;
     location;
@@ -1574,11 +1718,22 @@ export class GoogleVertexProvider extends BaseProvider {
                 // conversation crosses the window threshold — synthesize from what
                 // we have instead of stepping into a provider rejection.
                 if (contextGuard.shouldStop()) {
-                    hitContextLimit = true;
-                    logger.warn(`[GoogleVertex] Gemini turn stopped by the context guard: ` +
-                        `projected prompt ~${contextGuard.projectedNextPromptTokens} tokens ` +
-                        `>= threshold ${contextGuard.thresholdTokens} (step ${step}) — synthesizing a final answer.`);
-                    break;
+                    // Parity upgrade: try to RECLAIM budget and keep going before
+                    // falling back to the historic stop-only behaviour. Ending the turn
+                    // early is safe but throws away work the model was mid-way through;
+                    // dropping the oldest complete tool exchanges usually buys enough
+                    // room to finish. Only when reclaiming changes nothing do we stop.
+                    const reclaimed = reclaimVertexLoopContext(currentContents, modelName, contextGuard.projectedNextPromptTokens);
+                    if (reclaimed) {
+                        contextGuard.resetAfterReclaim();
+                    }
+                    else {
+                        hitContextLimit = true;
+                        logger.warn(`[GoogleVertex] Gemini turn stopped by the context guard: ` +
+                            `projected prompt ~${contextGuard.projectedNextPromptTokens} tokens ` +
+                            `>= threshold ${contextGuard.thresholdTokens} (step ${step}) — synthesizing a final answer.`);
+                        break;
+                    }
                 }
                 step++;
                 turnClock.noteProgress();
@@ -2550,11 +2705,22 @@ export class GoogleVertexProvider extends BaseProvider {
                 // conversation crosses the window threshold — synthesize from what
                 // we have instead of stepping into a provider rejection.
                 if (contextGuard.shouldStop()) {
-                    hitContextLimit = true;
-                    logger.warn(`[GoogleVertex] Gemini turn stopped by the context guard: ` +
-                        `projected prompt ~${contextGuard.projectedNextPromptTokens} tokens ` +
-                        `>= threshold ${contextGuard.thresholdTokens} (step ${step}) — synthesizing a final answer.`);
-                    break;
+                    // Parity upgrade: try to RECLAIM budget and keep going before
+                    // falling back to the historic stop-only behaviour. Ending the turn
+                    // early is safe but throws away work the model was mid-way through;
+                    // dropping the oldest complete tool exchanges usually buys enough
+                    // room to finish. Only when reclaiming changes nothing do we stop.
+                    const reclaimed = reclaimVertexLoopContext(currentContents, modelName, contextGuard.projectedNextPromptTokens);
+                    if (reclaimed) {
+                        contextGuard.resetAfterReclaim();
+                    }
+                    else {
+                        hitContextLimit = true;
+                        logger.warn(`[GoogleVertex] Gemini turn stopped by the context guard: ` +
+                            `projected prompt ~${contextGuard.projectedNextPromptTokens} tokens ` +
+                            `>= threshold ${contextGuard.thresholdTokens} (step ${step}) — synthesizing a final answer.`);
+                        break;
+                    }
                 }
                 step++;
                 turnClock.noteProgress();
@@ -3671,11 +3837,19 @@ export class GoogleVertexProvider extends BaseProvider {
                     // Context guard: stop the tool loop before the accumulated
                     // conversation crosses the window threshold (see generate twin).
                     if (contextGuard.shouldStop()) {
-                        hitContextLimit = true;
-                        logger.warn(`[GoogleVertex] Anthropic stream turn stopped by the context guard: ` +
-                            `projected prompt ~${contextGuard.projectedNextPromptTokens} tokens ` +
-                            `>= threshold ${contextGuard.thresholdTokens} (step ${step}) — synthesizing a final answer.`);
-                        break;
+                        // Parity upgrade: reclaim and continue where possible; the
+                        // historic stop-only behaviour remains the fallback.
+                        const reclaimed = reclaimVertexAnthropicContext(currentMessages, modelName, contextGuard.projectedNextPromptTokens);
+                        if (reclaimed) {
+                            contextGuard.resetAfterReclaim();
+                        }
+                        else {
+                            hitContextLimit = true;
+                            logger.warn(`[GoogleVertex] Anthropic stream turn stopped by the context guard: ` +
+                                `projected prompt ~${contextGuard.projectedNextPromptTokens} tokens ` +
+                                `>= threshold ${contextGuard.thresholdTokens} (step ${step}) — synthesizing a final answer.`);
+                            break;
+                        }
                     }
                     step++;
                     turnClock.noteProgress();
@@ -4929,11 +5103,17 @@ export class GoogleVertexProvider extends BaseProvider {
             // this step's appended tool results/output) would cross the window
             // threshold — stop the tool loop and synthesize from what we have.
             if (contextGuard.shouldStop()) {
-                hitContextLimit = true;
-                logger.warn(`[GoogleVertex] Anthropic generate turn stopped by the context guard: ` +
-                    `projected prompt ~${contextGuard.projectedNextPromptTokens} tokens ` +
-                    `>= threshold ${contextGuard.thresholdTokens} (step ${step}) — synthesizing a final answer.`);
-                break;
+                const reclaimed = reclaimVertexAnthropicContext(currentMessages, modelName, contextGuard.projectedNextPromptTokens);
+                if (reclaimed) {
+                    contextGuard.resetAfterReclaim();
+                }
+                else {
+                    hitContextLimit = true;
+                    logger.warn(`[GoogleVertex] Anthropic generate turn stopped by the context guard: ` +
+                        `projected prompt ~${contextGuard.projectedNextPromptTokens} tokens ` +
+                        `>= threshold ${contextGuard.thresholdTokens} (step ${step}) — synthesizing a final answer.`);
+                    break;
+                }
             }
             step++;
             turnClock.noteProgress();

package/dist/lib/types/context.d.ts

@@ -471,6 +471,15 @@ export type AnthropicGuardMessage = {
     role: "user" | "assistant" | "system";
     content: string | AnthropicGuardBlock[];
 };
+/**
+ * Structural view of one Gemini history entry, loose enough to accept both the
+ * native Vertex loop's `{ role, parts }` array and `@google/genai` contents
+ * without a cast at either call site.
+ */
+export type GeminiGuardContent = {
+    role: string;
+    parts: unknown[];
+};
 /** Tuning for {@link planLoopGuardReclaim}. */
 export type LoopGuardPolicy = {
     availableInputTokens: number;