@juspay/neurolink 12.14.15 → 12.14.16

package/dist/providers/googleVertex/client.js

@@ -1406,8 +1406,10 @@ export class GoogleVertexProvider extends BaseProvider {
         if (effectiveSystemPrompt) {
             config.systemInstruction = effectiveSystemPrompt;
         }
-        // Add thinking config for Gemini 3
-        const nativeThinkingConfig = createNativeThinkingConfig(options.thinkingConfig);
+        // Add thinking config. Gemini 3 takes `thinkingLevel` directly; Gemini
+        // 2.5 rejects that field and needs a translated `thinkingBudget` instead
+        // — createNativeThinkingConfig picks the wire shape from modelName.
+        const nativeThinkingConfig = createNativeThinkingConfig(options.thinkingConfig, modelName);
         if (nativeThinkingConfig) {
             config.thinkingConfig = nativeThinkingConfig;
         }
@@ -2216,8 +2218,10 @@ export class GoogleVertexProvider extends BaseProvider {
         if (effectiveSystemPrompt) {
             config.systemInstruction = effectiveSystemPrompt;
         }
-        // Add thinking config for Gemini 3
-        const nativeThinkingConfig2 = createNativeThinkingConfig(options.thinkingConfig);
+        // Add thinking config. Gemini 3 takes `thinkingLevel` directly; Gemini
+        // 2.5 rejects that field and needs a translated `thinkingBudget` instead
+        // — createNativeThinkingConfig picks the wire shape from modelName.
+        const nativeThinkingConfig2 = createNativeThinkingConfig(options.thinkingConfig, modelName);
         if (nativeThinkingConfig2) {
             config.thinkingConfig = nativeThinkingConfig2;
         }
@@ -2883,6 +2887,72 @@ export class GoogleVertexProvider extends BaseProvider {
      * Execute stream using native @anthropic-ai/vertex-sdk for Claude models on Vertex AI
      * This bypasses @ai-sdk/google-vertex completely and uses Anthropic's native SDK
      */
+    /**
+     * Extended thinking for Claude-on-Vertex.
+     *
+     * The direct Anthropic provider has always translated `thinkingConfig` into
+     * the Messages API's `thinking` field (anthropic/client.ts). This path never
+     * did — it built the request without one — so `thinkingConfig` was accepted
+     * and silently ignored here: no error, `usage.reasoning` 0, no reasoning
+     * content. Measured against the raw @anthropic-ai/vertex-sdk with the same
+     * project, region, credentials and model, `thinking` is supported and
+     * returns a real thinking block, so the capability was ours to send.
+     *
+     * `thinkingLevel` is deliberately not mapped to a budget: the option's
+     * contract reserves `budgetTokens` for Anthropic models and `thinkingLevel`
+     * for Gemini 3, and inventing a conversion here would be guessing at the
+     * caller's intent.
+     *
+     * The budget must leave room inside `max_tokens` for an answer, so it is
+     * clamped below the ceiling rather than passed through — an over-large
+     * budget is a 400 from the API.
+     *
+     * `useFinalResultTool` (schema / structured-output mode) always pairs with
+     * a forced `tool_choice:{type:"any"}` in the request built right after this
+     * call — Anthropic hard-rejects `thinking` combined with a `tool_choice`
+     * that forces tool use: a live 400, "Thinking may not be enabled when
+     * tool_choice forces tool use." So `thinking` is omitted entirely in that
+     * mode, preserving the prior (pre-thinking-fix) behaviour of silently
+     * ignoring `thinkingConfig` for schema calls instead of hard-failing them —
+     * mirrors the same guard already applied to the OAuth proxy path in
+     * `src/lib/proxy/oauthFetch.ts` (`delete parsed.thinking` when
+     * `tool_choice.type` is `"any"` or `"tool"`). The step/context-cap
+     * finalization backstop reuses this same omission for free since it spreads
+     * `...requestParams`. `tool_choice:{type:"none"}` (the separate
+     * tools-disabled backstop, used only outside schema mode) does not force
+     * tool use — it forces the opposite — so it is not gated here, consistent
+     * with oauthFetch.ts leaving `"none"` alone too.
+     */
+    buildClaudeThinkingParam(
+    // Structural, not TextGenerationOptions: the streaming caller passes
+    // StreamOptions, and only these two fields are read.
+    options, maxTokens, useFinalResultTool) {
+        if (useFinalResultTool) {
+            if (options.thinkingConfig?.enabled) {
+                logger.debug("[GoogleVertex] Omitting thinking: schema mode forces tool_choice:any, which Anthropic rejects alongside thinking");
+            }
+            return undefined;
+        }
+        const budget = options.thinkingConfig?.budgetTokens;
+        if (!options.thinkingConfig?.enabled || !budget) {
+            return undefined;
+        }
+        // Two independent floors, checked explicitly rather than folded into one
+        // Math.max/min expression: Anthropic's own 1024 minimum on budget_tokens,
+        // and this function's 1024-token reservation for the answer that follows
+        // thinking. When maxTokens leaves no room for both — 1025..2047 is the
+        // narrow band where that happens — there is no valid budget, so thinking
+        // is omitted rather than silently coerced to exactly 1024 regardless of
+        // what the caller asked for.
+        if (maxTokens <= 1024) {
+            return undefined;
+        }
+        const clamped = Math.min(budget, maxTokens - 1024);
+        if (clamped < 1024) {
+            return undefined;
+        }
+        return { type: "enabled", budget_tokens: clamped };
+    }
     async executeNativeAnthropicStream(options) {
         const modelName = toVertexAnthropicModelId(options.model || this.modelName || "claude-sonnet-4-5@20250929");
         const startTime = Date.now();
@@ -3102,13 +3172,16 @@ export class GoogleVertexProvider extends BaseProvider {
             }),
             ...(options.topP !== undefined && { topP: options.topP }),
         }, "vertex.anthropic.stream");
+        const streamMaxTokens = resolveClaudeMaxTokens(modelName, options.maxTokens);
+        const streamThinking = this.buildClaudeThinkingParam(options, streamMaxTokens, useFinalResultTool);
         const requestParams = {
             model: modelName,
             // Default to the model's real output ceiling (e.g. 64K for Sonnet 4.x)
             // instead of the legacy 4096, which silently truncated large structured
             // responses mid-JSON. resolveClaudeMaxTokens also clamps over-large
             // caller values so the native Vertex path never 400s.
-            max_tokens: resolveClaudeMaxTokens(modelName, options.maxTokens),
+            max_tokens: streamMaxTokens,
+            ...(streamThinking && { thinking: streamThinking }),
             messages: messages,
             ...(tools && tools.length > 0 && { tools }),
             ...(useFinalResultTool && { tool_choice: { type: "any" } }),
@@ -3606,6 +3679,9 @@ export class GoogleVertexProvider extends BaseProvider {
                 });
                 const pump = (async () => {
                     for await (const chunk of engineStream) {
+                        if (chunk.reasoning) {
+                            channel.push({ content: "", reasoning: chunk.reasoning });
+                        }
                         if (chunk.content) {
                             channel.push({ content: chunk.content });
                             liveTextPushedLength += chunk.content.length;
@@ -3636,6 +3712,12 @@ export class GoogleVertexProvider extends BaseProvider {
                 if (engineResult) {
                     usage.input += engineResult.usage.inputTokens;
                     usage.output += engineResult.usage.outputTokens;
+                    // A SUBSET already included in outputTokens above — added here
+                    // only for observability, never folded into input/output/total.
+                    if (engineResult.usage.reasoningTokens) {
+                        usage.reasoning =
+                            (usage.reasoning ?? 0) + engineResult.usage.reasoningTokens;
+                    }
                     finishReasonRef.value =
                         engineResult.rawStopReason ?? finishReasonRef.value;
                     // NOT `toolCalls.length === 0`: that array accumulates across the
@@ -3841,9 +3923,22 @@ export class GoogleVertexProvider extends BaseProvider {
                                     tools,
                                     messages: currentMessages,
                                 });
+                                // budget_tokens must stay below max_tokens or Anthropic 400s
+                                // the call; terminalMaxTokens can land far below the ceiling
+                                // streamThinking was sized against (the context guard can
+                                // shrink it well under the original request), so the budget
+                                // is rebuilt for the shrunk limit rather than inherited
+                                // through the spread below.
+                                const backstopThinking = this.buildClaudeThinkingParam(options, terminalMaxTokens, false);
                                 const backstopStream = await client.messages.stream({
                                     ...requestParams,
                                     max_tokens: terminalMaxTokens,
+                                    // Assigned outright, never a conditional spread: spreading
+                                    // requestParams above may already carry a `thinking` sized
+                                    // for the original max_tokens, and only adding a key when
+                                    // backstopThinking is truthy would leave that stale value
+                                    // in place instead of clearing it.
+                                    thinking: backstopThinking,
                                     tool_choice: { type: "none" },
                                     system: cachedBackstop.system,
                                     ...(cachedBackstop.tools &&
@@ -3874,7 +3969,28 @@ export class GoogleVertexProvider extends BaseProvider {
                                         usage.output +
                                         turnCacheUsage.read +
                                         turnCacheUsage.creation;
+                                // A SUBSET already included in usage.output above (Anthropic
+                                // bills thinking as part of output_tokens) — additive only,
+                                // matching the main loop's own usage.reasoning accumulation.
+                                if (response.usage?.output_tokens_details?.thinking_tokens) {
+                                    usage.reasoning =
+                                        (usage.reasoning ?? 0) +
+                                            response.usage.output_tokens_details.thinking_tokens;
+                                }
                                 lastStopReason = response.stop_reason;
+                                // Extract<> rather than a hand-written object shape: the
+                                // real SDK's ThinkingBlock also requires `signature`, which
+                                // a literal `{ type: "thinking"; thinking: string }` predicate
+                                // omits — TS then rejects the predicate as not assignable to
+                                // ContentBlock. Extracting the union member sidesteps that
+                                // without hard-coding its full shape here.
+                                const backstopReasoning = response.content
+                                    .filter((block) => block.type === "thinking")
+                                    .map((block) => block.thinking)
+                                    .join("");
+                                if (backstopReasoning) {
+                                    channel.push({ content: "", reasoning: backstopReasoning });
+                                }
                                 const backstopText = response.content
                                     .filter((block) => block.type === "text")
                                     .map((b) => b.text)
@@ -4325,10 +4441,13 @@ export class GoogleVertexProvider extends BaseProvider {
             }),
             ...(options.topP !== undefined && { topP: options.topP }),
         }, "vertex.anthropic.generate");
+        const generateMaxTokens = resolveClaudeMaxTokens(modelName, options.maxTokens);
+        const generateThinking = this.buildClaudeThinkingParam(options, generateMaxTokens, useFinalResultTool);
         const requestParams = {
             model: modelName,
             // Default to the model's real output ceiling (see stream path note).
-            max_tokens: resolveClaudeMaxTokens(modelName, options.maxTokens),
+            max_tokens: generateMaxTokens,
+            ...(generateThinking && { thinking: generateThinking }),
             messages,
             ...(tools && tools.length > 0 && { tools }),
             ...(useFinalResultTool && { tool_choice: { type: "any" } }),
@@ -4371,6 +4490,16 @@ export class GoogleVertexProvider extends BaseProvider {
         // ~1.25x cache-write tiers instead of billing everything at full input rate.
         let totalCacheReadTokens = 0;
         let totalCacheCreationTokens = 0;
+        // A SUBSET already included in totalOutputTokens above (Anthropic bills
+        // thinking tokens as part of output_tokens) — reported separately for
+        // observability, never folded into the input/output/total rollup.
+        let totalReasoningTokens = 0;
+        // Reasoning text has no tool-triggered accumulation path the way
+        // `accumulatedStepText` does (buildToolResultMessages only fires for
+        // steps with tool calls), so it is captured directly from the engine's
+        // per-chunk stream below — otherwise a plain one-shot thinking answer
+        // never surfaces its reasoning text at all.
+        let accumulatedReasoningText = "";
         // Track the final Anthropic stop_reason so we can surface finishReason
         // (notably "length" on token truncation) — the legacy native path always
         // reported "stop", hiding truncation from callers.
@@ -4601,15 +4730,30 @@ export class GoogleVertexProvider extends BaseProvider {
             // engine's own per-tool bound cannot undercut it.
             toolTimeoutMs: toolExecTimeoutMs,
         });
-        // Drained and discarded: generate() returns one result rather than
-        // streaming, and the per-step text is accumulated in
+        // Text chunks are discarded here: generate() returns one result rather
+        // than streaming, and the per-step text is accumulated in
         // buildToolResultMessages instead — appendStepText joins steps with a
         // NEWLINE, which a chunk-by-chunk `+=` here would silently drop, running
-        // consecutive steps' text together. The drain still has to happen:
-        // leaving the channel unread stalls the engine once its buffer fills.
+        // consecutive steps' text together. Reasoning has no such step-boundary
+        // hook (buildToolResultMessages only runs for steps WITH tool calls, so
+        // a plain one-shot thinking answer never reaches it), so it is captured
+        // directly off the chunk stream instead. The drain still has to happen
+        // regardless: leaving the channel unread stalls the engine once its
+        // buffer fills.
+        //
+        // The plain `+=` below is deliberate, not the same gap as the text path:
+        // each `chunk.reasoning` here is one `thinking_delta` from inside a
+        // single step (loopAdapter pushes one per delta, not one per step), so
+        // joining on a NEWLINE the way appendStepText does would insert a break
+        // before nearly every delta and fragment one coherent thinking block
+        // into one line per token. Concatenation across steps is a known,
+        // accepted blur — there is no per-step boundary on this channel to join
+        // on — while concatenation within a step is exactly what the API sent.
         const pump = (async () => {
             for await (const chunk of engineStream) {
-                void chunk;
+                if (chunk.reasoning) {
+                    accumulatedReasoningText += chunk.reasoning;
+                }
             }
         })();
         let engineResult;
@@ -4638,6 +4782,7 @@ export class GoogleVertexProvider extends BaseProvider {
             totalOutputTokens += engineResult.usage.outputTokens;
             totalCacheReadTokens += engineResult.usage.cacheReadTokens ?? 0;
             totalCacheCreationTokens += engineResult.usage.cacheWriteTokens ?? 0;
+            totalReasoningTokens += engineResult.usage.reasoningTokens ?? 0;
             lastStopReason = engineResult.rawStopReason ?? lastStopReason;
             finalText = engineResult.text || finalText;
             // Replace in place: the terminal block and the finalization call both
@@ -4796,9 +4941,22 @@ export class GoogleVertexProvider extends BaseProvider {
                             tools,
                             messages: currentMessages,
                         });
+                        // budget_tokens must stay below max_tokens or Anthropic 400s the
+                        // call; terminalMaxTokens can land far below the ceiling
+                        // generateThinking was sized against (the context guard can
+                        // shrink it well under the original request), so the budget is
+                        // rebuilt for the shrunk limit rather than inherited through the
+                        // spread below.
+                        const backstopThinking = this.buildClaudeThinkingParam(options, terminalMaxTokens, false);
                         const response = await withTimeout(client.messages.create({
                             ...requestParams,
                             max_tokens: terminalMaxTokens,
+                            // Assigned outright, never a conditional spread: spreading
+                            // requestParams above may already carry a `thinking` sized
+                            // for the original max_tokens, and only adding a key when
+                            // backstopThinking is truthy would leave that stale value
+                            // in place instead of clearing it.
+                            thinking: backstopThinking,
                             tool_choice: { type: "none" },
                             system: cachedBackstop.system,
                             ...(cachedBackstop.tools &&
@@ -4813,7 +4971,25 @@ export class GoogleVertexProvider extends BaseProvider {
                             response.usage?.cache_read_input_tokens || 0;
                         totalCacheCreationTokens +=
                             response.usage?.cache_creation_input_tokens || 0;
+                        // A SUBSET already included in totalOutputTokens above
+                        // (Anthropic bills thinking as part of output_tokens) —
+                        // additive only, matching the main loop's own accumulation.
+                        totalReasoningTokens +=
+                            response.usage?.output_tokens_details?.thinking_tokens ?? 0;
                         lastStopReason = response.stop_reason;
+                        // Extract<> rather than a hand-written object shape: the real
+                        // SDK's ThinkingBlock also requires `signature`, which a literal
+                        // `{ type: "thinking"; thinking: string }` predicate omits — TS
+                        // then rejects the predicate as not assignable to ContentBlock.
+                        // Extracting the union member sidesteps that without
+                        // hard-coding its full shape here.
+                        const backstopReasoning = response.content
+                            .filter((block) => block.type === "thinking")
+                            .map((block) => block.thinking)
+                            .join("");
+                        if (backstopReasoning) {
+                            accumulatedReasoningText += backstopReasoning;
+                        }
                         const backstopText = response.content
                             .filter((block) => block.type === "text")
                             .map((b) => b.text)
@@ -4927,11 +5103,19 @@ export class GoogleVertexProvider extends BaseProvider {
                 ...(totalCacheCreationTokens > 0 && {
                     cacheCreationTokens: totalCacheCreationTokens,
                 }),
+                // A SUBSET already included in `output` above (Anthropic bills
+                // thinking tokens as part of output_tokens) — reported additively,
+                // never folded into output/total.
+                ...(totalReasoningTokens > 0 && { reasoning: totalReasoningTokens }),
             },
             responseTime,
             toolsUsed: externalToolCalls.map((tc) => tc.toolName),
             toolExecutions: resolveToolExecutionRecords(options, externalToolExecutions),
             enhancedWithTools: externalToolCalls.length > 0,
+            ...(accumulatedReasoningText && { reasoning: accumulatedReasoningText }),
+            ...(totalReasoningTokens > 0 && {
+                reasoningTokens: totalReasoningTokens,
+            }),
         };
         // Route through enhanceResult so analytics/evaluation/tracing are picked
         // up the same way the BaseProvider.generate() path picks them up. The
@@ -6245,6 +6429,17 @@ export class GoogleVertexProvider extends BaseProvider {
     /**
      * Get model suggestions when a model is not found
      */
+    /**
+     * Candidate model ids for a "model not available" error.
+     *
+     * This list is static. It cannot know what the caller's project and region
+     * actually serve, so it must not claim to: it previously announced
+     * "always available" and included the requested model itself, which
+     * produced errors that recommended the very id that had just failed —
+     * `gemini-3-pro-preview-11-2025` suggesting `gemini-3-pro-preview-11-2025`.
+     * The requested model is now filtered out, and the wording says these are
+     * ids to try rather than ids known to work.
+     */
     getModelSuggestions(requestedModel) {
         const availableModels = {
             google: [
@@ -6270,20 +6465,29 @@ export class GoogleVertexProvider extends BaseProvider {
                 "claude-3-opus-20240229",
             ],
         };
-        let suggestions = "\n🤖 Google Models (always available):\n";
-        availableModels.google.forEach((model) => {
+        // Never offer the id that just failed back to the caller. Compared by
+        // base id (before "@") so a versioned request (e.g. "gemini-2.5-pro@002")
+        // still excludes the unversioned list entry it failed against.
+        const requestedBase = (requestedModel ?? "").split("@")[0].toLowerCase();
+        const notRequested = (model) => model.split("@")[0].toLowerCase() !== requestedBase;
+        const google = availableModels.google.filter(notRequested);
+        const claude = availableModels.claude.filter(notRequested);
+        let suggestions = "\n🤖 Google Models (availability depends on your project and region):\n";
+        google.forEach((model) => {
             suggestions += `  • ${model}\n`;
         });
         suggestions += "\n🧠 Claude Models (requires Anthropic integration):\n";
-        availableModels.claude.forEach((model) => {
+        claude.forEach((model) => {
             suggestions += `  • ${model}\n`;
         });
-        // If the requested model looks like a Claude model, provide specific guidance
+        // If the requested model looks like a Claude model, provide specific guidance.
+        // Worded without requestedModel so the just-failed id isn't echoed back here too.
         if (requestedModel && requestedModel.toLowerCase().includes("claude")) {
-            suggestions += `\n💡 Tip: "${requestedModel}" appears to be a Claude model.\n`;
+            suggestions +=
+                "\n💡 Tip: this model id appears to be a Claude model, which just failed.\n";
             suggestions +=
                 "Ensure Anthropic integration is enabled in your Google Cloud project.\n";
-            suggestions += "Try using an available Claude model from the list above.";
+            suggestions += "Try another Claude model from the list above.";
         }
         return suggestions;
     }

package/dist/types/config.d.ts

@@ -506,8 +506,18 @@ export type CreateThinkingConfigOptions = {
     /** Thinking level for Gemini 3 models */
     thinkingLevel?: ThinkingLevel;
 };
-/** Native SDK thinkingConfig structure for Gemini native SDK. */
+/**
+ * Native SDK thinkingConfig structure for Gemini native SDK.
+ *
+ * `thinkingLevel` and `thinkingBudget` are mutually exclusive on the wire:
+ * Gemini 3 models accept `thinkingLevel`; Gemini 2.5 (and earlier) models
+ * reject it outright with INVALID_ARGUMENT "thinking_level not supported by
+ * this model" and require the numeric `thinkingBudget` instead. Both fields
+ * are optional here so a single type can represent either shape — callers
+ * building the request pick whichever field the target model accepts.
+ */
 export type NativeThinkingConfig = {
     includeThoughts: boolean;
-    thinkingLevel: ThinkingLevel;
+    thinkingLevel?: ThinkingLevel;
+    thinkingBudget?: number;
 };

package/dist/types/generate.d.ts

@@ -1394,19 +1394,28 @@ export type TextGenerationOptions = {
      * - Range: 5000-100000 tokens
      * - `thinkingLevel` is ignored for Anthropic
      *
-     * **Google Gemini 3 (gemini-3.1-pro-preview, gemini-3-flash-preview):**
-     * - Use `thinkingConfig.thinkingLevel` or `thinkingLevel`
+     * **Google Gemini 2.5 and 3 (gemini-2.5-pro/flash/flash-lite,
+     * gemini-3.1-pro-preview, gemini-3-flash-preview), via `thinkingConfig`:**
+     * - Use `thinkingConfig.thinkingLevel` (the public contract is the same
+     *   `thinkingLevel` lever for the whole Gemini family)
      * - Levels: minimal, low, medium, high
-     * - `budgetTokens` is ignored for Gemini (uses level-based allocation)
+     * - `thinkingConfig.budgetTokens` is not read for Gemini — the wire-level
+     *   Vertex/native-SDK request always carries a level-derived value.
+     *   Internally, Gemini 3 sends the vendor's `thinkingLevel` field as-is;
+     *   Gemini 2.5 has no such field (Vertex rejects it with INVALID_ARGUMENT
+     *   "thinking_level not supported by this model") and the requested level
+     *   is translated to the vendor's numeric `thinkingBudget` within that
+     *   model's verified range instead. That translation is an implementation
+     *   detail of the provider — callers keep using `thinkingLevel` either way.
      *
      * ### Option Compatibility Matrix
      *
-     * | Option         | Anthropic | Gemini 3 | Other Providers |
-     * |----------------|-----------|----------|-----------------|
-     * | thinking       | Yes       | Yes      | Ignored         |
-     * | thinkingBudget | Yes       | Ignored  | Ignored         |
-     * | thinkingLevel  | Ignored   | Yes      | Ignored         |
-     * | thinkingConfig | Yes       | Yes      | Ignored         |
+     * | Option         | Anthropic | Gemini 2.5 / 3 | Other Providers |
+     * |----------------|-----------|----------------|------------------|
+     * | thinking       | Yes       | Yes            | Ignored          |
+     * | thinkingBudget | Yes       | Ignored        | Ignored          |
+     * | thinkingLevel  | Ignored   | Yes            | Ignored          |
+     * | thinkingConfig | Yes       | Yes            | Ignored          |
      *
      * ### Examples
      *

package/dist/utils/modelDetection.d.ts

@@ -6,6 +6,16 @@ export declare function isGemini25Model(modelName: string): boolean;
 export declare function supportsThinkingConfig(modelName: string): boolean;
 export declare function supportsPromptCaching(modelName: string): boolean;
 export declare function getMaxThinkingBudgetTokens(modelName: string): number;
+/**
+ * Resolves the Vertex-accepted `thinkingBudget` bounds for a Gemini 2.5
+ * model. Returns undefined for anything that isn't a Gemini 2.5 model —
+ * Gemini 3 takes `thinkingLevel` directly, and no thinking-budget mapping
+ * has been verified for earlier Gemini generations.
+ */
+export declare function getGemini25ThinkingBudgetRange(modelName: string): {
+    min: number;
+    max: number;
+} | undefined;
 export declare function getModelFamily(modelName: string): string;
 /**
  * Check if a model has restricted output token limit (32768 max)

package/dist/utils/modelDetection.js

@@ -58,6 +58,44 @@ export function getMaxThinkingBudgetTokens(modelName) {
     }
     return 10000;
 }
+// Per-model `thinkingBudget` bounds for the Gemini 2.5 family, confirmed
+// against live Vertex generateContent responses (not just vendor docs, which
+// have been observed to drift from runtime behavior — see the "known gotcha"
+// on Gemini 2.5 Pro's range in public bug reports). Vertex rejects a budget
+// outside these bounds with INVALID_ARGUMENT "thinking_budget is out of
+// range; supported values are integers from <min> to <max>".
+//
+// Flash's true floor is 1, but budget:1 measured 0 thoughtsTokenCount — i.e.
+// technically accepted but indistinguishable from thinking being off. The
+// floor is bumped to 128 (Pro's real floor) here so a "minimal" mapping
+// still produces observable thinking. Must precede the plain "flash" pattern
+// below — "gemini-2.5-flash-lite" also matches a bare `/^gemini-2\.5-flash/`.
+const GEMINI_25_THINKING_BUDGET_RANGES = [
+    { pattern: /^gemini-2\.5-flash-lite/i, min: 512, max: 24576 },
+    { pattern: /^gemini-2\.5-flash/i, min: 128, max: 24576 },
+    { pattern: /^gemini-2\.5-pro/i, min: 128, max: 32768 },
+];
+// Bounds safe for any Gemini 2.5 variant not explicitly listed above — the
+// intersection of all three known models' verified ranges, so a model we
+// haven't named still gets a budget every family member accepts.
+const GEMINI_25_FALLBACK_BUDGET_RANGE = { min: 512, max: 24576 };
+/**
+ * Resolves the Vertex-accepted `thinkingBudget` bounds for a Gemini 2.5
+ * model. Returns undefined for anything that isn't a Gemini 2.5 model —
+ * Gemini 3 takes `thinkingLevel` directly, and no thinking-budget mapping
+ * has been verified for earlier Gemini generations.
+ */
+export function getGemini25ThinkingBudgetRange(modelName) {
+    if (!isValidModelName(modelName) || !isGemini25Model(modelName)) {
+        return undefined;
+    }
+    for (const { pattern, min, max } of GEMINI_25_THINKING_BUDGET_RANGES) {
+        if (pattern.test(modelName)) {
+            return { min, max };
+        }
+    }
+    return GEMINI_25_FALLBACK_BUDGET_RANGE;
+}
 export function getModelFamily(modelName) {
     if (!isValidModelName(modelName)) {
         return "unknown";

package/dist/utils/streamResultAccessors.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Helpers that keep lazily-populated StreamResult fields (`toolsUsed`,
+ * `toolExecutions`, and any other field a provider defines via
+ * `Object.defineProperty` with only a `get`) alive as the result object is
+ * re-wrapped or narrowed while it travels from a provider's `stream()`
+ * implementation up through BaseProvider and NeuroLink to the caller.
+ *
+ * A plain object spread (`{ ...result }`) or an object literal that reads
+ * `result.someField` invokes any getter on `result` immediately and stores
+ * the RETURNED VALUE as a static data property on the copy. For a
+ * background-loop stream (native Vertex/Anthropic paths, and any
+ * OpenAI-compatible provider that appends to `toolExecutionSummaries` while
+ * the consumer drains the stream), that snapshot happens before a single
+ * chunk has been pulled — so the copy is permanently frozen at empty/undefined
+ * even though the source object goes on to reflect real values as the
+ * background loop runs. Re-applying the ORIGINAL property descriptor (not
+ * the value it currently returns) keeps the copy lazy: every later read on
+ * the copy still calls the same getter, closing over the same live backing
+ * state.
+ */
+/**
+ * Re-apply every getter-defined accessor from `source` onto `target`,
+ * in place. Plain data properties (arrays copied by reference, primitives)
+ * are left untouched — an object spread already preserves those correctly,
+ * since copying an array reference keeps observing later `.push()`es.
+ */
+export declare function preserveLiveStreamAccessors<T extends object>(source: T, target: T): T;
+/**
+ * Build a `PropertyDescriptorMap` carrying the named fields' descriptors
+ * (data or accessor) from `source`, for use with `Object.defineProperties`
+ * when constructing a NEW, narrower object at a boundary that lists an
+ * explicit field set. Reading `source[key]` directly at such a boundary
+ * (`target.toolsUsed = source.toolsUsed`) would invoke a getter immediately;
+ * copying the descriptor instead defers that read to whoever accesses the
+ * field on `target` later. Keys absent from `source` are omitted, matching
+ * how an optional field would be omitted from a manual copy.
+ */
+export declare function pickLiveStreamDescriptors(source: object, keys: readonly string[]): PropertyDescriptorMap;

package/dist/utils/streamResultAccessors.js

@@ -0,0 +1,55 @@
+/**
+ * Helpers that keep lazily-populated StreamResult fields (`toolsUsed`,
+ * `toolExecutions`, and any other field a provider defines via
+ * `Object.defineProperty` with only a `get`) alive as the result object is
+ * re-wrapped or narrowed while it travels from a provider's `stream()`
+ * implementation up through BaseProvider and NeuroLink to the caller.
+ *
+ * A plain object spread (`{ ...result }`) or an object literal that reads
+ * `result.someField` invokes any getter on `result` immediately and stores
+ * the RETURNED VALUE as a static data property on the copy. For a
+ * background-loop stream (native Vertex/Anthropic paths, and any
+ * OpenAI-compatible provider that appends to `toolExecutionSummaries` while
+ * the consumer drains the stream), that snapshot happens before a single
+ * chunk has been pulled — so the copy is permanently frozen at empty/undefined
+ * even though the source object goes on to reflect real values as the
+ * background loop runs. Re-applying the ORIGINAL property descriptor (not
+ * the value it currently returns) keeps the copy lazy: every later read on
+ * the copy still calls the same getter, closing over the same live backing
+ * state.
+ */
+/**
+ * Re-apply every getter-defined accessor from `source` onto `target`,
+ * in place. Plain data properties (arrays copied by reference, primitives)
+ * are left untouched — an object spread already preserves those correctly,
+ * since copying an array reference keeps observing later `.push()`es.
+ */
+export function preserveLiveStreamAccessors(source, target) {
+    for (const key of Object.getOwnPropertyNames(source)) {
+        const descriptor = Object.getOwnPropertyDescriptor(source, key);
+        if (descriptor && typeof descriptor.get === "function") {
+            Object.defineProperty(target, key, descriptor);
+        }
+    }
+    return target;
+}
+/**
+ * Build a `PropertyDescriptorMap` carrying the named fields' descriptors
+ * (data or accessor) from `source`, for use with `Object.defineProperties`
+ * when constructing a NEW, narrower object at a boundary that lists an
+ * explicit field set. Reading `source[key]` directly at such a boundary
+ * (`target.toolsUsed = source.toolsUsed`) would invoke a getter immediately;
+ * copying the descriptor instead defers that read to whoever accesses the
+ * field on `target` later. Keys absent from `source` are omitted, matching
+ * how an optional field would be omitted from a manual copy.
+ */
+export function pickLiveStreamDescriptors(source, keys) {
+    const descriptors = {};
+    for (const key of keys) {
+        const descriptor = Object.getOwnPropertyDescriptor(source, key);
+        if (descriptor) {
+            descriptors[key] = descriptor;
+        }
+    }
+    return descriptors;
+}