@juspay/neurolink 9.69.0 → 9.69.2

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,8 +12,11 @@ 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.
+ * 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.
@@ -34,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,8 +142,11 @@ 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.
+ * 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.
@@ -195,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

package/dist/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,13 +268,37 @@ 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"
@@ -272,7 +308,9 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                 // 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`.
-                const reasoningText = choice?.message?.reasoning_content ?? choice?.message?.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 });
                 }
@@ -307,11 +345,13 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                         },
                         outputTokens: {
                             total: json.usage?.completion_tokens,
+                            // 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
-                                ? json.usage.completion_tokens -
-                                    json.usage.completion_tokens_details.reasoning_tokens
+                                ? 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,
                         },
@@ -579,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",
@@ -589,7 +629,27 @@ 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`);

package/dist/providers/openaiChatCompletionsClient.js

@@ -397,6 +397,13 @@ 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, onReasoningDelta) => {
@@ -437,7 +444,9 @@ export const parseSSEStream = async (body, onTextDelta, onReasoningDelta) => {
         // 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.
-        const reasoningDelta = delta?.reasoning_content ?? delta?.reasoning;
+        // `||` (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);

package/dist/types/openaiCompatible.d.ts

@@ -248,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/utils/noOutputSentinel.d.ts

@@ -44,7 +44,7 @@ underlyingError?: unknown): Promise<{
  * observation with the enriched status message. Without this, only
  * `StreamHandler`-based providers produced the rich telemetry; the
  * provider-specific paths (openAI, openaiCompatible, litellm,
- * huggingFace, openRouter, anthropicBaseProvider) yielded the sentinel
+ * huggingFace, openRouter, anthropic) yielded the sentinel
  * to direct stream consumers but Pipeline B saw nothing.
  *
  * Stamps three attributes:

package/dist/utils/noOutputSentinel.js

@@ -135,7 +135,7 @@ underlyingError) {
  * observation with the enriched status message. Without this, only
  * `StreamHandler`-based providers produced the rich telemetry; the
  * provider-specific paths (openAI, openaiCompatible, litellm,
- * huggingFace, openRouter, anthropicBaseProvider) yielded the sentinel
+ * huggingFace, openRouter, anthropic) yielded the sentinel
  * to direct stream consumers but Pipeline B saw nothing.
  *
  * Stamps three attributes:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "9.69.0",
+  "version": "9.69.2",
   "packageManager": "pnpm@10.15.1",
   "description": "Universal AI Development Platform with working MCP integration, multi-provider support, voice (TTS/STT/realtime), and professional CLI. 58+ external MCP servers discoverable, multimodal file processing, RAG pipelines. Build, test, and deploy AI applications with 21+ providers: OpenAI, Anthropic, Google AI Studio, Google Vertex, AWS Bedrock, Azure OpenAI, Mistral, LiteLLM, SageMaker, Hugging Face, Ollama, OpenAI-compatible, OpenRouter, DeepSeek, NVIDIA NIM, LM Studio, llama.cpp, plus voice (OpenAI TTS, ElevenLabs, Deepgram, Azure Speech).",
   "author": {
@@ -301,6 +301,7 @@
     "@ai-sdk/mistral": "^3.0.21",
     "@ai-sdk/openai": "^3.0.37",
     "@ai-sdk/provider": "^3.0.8",
+    "@anthropic-ai/sdk": "^0.102.0",
     "@anthropic-ai/vertex-sdk": "^0.16.0",
     "@aws-sdk/client-bedrock": "^3.1000.0",
     "@aws-sdk/client-bedrock-runtime": "^3.1000.0",

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

@@ -1,23 +0,0 @@
-import type { ZodType } from "zod";
-import { type AIProviderName } from "../constants/enums.js";
-import { BaseProvider } from "../core/baseProvider.js";
-import type { StreamOptions, StreamResult } from "../types/index.js";
-import type { LanguageModel, Schema } from "../types/index.js";
-/**
- * Anthropic provider implementation using BaseProvider pattern
- * Migrated from direct API calls to Vercel AI SDK (@ai-sdk/anthropic)
- * Follows exact Google AI interface patterns for compatibility
- */
-export declare class AnthropicProviderV2 extends BaseProvider {
-    constructor(modelName?: string);
-    protected getProviderName(): AIProviderName;
-    protected getDefaultModel(): string;
-    /**
-     * Returns the Vercel AI SDK model instance for Anthropic
-     */
-    protected getAISDKModel(): LanguageModel;
-    protected formatProviderError(error: unknown): Error;
-    private getApiKey;
-    protected executeStream(options: StreamOptions, _analysisSchema?: ZodType | Schema<unknown>): Promise<StreamResult>;
-}
-export default AnthropicProviderV2;

package/dist/lib/providers/anthropicBaseProvider.js

@@ -1,213 +0,0 @@
-import { createAnthropic } from "@ai-sdk/anthropic";
-import { SpanKind, SpanStatusCode, trace } from "@opentelemetry/api";
-import { AnthropicModels } from "../constants/enums.js";
-import { BaseProvider } from "../core/baseProvider.js";
-import { AuthenticationError, NetworkError, ProviderError, RateLimitError, } from "../types/index.js";
-import { logger } from "../utils/logger.js";
-import { buildNoOutputSentinel, detectPostStreamNoOutput, stampNoOutputSpan, } from "../utils/noOutputSentinel.js";
-import { calculateCost } from "../utils/pricing.js";
-import { createAnthropicBaseConfig, validateApiKey, } from "../utils/providerConfig.js";
-import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
-import { resolveToolChoice } from "../utils/toolChoice.js";
-import { getModelId } from "./providerTypeUtils.js";
-import { NoOutputGeneratedError } from "../utils/generationErrors.js";
-import { streamText } from "../utils/generation.js";
-const streamTracer = trace.getTracer("neurolink.provider.anthropic");
-/**
- * Anthropic provider implementation using BaseProvider pattern
- * Migrated from direct API calls to Vercel AI SDK (@ai-sdk/anthropic)
- * Follows exact Google AI interface patterns for compatibility
- */
-export class AnthropicProviderV2 extends BaseProvider {
-    constructor(modelName) {
-        super(modelName, "anthropic");
-        logger.debug("AnthropicProviderV2 initialized", {
-            model: this.modelName,
-            provider: this.providerName,
-        });
-    }
-    // ===================
-    // ABSTRACT METHOD IMPLEMENTATIONS
-    // ===================
-    getProviderName() {
-        return "anthropic";
-    }
-    getDefaultModel() {
-        return process.env.ANTHROPIC_MODEL || AnthropicModels.CLAUDE_3_5_SONNET;
-    }
-    /**
-     * Returns the Vercel AI SDK model instance for Anthropic
-     */
-    getAISDKModel() {
-        const apiKey = this.getApiKey();
-        const anthropic = createAnthropic({ apiKey });
-        return anthropic(this.modelName);
-    }
-    formatProviderError(error) {
-        if (error instanceof TimeoutError) {
-            return new NetworkError(`Request timed out: ${error.message}`, this.providerName);
-        }
-        const errorWithStatus = error;
-        if (errorWithStatus?.status === 401) {
-            return new AuthenticationError("Invalid Anthropic API key. Please check your ANTHROPIC_API_KEY environment variable.", this.providerName);
-        }
-        if (errorWithStatus?.status === 429) {
-            return new RateLimitError("Anthropic rate limit exceeded. Please try again later.", this.providerName);
-        }
-        if (errorWithStatus?.status === 400) {
-            return new ProviderError(`Bad request: ${errorWithStatus?.message || "Invalid request parameters"}`, this.providerName);
-        }
-        return new ProviderError(`Anthropic error: ${errorWithStatus?.message || String(error) || "Unknown error"}`, this.providerName);
-    }
-    // Configuration helper - now using consolidated utility
-    getApiKey() {
-        return validateApiKey(createAnthropicBaseConfig());
-    }
-    // executeGenerate removed - BaseProvider handles all generation with tools
-    async executeStream(options, _analysisSchema) {
-        // Note: StreamOptions validation handled differently than TextGenerationOptions
-        const model = await this.getAISDKModelWithMiddleware(options);
-        const timeout = this.getTimeout(options);
-        const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
-        try {
-            // Get tools - options.tools is pre-merged by BaseProvider.stream()
-            const shouldUseTools = !options.disableTools && this.supportsTools();
-            const tools = shouldUseTools
-                ? options.tools || (await this.getAllTools())
-                : {};
-            // Wrap streamText in an OTel span to capture provider-level latency and token usage
-            const streamSpan = streamTracer.startSpan("neurolink.provider.streamText", {
-                kind: SpanKind.CLIENT,
-                attributes: {
-                    "gen_ai.system": "anthropic",
-                    "gen_ai.request.model": getModelId(model, this.modelName || "unknown"),
-                },
-            });
-            // Reviewer follow-up: capture upstream provider errors via onError
-            // so the post-stream NoOutput detect can propagate the real cause
-            // into the sentinel's providerError / modelResponseRaw.
-            let capturedProviderError;
-            let result;
-            try {
-                result = streamText({
-                    model,
-                    prompt: options.input.text ?? "",
-                    system: options.systemPrompt,
-                    temperature: options.temperature,
-                    maxOutputTokens: options.maxTokens, // No default limit - unlimited unless specified
-                    maxRetries: 0, // NL11: Disable AI SDK's invisible internal retries; we handle retries with OTel instrumentation
-                    tools,
-                    toolChoice: resolveToolChoice(options, tools, shouldUseTools),
-                    abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
-                    experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
-                    experimental_repairToolCall: this.getToolCallRepairFn(options),
-                    onError: (event) => {
-                        capturedProviderError = event.error;
-                        logger.error("AnthropicBaseProvider: Stream error", {
-                            error: event.error instanceof Error
-                                ? event.error.message
-                                : String(event.error),
-                        });
-                    },
-                    onStepFinish: ({ toolCalls, toolResults }) => {
-                        this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {
-                            logger.warn("[AnthropicBaseProvider] Failed to store tool executions", {
-                                provider: this.providerName,
-                                error: error instanceof Error ? error.message : String(error),
-                            });
-                        });
-                    },
-                });
-            }
-            catch (err) {
-                streamSpan.recordException(err instanceof Error ? err : new Error(String(err)));
-                streamSpan.setStatus({
-                    code: SpanStatusCode.ERROR,
-                    message: err instanceof Error ? err.message : String(err),
-                });
-                streamSpan.end();
-                throw err;
-            }
-            // Collect token usage and finish reason asynchronously when the stream completes,
-            // then end the span. This avoids blocking the stream consumer.
-            Promise.resolve(result.usage)
-                .then((usage) => {
-                streamSpan.setAttribute("gen_ai.usage.input_tokens", usage.inputTokens || 0);
-                streamSpan.setAttribute("gen_ai.usage.output_tokens", usage.outputTokens || 0);
-                const cost = calculateCost(this.providerName, this.modelName, {
-                    input: usage.inputTokens || 0,
-                    output: usage.outputTokens || 0,
-                    total: (usage.inputTokens || 0) + (usage.outputTokens || 0),
-                });
-                if (cost && cost > 0) {
-                    streamSpan.setAttribute("neurolink.cost", cost);
-                }
-            })
-                .catch(() => {
-                // Usage may not be available if the stream is aborted
-            });
-            Promise.resolve(result.finishReason)
-                .then((reason) => {
-                streamSpan.setAttribute("gen_ai.response.finish_reason", reason || "unknown");
-            })
-                .catch(() => {
-                // Finish reason may not be available if the stream is aborted
-            });
-            Promise.resolve(result.text)
-                .then(() => {
-                streamSpan.end();
-            })
-                .catch((err) => {
-                streamSpan.setStatus({
-                    code: SpanStatusCode.ERROR,
-                    message: err instanceof Error ? err.message : String(err),
-                });
-                streamSpan.end();
-            });
-            timeoutController?.cleanup();
-            // Transform string stream to content object stream (match Google AI pattern)
-            const transformedStream = async function* () {
-                let chunkCount = 0;
-                try {
-                    for await (const chunk of result.textStream) {
-                        chunkCount++;
-                        yield { content: chunk };
-                    }
-                }
-                catch (streamError) {
-                    if (NoOutputGeneratedError.isInstance(streamError)) {
-                        logger.warn("AnthropicBaseProvider: Stream produced no output (NoOutputGeneratedError) — caught from textStream");
-                        const sentinel = await buildNoOutputSentinel(streamError, result, capturedProviderError);
-                        stampNoOutputSpan(sentinel);
-                        yield sentinel;
-                        return;
-                    }
-                    throw streamError;
-                }
-                // Curator P3-6 (round-2 fix): production trigger sets the error
-                // on result.finishReason rejection, not on textStream iteration.
-                // Surface that path here so the sentinel actually fires.
-                if (chunkCount === 0) {
-                    const detected = await detectPostStreamNoOutput(result, capturedProviderError);
-                    if (detected) {
-                        logger.warn("AnthropicBaseProvider: Stream produced no output (NoOutputGeneratedError) — caught from finishReason rejection");
-                        stampNoOutputSpan(detected.sentinel);
-                        yield detected.sentinel;
-                    }
-                }
-            };
-            return {
-                stream: transformedStream(),
-                provider: this.providerName,
-                model: this.modelName,
-            };
-        }
-        catch (error) {
-            timeoutController?.cleanup();
-            throw this.handleProviderError(error);
-        }
-    }
-}
-// Export for testing
-export default AnthropicProviderV2;
-//# sourceMappingURL=anthropicBaseProvider.js.map

package/dist/providers/anthropicBaseProvider.d.ts

@@ -1,23 +0,0 @@
-import type { ZodType } from "zod";
-import { type AIProviderName } from "../constants/enums.js";
-import { BaseProvider } from "../core/baseProvider.js";
-import type { StreamOptions, StreamResult } from "../types/index.js";
-import type { LanguageModel, Schema } from "../types/index.js";
-/**
- * Anthropic provider implementation using BaseProvider pattern
- * Migrated from direct API calls to Vercel AI SDK (@ai-sdk/anthropic)
- * Follows exact Google AI interface patterns for compatibility
- */
-export declare class AnthropicProviderV2 extends BaseProvider {
-    constructor(modelName?: string);
-    protected getProviderName(): AIProviderName;
-    protected getDefaultModel(): string;
-    /**
-     * Returns the Vercel AI SDK model instance for Anthropic
-     */
-    protected getAISDKModel(): LanguageModel;
-    protected formatProviderError(error: unknown): Error;
-    private getApiKey;
-    protected executeStream(options: StreamOptions, _analysisSchema?: ZodType | Schema<unknown>): Promise<StreamResult>;
-}
-export default AnthropicProviderV2;