@juspay/neurolink 9.54.6 → 9.54.7

package/dist/lib/core/baseProvider.js

@@ -3,12 +3,9 @@ import { generateText } from "ai";
 import { directAgentTools } from "../agent/directTools.js";
 import { IMAGE_GENERATION_MODELS } from "../core/constants.js";
 import { MiddlewareFactory } from "../middleware/factory.js";
-import { SpanStatus, SpanType } from "../types/index.js";
-import { SpanSerializer } from "../observability/utils/spanSerializer.js";
 import { ATTR, tracers } from "../telemetry/index.js";
 import { isAbortError } from "../utils/errorHandling.js";
 import { logger } from "../utils/logger.js";
-import { calculateCost } from "../utils/pricing.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { shouldDisableBuiltinTools } from "../utils/toolUtils.js";
 import { getKeyCount, getKeysAsString } from "../utils/transformationUtils.js";
@@ -61,7 +58,7 @@ export class BaseProvider {
         this.messageBuilder = new MessageBuilder(this.providerName, this.modelName);
         this.streamHandler = new StreamHandler(this.providerName, this.modelName);
         this.telemetryHandler = new TelemetryHandler(this.providerName, this.modelName, this.neurolink);
-        this.generationHandler = new GenerationHandler(this.providerName, this.modelName, () => this.supportsTools(), (options, type) => this.telemetryHandler.getTelemetryConfig(options, type), (toolCalls, toolResults, options, timestamp) => this.handleToolExecutionStorage(toolCalls, toolResults, options, timestamp));
+        this.generationHandler = new GenerationHandler(this.providerName, this.modelName, () => this.supportsTools(), (options, type) => this.telemetryHandler.getTelemetryConfig(options, type), (toolCalls, toolResults, options, timestamp) => this.handleToolExecutionStorage(toolCalls, toolResults, options, timestamp), () => this.neurolink?.getEventEmitter());
         this.utilities = new Utilities(this.providerName, this.modelName, this.defaultTimeout, this.middlewareOptions);
         this.toolsManager = new ToolsManager(this.providerName, this.directTools, this.neurolink, {
             isZodSchema: (schema) => this.isZodSchema(schema),
@@ -87,135 +84,103 @@ export class BaseProvider {
      */
     async stream(optionsOrPrompt, analysisSchema) {
         let options = this.normalizeStreamOptions(optionsOrPrompt);
-        // Observability: create metrics span for provider.stream
-        const metricsSpan = SpanSerializer.createSpan(SpanType.MODEL_GENERATION, "provider.stream", {
-            "ai.provider": this.providerName || "unknown",
-            "ai.model": this.modelName || options.model || "unknown",
-            "ai.temperature": options.temperature,
-            "ai.max_tokens": options.maxTokens,
-        }, this._traceContext?.parentSpanId, this._traceContext?.traceId);
-        let metricsSpanRecorded = false;
-        // OTEL span for provider-level stream tracing
-        const otelStreamSpan = tracers.provider.startSpan("neurolink.provider.stream", {
-            kind: SpanKind.CLIENT,
-            attributes: {
-                [ATTR.GEN_AI_SYSTEM]: this.providerName || "unknown",
-                [ATTR.GEN_AI_MODEL]: this.modelName || options.model || "unknown",
-                [ATTR.GEN_AI_OPERATION]: "stream",
-                [ATTR.NL_PROVIDER]: this.providerName || "unknown",
-            },
+        logger.info(`Starting stream`, {
+            provider: this.providerName,
+            hasTools: !options.disableTools && this.supportsTools(),
+            disableTools: !!options.disableTools,
+            supportsTools: this.supportsTools(),
+            inputLength: options.input?.text?.length || 0,
+            maxTokens: options.maxTokens,
+            temperature: options.temperature,
+            timestamp: Date.now(),
         });
-        try {
-            logger.info(`Starting stream`, {
-                provider: this.providerName,
-                hasTools: !options.disableTools && this.supportsTools(),
-                disableTools: !!options.disableTools,
-                supportsTools: this.supportsTools(),
-                inputLength: options.input?.text?.length || 0,
-                maxTokens: options.maxTokens,
-                temperature: options.temperature,
-                timestamp: Date.now(),
-            });
-            // ===== EARLY MULTIMODAL DETECTION =====
-            const hasFileInput = !!options.input?.files?.length || !!options.input?.videoFiles?.length;
-            if (hasFileInput) {
-                // ===== VIDEO ANALYSIS DETECTION =====
-                // Check if video frames are present and handle with fake streaming
-                const messages = await this.buildMessagesForStream(options);
-                if (hasVideoFrames(messages)) {
-                    logger.info(`Video frames detected in stream, using fake streaming for video analysis`, {
-                        provider: this.providerName,
-                        model: this.modelName,
-                    });
-                    return await this.executeFakeStreaming(options, analysisSchema);
-                }
-            }
-            // CRITICAL: Image generation models don't support real streaming
-            // Force fake streaming for image models to ensure image output is yielded.
-            // Skip this path when the caller explicitly requests non-image output (e.g.
-            // JSON analysis) so dual-mode models like gemini-3.1-flash-image-preview
-            // can still perform text/structured generation.
-            const isImageModel = IMAGE_GENERATION_MODELS.some((m) => this.modelName.includes(m));
-            const requestsNonImageOutput = options.output?.format === "json" ||
-                options.output?.format === "structured" ||
-                options.output?.format === "text";
-            if (isImageModel && !requestsNonImageOutput) {
-                logger.info(`Image model detected, forcing fake streaming`, {
+        // ===== EARLY MULTIMODAL DETECTION =====
+        const hasFileInput = !!options.input?.files?.length || !!options.input?.videoFiles?.length;
+        if (hasFileInput) {
+            // ===== VIDEO ANALYSIS DETECTION =====
+            // Check if video frames are present and handle with fake streaming
+            const messages = await this.buildMessagesForStream(options);
+            if (hasVideoFrames(messages)) {
+                logger.info(`Video frames detected in stream, using fake streaming for video analysis`, {
                     provider: this.providerName,
                     model: this.modelName,
-                    reason: "Image generation requires fake streaming to yield image output",
                 });
-                // Skip real streaming, go directly to fake streaming
                 return await this.executeFakeStreaming(options, analysisSchema);
             }
-            // Central tool merge: Pre-merge base tools (MCP/built-in) with user-provided
-            // tools (e.g. RAG tools) into options.tools. This way, every provider's
-            // executeStream() can simply use options.tools (or getAllTools() + options.tools)
-            // and get the complete tool set without needing per-provider merge logic.
-            if (!options.disableTools && this.supportsTools()) {
-                const mergedTools = await this.getToolsForStream(options);
-                options = { ...options, tools: mergedTools };
-            }
-            else {
-                options = { ...options, tools: {} };
-            }
-            // CRITICAL FIX: Always prefer real streaming over fake streaming
-            // Try real streaming first, use fake streaming only as fallback
-            try {
-                logger.debug(`Attempting real streaming`, {
-                    provider: this.providerName,
-                    timestamp: Date.now(),
-                });
-                const realStreamResult = await this.executeStream(options, analysisSchema);
-                logger.info(`Real streaming succeeded`, {
-                    provider: this.providerName,
-                    timestamp: Date.now(),
-                });
-                // If real streaming succeeds, return it (with tools support via Vercel AI SDK)
-                return realStreamResult;
-            }
-            catch (realStreamError) {
-                logger.warn(`Real streaming failed for ${this.providerName}, falling back to fake streaming:`, {
-                    error: realStreamError instanceof Error
-                        ? realStreamError.message
-                        : String(realStreamError),
-                    timestamp: Date.now(),
-                });
-                // Fallback to fake streaming only if real streaming fails AND tools are enabled
-                if (!options.disableTools && this.supportsTools()) {
-                    return await this.executeFakeStreaming(options, analysisSchema);
-                }
-                else {
-                    // If real streaming failed and no tools are enabled, re-throw the original error
-                    logger.error(`Real streaming failed for ${this.providerName}:`, realStreamError);
-                    throw this.handleProviderError(realStreamError);
-                }
-            }
         }
-        catch (error) {
-            // Observability: record failed stream span
-            metricsSpanRecorded = true;
-            const _endedStreamSpan = SpanSerializer.endSpan(metricsSpan, SpanStatus.ERROR, error instanceof Error ? error.message : String(error));
-            // Note: Do NOT record to getMetricsAggregator() here — neurolink.ts
-            // stream:complete listener handles authoritative metrics to avoid double-counting.
-            otelStreamSpan.setStatus({
-                code: SpanStatusCode.ERROR,
-                message: error instanceof Error ? error.message : String(error),
+        // CRITICAL: Image generation models don't support real streaming
+        // Force fake streaming for image models to ensure image output is yielded.
+        // Skip this path when the caller explicitly requests non-image output (e.g.
+        // JSON analysis) so dual-mode models like gemini-3.1-flash-image-preview
+        // can still perform text/structured generation.
+        const isImageModel = IMAGE_GENERATION_MODELS.some((m) => this.modelName.includes(m));
+        const requestsNonImageOutput = options.output?.format === "json" ||
+            options.output?.format === "structured" ||
+            options.output?.format === "text";
+        if (isImageModel && !requestsNonImageOutput) {
+            logger.info(`Image model detected, forcing fake streaming`, {
+                provider: this.providerName,
+                model: this.modelName,
+                reason: "Image generation requires fake streaming to yield image output",
             });
-            otelStreamSpan.end();
-            throw error;
+            // Skip real streaming, go directly to fake streaming
+            return await this.executeFakeStreaming(options, analysisSchema);
         }
-        finally {
-            // Observability: record successful stream span (only if not already ended via error path)
-            if (!metricsSpanRecorded) {
-                const _endedStreamSpan = SpanSerializer.endSpan(metricsSpan, SpanStatus.OK);
-                // Note: Do NOT record to getMetricsAggregator() here — neurolink.ts
-                // stream:complete listener handles authoritative metrics to avoid double-counting.
+        // Central tool merge: Pre-merge base tools (MCP/built-in) with user-provided
+        // tools (e.g. RAG tools) into options.tools. This way, every provider's
+        // executeStream() can simply use options.tools (or getAllTools() + options.tools)
+        // and get the complete tool set without needing per-provider merge logic.
+        if (!options.disableTools && this.supportsTools()) {
+            const mergedTools = await this.getToolsForStream(options);
+            options = { ...options, tools: mergedTools };
+        }
+        else {
+            options = { ...options, tools: {} };
+        }
+        // CRITICAL FIX: Always prefer real streaming over fake streaming
+        // Try real streaming first, use fake streaming only as fallback
+        try {
+            logger.debug(`Attempting real streaming`, {
+                provider: this.providerName,
+                timestamp: Date.now(),
+            });
+            const realStreamResult = await this.executeStream(options, analysisSchema);
+            logger.info(`Real streaming succeeded`, {
+                provider: this.providerName,
+                timestamp: Date.now(),
+            });
+            // If real streaming succeeds, return it (with tools support via Vercel AI SDK)
+            return realStreamResult;
+        }
+        catch (realStreamError) {
+            // Don't retry on terminal/abort errors — only fall back for
+            // "real streaming with tools is unsupported" style failures.
+            const errMsg = realStreamError instanceof Error
+                ? realStreamError.message
+                : String(realStreamError);
+            const errName = realStreamError instanceof Error ? realStreamError.name : "";
+            if (errName === "AbortError" ||
+                errMsg.includes("abort") ||
+                errMsg.includes("timeout") ||
+                errMsg.includes("401") ||
+                errMsg.includes("403") ||
+                errMsg.includes("quota") ||
+                errMsg.includes("rate limit") ||
+                errMsg.includes("authentication")) {
+                throw this.handleProviderError(realStreamError);
             }
-            // End OTEL span on success (only if not already ended via error path)
-            if (otelStreamSpan.isRecording()) {
-                otelStreamSpan.setStatus({ code: SpanStatusCode.OK });
-                otelStreamSpan.end();
+            logger.warn(`Real streaming failed for ${this.providerName}, falling back to fake streaming:`, {
+                error: errMsg,
+                timestamp: Date.now(),
+            });
+            // Fallback to fake streaming only if real streaming fails AND tools are enabled
+            if (!options.disableTools && this.supportsTools()) {
+                return await this.executeFakeStreaming(options, analysisSchema);
+            }
+            else {
+                // If real streaming failed and no tools are enabled, re-throw the original error
+                logger.error(`Real streaming failed for ${this.providerName}:`, realStreamError);
+                throw this.handleProviderError(realStreamError);
             }
         }
     }
@@ -508,13 +473,6 @@ export class BaseProvider {
         const options = this.normalizeTextOptions(optionsOrPrompt);
         this.validateOptions(options);
         const startTime = Date.now();
-        // Observability: create metrics span for provider.generate
-        const metricsSpan = SpanSerializer.createSpan(SpanType.MODEL_GENERATION, "provider.generate", {
-            "ai.provider": this.providerName || "unknown",
-            "ai.model": this.modelName || options.model || "unknown",
-            "ai.temperature": options.temperature,
-            "ai.max_tokens": options.maxTokens,
-        }, this._traceContext?.parentSpanId, this._traceContext?.traceId);
         // OTEL span for provider-level generate tracing
         // Use startActiveSpan pattern via context.with() so child spans become descendants
         const otelSpan = tracers.provider.startSpan("neurolink.provider.generate", {
@@ -529,7 +487,7 @@ export class BaseProvider {
         // Set this span as the active context so child spans (GenerationHandler, etc.) become descendants
         const activeCtx = trace.setSpan(context.active(), otelSpan);
         const otelSpanState = { ended: false };
-        return await context.with(activeCtx, async () => this.runGenerateInActiveContext(options, startTime, metricsSpan, otelSpan, otelSpanState));
+        return await context.with(activeCtx, async () => this.runGenerateInActiveContext(options, startTime, otelSpan, otelSpanState));
     }
     /**
      * Alias for generate method - implements AIProvider interface
@@ -537,7 +495,7 @@ export class BaseProvider {
     async gen(optionsOrPrompt, analysisSchema) {
         return this.generate(optionsOrPrompt, analysisSchema);
     }
-    async runGenerateInActiveContext(options, startTime, metricsSpan, otelSpan, otelSpanState) {
+    async runGenerateInActiveContext(options, startTime, otelSpan, otelSpanState) {
         try {
             if (options.output?.mode === "video") {
                 return await this.handleVideoGeneration(options, startTime);
@@ -563,10 +521,9 @@ export class BaseProvider {
             if (videoFrameResult) {
                 return videoFrameResult;
             }
-            return await this.executeStandardGenerateFlow(options, startTime, metricsSpan, model, messages, tools);
+            return await this.executeStandardGenerateFlow(options, startTime, model, messages, tools);
         }
         catch (error) {
-            SpanSerializer.endSpan(metricsSpan, SpanStatus.ERROR, error instanceof Error ? error.message : String(error));
             otelSpan.setStatus({
                 code: SpanStatusCode.ERROR,
                 message: error instanceof Error ? error.message : String(error),
@@ -673,7 +630,7 @@ export class BaseProvider {
             usage,
         }, options, startTime);
     }
-    async executeStandardGenerateFlow(options, startTime, metricsSpan, model, messages, tools) {
+    async executeStandardGenerateFlow(options, startTime, model, messages, tools) {
         const timeoutController = createTimeoutController(options.timeout, this.providerName, "generate");
         const composedSignal = composeAbortSignals(options.abortSignal, timeoutController?.controller.signal);
         const composedOptions = composedSignal
@@ -693,23 +650,6 @@ export class BaseProvider {
         const { toolsUsed, toolExecutions } = this.extractToolInformation(generateResult);
         let enhancedResult = this.formatEnhancedResult(generateResult, tools, toolsUsed, toolExecutions, options);
         enhancedResult = await this.synthesizeAIResponseIfNeeded(enhancedResult, options);
-        let enrichedGenerateSpan = { ...metricsSpan };
-        if (enhancedResult?.usage) {
-            enrichedGenerateSpan = SpanSerializer.enrichWithTokenUsage(enrichedGenerateSpan, {
-                promptTokens: enhancedResult.usage.input || 0,
-                completionTokens: enhancedResult.usage.output || 0,
-                totalTokens: enhancedResult.usage.total || 0,
-            });
-            const cost = calculateCost(this.providerName, this.modelName, {
-                input: enhancedResult.usage.input || 0,
-                output: enhancedResult.usage.output || 0,
-                total: enhancedResult.usage.total || 0,
-            });
-            if (cost && cost > 0) {
-                enrichedGenerateSpan = SpanSerializer.enrichWithCost(enrichedGenerateSpan, { totalCost: cost });
-            }
-        }
-        SpanSerializer.endSpan(enrichedGenerateSpan, SpanStatus.OK);
         return this.enhanceResult(enhancedResult, options, startTime);
     }
     async synthesizeAIResponseIfNeeded(enhancedResult, options) {
@@ -1000,7 +940,38 @@ export class BaseProvider {
                 ? error
                 : new DOMException("The operation was aborted", "AbortError");
         }
-        return this.formatProviderError(error);
+        const formatted = this.formatProviderError(error);
+        // P3 fix: Classify error and set error.type on the active OTel span
+        try {
+            const activeSpan = trace.getSpan(context.active());
+            if (activeSpan) {
+                let errorType = "provider_error";
+                const errName = formatted?.constructor?.name ?? "";
+                if (errName === "RateLimitError") {
+                    errorType = "rate_limit";
+                }
+                else if (errName === "AuthenticationError") {
+                    errorType = "auth_failure";
+                }
+                else if (errName === "NetworkError") {
+                    errorType = "network";
+                }
+                else if (errName === "InvalidModelError") {
+                    errorType = "invalid_model";
+                }
+                else if (errName === "TimeoutError") {
+                    errorType = "timeout";
+                }
+                activeSpan.setAttribute("error.type", errorType);
+                if (formatted instanceof Error) {
+                    activeSpan.setAttribute("error.message", formatted.message.substring(0, 500));
+                }
+            }
+        }
+        catch {
+            // Non-blocking — telemetry failures shouldn't mask the original error
+        }
+        return formatted;
     }
     /**
      * Image generation method. Providers that support it should override this.

package/dist/lib/core/infrastructure/baseRegistry.d.ts

@@ -1,11 +1,6 @@
 import type { InfraRegistryEntry } from "../../types/index.js";
-/**
- * Local alias: the canonical type was renamed to InfraRegistryEntry to avoid
- * collision with other RegistryEntry types in the codebase.
- */
-type RegistryEntry<TItem, TMetadata = unknown> = InfraRegistryEntry<TItem, TMetadata>;
 export declare abstract class BaseRegistry<TItem, TMetadata = unknown> {
-    protected items: Map<string, RegistryEntry<TItem, TMetadata>>;
+    protected items: Map<string, InfraRegistryEntry<TItem, TMetadata>>;
     protected initialized: boolean;
     protected initPromise: Promise<void> | null;
     protected abstract registerAll(): Promise<void>;
@@ -22,4 +17,3 @@ export declare abstract class BaseRegistry<TItem, TMetadata = unknown> {
     clear(): void;
     isInitialized(): boolean;
 }
-export {};

package/dist/lib/core/modules/GenerationHandler.d.ts

@@ -14,7 +14,7 @@
  */
 import type { LanguageModel, ModelMessage, Tool } from "ai";
 import { generateText } from "ai";
-import type { AIProviderName, EnhancedGenerateResult, StandardRecord, TextGenerationOptions } from "../../types/index.js";
+import type { AIProviderName, EnhancedGenerateResult, NeuroLinkEvents, StandardRecord, TextGenerationOptions, TypedEventEmitter } from "../../types/index.js";
 /**
  * GenerationHandler class - Handles text generation operations for AI providers
  */
@@ -24,11 +24,12 @@ export declare class GenerationHandler {
     private readonly supportsToolsFn;
     private readonly getTelemetryConfigFn;
     private readonly handleToolStorageFn;
+    private readonly getEmitterFn?;
     constructor(providerName: AIProviderName, modelName: string, supportsToolsFn: () => boolean, getTelemetryConfigFn: (options: TextGenerationOptions, type: string) => {
         isEnabled: boolean;
         functionId?: string;
         metadata?: Record<string, string | number | boolean>;
-    } | undefined, handleToolStorageFn: (toolCalls: unknown[], toolResults: unknown[], options: TextGenerationOptions, timestamp: Date) => Promise<void>);
+    } | undefined, handleToolStorageFn: (toolCalls: unknown[], toolResults: unknown[], options: TextGenerationOptions, timestamp: Date) => Promise<void>, getEmitterFn?: (() => TypedEventEmitter<NeuroLinkEvents> | undefined) | undefined);
     /**
      * Helper method to call generateText with optional structured output
      * @private

package/dist/lib/core/modules/GenerationHandler.js

@@ -17,6 +17,7 @@ import { generateText, NoObjectGeneratedError, Output, stepCountIs } from "ai";
 import { getModelId } from "../../providers/providerTypeUtils.js";
 import { tracers } from "../../telemetry/tracers.js";
 import { logger } from "../../utils/logger.js";
+import { emitToolEndFromStepFinish } from "../../utils/toolEndEmitter.js";
 import { calculateCost } from "../../utils/pricing.js";
 import { withProviderRetry } from "../../utils/providerRetry.js";
 import { calculateCacheSavingsPercent, extractCacheCreationTokens, extractCacheReadTokens, extractTokenUsage, } from "../../utils/tokenUtils.js";
@@ -47,12 +48,14 @@ export class GenerationHandler {
     supportsToolsFn;
     getTelemetryConfigFn;
     handleToolStorageFn;
-    constructor(providerName, modelName, supportsToolsFn, getTelemetryConfigFn, handleToolStorageFn) {
+    getEmitterFn;
+    constructor(providerName, modelName, supportsToolsFn, getTelemetryConfigFn, handleToolStorageFn, getEmitterFn) {
         this.providerName = providerName;
         this.modelName = modelName;
         this.supportsToolsFn = supportsToolsFn;
         this.getTelemetryConfigFn = getTelemetryConfigFn;
         this.handleToolStorageFn = handleToolStorageFn;
+        this.getEmitterFn = getEmitterFn;
     }
     /**
      * Helper method to call generateText with optional structured output
@@ -154,6 +157,11 @@ export class GenerationHandler {
             experimental_telemetry: this.getTelemetryConfigFn(options, "generate"),
             onStepFinish: ({ toolCalls, toolResults }) => {
                 logger.info("Tool execution completed", { toolResults, toolCalls });
+                // Emit tool:end events for Pipeline B (metrics aggregator).
+                // This surfaces AI-SDK-driven tool completions as telemetry events
+                // so that tool spans are created even when the SDK runs tools
+                // internally (gaps G5 / S2).
+                emitToolEndFromStepFinish(this.getEmitterFn?.(), toolResults);
                 // Handle tool execution storage
                 this.handleToolStorageFn(toolCalls, toolResults, options, new Date()).catch((error) => {
                     logger.warn("[GenerationHandler] Failed to store tool executions", {

package/dist/lib/core/modules/StreamHandler.js

@@ -113,6 +113,15 @@ export class StreamHandler {
                 // rather than crashing the process with an unhandled rejection.
                 if (NoOutputGeneratedError.isInstance(error)) {
                     logger.warn(`${providerName}: Stream produced no output (NoOutputGeneratedError), returning empty stream`);
+                    // S4 fix: yield a sentinel chunk so Pipeline B can detect the empty stream
+                    // and set the span to WARNING status instead of OK
+                    yield {
+                        content: "",
+                        metadata: {
+                            noOutput: true,
+                            errorType: "NoOutputGeneratedError",
+                        },
+                    };
                 }
                 else {
                     throw error;

package/dist/lib/core/modules/ToolsManager.js

@@ -442,7 +442,15 @@ export class ToolsManager {
                                 }
                             }
                             customToolSpan.setAttribute("tool.result.status", errorResult ? "error" : "success");
-                            customToolSpan.setStatus({ code: SpanStatusCode.OK });
+                            if (errorResult) {
+                                customToolSpan.setStatus({
+                                    code: SpanStatusCode.ERROR,
+                                    message: `Tool ${toolName} returned isError: true`,
+                                });
+                            }
+                            else {
+                                customToolSpan.setStatus({ code: SpanStatusCode.OK });
+                            }
                             return convertedResult;
                         }
                         // Fallback: direct execution (standalone usage without NeuroLink SDK)
@@ -472,7 +480,15 @@ export class ToolsManager {
                         }
                         customToolSpan.setAttribute("tool.duration_ms", endTime - startTime);
                         customToolSpan.setAttribute("tool.result.status", errorResult ? "error" : "success");
-                        customToolSpan.setStatus({ code: SpanStatusCode.OK });
+                        if (errorResult) {
+                            customToolSpan.setStatus({
+                                code: SpanStatusCode.ERROR,
+                                message: `Tool ${toolName} returned isError: true`,
+                            });
+                        }
+                        else {
+                            customToolSpan.setStatus({ code: SpanStatusCode.OK });
+                        }
                         return convertedResult;
                     }
                     catch (error) {

package/dist/lib/evaluation/BatchEvaluator.d.ts

@@ -2,102 +2,7 @@
  * @file BatchEvaluator - Supports batch evaluation of multiple responses.
  * Enables parallel evaluation with configurable concurrency and error handling.
  */
-import type { LanguageModelV3CallOptions } from "@ai-sdk/provider";
-import type { GenerateResult, EvaluationConfig, EvaluationData, AutoEvaluationConfig } from "../types/index.js";
-/**
- * Configuration for batch evaluation.
- */
-type BatchEvaluationConfig = EvaluationConfig & {
-    /** Maximum number of concurrent evaluations (default: 5) */
-    concurrency?: number;
-    /** Whether to continue on individual failures (default: true) */
-    continueOnError?: boolean;
-    /** Maximum retries for retryable errors (default: 2) */
-    maxRetries?: number;
-    /** Delay between retries in milliseconds (default: 1000) */
-    retryDelay?: number;
-    /** Callback for progress updates */
-    onProgress?: (progress: BatchProgress) => void;
-    /** Callback for individual evaluation completion */
-    onItemComplete?: (result: BatchEvaluationItemResult) => void;
-};
-/**
- * Progress information for batch evaluation.
- */
-type BatchProgress = {
-    /** Total items to evaluate */
-    total: number;
-    /** Items completed (success + failed) */
-    completed: number;
-    /** Items that succeeded */
-    succeeded: number;
-    /** Items that failed */
-    failed: number;
-    /** Items still pending */
-    pending: number;
-    /** Percentage complete */
-    percentComplete: number;
-};
-/**
- * Input item for batch evaluation.
- */
-type BatchEvaluationItem = {
-    /** Unique identifier for this item */
-    id: string;
-    /** The generation options */
-    options: LanguageModelV3CallOptions;
-    /** The generation result to evaluate */
-    result: GenerateResult;
-    /** Optional item-specific threshold override */
-    threshold?: number;
-};
-/**
- * Result for a single item in batch evaluation.
- */
-type BatchEvaluationItemResult = {
-    /** The item ID */
-    id: string;
-    /** Whether the evaluation succeeded */
-    success: boolean;
-    /** The evaluation data (if successful) */
-    data?: EvaluationData;
-    /** Error information (if failed) */
-    error?: {
-        message: string;
-        code?: string;
-        retryable?: boolean;
-    };
-    /** Time taken for this evaluation in milliseconds */
-    duration: number;
-    /** Number of retry attempts (if any) */
-    retryCount: number;
-};
-/**
- * Result of a batch evaluation operation.
- */
-type BatchEvaluationResult = {
-    /** All item results */
-    results: BatchEvaluationItemResult[];
-    /** Summary statistics */
-    summary: {
-        /** Total items evaluated */
-        total: number;
-        /** Number of successful evaluations */
-        succeeded: number;
-        /** Number of failed evaluations */
-        failed: number;
-        /** Average evaluation score (for successful items) */
-        averageScore: number;
-        /** Average evaluation time in milliseconds */
-        averageDuration: number;
-        /** Total time for batch evaluation */
-        totalDuration: number;
-        /** Passing rate (percentage of items meeting threshold) */
-        passingRate: number;
-    };
-    /** Whether all evaluations succeeded */
-    allSucceeded: boolean;
-};
+import type { AutoEvaluationConfig, BatchEvaluationConfig, BatchEvaluationItem, BatchEvaluationResult } from "../types/index.js";
 /**
  * BatchEvaluator - Performs evaluation on multiple items in parallel.
  * Supports configurable concurrency, retry logic, and progress tracking.
@@ -158,4 +63,3 @@ export declare class BatchEvaluator {
      */
     private delay;
 }
-export {};