@juspay/neurolink 9.94.6 → 9.95.0

package/dist/neurolink.js

@@ -59,6 +59,7 @@ import { buildSkillActivationMessage } from "./skills/skillSessionTracker.js";
 import { SkillsManager } from "./skills/skillsManager.js";
 import { createSkillCallTools, createSkillTools } from "./skills/skillTools.js";
 import { getMetricsAggregator, MetricsAggregator, } from "./observability/metricsAggregator.js";
+import { AnalyticsService, calculateAdvancedCost, parseAnalyticsQualityScore, } from "./analytics/index.js";
 import { SpanStatus, SpanType, CircuitBreakerOpenError, ConversationMemoryError, ModelAccessDeniedError, } from "./types/index.js";
 import { SpanSerializer } from "./observability/utils/spanSerializer.js";
 import { flushOpenTelemetry, getLangfuseContext, getLangfuseHealthStatus, initializeOpenTelemetry, isOpenTelemetryInitialized, runWithCurrentLangfuseContext, setLangfuseContext, shutdownOpenTelemetry, stampGuestRescueIdentity, } from "./services/server/ai/observability/instrumentation.js";
@@ -802,6 +803,7 @@ export class NeuroLink {
      */
     observabilityConfig;
     metricsAggregator = new MetricsAggregator();
+    analyticsService;
     /**
      * Per-request metrics trace context backed by AsyncLocalStorage.
      * Safe for concurrent requests on the same SDK instance.
@@ -814,6 +816,7 @@ export class NeuroLink {
         this.toolRegistry = config?.toolRegistry || new MCPToolRegistry();
         this.fileRegistry = new FileReferenceRegistry();
         this.observabilityConfig = config?.observability;
+        this.analyticsService = new AnalyticsService();
         // Initialize orchestration setting
         this.enableOrchestration = config?.enableOrchestration ?? false;
         // NL-004: Initialize model alias configuration
@@ -2564,6 +2567,38 @@ Current user's request: ${currentInput}`;
     recordMetricsSpan(span) {
         this.metricsAggregator.recordSpan(span);
     }
+    /**
+     * Get provider metrics analysis
+     * Retrieves aggregated performance, token usage, latency, and success rates per provider.
+     *
+     * @param options - Filtering options
+     * @returns Comprehensive provider metrics result
+     */
+    async getProviderMetrics(options) {
+        // Propagate unexpected failures — empty datasets are returned by the
+        // service as valid zeroed results; fabricating those here hid real bugs.
+        return this.analyticsService.getProviderMetrics(options);
+    }
+    /**
+     * Get cost analysis breakdown
+     * Analyzes AI generation costs across requested groups and provides future projections.
+     *
+     * @param options - Cost configuration options
+     * @returns Detailed cost analysis breakdown
+     */
+    async getCostAnalysis(options) {
+        return this.analyticsService.getCostAnalysis(options);
+    }
+    /**
+     * Get team-wide usage analytics
+     * Retrieves request counts, unique active users, provider breakdown, and quality scoring.
+     *
+     * @param options - Team query options
+     * @returns Comprehensive team analytics report
+     */
+    async getTeamAnalytics(options) {
+        return this.analyticsService.getTeamAnalytics(options);
+    }
     /**
      * Record a memory operation span to both instance and global metrics aggregators.
      * This ensures memory spans are visible via sdk.getSpans() and getMetricsAggregator().getSpans().
@@ -2661,29 +2696,49 @@ Current user's request: ${currentInput}`;
         }
     }
     /**
-     * Initialize event listeners that feed span data to MetricsAggregator.
-     * Listens to generation:end, stream:complete, and tool:end events.
+     * Fire-and-forget analytics tracking with rejection logging.
      */
-    initializeMetricsListeners() {
-        this.emitter.on("generation:end", ((...args) => {
-            const data = args[0];
-            // A2 fix: When Pipeline A (AI SDK → @langfuse/otel) already creates a
-            // GENERATION observation, skip the Pipeline B span to avoid duplicates.
-            // Native providers (Bedrock, Ollama, Gemini 3) do NOT set this flag —
-            // Pipeline B remains their only observation source.
-            if (data.pipelineAHandled) {
-                return;
-            }
-            try {
-                const result = data.result;
-                const usage = result?.usage;
-                const analytics = result?.analytics;
-                const provider = data.provider ||
-                    result?.provider ||
-                    "unknown";
-                const model = result?.model || "unknown";
-                const responseTime = data.responseTime || 0;
-                const traceCtx = this._metricsTraceContext;
+    enqueueAnalyticsTrackRequest(record) {
+        this.analyticsService.trackRequest(record).catch((error) => {
+            logger.debug("[NeuroLink] analytics trackRequest failed", {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        });
+    }
+    /**
+     * Estimate cost using the canonical SDK pricing table (same source as
+     * AnalyticsService.trackRequest) — avoids diverging TokenTracker rates.
+     */
+    estimateCostFromUsage(provider, model, usage) {
+        if (!usage || model === "unknown") {
+            return undefined;
+        }
+        const totalCost = calculateAdvancedCost(model, usage.input || 0, usage.output || 0, provider === "unknown" ? undefined : provider);
+        return totalCost > 0 ? totalCost : undefined;
+    }
+    /**
+     * Handle generation:end for Pipeline B spans + advanced analytics.
+     * When pipelineAHandled is set, skips Pipeline B spans but still tracks
+     * analytics so successful AI-SDK generate/stream calls are recorded.
+     * Stream analytics are owned here (not stream:complete) to avoid duplicates.
+     */
+    handleGenerationEndMetrics(data) {
+        const skipPipelineBSpan = data.pipelineAHandled === true;
+        try {
+            const result = data.result;
+            const usage = result?.usage;
+            const analytics = result?.analytics;
+            const provider = data.provider || result?.provider || "unknown";
+            const model = result?.model || data.model || "unknown";
+            const responseTime = data.responseTime || 0;
+            const eventTimestamp = typeof data.timestamp === "number" && Number.isFinite(data.timestamp)
+                ? data.timestamp
+                : Date.now();
+            const traceCtx = this._metricsTraceContext;
+            let computedCost = typeof analytics?.cost === "number" && Number.isFinite(analytics.cost)
+                ? analytics.cost
+                : undefined;
+            if (!skipPipelineBSpan) {
                 let span = SpanSerializer.createGenerationSpan({
                     provider,
                     model,
@@ -2693,17 +2748,9 @@ Current user's request: ${currentInput}`;
                     temperature: data.temperature,
                     maxTokens: data.maxTokens,
                 });
-                // Link to the OTel parent span; each Pipeline B span keeps its own
-                // unique spanId to comply with OTel/W3C uniqueness requirements.
                 if (traceCtx) {
                     span.parentSpanId = traceCtx.parentSpanId;
                 }
-                // Mark failed generations with ERROR status so metrics count them
-                // correctly. Client aborts (data.aborted === true) are NOT failures —
-                // they are user-initiated cancellations and must not pollute the
-                // failure rate. Map them to WARNING with the canonical
-                // "Generation aborted by client" message (matches the Langfuse
-                // ContextEnricher mapping for outer/internal generation spans).
                 let spanStatus;
                 let statusMessage;
                 if (data.aborted === true) {
@@ -2719,7 +2766,6 @@ Current user's request: ${currentInput}`;
                 }
                 span = SpanSerializer.endSpan(span, spanStatus, statusMessage);
                 span.durationMs = responseTime;
-                // G2 fix: Check finishReason and escalate to WARNING for partial failures
                 const finishReason = result?.finishReason ??
                     data.finishReason;
                 if (finishReason) {
@@ -2728,7 +2774,6 @@ Current user's request: ${currentInput}`;
                         span = SpanSerializer.endSpan(span, SpanStatus.WARNING, `Generation stopped: finishReason=${finishReason}`);
                     }
                 }
-                // G6 fix: Record retry count on Pipeline B span
                 if (data.retryCount !== undefined) {
                     span.attributes["gen_ai.retry_count"] = data.retryCount;
                 }
@@ -2744,24 +2789,14 @@ Current user's request: ${currentInput}`;
                         totalCost: analytics.cost,
                     });
                 }
-                else if (usage && model !== "unknown") {
-                    // Fallback: compute cost from token usage + built-in pricing
-                    const tokenTracker = this.metricsAggregator.getTokenTracker();
-                    const pricing = tokenTracker.getModelPricing(model);
-                    if (pricing) {
-                        const inputCost = ((usage.input || 0) / 1_000_000) * pricing.inputPricePerMillion;
-                        const outputCost = ((usage.output || 0) / 1_000_000) * pricing.outputPricePerMillion;
-                        const totalCost = inputCost + outputCost;
-                        if (totalCost > 0) {
-                            span = SpanSerializer.enrichWithCost(span, {
-                                inputCost,
-                                outputCost,
-                                totalCost,
-                            });
-                        }
+                else {
+                    const estimated = this.estimateCostFromUsage(provider, model, usage);
+                    if (estimated !== undefined) {
+                        span = SpanSerializer.enrichWithCost(span, {
+                            totalCost: estimated,
+                        });
                     }
                 }
-                // Record output (truncated for safety)
                 const content = result?.content || result?.text;
                 if (content) {
                     span = SpanSerializer.updateAttributes(span, {
@@ -2772,174 +2807,218 @@ Current user's request: ${currentInput}`;
                 }
                 this.metricsAggregator.recordSpan(span);
                 getMetricsAggregator().recordSpan(span);
+                const spanCost = span.attributes["ai.cost.total"];
+                if (typeof spanCost === "number" && spanCost > 0) {
+                    computedCost = spanCost;
+                }
+                this.enqueueAnalyticsTrackRequest({
+                    provider,
+                    model,
+                    userId: data.userId || data.user || undefined,
+                    teamId: data.teamId || undefined,
+                    department: data.department || undefined,
+                    timestamp: eventTimestamp,
+                    latency: responseTime,
+                    inputTokens: usage?.input || 0,
+                    outputTokens: usage?.output || 0,
+                    totalTokens: usage?.total || (usage?.input || 0) + (usage?.output || 0),
+                    cost: computedCost,
+                    isError: span.status === SpanStatus.ERROR,
+                    errorMessage: statusMessage,
+                    qualityScore: parseAnalyticsQualityScore(data.qualityScore),
+                });
             }
-            catch {
-                // Non-blocking
-            }
-        }));
-        this.emitter.on("stream:complete", ((...args) => {
-            const data = args[0];
-            try {
-                const metadata = data.metadata;
-                const durationMs = metadata?.durationMs || 0;
-                const chunkCount = metadata?.chunkCount || 0;
-                const totalLength = metadata?.totalLength || 0;
-                const provider = data.provider || "unknown";
-                const model = data.model || "unknown";
-                const traceCtx = this._metricsTraceContext;
-                let span = SpanSerializer.createGenerationSpan({
+            else {
+                // Pipeline A handled the observation — still record analytics so
+                // successful AI-SDK generate()/stream() calls are not silently dropped.
+                if (computedCost === undefined) {
+                    computedCost = this.estimateCostFromUsage(provider, model, usage);
+                }
+                this.enqueueAnalyticsTrackRequest({
                     provider,
                     model,
-                    name: `gen_ai.${provider}.stream`,
-                    traceId: traceCtx?.traceId,
+                    userId: data.userId || data.user || undefined,
+                    teamId: data.teamId || undefined,
+                    department: data.department || undefined,
+                    timestamp: eventTimestamp,
+                    latency: responseTime,
+                    inputTokens: usage?.input || 0,
+                    outputTokens: usage?.output || 0,
+                    totalTokens: usage?.total || (usage?.input || 0) + (usage?.output || 0),
+                    cost: computedCost,
+                    isError: data.success === false || Boolean(data.error),
+                    errorMessage: data.error ? String(data.error) : undefined,
+                    qualityScore: parseAnalyticsQualityScore(data.qualityScore),
                 });
-                // Link to the OTel parent span; keep unique spanId per W3C spec.
-                if (traceCtx) {
-                    span.parentSpanId = traceCtx.parentSpanId;
+            }
+        }
+        catch {
+            // Non-blocking
+        }
+    }
+    /**
+     * Pipeline B span recording for stream:complete.
+     * Advanced analytics are recorded from generation:end only (avoids duplicates
+     * when both stream:complete and generation:end fire for the same request).
+     */
+    handleStreamCompleteMetrics(data) {
+        try {
+            const metadata = data.metadata;
+            const durationMs = metadata?.durationMs || 0;
+            const chunkCount = metadata?.chunkCount || 0;
+            const totalLength = metadata?.totalLength || 0;
+            const provider = data.provider || "unknown";
+            const model = data.model || "unknown";
+            const traceCtx = this._metricsTraceContext;
+            let span = SpanSerializer.createGenerationSpan({
+                provider,
+                model,
+                name: `gen_ai.${provider}.stream`,
+                traceId: traceCtx?.traceId,
+            });
+            if (traceCtx) {
+                span.parentSpanId = traceCtx.parentSpanId;
+            }
+            span = SpanSerializer.endSpan(span, SpanStatus.OK);
+            span.durationMs = durationMs;
+            span.attributes["stream.chunk_count"] = chunkCount;
+            span.attributes["stream.content_length"] = totalLength;
+            const streamFinishReason = metadata?.finishReason ??
+                data.finishReason;
+            if (streamFinishReason) {
+                span.attributes["gen_ai.finish_reason"] = streamFinishReason;
+                if (streamFinishReason === "content-filter" ||
+                    streamFinishReason === "length") {
+                    span = SpanSerializer.endSpan(span, SpanStatus.WARNING, `Stream stopped: finishReason=${streamFinishReason}`);
+                }
+            }
+            if (data.prompt) {
+                const promptStr = String(data.prompt);
+                span = SpanSerializer.updateAttributes(span, {
+                    input: promptStr.length > 5000
+                        ? promptStr.substring(0, 5000) + "...[truncated]"
+                        : promptStr,
+                });
+            }
+            const streamContent = data.content;
+            if (streamContent) {
+                span = SpanSerializer.updateAttributes(span, {
+                    output: streamContent.length > 5000
+                        ? streamContent.substring(0, 5000) + "...[truncated]"
+                        : streamContent,
+                });
+            }
+            const usage = metadata?.usage;
+            if (usage) {
+                span = SpanSerializer.enrichWithTokenUsage(span, {
+                    promptTokens: usage.input || 0,
+                    completionTokens: usage.output || 0,
+                    totalTokens: usage.total || (usage.input || 0) + (usage.output || 0),
+                });
+                const estimated = this.estimateCostFromUsage(provider, model, usage);
+                if (estimated !== undefined) {
+                    span = SpanSerializer.enrichWithCost(span, { totalCost: estimated });
                 }
-                span = SpanSerializer.endSpan(span, SpanStatus.OK);
-                span.durationMs = durationMs;
-                span.attributes["stream.chunk_count"] = chunkCount;
-                span.attributes["stream.content_length"] = totalLength;
-                // S3 fix: Record finishReason on Pipeline B stream span
-                const streamFinishReason = metadata?.finishReason ??
-                    data.finishReason;
-                if (streamFinishReason) {
-                    span.attributes["gen_ai.finish_reason"] = streamFinishReason;
-                    if (streamFinishReason === "content-filter" ||
-                        streamFinishReason === "length") {
-                        span = SpanSerializer.endSpan(span, SpanStatus.WARNING, `Stream stopped: finishReason=${streamFinishReason}`);
-                    }
+            }
+            this.metricsAggregator.recordSpan(span);
+            getMetricsAggregator().recordSpan(span);
+        }
+        catch {
+            // Non-blocking
+        }
+    }
+    handleToolEndMetrics(data) {
+        try {
+            const toolName = data.toolName || data.tool || "unknown";
+            const responseTime = data.responseTime || data.duration || 0;
+            const success = data.success !== undefined ? data.success : !data.error;
+            const traceCtx = this._metricsTraceContext;
+            let span = SpanSerializer.createSpan(SpanType.TOOL_CALL, `tool.${toolName}`, {
+                "tool.name": toolName,
+                "tool.success": success,
+            }, traceCtx?.parentSpanId, traceCtx?.traceId);
+            span = SpanSerializer.endSpan(span, success ? SpanStatus.OK : SpanStatus.ERROR);
+            span.durationMs = responseTime;
+            if (!success) {
+                if (data.error) {
+                    span.statusMessage = String(data.error);
                 }
-                // Record stream input prompt
-                if (data.prompt) {
-                    const promptStr = String(data.prompt);
-                    span = SpanSerializer.updateAttributes(span, {
-                        input: promptStr.length > 5000
-                            ? promptStr.substring(0, 5000) + "...[truncated]"
-                            : promptStr,
-                    });
+                else if (data.result) {
+                    span.statusMessage = extractMcpErrorText(data.result);
                 }
-                // Record streamed output (truncated for safety)
-                const streamContent = data.content;
-                if (streamContent) {
-                    span = SpanSerializer.updateAttributes(span, {
-                        output: streamContent.length > 5000
-                            ? streamContent.substring(0, 5000) + "...[truncated]"
-                            : streamContent,
-                    });
+            }
+            if (data.result) {
+                try {
+                    span.attributes["tool.result"] = JSON.stringify(data.result).substring(0, 500);
                 }
-                // Enrich stream span with token usage if available
-                const usage = metadata?.usage;
-                if (usage) {
-                    span = SpanSerializer.enrichWithTokenUsage(span, {
-                        promptTokens: usage.input || 0,
-                        completionTokens: usage.output || 0,
-                        totalTokens: usage.total || (usage.input || 0) + (usage.output || 0),
-                    });
-                    // Compute cost from token usage
-                    if (model !== "unknown") {
-                        const tokenTracker = this.metricsAggregator.getTokenTracker();
-                        const pricing = tokenTracker.getModelPricing(model);
-                        if (pricing) {
-                            const inputCost = ((usage.input || 0) / 1_000_000) * pricing.inputPricePerMillion;
-                            const outputCost = ((usage.output || 0) / 1_000_000) *
-                                pricing.outputPricePerMillion;
-                            const totalCost = inputCost + outputCost;
-                            if (totalCost > 0) {
-                                span = SpanSerializer.enrichWithCost(span, {
-                                    inputCost,
-                                    outputCost,
-                                    totalCost,
-                                });
-                            }
-                        }
-                    }
+                catch {
+                    // Non-blocking
                 }
-                this.metricsAggregator.recordSpan(span);
-                getMetricsAggregator().recordSpan(span);
             }
-            catch {
-                // Non-blocking
+            this.metricsAggregator.recordSpan(span);
+            getMetricsAggregator().recordSpan(span);
+        }
+        catch {
+            // Non-blocking
+        }
+    }
+    /**
+     * Pipeline B span recording for stream:error.
+     * Analytics for failed streams come from generation:end (success: false).
+     */
+    handleStreamErrorMetrics(data) {
+        try {
+            const metadata = data.metadata;
+            const durationMs = metadata?.durationMs || 0;
+            const chunkCount = metadata?.chunkCount || 0;
+            const errorName = metadata?.errorName || "UnknownError";
+            const errorMessage = data.content || "Stream error";
+            const provider = data.provider || "unknown";
+            const model = data.model || "unknown";
+            const traceCtx = this._metricsTraceContext;
+            let span = SpanSerializer.createGenerationSpan({
+                provider,
+                model,
+                name: `gen_ai.${provider}.stream.error`,
+                traceId: traceCtx?.traceId,
+            });
+            if (traceCtx) {
+                span.parentSpanId = traceCtx.parentSpanId;
             }
+            span = SpanSerializer.endSpan(span, SpanStatus.ERROR);
+            span.durationMs = durationMs;
+            span.statusMessage = `${errorName}: ${errorMessage}`;
+            span.attributes["stream.chunk_count"] = chunkCount;
+            const isAbort = errorName === "AbortError" ||
+                errorMessage.toLowerCase().includes("aborted") ||
+                errorMessage.toLowerCase().includes("abort");
+            span.attributes["error.type"] = isAbort ? "abort" : errorName;
+            if (isAbort) {
+                span.attributes["stream.aborted"] = true;
+            }
+            this.metricsAggregator.recordSpan(span);
+            getMetricsAggregator().recordSpan(span);
+        }
+        catch {
+            // Non-blocking
+        }
+    }
+    /**
+     * Initialize event listeners that feed span data to MetricsAggregator.
+     * Listens to generation:end, stream:complete, and tool:end events.
+     */
+    initializeMetricsListeners() {
+        this.emitter.on("generation:end", ((...args) => {
+            this.handleGenerationEndMetrics(args[0]);
+        }));
+        this.emitter.on("stream:complete", ((...args) => {
+            this.handleStreamCompleteMetrics(args[0]);
         }));
         this.emitter.on("tool:end", ((...args) => {
-            const data = args[0];
-            try {
-                // Handle both event formats: {toolName} (from emitToolEnd) and {tool} (from executeToolInternal)
-                const toolName = data.toolName || data.tool || "unknown";
-                const responseTime = data.responseTime || data.duration || 0;
-                // success is explicit in one format; infer from error presence in the other
-                const success = data.success !== undefined ? data.success : !data.error;
-                const traceCtx = this._metricsTraceContext;
-                let span = SpanSerializer.createSpan(SpanType.TOOL_CALL, `tool.${toolName}`, {
-                    "tool.name": toolName,
-                    "tool.success": success,
-                }, traceCtx?.parentSpanId, traceCtx?.traceId);
-                span = SpanSerializer.endSpan(span, success ? SpanStatus.OK : SpanStatus.ERROR);
-                span.durationMs = responseTime;
-                if (!success) {
-                    if (data.error) {
-                        span.statusMessage = String(data.error);
-                    }
-                    else if (data.result) {
-                        span.statusMessage = extractMcpErrorText(data.result);
-                    }
-                }
-                if (data.result) {
-                    try {
-                        span.attributes["tool.result"] = JSON.stringify(data.result).substring(0, 500);
-                    }
-                    catch {
-                        // Non-blocking
-                    }
-                }
-                this.metricsAggregator.recordSpan(span);
-                getMetricsAggregator().recordSpan(span);
-            }
-            catch {
-                // Non-blocking
-            }
+            this.handleToolEndMetrics(args[0]);
         }));
         this.emitter.on("stream:error", ((...args) => {
-            const data = args[0];
-            try {
-                const metadata = data.metadata;
-                const durationMs = metadata?.durationMs || 0;
-                const chunkCount = metadata?.chunkCount || 0;
-                const errorName = metadata?.errorName || "UnknownError";
-                const errorMessage = data.content || "Stream error";
-                const provider = data.provider || "unknown";
-                const model = data.model || "unknown";
-                const traceCtx = this._metricsTraceContext;
-                let span = SpanSerializer.createGenerationSpan({
-                    provider,
-                    model,
-                    name: `gen_ai.${provider}.stream.error`,
-                    traceId: traceCtx?.traceId,
-                });
-                // Link to the OTel parent span; keep unique spanId per W3C spec.
-                if (traceCtx) {
-                    span.parentSpanId = traceCtx.parentSpanId;
-                }
-                span = SpanSerializer.endSpan(span, SpanStatus.ERROR);
-                span.durationMs = durationMs;
-                span.statusMessage = `${errorName}: ${errorMessage}`;
-                span.attributes["stream.chunk_count"] = chunkCount;
-                // S7 fix: Distinguish aborts from errors
-                const isAbort = errorName === "AbortError" ||
-                    errorMessage.toLowerCase().includes("aborted") ||
-                    errorMessage.toLowerCase().includes("abort");
-                span.attributes["error.type"] = isAbort ? "abort" : errorName;
-                if (isAbort) {
-                    span.attributes["stream.aborted"] = true;
-                }
-                this.metricsAggregator.recordSpan(span);
-                getMetricsAggregator().recordSpan(span);
-            }
-            catch {
-                // Non-blocking
-            }
+            this.handleStreamErrorMetrics(args[0]);
         }));
     }
     /**
@@ -8251,21 +8330,40 @@ Current user's request: ${currentInput}`;
                         responseTimeMs: Date.now() - startTime,
                         contentLength: fallbackAccumulatedContent.length,
                     });
-                    // S6 fix: Emit stream:complete after successful fallback so Pipeline B records it
+                    // S6 fix: Emit stream:complete after successful fallback so Pipeline B records it.
+                    // Also emit generation:end so advanced analytics tracks the successful fallback
+                    // (stream:complete no longer records analytics — avoids double-counting elsewhere).
                     try {
+                        const fallbackModel = options.model || "unknown";
+                        const fallbackDuration = Date.now() - startTime;
                         self.emitter.emit("stream:complete", {
                             content: fallbackAccumulatedContent,
                             provider: providerName,
-                            model: options.model || "unknown",
+                            model: fallbackModel,
                             finishReason: "stop",
                             metadata: {
-                                durationMs: Date.now() - startTime,
+                                durationMs: fallbackDuration,
                                 chunkCount: 0,
                                 totalLength: fallbackAccumulatedContent.length,
                                 isFallback: true,
                                 finishReason: "stop",
                             },
                         });
+                        self.emitter.emit("generation:end", {
+                            provider: providerName,
+                            model: fallbackModel,
+                            responseTime: fallbackDuration,
+                            timestamp: Date.now(),
+                            result: {
+                                content: fallbackAccumulatedContent,
+                                usage: { input: 0, output: 0, total: 0 },
+                                model: fallbackModel,
+                                provider: providerName,
+                                finishReason: "stop",
+                            },
+                            success: true,
+                            pipelineAHandled: true,
+                        });
                     }
                     catch {
                         /* non-blocking */