@juspay/neurolink 9.14.0 → 9.16.0

package/dist/lib/providers/anthropicBaseProvider.js

@@ -1,11 +1,14 @@
 import { createAnthropic } from "@ai-sdk/anthropic";
 import { streamText } from "ai";
+import { trace, SpanKind, SpanStatusCode } from "@opentelemetry/api";
 import { AIProviderName, AnthropicModels } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import { AuthenticationError, NetworkError, ProviderError, RateLimitError, } from "../types/errors.js";
 import { logger } from "../utils/logger.js";
+import { calculateCost } from "../utils/pricing.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { validateApiKey, createAnthropicBaseConfig, } from "../utils/providerConfig.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)
@@ -68,25 +71,82 @@ export class AnthropicProviderV2 extends BaseProvider {
             const tools = shouldUseTools
                 ? options.tools || (await this.getAllTools())
                 : {};
-            const result = await streamText({
-                model,
-                prompt: options.input.text,
-                system: options.systemPrompt,
-                temperature: options.temperature,
-                maxTokens: options.maxTokens, // No default limit - unlimited unless specified
-                tools,
-                toolChoice: shouldUseTools ? "auto" : "none",
-                abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
-                experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
-                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),
-                        });
-                    });
+            // 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": model.modelId || this.modelName || "unknown",
                 },
             });
+            let result;
+            try {
+                result = streamText({
+                    model,
+                    prompt: options.input.text,
+                    system: options.systemPrompt,
+                    temperature: options.temperature,
+                    maxTokens: 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: shouldUseTools ? "auto" : "none",
+                    abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
+                    experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
+                    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.
+            result.usage
+                .then((usage) => {
+                streamSpan.setAttribute("gen_ai.usage.input_tokens", usage.promptTokens || 0);
+                streamSpan.setAttribute("gen_ai.usage.output_tokens", usage.completionTokens || 0);
+                const cost = calculateCost(this.providerName, this.modelName, {
+                    input: usage.promptTokens || 0,
+                    output: usage.completionTokens || 0,
+                    total: (usage.promptTokens || 0) + (usage.completionTokens || 0),
+                });
+                if (cost && cost > 0) {
+                    streamSpan.setAttribute("neurolink.cost", cost);
+                }
+            })
+                .catch(() => {
+                // Usage may not be available if the stream is aborted
+            });
+            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
+            });
+            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* () {

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

@@ -56,7 +56,7 @@ export declare class GoogleAIStudioProvider extends BaseProvider {
      */
     private detectImageType;
     /**
-     * Estimate token count from text (simple character-based estimation)
+     * Estimate token count from text using centralized estimation with provider multipliers
      */
     private estimateTokenCount;
     protected executeStream(options: StreamOptions, _analysisSchema?: ZodUnknownSchema | Schema<unknown>): Promise<StreamResult>;