@juspay/neurolink 9.68.21 → 9.69.1

package/dist/lib/providers/deepseek.d.ts

@@ -16,12 +16,12 @@ import { OpenAIChatCompletionsProvider } from "./openaiChatCompletionsBase.js";
  *      `@ai-sdk/openai-compatible` path this migration replaced. The base
  *      client injects the literal "json" word the API requires for that mode.
  *
- *   2. Reasoning support — the opt-in `thinking` request param (non-reasoner
- *      chat models) and `reasoning_content` surfacing (deepseek-reasoner / R1)
- *      both require plumbing the thinking signal and the reasoning delta
- *      through the native base client. That plumbing isn't in place yet, so
- *      neither is wired here; it is tracked as a base-client follow-up. All
- *      other behavior is preserved.
+ *   2. Reasoning support — `reasoning_content` (deepseek-reasoner / R1) is
+ *      surfaced automatically by the native base client: streamed deltas
+ *      arrive as `{ content: "", reasoning }` chunks and the non-streaming
+ *      result carries `result.reasoning`. The opt-in `thinking` request
+ *      param (non-reasoner chat models) still needs thinking-signal plumbing
+ *      and is tracked as a follow-up. All other behavior is preserved.
  *
  * @see https://api-docs.deepseek.com
  */

package/dist/lib/providers/deepseek.js

