@juspay/neurolink 12.12.11 → 12.12.13

package/dist/constants/contextWindows.js

@@ -67,6 +67,7 @@ export const MODEL_CONTEXT_WINDOWS = {
         "mistralai/mixtral-8x7b-instruct-v0.1": 32_768,
         "microsoft/phi-4": 16_384,
         "google/gemma-3-27b-it": 8_192,
+        "openai/gpt-oss-20b": 131_072,
     },
     "lm-studio": {
         _default: 8_192,

package/dist/constants/enums.d.ts

@@ -644,6 +644,7 @@ export declare enum DeepSeekModels {
  * Note: NIM hosts hundreds of models; pass arbitrary IDs via --model.
  */
 export declare enum NvidiaNimModels {
+    GPT_OSS_20B = "openai/gpt-oss-20b",
     LLAMA_3_3_70B_INSTRUCT = "meta/llama-3.3-70b-instruct",
     LLAMA_3_1_405B_INSTRUCT = "meta/llama-3.1-405b-instruct",
     LLAMA_3_1_70B_INSTRUCT = "meta/llama-3.1-70b-instruct",

package/dist/constants/enums.js

@@ -872,6 +872,13 @@ export var DeepSeekModels;
  */
 export var NvidiaNimModels;
 (function (NvidiaNimModels) {
+    // NVIDIA retired a large part of this list upstream on 2026-08-26 —
+    // llama-3.3-70b, llama-3.1-70b, llama-3.2-90b-vision, the deepseek-r1
+    // distill and gemma-3-27b all answer "no longer available" now. The members
+    // are kept so existing callers still compile, but the provider default
+    // below must point at something live: gpt-oss-20b is on the current roster
+    // and was probed for text, streaming, tool calling and structured output.
+    NvidiaNimModels["GPT_OSS_20B"] = "openai/gpt-oss-20b";
     // Meta Llama
     NvidiaNimModels["LLAMA_3_3_70B_INSTRUCT"] = "meta/llama-3.3-70b-instruct";
     NvidiaNimModels["LLAMA_3_1_405B_INSTRUCT"] = "meta/llama-3.1-405b-instruct";

package/dist/core/baseProvider.js

@@ -1260,7 +1260,7 @@ export class BaseProvider {
                     [ATTR.NL_PROVIDER]: this.providerName || "unknown",
                 },
             });
-            // Set this span as the active context so child spans (GenerationHandler, etc.) become descendants
+            // Set this span as the active context so child spans (provider calls, tool executions) become descendants
             const activeCtx = trace.setSpan(context.active(), otelSpan);
             const otelSpanState = { ended: false };
             return await context.with(activeCtx, async () => this.runGenerateInActiveContext(options, startTime, otelSpan, otelSpanState));
@@ -1706,9 +1706,9 @@ export class BaseProvider {
             analytics: result.analytics,
             evaluation: result.evaluation,
             audio: result.audio,
-            // Forward reasoning fields populated by GenerationHandler from AI-SDK
-            // reasoning parts (DeepSeek `reasoning_content`, Anthropic thinking,
-            // Gemini thought parts, OpenAI o1).
+            // Forward reasoning fields populated by the native generate loop from
+            // vendor reasoning parts (DeepSeek `reasoning_content`, Anthropic
+            // thinking, Gemini thought parts, OpenAI o1).
             reasoning: result.reasoning,
             reasoningTokens: result.reasoningTokens,
         };

package/dist/core/modules/structuredOutputPolicy.d.ts

@@ -25,12 +25,12 @@ export declare function isGeminiProvider(providerName: string, modelName: string
  * matched here (different transport, no conflict).
  *
  * Being excluded here no longer means the schema is LOST for provider
- * "anthropic": GenerationHandler forwards the JSON Schema to the provider via
- * `providerOptions.anthropic.finalResultSchema`, and the provider appends an
- * additive `final_result` tool (see providers/anthropic/structuredOutput.ts) —
- * schema enforcement without giving up tool calling. "bedrock" has no such
- * handling (it talks to the raw AWS SDK directly, not an ai-sdk provider
- * package) and still falls back to text-mode coercion.
+ * "anthropic": the client puts the JSON Schema on
+ * `providerOptions.anthropic.finalResultSchema` and its `doGenerate` appends
+ * an additive `final_result` tool (see providers/anthropic/structuredOutput.ts)
+ * — schema enforcement without giving up tool calling. "bedrock" has no such
+ * handling (it talks to the raw AWS SDK directly) and still falls back to
+ * text-mode coercion.
  */
 export declare function isNativeAnthropicProvider(providerName: string): boolean;
 /**

package/dist/core/modules/structuredOutputPolicy.js

@@ -35,12 +35,12 @@ export function isGeminiProvider(providerName, modelName) {
  * matched here (different transport, no conflict).
  *
  * Being excluded here no longer means the schema is LOST for provider
- * "anthropic": GenerationHandler forwards the JSON Schema to the provider via
- * `providerOptions.anthropic.finalResultSchema`, and the provider appends an
- * additive `final_result` tool (see providers/anthropic/structuredOutput.ts) —
- * schema enforcement without giving up tool calling. "bedrock" has no such
- * handling (it talks to the raw AWS SDK directly, not an ai-sdk provider
- * package) and still falls back to text-mode coercion.
+ * "anthropic": the client puts the JSON Schema on
+ * `providerOptions.anthropic.finalResultSchema` and its `doGenerate` appends
+ * an additive `final_result` tool (see providers/anthropic/structuredOutput.ts)
+ * — schema enforcement without giving up tool calling. "bedrock" has no such
+ * handling (it talks to the raw AWS SDK directly) and still falls back to
+ * text-mode coercion.
  */
 export function isNativeAnthropicProvider(providerName) {
     return providerName === "anthropic" || providerName === "bedrock";

package/dist/core/nativeGenerateLoop.js

@@ -96,6 +96,7 @@ export const appendJsonSchemaInstruction = (conversation, schema) => {
 export async function runNativeGenerateLoop(args, toolExecutionSummaries) {
     const toolsUsed = [];
     let text = "";
+    let reasoning = "";
     let finishReason = "stop";
     let rawFinishReason;
     let inputTokens = 0;
@@ -175,6 +176,15 @@ export async function runNativeGenerateLoop(args, toolExecutionSummaries) {
             .filter((p) => p.type === "text" && typeof p.text === "string")
             .map((p) => p.text)
             .join("");
+        // Reasoner models (DeepSeek `reasoning_content`, gateway `reasoning`,
+        // OpenAI o-series) emit reasoning as its own V3 content part. Join it on
+        // the same replace-per-step rule as the text so the caller can surface
+        // `result.reasoning`; without this the provider builds the part and the
+        // loop drops it.
+        reasoning = parts
+            .filter((p) => p.type === "reasoning" && typeof p.text === "string")
+            .map((p) => p.text)
+            .join("");
         const fr = res.finishReason;
         if (typeof fr === "string") {
             finishReason = fr;
@@ -287,6 +297,7 @@ export async function runNativeGenerateLoop(args, toolExecutionSummaries) {
     }
     return {
         text,
+        ...(reasoning ? { reasoning } : {}),
         finishReason,
         ...(rawFinishReason ? { rawFinishReason } : {}),
         inputTokens,

package/dist/core/nativeToolFormat.js

@@ -16,8 +16,8 @@ export function toNativeToolDeclarations(tools, format) {
         const input_schema = (rawSchema
             ? convertZodToJsonSchema(rawSchema)
             : { type: "object", properties: {} });
-        // GenerationHandler marks the last tool definition with a cache
-        // breakpoint when prompt caching is active — keep honoring it.
+        // Honor a cache breakpoint the caller set on this tool. The direct
+        // Anthropic path marks the last tool itself, on the assembled request.
         const cc = cacheControlOf(tool);
         const declaration = {
             name,

package/dist/factories/providerDescriptors.js

@@ -321,7 +321,7 @@ const HAND_DESCRIPTORS = [
             baseURL: "NVIDIA_NIM_BASE_URL",
             model: "NVIDIA_NIM_MODEL",
         },
-        defaultModel: NvidiaNimModels.LLAMA_3_3_70B_INSTRUCT,
+        defaultModel: NvidiaNimModels.GPT_OSS_20B,
         toolSupport: "native",
         localRuntime: false,
         healthCheck: "env-only",

package/dist/factories/providerRegistry.js

@@ -174,7 +174,10 @@ export class ProviderRegistry {
                 const nimCreds = credentials;
                 const { NvidiaNimProvider } = await import("../providers/nvidiaNim/index.js");
                 return new NvidiaNimProvider(modelName, sdk, undefined, nimCreds);
-            }, process.env.NVIDIA_NIM_MODEL || NvidiaNimModels.LLAMA_3_3_70B_INSTRUCT, ["nvidia", "nim", "nvidia-nim"], PROVIDER_DESCRIPTORS_BY_NAME.get(AIProviderName.NVIDIA_NIM));
+            }, process.env.NVIDIA_NIM_MODEL ||
+                PROVIDER_DESCRIPTORS_BY_NAME.get(AIProviderName.NVIDIA_NIM)
+                    ?.defaultModel ||
+                NvidiaNimModels.GPT_OSS_20B, ["nvidia", "nim", "nvidia-nim"], PROVIDER_DESCRIPTORS_BY_NAME.get(AIProviderName.NVIDIA_NIM));
             // Register LM Studio provider (local)
             ProviderFactory.registerProvider(AIProviderName.LM_STUDIO, async (modelName, _providerName, sdk, _region, credentials) => {
                 const lmStudioCreds = credentials;

package/dist/neurolink.js

@@ -4386,7 +4386,7 @@ Current user's request: ${currentInput}`;
             music: textResult.music,
             ppt: textResult.ppt,
             // Forward reasoning/reasoningTokens from the provider layer.
-            // BaseProvider's GenerationHandler extracts these from AI-SDK reasoning
+            // The native generate loop extracts these from vendor reasoning
             // parts (DeepSeek's `reasoning_content`, Anthropic thinking blocks,
             // Gemini thought parts, OpenAI o1) and they're declared on
             // `GenerateResult`, but the builder previously dropped them on the

package/dist/providers/amazonSagemaker.js

@@ -197,6 +197,7 @@ export class AmazonSageMakerProvider extends BaseProvider {
                 total: loop.inputTokens + loop.outputTokens,
             },
             responseTime: Date.now() - startTime,
+            ...(loop.reasoning ? { reasoning: loop.reasoning } : {}),
             toolsUsed: loop.toolsUsed,
             toolCalls: toolCallsFromSummaries(toolExecutionSummaries),
             toolExecutions: resolveToolExecutionRecords(options, transformToolExecutions(toolExecutionSummaries)),

package/dist/providers/anthropic/cacheControl.d.ts

@@ -1,9 +1,9 @@
 import type Anthropic from "@anthropic-ai/sdk";
 /**
  * Read an Anthropic cache breakpoint from a message/part/tool carrier.
- * MessageBuilder marks system messages (and GenerationHandler marks the last
- * tool definition) with `providerOptions.anthropic.cacheControl` — the
- * AI-SDK-era prompt-caching contract this native path must keep honoring.
+ * MessageBuilder marks system messages with
+ * `providerOptions.anthropic.cacheControl`; the Anthropic client marks the last
+ * tool definition on the assembled request. This reader is what honors both.
  *
  * Extracted from anthropic/client.ts so `src/lib/core/nativeToolFormat.ts`
  * can share it without importing the provider client (which would create a

package/dist/providers/anthropic/cacheControl.js

@@ -1,8 +1,8 @@
 /**
  * Read an Anthropic cache breakpoint from a message/part/tool carrier.
- * MessageBuilder marks system messages (and GenerationHandler marks the last
- * tool definition) with `providerOptions.anthropic.cacheControl` — the
- * AI-SDK-era prompt-caching contract this native path must keep honoring.
+ * MessageBuilder marks system messages with
+ * `providerOptions.anthropic.cacheControl`; the Anthropic client marks the last
+ * tool definition on the assembled request. This reader is what honors both.
  *
  * Extracted from anthropic/client.ts so `src/lib/core/nativeToolFormat.ts`
  * can share it without importing the provider client (which would create a

package/dist/providers/anthropic/client.js

@@ -1027,8 +1027,8 @@ export class AnthropicProvider extends BaseProvider {
                 let tools = (options.tools ?? [])
                     .filter((t) => t.type === "function")
                     .map((t) => {
-                    // GenerationHandler marks the last tool definition with a cache
-                    // breakpoint when prompt caching is active — keep honoring it.
+                    // Honor a cache breakpoint the caller set on this tool. When no
+                    // tool carries one, the last tool is marked further below.
                     const cc = cacheControlOf(t);
                     return {
                         name: t.name,
@@ -1069,10 +1069,10 @@ export class AnthropicProvider extends BaseProvider {
                 }
                 // Additive structured output: when the caller wants a schema AND real
                 // tools, the forced-json path above cannot be used (it replaces the
-                // tools array), and the AI-SDK experimental_output path is excluded
-                // for this surface by structuredOutputPolicy. GenerationHandler hands
-                // the JSON Schema down here instead, and we APPEND a `final_result`
-                // tool — tool_choice stays auto, so every real tool keeps working and
+                // tools array), and structured output is excluded for this surface
+                // by structuredOutputPolicy. The schema arrives instead on
+                // `providerOptions.anthropic.finalResultSchema` and we APPEND a
+                // `final_result` tool — tool_choice stays auto, so every real tool keeps working and
                 // the model self-selects final_result when it is ready to answer.
                 const finalResultSchema = options.providerOptions?.anthropic
                     ?.finalResultSchema;
@@ -1087,9 +1087,26 @@ export class AnthropicProvider extends BaseProvider {
                 }
                 // Extended thinking passthrough (providerOptions.anthropic.thinking).
                 const thinking = options.providerOptions?.anthropic?.thinking;
+                // Close the stable prefix with a breakpoint on the LAST tool. Tool
+                // definitions sit between the system prompt and the conversation and
+                // rarely change, so without this the whole tools block is re-billed
+                // every turn. Applied after every tool mutation above (including the
+                // appended final_result tool) so the marker really is last, and before
+                // the count below so the history budget accounts for it. A caller that
+                // marked a tool itself wins.
+                if (tools && tools.length > 0) {
+                    const alreadyMarked = tools.some((t) => cacheControlOf(t));
+                    if (!alreadyMarked) {
+                        const last = tools[tools.length - 1];
+                        tools = [
+                            ...tools.slice(0, -1),
+                            { ...last, cache_control: { type: "ephemeral" } },
+                        ];
+                    }
+                }
                 // Prompt-cache parity with the native Vertex+Claude path: upstream
-                // layers mark only the stable prefix (system via MessageBuilder,
-                // last tool via GenerationHandler) — the growing conversation
+                // layers mark the stable prefix (system via MessageBuilder, and the
+                // last tool just above) — the growing conversation
                 // history has no breakpoint, so on every turn it falls after the
                 // last marker and is re-billed as fresh input. Add rolling history
                 // breakpoints in whatever budget remains under Anthropic's
@@ -1469,6 +1486,7 @@ export class AnthropicProvider extends BaseProvider {
             ...(loop.rawFinishReason
                 ? { rawFinishReason: loop.rawFinishReason }
                 : {}),
+            ...(loop.reasoning ? { reasoning: loop.reasoning } : {}),
             usage: {
                 input: loop.inputTokens,
                 output: loop.outputTokens,

package/dist/providers/configuredOpenAICompat.d.ts

@@ -44,7 +44,7 @@ export declare class ConfiguredOpenAICompatProvider extends OpenAIChatCompletion
      * a `tools` array — Mancer's free model rejects one with 400 — so the
      * declaration wins here and the registry is only consulted otherwise.
      * Like the other entry-reading overrides above, this runs only after
-     * construction: BaseProvider merely closes over it for GenerationHandler.
+     * construction: BaseProvider merely closes over it.
      */
     supportsTools(): boolean;
     protected adjustRequestBody(body: OpenAICompatChatRequest, modelId: string): OpenAICompatChatRequest;

package/dist/providers/configuredOpenAICompat.js

@@ -94,7 +94,7 @@ export class ConfiguredOpenAICompatProvider extends OpenAIChatCompletionsProvide
      * a `tools` array — Mancer's free model rejects one with 400 — so the
      * declaration wins here and the registry is only consulted otherwise.
      * Like the other entry-reading overrides above, this runs only after
-     * construction: BaseProvider merely closes over it for GenerationHandler.
+     * construction: BaseProvider merely closes over it.
      */
     supportsTools() {
         if (this.entry.supportsTools === false) {

package/dist/providers/googleAiStudio/client.js

@@ -1307,9 +1307,8 @@ export class GoogleAIStudioProvider extends BaseProvider {
         try {
             // Wrap in `neurolink.executeGeneration` so the observability span
             // chain (Test: Generate Span Chain) sees a third inner span on the
-            // native @google/genai path — Pipeline A providers get this from
-            // GenerationHandler.executeGeneration; the native path bypasses
-            // GenerationHandler so we add the span here.
+            // native @google/genai path. This provider overrides generate() instead
+            // of using BaseProvider's shared flow, so the span is added here.
             let result = await withSpan({
                 name: "neurolink.executeGeneration",
                 tracer: tracers.provider,

package/dist/providers/googleVertex/client.js

@@ -5245,8 +5245,8 @@ export class GoogleVertexProvider extends BaseProvider {
                 // Wrap the actual native generate call in `neurolink.executeGeneration`
                 // so the observability span chain (tested by
                 // "Tracing: Generate Span Chain") sees a third inner span on the
-                // native @google/genai / @anthropic-ai/vertex-sdk path — Pipeline A
-                // gets this for free from GenerationHandler.executeGeneration.
+                // native @google/genai / @anthropic-ai/vertex-sdk path. This
+                // provider overrides generate(), so the span is added here.
                 result = await withSpan({
                     name: "neurolink.executeGeneration",
                     tracer: tracers.provider,

package/dist/providers/nvidiaNim/client.js

@@ -5,6 +5,7 @@ import { logger } from "../../utils/logger.js";
 import { redactUrlCredentials } from "../../utils/logSanitize.js";
 import { createNvidiaNimConfig, getProviderModel, validateApiKey, } from "../../utils/providerConfig.js";
 import { OpenAIChatCompletionsProvider } from "../openaiChatCompletionsBase.js";
+import { PROVIDER_DESCRIPTORS_BY_NAME } from "../../factories/providerDescriptors.js";
 /**
  * Decide whether a NIM 400 response body is a rejection of the named
  * field (as opposed to an unrelated 400 that happens to mention the
@@ -136,7 +137,16 @@ const getNimApiKey = () => {
     return validateApiKey(createNvidiaNimConfig());
 };
 const getDefaultNimModel = () => {
-    return getProviderModel("NVIDIA_NIM_MODEL", NvidiaNimModels.LLAMA_3_3_70B_INSTRUCT);
+    // NVIDIA retired meta/llama-3.3-70b-instruct upstream on 2026-08-26, so this
+    // fallback answered "no longer available" for anyone who selected nvidia-nim
+    // without naming a model. gpt-oss-20b is on the current roster and was
+    // probed for text, streaming, tool calling and structured output.
+    // Read the descriptor rather than repeating the literal. Review on this PR
+    // pointed out the default lived in four places and that changing only some
+    // of them is a no-op — which happened twice while tracking this down. The
+    // descriptor is the Factory+Registry convention's source of truth.
+    return getProviderModel("NVIDIA_NIM_MODEL", PROVIDER_DESCRIPTORS_BY_NAME.get("nvidia-nim")
+        ?.defaultModel ?? NvidiaNimModels.GPT_OSS_20B);
 };
 /**
  * NVIDIA NIM Provider — native HTTP+SSE, no AI SDK.

package/dist/providers/openaiChatCompletionsBase.d.ts

@@ -76,13 +76,13 @@ export declare abstract class OpenAIChatCompletionsProvider extends BaseProvider
     protected adjustResponseFormat(rf: OpenAICompatResponseFormat | undefined, _modelId: string): OpenAICompatResponseFormat | undefined;
     /**
      * When true (default), `response_format` is NOT sent on requests that carry
-     * tools. The AI SDK sets responseFormat on EVERY step of a tool loop, and
-     * generic/proxy backends (LiteLLM→vllm/GLM, openai-compatible, local
+     * tools. The generate loop sets responseFormat on EVERY step of a tool
+     * loop, and generic/proxy backends (LiteLLM→vllm/GLM, openai-compatible, local
      * servers) may silently honor it over tool calling — answering with
      * final-shape JSON on step 1 instead of running the agentic loop. No error
      * is raised, so the runtime tools↔schema conflict detector cannot catch it.
-     * The schema is still enforced post-hoc (GenerationHandler coerces the final
-     * text against it) — the same contract as the Gemini tools↔schema exclusion.
+     * The schema is still enforced post-hoc (`coerceJsonToSchema` runs against
+     * the final text) — the same contract as the Gemini tools↔schema exclusion.
      * Mirrors the streaming path, which never sends response_format.
      *
      * Backends with first-party support for tools + json_schema in one request

package/dist/providers/openaiChatCompletionsBase.js

@@ -199,13 +199,13 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
     }
     /**
      * When true (default), `response_format` is NOT sent on requests that carry
-     * tools. The AI SDK sets responseFormat on EVERY step of a tool loop, and
-     * generic/proxy backends (LiteLLM→vllm/GLM, openai-compatible, local
+     * tools. The generate loop sets responseFormat on EVERY step of a tool
+     * loop, and generic/proxy backends (LiteLLM→vllm/GLM, openai-compatible, local
      * servers) may silently honor it over tool calling — answering with
      * final-shape JSON on step 1 instead of running the agentic loop. No error
      * is raised, so the runtime tools↔schema conflict detector cannot catch it.
-     * The schema is still enforced post-hoc (GenerationHandler coerces the final
-     * text against it) — the same contract as the Gemini tools↔schema exclusion.
+     * The schema is still enforced post-hoc (`coerceJsonToSchema` runs against
+     * the final text) — the same contract as the Gemini tools↔schema exclusion.
      * Mirrors the streaming path, which never sends response_format.
      *
      * Backends with first-party support for tools + json_schema in one request
@@ -709,7 +709,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                 const content = [];
                 // Reasoner-model output (DeepSeek `reasoning_content`, gateway
                 // `reasoning`) becomes a V3 reasoning part ahead of the text part —
-                // GenerationHandler joins reasoning parts into `result.reasoning`.
+                // the native generate loop joins those parts into `result.reasoning`.
                 // `||` so an empty-string reasoning_content falls through to a
                 // non-empty `reasoning` field instead of shadowing it.
                 const reasoningText = choice?.message?.reasoning_content || choice?.message?.reasoning;
@@ -921,11 +921,11 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
         // words instead: drop `response_format` and spell the JSON Schema into the
         // system prompt, letting coerceJsonToSchema recover the object from text.
         //
-        // Ported from GenerationHandler's `promptJsonInstruction` fallback, which
-        // runs this on the ai-package path. That path is unreachable for every
-        // provider driven by this loop — GMI Cloud's MiniMax endpoint, the one it
-        // was written for, is a Tier-2 catalog provider on this very base class —
-        // so without this the recovery would simply not happen for it.
+        // Ported from GenerationHandler's `promptJsonInstruction` fallback on the
+        // ai-package path, which has since been deleted — GMI Cloud's MiniMax
+        // endpoint, the one it was written for, is a Tier-2 catalog provider on
+        // this very base class, so without this the recovery would simply not
+        // happen for it.
         let loop;
         try {
             loop = await runLoop(conversation, responseFormat);
@@ -991,6 +991,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                     : {}),
             },
             responseTime: Date.now() - startTime,
+            ...(loop.reasoning ? { reasoning: loop.reasoning } : {}),
             toolsUsed,
             toolCalls: toolCallsFromSummaries(toolExecutionSummaries),
             toolExecutions: resolveToolExecutionRecords(options, transformToolExecutions(toolExecutionSummaries)),

package/dist/types/context.d.ts

@@ -219,28 +219,6 @@ export type BudgetCheckResult = {
         fileAttachments: number;
     };
 };
-/**
- * Configuration for the per-step context budget guard that compacts the
- * AI-SDK tool loop's messages before they overflow the model window
- * (context/stepBudgetGuard.ts).
- */
-export type StepBudgetGuardConfig = {
-    provider: string;
-    model?: string;
-    /** The caller's requested output budget (reserved out of the window). */
-    maxTokens?: number;
-    /** Static token cost of the hoisted system prompt + tool definitions. */
-    fixedOverheadTokens?: number;
-    /**
-     * Dynamic overhead resolver, re-evaluated on EVERY guard invocation. Takes
-     * precedence over `fixedOverheadTokens`. Use when the tool set can grow
-     * mid-loop (search_tools hydration) so newly added definitions count toward
-     * the budget.
-     */
-    getFixedOverheadTokens?: () => number;
-    /** Override the trigger ratio; defaults to DEFAULT_CONTEXT_GUARD_RATIO. */
-    thresholdRatio?: number;
-};
 /** Parameters for budget checking. */
 export type BudgetCheckParams = {
     provider: string;

package/dist/types/generate.d.ts

@@ -1567,23 +1567,6 @@ export type ModelAliasConfig = {
 export type GenerateOptionsNormalized = GenerateOptions & {
     input: NonNullable<GenerateOptions["input"]>;
 };
-/**
- * Per-call configuration for GenerationHandler's AI-SDK loop invocation,
- * shared by the initial call and every fallback retry so they cannot drift.
- */
-export type GenerationCallConfig = {
-    shouldUseTools: boolean;
-    includeStructuredOutput: boolean;
-    /** Anchor for the turn deadline — the ORIGINAL executeGeneration start,
-     *  shared across fallback/provider retries so they can't refresh the
-     *  wall-clock budget. */
-    turnStartMs: number;
-    /** Structured-output fallback retry: also spell the JSON Schema out in the
-     *  system prompt, for vendors that ignore `response_format`. */
-    promptJsonInstruction?: boolean;
-    /** Set on the single toolChoice:"none" re-ask so it can never recurse. */
-    isToolReask?: boolean;
-};
 /**
  * Inputs to the shared native generate loop (`core/nativeGenerateLoop.ts`).
  * One loop serves every provider whose delegating model exposes a v3-shaped
@@ -1611,6 +1594,8 @@ export type NativeGenerateLoopArgs = {
 };
 export type NativeGenerateLoopResult = {
     text: string;
+    /** Joined reasoning content parts from the final step, when the vendor sent any. */
+    reasoning?: string;
     finishReason: string;
     rawFinishReason?: string;
     inputTokens: number;

package/dist/types/providers.d.ts

@@ -5,7 +5,7 @@ import type { UnknownRecord, JsonValue, StreamingCapability } from "./common.js"
 import type { NeuroLink } from "../neurolink.js";
 import { AIProviderName, AnthropicModels, BedrockModels, DeepSeekModels, GoogleAIModels, LlamaCppModels, LMStudioModels, NvidiaNimModels, OpenAIModels, VertexModels } from "../constants/enums.js";
 import type { ValidationSchema } from "./aliases.js";
-import type { EnhancedGenerateResult, GenerateResult, TextGenerationOptions } from "./generate.js";
+import type { EnhancedGenerateResult, TextGenerationOptions } from "./generate.js";
 import type { MultimodalAudioEntry } from "./file.js";
 import type { StreamOptions, StreamResult } from "./stream.js";
 import type { ProviderError, ProviderErrorRule } from "./errors.js";
@@ -824,20 +824,6 @@ export type ProviderCapability = "text-generation" | "streaming" | "tool-calling
  * Extended tool type that combines AI SDK tools with external MCP tool info
  */
 export type ExtendedTool = Tool & Partial<ExternalMCPToolInfo>;
-/**
- * AI SDK generate result with steps support (extends GenerateResult)
- */
-export type AISDKGenerateResult = GenerateResult & {
-    steps?: Array<{
-        toolCalls?: Array<{
-            toolName?: string;
-            name?: string;
-            [key: string]: unknown;
-        }>;
-        [key: string]: unknown;
-    }>;
-    [key: string]: unknown;
-};
 /**
  * Bedrock tool usage structure
  */
@@ -1852,18 +1838,6 @@ export type LanguageModelObject = {
     readonly modelId: string;
     readonly provider: string;
 };
-/** Step finish event shape for multi-step generation. */
-export type StepFinishEvent = {
-    readonly toolCalls: ReadonlyArray<unknown>;
-    readonly toolResults: ReadonlyArray<unknown>;
-    readonly text: string;
-    readonly finishReason: string;
-    readonly usage: {
-        inputTokens?: number;
-        outputTokens?: number;
-    };
-    [key: string]: unknown;
-};
 /**
  * Represents an AI SDK Tool that may carry a legacy `parameters` field
  * (from AI SDK v3/v4) in addition to the current `inputSchema`.

package/dist/utils/anthropicCacheBreakpoints.d.ts

@@ -17,11 +17,11 @@ export declare const ANTHROPIC_MAX_CACHE_BREAKPOINTS = 4;
 export declare function applyVertexAnthropicCacheBreakpoints(input: VertexAnthropicCacheInput): VertexAnthropicCacheOutput;
 /**
  * Count the `cache_control` markers already present on a request. The direct
- * Anthropic path (AI-SDK pipeline) arrives with markers the upstream layers
- * placed — MessageBuilder tags the system prompt, GenerationHandler tags the
- * last tool definition, and message content blocks may carry translated
- * AI-SDK markers. Anthropic rejects requests with more than four markers, so
- * any additional history breakpoints must fit in the remaining budget.
+ * Anthropic path arrives with markers the upstream layers placed —
+ * MessageBuilder tags the system prompt, the client tags the last tool
+ * definition, and message content blocks may carry their own. Anthropic
+ * rejects requests with more than four markers, so any additional history
+ * breakpoints must fit in the remaining budget.
  */
 export declare function countAnthropicCacheMarkers(input: {
     system?: string | ReadonlyArray<{
@@ -35,7 +35,7 @@ export declare function countAnthropicCacheMarkers(input: {
 /**
  * Rolling history breakpoints for request paths whose stable-prefix markers
  * are managed upstream (direct Anthropic: system via MessageBuilder, last
- * tool via GenerationHandler). Marks the last content block of up to `budget`
+ * tool via the provider client). Marks the last content block of up to `budget`
  * tail messages; a tail block that already carries a marker is left as-is
  * without consuming budget (it already serves as that breakpoint). Pure —
  * the input array is cloned, never mutated.

package/dist/utils/anthropicCacheBreakpoints.js

@@ -63,11 +63,11 @@ export function applyVertexAnthropicCacheBreakpoints(input) {
 }
 /**
  * Count the `cache_control` markers already present on a request. The direct
- * Anthropic path (AI-SDK pipeline) arrives with markers the upstream layers
- * placed — MessageBuilder tags the system prompt, GenerationHandler tags the
- * last tool definition, and message content blocks may carry translated
- * AI-SDK markers. Anthropic rejects requests with more than four markers, so
- * any additional history breakpoints must fit in the remaining budget.
+ * Anthropic path arrives with markers the upstream layers placed —
+ * MessageBuilder tags the system prompt, the client tags the last tool
+ * definition, and message content blocks may carry their own. Anthropic
+ * rejects requests with more than four markers, so any additional history
+ * breakpoints must fit in the remaining budget.
  */
 export function countAnthropicCacheMarkers(input) {
     let count = 0;
@@ -87,7 +87,7 @@ export function countAnthropicCacheMarkers(input) {
 /**
  * Rolling history breakpoints for request paths whose stable-prefix markers
  * are managed upstream (direct Anthropic: system via MessageBuilder, last
- * tool via GenerationHandler). Marks the last content block of up to `budget`
+ * tool via the provider client). Marks the last content block of up to `budget`
  * tail messages; a tail block that already carries a marker is left as-is
  * without consuming budget (it already serves as that breakpoint). Pure —
  * the input array is cloned, never mutated.

package/dist/utils/json/coerce.d.ts

@@ -15,8 +15,9 @@ export declare function schemaAccepts(schema: ValidationSchema | undefined, valu
  * object/array case is handled by `coerceJsonToSchema`; this covers the
  * residual scalar root after that path returns null. Encapsulates the JSON
  * parsing, the empty-string normalization, and the `schemaAccepts` gate so the
- * same policy cannot drift between consumers (`neurolink.recoverStructuredData`
- * and `GenerationHandler.coerceTextMode`).
+ * same policy cannot drift between consumers. `neurolink.recoverStructuredData`
+ * is the only one left; `GenerationHandler.coerceTextMode` was the other until
+ * the ai-package path was deleted.
  */
 export declare function recoverScalarRoot(text: string, schema: ValidationSchema | undefined): ScalarRecoveryDecision;
 /**

package/dist/utils/json/coerce.js

@@ -44,8 +44,9 @@ export function schemaAccepts(schema, value) {
  * object/array case is handled by `coerceJsonToSchema`; this covers the
  * residual scalar root after that path returns null. Encapsulates the JSON
  * parsing, the empty-string normalization, and the `schemaAccepts` gate so the
- * same policy cannot drift between consumers (`neurolink.recoverStructuredData`
- * and `GenerationHandler.coerceTextMode`).
+ * same policy cannot drift between consumers. `neurolink.recoverStructuredData`
+ * is the only one left; `GenerationHandler.coerceTextMode` was the other until
+ * the ai-package path was deleted.
  */
 export function recoverScalarRoot(text, schema) {
     try {