@@ -27,12 +27,12 @@ const getDefaultDeepSeekModel = () => {
  *      `@ai-sdk/openai-compatible` path this migration replaced. The base
  *      client injects the literal "json" word the API requires for that mode.
  *
- *   2. Reasoning support — the opt-in `thinking` request param (non-reasoner
- *      chat models) and `reasoning_content` surfacing (deepseek-reasoner / R1)
- *      both require plumbing the thinking signal and the reasoning delta
- *      through the native base client. That plumbing isn't in place yet, so
- *      neither is wired here; it is tracked as a base-client follow-up. All
- *      other behavior is preserved.
+ *   2. Reasoning support — `reasoning_content` (deepseek-reasoner / R1) is
+ *      surfaced automatically by the native base client: streamed deltas
+ *      arrive as `{ content: "", reasoning }` chunks and the non-streaming
+ *      result carries `result.reasoning`. The opt-in `thinking` request
+ *      param (non-reasoner chat models) still needs thinking-signal plumbing
+ *      and is tracked as a follow-up. All other behavior is preserved.
  *
  * @see https://api-docs.deepseek.com
  */

package/dist/lib/providers/nvidiaNim.d.ts

@@ -1,5 +1,5 @@
 import type { AIProviderName } from "../constants/enums.js";
-import type { NeurolinkCredentials, OpenAICompatBuildBodyArgs } from "../types/index.js";
+import type { NeurolinkCredentials, OpenAICompatBuildBodyArgs, OpenAICompatChatRequest } from "../types/index.js";
 import { OpenAIChatCompletionsProvider } from "./openaiChatCompletionsBase.js";
 declare const isNimFieldRejection: (body: string, field: string) => boolean;
 /**
@@ -12,9 +12,14 @@ declare const stripFieldFromJsonBody: (body: string, field: "reasoning_budget" |
  * NVIDIA NIM Provider — native HTTP+SSE, no AI SDK.
  *
  * Wraps NVIDIA's hosted (or self-hosted) inference endpoints.
- * Passes NIM-specific extras (top_k, min_p, repetition_penalty,
- * chat_template_kwargs.reasoning_budget) via adjustBuildBodyOptions.
- * reasoning_content surfacing is a pending base-client follow-up (not emitted natively yet); all other behavior is preserved.
+ * Passes NIM-specific extras (top_k, min_p, repetition_penalty, min_tokens,
+ * chat_template, chat_template_kwargs.reasoning_budget) to the wire via the
+ * `extraBody` channel of adjustBuildBodyOptions, and retries once without
+ * `chat_template`/`reasoning_budget` when a model server rejects them with a
+ * 400 (adjustBodyAfter400 — applies on both generate and stream paths).
+ * reasoning_content is surfaced automatically by the native base client
+ * (streamed as `{ content: "", reasoning }` chunks; `result.reasoning` on
+ * the non-streaming path); all other behavior is preserved.
  *
  * @see https://docs.api.nvidia.com/nim/reference/
  */
@@ -32,6 +37,17 @@ export declare class NvidiaNimProvider extends OpenAIChatCompletionsProvider {
      * value is the full StreamOptions object.
      */
     protected adjustBuildBodyOptions(_modelId: string, opts: OpenAICompatBuildBodyArgs["options"]): OpenAICompatBuildBodyArgs["options"] & Record<string, unknown>;
+    /**
+     * One-shot 400 retry (base hook): some NIM model servers reject
+     * `chat_template` or `chat_template_kwargs.reasoning_budget` with a 400
+     * naming the field. Strip the rejected field(s) and let the base retry
+     * once, restoring the pre-migration fetch-level behavior. Returns
+     * undefined for unrelated 400s so they propagate unchanged.
+     */
+    protected adjustBodyAfter400(body: OpenAICompatChatRequest, error: Error & {
+        statusCode?: number;
+        responseBody?: string;
+    }): OpenAICompatChatRequest | undefined;
     protected formatProviderError(error: unknown): Error;
     validateConfiguration(): Promise<boolean>;
     getConfiguration(): {

package/dist/lib/providers/nvidiaNim.js

@@ -142,9 +142,14 @@ const getDefaultNimModel = () => {
  * NVIDIA NIM Provider — native HTTP+SSE, no AI SDK.
  *
  * Wraps NVIDIA's hosted (or self-hosted) inference endpoints.
- * Passes NIM-specific extras (top_k, min_p, repetition_penalty,
- * chat_template_kwargs.reasoning_budget) via adjustBuildBodyOptions.
- * reasoning_content surfacing is a pending base-client follow-up (not emitted natively yet); all other behavior is preserved.
+ * Passes NIM-specific extras (top_k, min_p, repetition_penalty, min_tokens,
+ * chat_template, chat_template_kwargs.reasoning_budget) to the wire via the
+ * `extraBody` channel of adjustBuildBodyOptions, and retries once without
+ * `chat_template`/`reasoning_budget` when a model server rejects them with a
+ * 400 (adjustBodyAfter400 — applies on both generate and stream paths).
+ * reasoning_content is surfaced automatically by the native base client
+ * (streamed as `{ content: "", reasoning }` chunks; `result.reasoning` on
+ * the non-streaming path); all other behavior is preserved.
  *
  * @see https://docs.api.nvidia.com/nim/reference/
  */
@@ -193,7 +198,43 @@ export class NvidiaNimProvider extends OpenAIChatCompletionsProvider {
         const thinkingEnabled = tl !== undefined && tl !== "minimal";
         const maxTokens = typeof fullOpts.maxTokens === "number" ? fullOpts.maxTokens : undefined;
         const extra = buildNvidiaNimExtraBody(thinkingEnabled, maxTokens);
-        return { ...opts, ...extra };
+        // Attach via the explicit extraBody channel — buildBody spreads it onto
+        // the wire body. (Loose unknown keys on the returned options object are
+        // dropped by buildBody, which is why the extras previously never reached
+        // the wire.)
+        return Object.keys(extra).length > 0
+            ? { ...opts, extraBody: extra }
+            : opts;
+    }
+    /**
+     * One-shot 400 retry (base hook): some NIM model servers reject
+     * `chat_template` or `chat_template_kwargs.reasoning_budget` with a 400
+     * naming the field. Strip the rejected field(s) and let the base retry
+     * once, restoring the pre-migration fetch-level behavior. Returns
+     * undefined for unrelated 400s so they propagate unchanged.
+     */
+    adjustBodyAfter400(body, error) {
+        const responseBody = error.responseBody ?? "";
+        let serialized = JSON.stringify(body);
+        const strippedFields = [];
+        for (const field of ["chat_template", "reasoning_budget"]) {
+            if (isNimFieldRejection(responseBody, field)) {
+                const next = stripFieldFromJsonBody(serialized, field);
+                if (next !== null) {
+                    serialized = next;
+                    strippedFields.push(field);
+                }
+            }
+        }
+        if (strippedFields.length === 0) {
+            return undefined;
+        }
+        logger.debug("NVIDIA NIM: 400 rejected request field(s) — retrying once without them", {
+            strippedFields,
+            model: body.model,
+            rejection: responseBody.slice(0, 200),
+        });
+        return JSON.parse(serialized);
     }
     formatProviderError(error) {
         if (error instanceof TimeoutError) {

package/dist/lib/providers/openaiChatCompletionsBase.d.ts

@@ -70,6 +70,18 @@ export declare abstract class OpenAIChatCompletionsProvider extends BaseProvider
      * `max_tokens` and require `max_completion_tokens`.
      */
     protected adjustRequestBody(body: OpenAICompatChatRequest, _modelId: string): OpenAICompatChatRequest;
+    /**
+     * Hook called when a request fails with HTTP 400. Return a modified body to
+     * retry ONCE with it; return undefined (default) to propagate the error
+     * unchanged. Applies on both the non-streaming doGenerate path and the
+     * streaming path. NVIDIA NIM uses this to strip `chat_template` /
+     * `chat_template_kwargs.reasoning_budget` when a model server rejects them,
+     * restoring the pre-migration fetch-level retry behavior.
+     */
+    protected adjustBodyAfter400(_body: OpenAICompatChatRequest, _error: Error & {
+        statusCode?: number;
+        responseBody?: string;
+    }): OpenAICompatChatRequest | undefined;
     /**
      * Hook called once at the start of every `executeStream` invocation.
      * Return lifecycle listeners (onUsage / onFinish) to receive deferred

package/dist/lib/providers/openaiChatCompletionsBase.js

@@ -86,6 +86,17 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
     adjustRequestBody(body, _modelId) {
         return body;
     }
+    /**
+     * Hook called when a request fails with HTTP 400. Return a modified body to
+     * retry ONCE with it; return undefined (default) to propagate the error
+     * unchanged. Applies on both the non-streaming doGenerate path and the
+     * streaming path. NVIDIA NIM uses this to strip `chat_template` /
+     * `chat_template_kwargs.reasoning_budget` when a model server rejects them,
+     * restoring the pre-migration fetch-level retry behavior.
+     */
+    adjustBodyAfter400(_body, _error) {
+        return undefined;
+    }
     /**
      * Hook called once at the start of every `executeStream` invocation.
      * Return lifecycle listeners (onUsage / onFinish) to receive deferred
@@ -209,6 +220,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
         const adjustBuildBodyOptions = this.adjustBuildBodyOptions.bind(this);
         const adjustResponseFormat = this.adjustResponseFormat.bind(this);
         const adjustRequestBody = this.adjustRequestBody.bind(this);
+        const adjustBodyAfter400 = this.adjustBodyAfter400.bind(this);
         const getTimeoutForOptions = (opts) => this.getTimeout((opts ?? {}));
         return {
             specificationVersion: "v3",
@@ -256,19 +268,52 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                         body: JSON.stringify(body),
                         ...(composedSignal ? { signal: composedSignal } : {}),
                     });
+                    if (!res.ok) {
+                        const apiErr = await buildAPIError(url, body, res);
+                        // One-shot 400 retry: a subclass may strip a rejected field and
+                        // return a modified body (e.g. NIM's chat_template /
+                        // reasoning_budget). The retry runs under the SAME timeout
+                        // controller as the first attempt, so the configured timeout caps
+                        // the overall call — matching the streaming path, which reuses
+                        // its composed signal for the retry.
+                        const retryBody = res.status === 400
+                            ? adjustBodyAfter400(body, apiErr)
+                            : undefined;
+                        if (!retryBody) {
+                            throw apiErr;
+                        }
+                        res = await fetchImpl(url, {
+                            method: "POST",
+                            headers: {
+                                "Content-Type": "application/json",
+                                ...getAuthHeaders(),
+                            },
+                            body: JSON.stringify(retryBody),
+                            ...(composedSignal ? { signal: composedSignal } : {}),
+                        });
+                        if (!res.ok) {
+                            throw await buildAPIError(url, retryBody, res);
+                        }
+                    }
                 }
                 finally {
                     timeoutController?.cleanup();
                 }
-                if (!res.ok) {
-                    throw await buildAPIError(url, body, res);
-                }
                 const json = (await res.json());
                 const choice = json.choices?.[0];
                 const text = (typeof choice?.message?.content === "string"
                     ? choice.message.content
                     : "") ?? "";
                 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`.
+                // `||` 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;
+                if (typeof reasoningText === "string" && reasoningText.length > 0) {
+                    content.push({ type: "reasoning", text: reasoningText });
+                }
                 if (text.length > 0) {
                     content.push({ type: "text", text });
                 }
@@ -300,8 +345,15 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                         },
                         outputTokens: {
                             total: json.usage?.completion_tokens,
-                            text: json.usage?.completion_tokens,
-                            reasoning: undefined,
+                            // Clamped at 0 — some gateways report inconsistent usage where
+                            // reasoning_tokens exceeds completion_tokens.
+                            text: json.usage?.completion_tokens !== undefined &&
+                                json.usage?.completion_tokens_details?.reasoning_tokens !==
+                                    undefined
+                                ? Math.max(0, json.usage.completion_tokens -
+                                    json.usage.completion_tokens_details.reasoning_tokens)
+                                : json.usage?.completion_tokens,
+                            reasoning: json.usage?.completion_tokens_details?.reasoning_tokens,
                         },
                     },
                     warnings: [],
@@ -567,7 +619,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                 : {}),
             streaming: true,
         }), args.modelId));
-        const res = await args.fetchImpl(args.url, {
+        let res = await args.fetchImpl(args.url, {
             method: "POST",
             headers: {
                 "Content-Type": "application/json",
@@ -577,13 +629,37 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
             ...(args.abortSignal ? { signal: args.abortSignal } : {}),
         });
         if (!res.ok) {
-            throw await buildAPIError(args.url, body, res);
+            const apiErr = await buildAPIError(args.url, body, res);
+            // One-shot 400 retry — same hook as the doGenerate path (e.g. NIM
+            // strips chat_template/reasoning_budget when a model rejects them).
+            const retryBody = res.status === 400
+                ? this.adjustBodyAfter400(body, apiErr)
+                : undefined;
+            if (!retryBody) {
+                throw apiErr;
+            }
+            res = await args.fetchImpl(args.url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    ...this.getAuthHeaders(),
+                },
+                body: JSON.stringify(retryBody),
+                ...(args.abortSignal ? { signal: args.abortSignal } : {}),
+            });
+            if (!res.ok) {
+                throw await buildAPIError(args.url, retryBody, res);
+            }
         }
         if (!res.body) {
             throw new Error(`${this.providerName}: stream response had no body`);
         }
         return parseSSEStream(res.body, (delta) => {
             args.pushChunk({ content: delta });
+        }, (reasoningDelta) => {
+            // Reasoning rides alongside an empty `content` so plain-text
+            // consumers (which only read chunk.content) are unaffected.
+            args.pushChunk({ content: "", reasoning: reasoningDelta });
         });
     }
     async executeToolBatch(args) {

package/dist/lib/providers/openaiChatCompletionsClient.d.ts

@@ -35,7 +35,7 @@ export declare const messagesContainJsonWord: (messages: ReadonlyArray<OpenAICom
 export declare const ensureJsonWordInBody: (body: OpenAICompatChatRequest) => OpenAICompatChatRequest;
 export declare const requiresMaxCompletionTokens: (modelId: string) => boolean;
 export declare const buildBody: (args: OpenAICompatBuildBodyArgs) => OpenAICompatChatRequest;
-export declare const parseSSEStream: (body: ReadableStream<Uint8Array>, onTextDelta: (delta: string) => void) => Promise<OpenAICompatSSEResult>;
+export declare const parseSSEStream: (body: ReadableStream<Uint8Array>, onTextDelta: (delta: string) => void, onReasoningDelta?: (delta: string) => void) => Promise<OpenAICompatSSEResult>;
 export declare const buildAPIError: (url: string, body: OpenAICompatChatRequest, res: Response) => Promise<Error>;
 export declare const createDeferredAnalytics: () => {
     usagePromise: Promise<{

package/dist/lib/providers/openaiChatCompletionsClient.js

@@ -397,11 +397,19 @@ export const buildBody = (args) => {
     if (responseFormat) {
         body.response_format = responseFormat;
     }
+    // Provider-specific extras attached via options.extraBody (the explicit
+    // channel from adjustBuildBodyOptions) land verbatim on the wire body.
+    // Spread last — a provider that puts a core field here is intentionally
+    // overriding it.
+    if (options.extraBody) {
+        Object.assign(body, options.extraBody);
+    }
     return body;
 };
-export const parseSSEStream = async (body, onTextDelta) => {
+export const parseSSEStream = async (body, onTextDelta, onReasoningDelta) => {
     const result = {
         text: "",
+        reasoning: "",
         toolCalls: new Map(),
         finishReason: null,
         usage: undefined,
@@ -433,6 +441,16 @@ export const parseSSEStream = async (body, onTextDelta) => {
             result.text += delta.content;
             onTextDelta(delta.content);
         }
+        // Reasoner-model deltas: DeepSeek/NIM emit `reasoning_content`, some
+        // gateways emit `reasoning`. The AI SDK's openai-compatible wrapper
+        // surfaced these automatically; the native client must do the same.
+        // `||` (not `??`) so an empty-string reasoning_content falls through to
+        // a non-empty `reasoning` field instead of shadowing it.
+        const reasoningDelta = delta?.reasoning_content || delta?.reasoning;
+        if (reasoningDelta) {
+            result.reasoning += reasoningDelta;
+            onReasoningDelta?.(reasoningDelta);
+        }
         if (delta?.tool_calls) {
             for (const tc of delta.tool_calls) {
                 let state = result.toolCalls.get(tc.index);

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

@@ -104,6 +104,8 @@ export type OpenAICompatChatChoiceMessage = {
     content?: string | null;
     tool_calls?: OpenAICompatToolCallWire[];
     refusal?: string | null;
+    reasoning_content?: string | null;
+    reasoning?: string | null;
 };
 export type OpenAICompatChatChoice = {
     index: number;
@@ -132,6 +134,8 @@ export type OpenAICompatStreamDelta = {
         };
     }>;
     refusal?: string | null;
+    reasoning_content?: string | null;
+    reasoning?: string | null;
 };
 export type OpenAICompatStreamChunkChoice = {
     index: number;
@@ -186,6 +190,8 @@ export type OpenAICompatMessage = {
 };
 export type OpenAICompatSSEResult = {
     text: string;
+    /** Accumulated reasoner-model output (`reasoning_content` / `reasoning` deltas). */
+    reasoning: string;
     toolCalls: Map<number, {
         id: string;
         name: string;
@@ -196,6 +202,7 @@ export type OpenAICompatSSEResult = {
 };
 export type OpenAICompatStreamChunk = {
     content: string;
+    reasoning?: string;
 } | {
     done: true;
 };
@@ -241,6 +248,14 @@ export type OpenAICompatBuildBodyArgs = {
         frequencyPenalty?: number | null;
         seed?: number | null;
         stopSequences?: string[];
+        /**
+         * Provider-specific extra wire fields, spread verbatim onto the final
+         * request body by `buildBody` (after the standard fields). This is the
+         * explicit channel for non-OpenAI knobs (e.g. NVIDIA NIM's `top_k` /
+         * `chat_template_kwargs`) — loose unknown keys returned from
+         * `adjustBuildBodyOptions` are intentionally NOT forwarded.
+         */
+        extraBody?: Record<string, unknown>;
     };
     tools?: OpenAICompatChatTool[];
     toolChoice?: OpenAICompatToolChoiceWire;

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

@@ -498,6 +498,7 @@ export type StreamOptions = {
 export type StreamResult = {
     stream: AsyncIterable<{
         content: string;
+        reasoning?: string;
     } | StreamNoOutputSentinel | {
         type: "audio";
         audio: AudioChunk;

package/dist/providers/deepseek.d.ts

@@ -16,12 +16,12 @@ import { OpenAIChatCompletionsProvider } from "./openaiChatCompletionsBase.js";
  *      `@ai-sdk/openai-compatible` path this migration replaced. The base
  *      client injects the literal "json" word the API requires for that mode.
  *
- *   2. Reasoning support — the opt-in `thinking` request param (non-reasoner
- *      chat models) and `reasoning_content` surfacing (deepseek-reasoner / R1)
- *      both require plumbing the thinking signal and the reasoning delta
- *      through the native base client. That plumbing isn't in place yet, so
- *      neither is wired here; it is tracked as a base-client follow-up. All
- *      other behavior is preserved.
+ *   2. Reasoning support — `reasoning_content` (deepseek-reasoner / R1) is
+ *      surfaced automatically by the native base client: streamed deltas
+ *      arrive as `{ content: "", reasoning }` chunks and the non-streaming
+ *      result carries `result.reasoning`. The opt-in `thinking` request
+ *      param (non-reasoner chat models) still needs thinking-signal plumbing
+ *      and is tracked as a follow-up. All other behavior is preserved.
  *
  * @see https://api-docs.deepseek.com
  */

package/dist/providers/deepseek.js

@@ -27,12 +27,12 @@ const getDefaultDeepSeekModel = () => {
  *      `@ai-sdk/openai-compatible` path this migration replaced. The base
  *      client injects the literal "json" word the API requires for that mode.
  *
- *   2. Reasoning support — the opt-in `thinking` request param (non-reasoner
- *      chat models) and `reasoning_content` surfacing (deepseek-reasoner / R1)
- *      both require plumbing the thinking signal and the reasoning delta
- *      through the native base client. That plumbing isn't in place yet, so
- *      neither is wired here; it is tracked as a base-client follow-up. All
- *      other behavior is preserved.
+ *   2. Reasoning support — `reasoning_content` (deepseek-reasoner / R1) is
+ *      surfaced automatically by the native base client: streamed deltas
+ *      arrive as `{ content: "", reasoning }` chunks and the non-streaming
+ *      result carries `result.reasoning`. The opt-in `thinking` request
+ *      param (non-reasoner chat models) still needs thinking-signal plumbing
+ *      and is tracked as a follow-up. All other behavior is preserved.
  *
  * @see https://api-docs.deepseek.com
  */

package/dist/providers/nvidiaNim.d.ts

@@ -1,5 +1,5 @@
 import type { AIProviderName } from "../constants/enums.js";
-import type { NeurolinkCredentials, OpenAICompatBuildBodyArgs } from "../types/index.js";
+import type { NeurolinkCredentials, OpenAICompatBuildBodyArgs, OpenAICompatChatRequest } from "../types/index.js";
 import { OpenAIChatCompletionsProvider } from "./openaiChatCompletionsBase.js";
 declare const isNimFieldRejection: (body: string, field: string) => boolean;
 /**
@@ -12,9 +12,14 @@ declare const stripFieldFromJsonBody: (body: string, field: "reasoning_budget" |
  * NVIDIA NIM Provider — native HTTP+SSE, no AI SDK.
  *
  * Wraps NVIDIA's hosted (or self-hosted) inference endpoints.
- * Passes NIM-specific extras (top_k, min_p, repetition_penalty,
- * chat_template_kwargs.reasoning_budget) via adjustBuildBodyOptions.
- * reasoning_content surfacing is a pending base-client follow-up (not emitted natively yet); all other behavior is preserved.
+ * Passes NIM-specific extras (top_k, min_p, repetition_penalty, min_tokens,
+ * chat_template, chat_template_kwargs.reasoning_budget) to the wire via the
+ * `extraBody` channel of adjustBuildBodyOptions, and retries once without
+ * `chat_template`/`reasoning_budget` when a model server rejects them with a
+ * 400 (adjustBodyAfter400 — applies on both generate and stream paths).
+ * reasoning_content is surfaced automatically by the native base client
+ * (streamed as `{ content: "", reasoning }` chunks; `result.reasoning` on
+ * the non-streaming path); all other behavior is preserved.
  *
  * @see https://docs.api.nvidia.com/nim/reference/
  */
@@ -32,6 +37,17 @@ export declare class NvidiaNimProvider extends OpenAIChatCompletionsProvider {
      * value is the full StreamOptions object.
      */
     protected adjustBuildBodyOptions(_modelId: string, opts: OpenAICompatBuildBodyArgs["options"]): OpenAICompatBuildBodyArgs["options"] & Record<string, unknown>;
+    /**
+     * One-shot 400 retry (base hook): some NIM model servers reject
+     * `chat_template` or `chat_template_kwargs.reasoning_budget` with a 400
+     * naming the field. Strip the rejected field(s) and let the base retry
+     * once, restoring the pre-migration fetch-level behavior. Returns
+     * undefined for unrelated 400s so they propagate unchanged.
+     */
+    protected adjustBodyAfter400(body: OpenAICompatChatRequest, error: Error & {
+        statusCode?: number;
+        responseBody?: string;
+    }): OpenAICompatChatRequest | undefined;
     protected formatProviderError(error: unknown): Error;
     validateConfiguration(): Promise<boolean>;
     getConfiguration(): {

package/dist/providers/nvidiaNim.js

@@ -142,9 +142,14 @@ const getDefaultNimModel = () => {
  * NVIDIA NIM Provider — native HTTP+SSE, no AI SDK.
  *
  * Wraps NVIDIA's hosted (or self-hosted) inference endpoints.
- * Passes NIM-specific extras (top_k, min_p, repetition_penalty,
- * chat_template_kwargs.reasoning_budget) via adjustBuildBodyOptions.
- * reasoning_content surfacing is a pending base-client follow-up (not emitted natively yet); all other behavior is preserved.
+ * Passes NIM-specific extras (top_k, min_p, repetition_penalty, min_tokens,
+ * chat_template, chat_template_kwargs.reasoning_budget) to the wire via the
+ * `extraBody` channel of adjustBuildBodyOptions, and retries once without
+ * `chat_template`/`reasoning_budget` when a model server rejects them with a
+ * 400 (adjustBodyAfter400 — applies on both generate and stream paths).
+ * reasoning_content is surfaced automatically by the native base client
+ * (streamed as `{ content: "", reasoning }` chunks; `result.reasoning` on
+ * the non-streaming path); all other behavior is preserved.
  *
  * @see https://docs.api.nvidia.com/nim/reference/
  */
@@ -193,7 +198,43 @@ export class NvidiaNimProvider extends OpenAIChatCompletionsProvider {
         const thinkingEnabled = tl !== undefined && tl !== "minimal";
         const maxTokens = typeof fullOpts.maxTokens === "number" ? fullOpts.maxTokens : undefined;
         const extra = buildNvidiaNimExtraBody(thinkingEnabled, maxTokens);
-        return { ...opts, ...extra };
+        // Attach via the explicit extraBody channel — buildBody spreads it onto
+        // the wire body. (Loose unknown keys on the returned options object are
+        // dropped by buildBody, which is why the extras previously never reached
+        // the wire.)
+        return Object.keys(extra).length > 0
+            ? { ...opts, extraBody: extra }
+            : opts;
+    }
+    /**
+     * One-shot 400 retry (base hook): some NIM model servers reject
+     * `chat_template` or `chat_template_kwargs.reasoning_budget` with a 400
+     * naming the field. Strip the rejected field(s) and let the base retry
+     * once, restoring the pre-migration fetch-level behavior. Returns
+     * undefined for unrelated 400s so they propagate unchanged.
+     */
+    adjustBodyAfter400(body, error) {
+        const responseBody = error.responseBody ?? "";
+        let serialized = JSON.stringify(body);
+        const strippedFields = [];
+        for (const field of ["chat_template", "reasoning_budget"]) {
+            if (isNimFieldRejection(responseBody, field)) {
+                const next = stripFieldFromJsonBody(serialized, field);
+                if (next !== null) {
+                    serialized = next;
+                    strippedFields.push(field);
+                }
+            }
+        }
+        if (strippedFields.length === 0) {
+            return undefined;
+        }
+        logger.debug("NVIDIA NIM: 400 rejected request field(s) — retrying once without them", {
+            strippedFields,
+            model: body.model,
+            rejection: responseBody.slice(0, 200),
+        });
+        return JSON.parse(serialized);
     }
     formatProviderError(error) {
         if (error instanceof TimeoutError) {

package/dist/providers/openaiChatCompletionsBase.d.ts

@@ -70,6 +70,18 @@ export declare abstract class OpenAIChatCompletionsProvider extends BaseProvider
      * `max_tokens` and require `max_completion_tokens`.
      */
     protected adjustRequestBody(body: OpenAICompatChatRequest, _modelId: string): OpenAICompatChatRequest;
+    /**
+     * Hook called when a request fails with HTTP 400. Return a modified body to
+     * retry ONCE with it; return undefined (default) to propagate the error
+     * unchanged. Applies on both the non-streaming doGenerate path and the
+     * streaming path. NVIDIA NIM uses this to strip `chat_template` /
+     * `chat_template_kwargs.reasoning_budget` when a model server rejects them,
+     * restoring the pre-migration fetch-level retry behavior.
+     */
+    protected adjustBodyAfter400(_body: OpenAICompatChatRequest, _error: Error & {
+        statusCode?: number;
+        responseBody?: string;
+    }): OpenAICompatChatRequest | undefined;
     /**
      * Hook called once at the start of every `executeStream` invocation.
      * Return lifecycle listeners (onUsage / onFinish) to receive deferred