@juspay/neurolink 9.54.5 → 9.54.7

package/dist/lib/providers/amazonBedrock.js

@@ -4,15 +4,17 @@ import path from "path";
 import { createAnalytics } from "../core/analytics.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
-import { AuthenticationError, ProviderError } from "../types/index.js";
+import { AuthenticationError, ProviderError, RateLimitError, } from "../types/index.js";
 import { isAbortError, withTimeout } from "../utils/errorHandling.js";
+import { emitToolEndFromStepFinish } from "../utils/toolEndEmitter.js";
 import { logger } from "../utils/logger.js";
 import { calculateCost } from "../utils/pricing.js";
 import { buildMultimodalMessagesArray } from "../utils/messageBuilder.js";
 import { buildMultimodalOptions } from "../utils/multimodalOptionsBuilder.js";
 import { convertZodToJsonSchema } from "../utils/schemaConversion.js";
-import { trace, SpanKind, SpanStatusCode } from "@opentelemetry/api";
-const bedrockTracer = trace.getTracer("neurolink.bedrock");
+import { SpanKind, SpanStatusCode } from "@opentelemetry/api";
+import { tracers } from "../telemetry/index.js";
+const bedrockTracer = tracers.provider;
 // Bedrock-specific types now imported from ../types/providerSpecific.js
 export class AmazonBedrockProvider extends BaseProvider {
     bedrockClient;
@@ -114,6 +116,7 @@ export class AmazonBedrockProvider extends BaseProvider {
     // Override the main generate method to implement conversation management
     async generate(optionsOrPrompt) {
         logger.debug("[AmazonBedrockProvider] generate() called with conversation management");
+        const generateStartTime = Date.now();
         const options = typeof optionsOrPrompt === "string"
             ? { prompt: optionsOrPrompt }
             : optionsOrPrompt;
@@ -159,10 +162,55 @@ export class AmazonBedrockProvider extends BaseProvider {
         }
         logger.debug(`[AmazonBedrockProvider] Starting conversation with ${this.conversationHistory.length} message(s)`);
         // Start conversation loop and return enhanced result
-        const text = await this.conversationLoop(options);
+        let text;
+        let usage;
+        let finishReason;
+        try {
+            ({ text, usage, finishReason } = await this.conversationLoop(options));
+        }
+        catch (error) {
+            // Emit failure generation:end so Pipeline B records the failed generation
+            const failEmitter = this.neurolink?.getEventEmitter();
+            if (failEmitter) {
+                failEmitter.emit("generation:end", {
+                    provider: this.providerName,
+                    responseTime: Date.now() - generateStartTime,
+                    timestamp: Date.now(),
+                    result: {
+                        content: "",
+                        usage: { input: 0, output: 0, total: 0 },
+                        model: this.modelName || this.getDefaultModel(),
+                        provider: this.providerName,
+                        finishReason: "error",
+                    },
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+            throw error;
+        }
+        // Emit generation:end so Pipeline B (Langfuse) creates a GENERATION observation.
+        // Bedrock bypasses the Vercel AI SDK so experimental_telemetry is never injected;
+        // we emit the event manually to fill that gap.
+        const generateEmitter = this.neurolink?.getEventEmitter();
+        if (generateEmitter) {
+            generateEmitter.emit("generation:end", {
+                provider: this.providerName,
+                responseTime: Date.now() - generateStartTime,
+                timestamp: Date.now(),
+                result: {
+                    content: text,
+                    usage,
+                    model: this.modelName || this.getDefaultModel(),
+                    provider: this.providerName,
+                    finishReason,
+                },
+                success: true,
+            });
+        }
         return {
             content: text, // CLI expects 'content' not 'text'
-            usage: { total: 0, input: 0, output: 0 },
+            usage,
             model: this.modelName || this.getDefaultModel(),
             provider: this.getProviderName(),
         };
@@ -170,6 +218,9 @@ export class AmazonBedrockProvider extends BaseProvider {
     async conversationLoop(options) {
         const maxIterations = 10; // Prevent infinite loops
         let iteration = 0;
+        let totalInputTokens = 0;
+        let totalOutputTokens = 0;
+        let lastFinishReason;
         while (iteration < maxIterations) {
             iteration++;
             logger.debug(`[AmazonBedrockProvider] Conversation iteration ${iteration}`);
@@ -177,6 +228,13 @@ export class AmazonBedrockProvider extends BaseProvider {
                 logger.debug(`[AmazonBedrockProvider] About to call Bedrock API`);
                 const response = await this.callBedrock(options);
                 logger.debug(`[AmazonBedrockProvider] Received Bedrock response`, JSON.stringify(response, null, 2));
+                // Accumulate real token counts and capture the stop reason so
+                // Pipeline B (Langfuse) gets correct usage and finishReason.
+                totalInputTokens += response.usage?.inputTokens ?? 0;
+                totalOutputTokens += response.usage?.outputTokens ?? 0;
+                if (response.stopReason) {
+                    lastFinishReason = response.stopReason;
+                }
                 const result = await this.handleBedrockResponse(response);
                 logger.debug(`[AmazonBedrockProvider] Handle response result:`, result);
                 if (result.shouldContinue) {
@@ -185,7 +243,15 @@ export class AmazonBedrockProvider extends BaseProvider {
                 else {
                     logger.debug(`[AmazonBedrockProvider] Conversation completed with final text`);
                     logger.debug(`[AmazonBedrockProvider] Returning final text: "${result.text}"`);
-                    return result.text || "";
+                    return {
+                        text: result.text || "",
+                        usage: {
+                            input: totalInputTokens,
+                            output: totalOutputTokens,
+                            total: totalInputTokens + totalOutputTokens,
+                        },
+                        finishReason: lastFinishReason,
+                    };
                 }
             }
             catch (error) {
@@ -905,6 +971,12 @@ export class AmazonBedrockProvider extends BaseProvider {
         const startTime = Date.now();
         const maxIterations = options.maxSteps || DEFAULT_MAX_STEPS;
         let iteration = 0;
+        // Shared counters updated by both the first-iteration inline loop and
+        // the processStreamResponse loop. Read by the final generation:end emit
+        // so Pipeline B (Langfuse) gets real token counts from Bedrock streams.
+        let streamTotalInputTokens = 0;
+        let streamTotalOutputTokens = 0;
+        let streamLastStopReason;
         // The REAL issue: ReadableStream errors don't bubble up to the caller
         // So we need to make the first streaming call synchronously to test permissions
         try {
@@ -999,9 +1071,23 @@ export class AmazonBedrockProvider extends BaseProvider {
                                 }
                                 if (chunk.messageStop) {
                                     firstStopReason = chunk.messageStop.stopReason || "end_turn";
+                                    // Don't break — metadata chunk with usage comes after messageStop
+                                    continue;
+                                }
+                                // Accumulate usage from Bedrock metadata chunk for Pipeline B.
+                                // The metadata chunk is emitted after messageStop with aggregate usage.
+                                if (chunk.metadata?.usage) {
+                                    streamTotalInputTokens +=
+                                        chunk.metadata.usage.inputTokens ?? 0;
+                                    streamTotalOutputTokens +=
+                                        chunk.metadata.usage.outputTokens ?? 0;
+                                    // Stream is effectively complete after metadata chunk
                                     break;
                                 }
                             }
+                            if (firstStopReason) {
+                                streamLastStopReason = firstStopReason;
+                            }
                             // Add first assistant message to conversation history
                             const firstAssistantMessage = {
                                 role: "assistant",
@@ -1033,7 +1119,15 @@ export class AmazonBedrockProvider extends BaseProvider {
                             iteration++;
                             logger.debug(`[AmazonBedrockProvider] Streaming iteration ${iteration}`);
                             const commandInput = await this.prepareStreamCommand(options);
-                            const { stopReason, assistantMessage } = await this.processStreamResponse(commandInput, controller);
+                            const { stopReason, assistantMessage, usage } = await this.processStreamResponse(commandInput, controller);
+                            // Accumulate real usage from Bedrock metadata chunks.
+                            if (usage) {
+                                streamTotalInputTokens += usage.input;
+                                streamTotalOutputTokens += usage.output;
+                            }
+                            if (stopReason) {
+                                streamLastStopReason = stopReason;
+                            }
                             streamSpan.addEvent("stream.turn_complete", {
                                 iteration,
                                 stop_reason: stopReason,
@@ -1064,14 +1158,60 @@ export class AmazonBedrockProvider extends BaseProvider {
                     }
                 },
             });
-            // Create analytics promise (without token tracking for now due to AWS SDK limitations)
-            const analyticsPromise = Promise.resolve(createAnalytics(this.providerName, this.modelName || this.getDefaultModel(), { usage: { input: 0, output: 0, total: 0 } }, Date.now() - startTime, {
-                requestId: `bedrock-stream-${Date.now()}`,
-                streamingMode: true,
-                note: "Token usage not available from AWS SDK streaming responses",
-            }));
+            // Emit generation:end after the stream completes so Pipeline B (Langfuse)
+            // creates a GENERATION observation. Bedrock bypasses the Vercel AI SDK so
+            // experimental_telemetry is never injected; we emit the event manually.
+            const streamEmitter = this.neurolink?.getEventEmitter();
+            const streamAsyncIterable = this.convertToAsyncIterable(stream);
+            const self = this;
+            // Defer analytics resolution until the stream completes so we have
+            // real token counts aggregated from Bedrock metadata chunks.
+            let resolveAnalytics;
+            const analyticsPromise = new Promise((resolve) => {
+                resolveAnalytics = resolve;
+            });
+            const wrappedStreamIterable = {
+                async *[Symbol.asyncIterator]() {
+                    let streamErrored = false;
+                    try {
+                        yield* streamAsyncIterable;
+                    }
+                    catch (error) {
+                        streamErrored = true;
+                        throw error;
+                    }
+                    finally {
+                        const aggregatedUsage = {
+                            input: streamTotalInputTokens,
+                            output: streamTotalOutputTokens,
+                            total: streamTotalInputTokens + streamTotalOutputTokens,
+                        };
+                        // Resolve analytics with accumulated token counts from Bedrock
+                        // metadata chunks so Pipeline A also reports real usage.
+                        resolveAnalytics(createAnalytics(self.providerName, self.modelName || self.getDefaultModel(), { usage: aggregatedUsage }, Date.now() - startTime, {
+                            requestId: `bedrock-stream-${Date.now()}`,
+                            streamingMode: true,
+                        }));
+                        if (streamEmitter) {
+                            streamEmitter.emit("generation:end", {
+                                provider: self.providerName,
+                                responseTime: Date.now() - startTime,
+                                timestamp: Date.now(),
+                                result: {
+                                    content: "",
+                                    usage: aggregatedUsage,
+                                    model: self.modelName || self.getDefaultModel(),
+                                    provider: self.providerName,
+                                    finishReason: streamErrored ? "error" : streamLastStopReason,
+                                },
+                                success: !streamErrored,
+                            });
+                        }
+                    }
+                },
+            };
             return {
-                stream: this.convertToAsyncIterable(stream),
+                stream: wrappedStreamIterable,
                 usage: { total: 0, input: 0, output: 0 },
                 model: this.modelName || this.getDefaultModel(),
                 provider: this.getProviderName(),
@@ -1174,6 +1314,7 @@ export class AmazonBedrockProvider extends BaseProvider {
         const currentMessageContent = [];
         let stopReason = "";
         let currentText = "";
+        let streamUsage;
         // Process streaming chunks
         for await (const chunk of response.stream) {
             if (chunk.contentBlockStart) {
@@ -1250,6 +1391,20 @@ export class AmazonBedrockProvider extends BaseProvider {
             }
             if (chunk.messageStop) {
                 stopReason = chunk.messageStop.stopReason || "end_turn";
+                // Don't break — metadata chunk with usage arrives after messageStop
+                continue;
+            }
+            // Bedrock ConverseStream emits a metadata chunk at the end with
+            // aggregate usage. Capture it for Pipeline B telemetry.
+            if (chunk.metadata?.usage) {
+                const input = chunk.metadata.usage.inputTokens ?? 0;
+                const output = chunk.metadata.usage.outputTokens ?? 0;
+                streamUsage = {
+                    input,
+                    output,
+                    total: chunk.metadata.usage.totalTokens ?? input + output,
+                };
+                // Stream is effectively complete after metadata chunk
                 break;
             }
         }
@@ -1259,7 +1414,7 @@ export class AmazonBedrockProvider extends BaseProvider {
             content: currentMessageContent,
         };
         this.conversationHistory.push(assistantMessage);
-        return { stopReason, assistantMessage };
+        return { stopReason, assistantMessage, usage: streamUsage };
     }
     async handleStreamStopReason(stopReason, assistantMessage, controller, options) {
         if (stopReason === "end_turn" || stopReason === "stop_sequence") {
@@ -1365,6 +1520,18 @@ export class AmazonBedrockProvider extends BaseProvider {
             };
             this.conversationHistory.push(userMessageWithToolResults);
             logger.debug(`📤 [AmazonBedrockProvider] Added ${toolResults.length} tool results to conversation (1:1 mapping validated)`);
+            // Emit tool:end for each completed tool result so Pipeline B
+            // captures telemetry for Bedrock-driven tool calls (gap S2).
+            emitToolEndFromStepFinish(this.neurolink?.getEventEmitter(), toolResultsForStorage.map((tr) => {
+                const hasError = tr.result && typeof tr.result === "object" && "error" in tr.result;
+                return {
+                    toolName: tr.toolName,
+                    result: tr.result,
+                    error: hasError
+                        ? String(tr.result.error)
+                        : undefined,
+                };
+            }));
             // Store tool execution for analytics and debugging (similar to Vertex onStepFinish)
             this.handleToolExecutionStorage(toolCalls, toolResultsForStorage, options, new Date()).catch((error) => {
                 logger.warn("[AmazonBedrockProvider] Failed to store tool executions", {
@@ -1437,6 +1604,13 @@ export class AmazonBedrockProvider extends BaseProvider {
         if (message.includes("ValidationException")) {
             return new ProviderError(`Validation error: ${message}`, this.providerName);
         }
+        // Check for AWS-specific throttling BEFORE generic mapping
+        const errName = error?.name ?? "";
+        const errCode = error?.code ?? "";
+        if (errName === "ThrottlingException" ||
+            errCode === "ThrottlingException") {
+            return new RateLimitError(`Bedrock rate limit (throttled): ${error instanceof Error ? error.message : String(error)}`, "bedrock");
+        }
         return new ProviderError(`AWS Bedrock error: ${message}`, this.providerName);
     }
     /**

package/dist/lib/providers/amazonSagemaker.js

@@ -6,6 +6,8 @@
  */
 import { BaseProvider } from "../core/baseProvider.js";
 import { logger } from "../utils/logger.js";
+import { withSpan } from "../telemetry/withSpan.js";
+import { tracers } from "../telemetry/tracers.js";
 // SageMaker-specific imports
 import { getDefaultSageMakerEndpoint, getSageMakerConfig, getSageMakerModel, getSageMakerModelConfig, } from "./sagemaker/config.js";
 import { handleSageMakerError, SageMakerError } from "./sagemaker/errors.js";
@@ -73,17 +75,29 @@ export class AmazonSageMakerProvider extends BaseProvider {
         return this.sagemakerModel;
     }
     async executeStream(_options, _analysisSchema) {
-        try {
-            // For now, throw an error indicating this is not yet implemented
-            throw new SageMakerError("SageMaker streaming not yet fully implemented. Coming in next phase.", {
-                code: "MODEL_ERROR",
-                statusCode: 501,
-                endpoint: this.modelConfig.endpointName,
-            });
-        }
-        catch (error) {
-            throw this.handleProviderError(error);
-        }
+        return withSpan({
+            name: "neurolink.provider.sagemaker.stream",
+            tracer: tracers.stream,
+            attributes: {
+                "provider.name": "sagemaker",
+                "model.name": this.modelName,
+                "sagemaker.endpoint": this.modelConfig.endpointName,
+                "sagemaker.region": this.sagemakerConfig.region,
+                "sagemaker.not_implemented": true,
+            },
+        }, async () => {
+            try {
+                // For now, throw an error indicating this is not yet implemented
+                throw new SageMakerError("SageMaker streaming not yet fully implemented. Coming in next phase.", {
+                    code: "MODEL_ERROR",
+                    statusCode: 501,
+                    endpoint: this.modelConfig.endpointName,
+                });
+            }
+            catch (error) {
+                throw this.handleProviderError(error);
+            }
+        });
     }
     formatProviderError(error) {
         if (error instanceof SageMakerError) {

package/dist/lib/providers/anthropic.js

@@ -17,6 +17,7 @@ import { calculateCost } from "../utils/pricing.js";
 import { createAnthropicConfig, getProviderModel, validateApiKey, } from "../utils/providerConfig.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { resolveToolChoice } from "../utils/toolChoice.js";
+import { emitToolEndFromStepFinish } from "../utils/toolEndEmitter.js";
 import { getModelId } from "./providerTypeUtils.js";
 /**
  * Beta headers for Claude Code integration.
@@ -804,6 +805,9 @@ export class AnthropicProvider extends BaseProvider {
                     experimental_repairToolCall: this.getToolCallRepairFn(options),
                     experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
                     onStepFinish: ({ toolCalls, toolResults }) => {
+                        // Emit tool:end for each completed tool result so Pipeline B
+                        // captures telemetry for AI-SDK-driven tool calls (gap S2).
+                        emitToolEndFromStepFinish(this.neurolink?.getEventEmitter(), toolResults);
                         this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {
                             logger.warn("[AnthropicProvider] Failed to store tool executions", {
                                 provider: this.providerName,
@@ -814,6 +818,15 @@ export class AnthropicProvider extends BaseProvider {
                 });
             }
             catch (streamError) {
+                streamSpan.setStatus({
+                    code: SpanStatusCode.ERROR,
+                    message: streamError instanceof Error
+                        ? streamError.message
+                        : String(streamError),
+                });
+                if (streamError instanceof Error) {
+                    streamSpan.recordException(streamError);
+                }
                 streamSpan.end();
                 throw streamError;
             }

package/dist/lib/providers/azureOpenai.js

@@ -4,6 +4,7 @@ import { APIVersions } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
+import { emitToolEndFromStepFinish } from "../utils/toolEndEmitter.js";
 import { logger } from "../utils/logger.js";
 import { createAzureAPIKeyConfig, createAzureEndpointConfig, validateApiKey, } from "../utils/providerConfig.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
@@ -126,6 +127,7 @@ export class AzureOpenAIProvider extends BaseProvider {
                 experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
                 experimental_repairToolCall: this.getToolCallRepairFn(options),
                 onStepFinish: (event) => {
+                    emitToolEndFromStepFinish(this.neurolink?.getEventEmitter(), event.toolResults);
                     this.handleToolExecutionStorage([...event.toolCalls], [...event.toolResults], options, new Date()).catch((error) => {
                         logger.warn("[AzureOpenaiProvider] Failed to store tool executions", {
                             provider: this.providerName,

package/dist/lib/providers/googleAiStudio.js

@@ -4,6 +4,7 @@ import { ErrorCategory, ErrorSeverity, GoogleAIModels, } from "../constants/enum
 import { BaseProvider } from "../core/baseProvider.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
+import { SpanStatusCode } from "@opentelemetry/api";
 import { ATTR, tracers, withClientSpan } from "../telemetry/index.js";
 import { AuthenticationError, NetworkError, ProviderError, RateLimitError, } from "../types/index.js";
 import { ERROR_CODES, NeuroLinkError } from "../utils/errorHandling.js";
@@ -12,6 +13,7 @@ import { isGemini3Model } from "../utils/modelDetection.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { estimateTokens } from "../utils/tokenEstimation.js";
 import { resolveToolChoice } from "../utils/toolChoice.js";
+import { emitToolEndFromStepFinish } from "../utils/toolEndEmitter.js";
 import { buildNativeConfig, buildNativeToolDeclarations, collectStreamChunks, collectStreamChunksIncremental, computeMaxSteps, createTextChannel, executeNativeToolCalls, extractTextFromParts, handleMaxStepsTermination, pushModelResponseToHistory, sanitizeToolsForGemini, } from "./googleNativeGemini3.js";
 import { toAnalyticsStreamResult } from "./providerTypeUtils.js";
 // Google AI Live API types now imported from ../types/providerSpecific.js
@@ -521,6 +523,9 @@ export class GoogleAIStudioProvider extends BaseProvider {
                             id: rawToolResult.toolCallId ?? toolResult.toolName,
                         });
                     }
+                    // Emit tool:end for each completed tool result so Pipeline B
+                    // captures telemetry for AI-SDK-driven tool calls (gap S2).
+                    emitToolEndFromStepFinish(this.neurolink?.getEventEmitter(), toolResults);
                     this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {
                         logger.warn("[GoogleAiStudioProvider] Failed to store tool executions", {
                             provider: this.providerName,
@@ -730,9 +735,62 @@ export class GoogleAIStudioProvider extends BaseProvider {
                             requestDuration: responseTime,
                             timestamp: new Date().toISOString(),
                         });
+                        // Emit generation:end so Pipeline B (Langfuse) creates a GENERATION
+                        // observation. The native @google/genai stream path bypasses the Vercel
+                        // AI SDK so experimental_telemetry is never injected; we emit manually.
+                        const nativeStreamEmitter = this.neurolink?.getEventEmitter();
+                        if (nativeStreamEmitter) {
+                            nativeStreamEmitter.emit("generation:end", {
+                                provider: this.providerName,
+                                responseTime,
+                                timestamp: Date.now(),
+                                result: {
+                                    content: "",
+                                    usage: {
+                                        input: totalInputTokens,
+                                        output: totalOutputTokens,
+                                        total: totalInputTokens + totalOutputTokens,
+                                    },
+                                    model: modelName,
+                                    provider: this.providerName,
+                                    finishReason: hitStepLimitWithoutFinalAnswer
+                                        ? "max_steps"
+                                        : "stop",
+                                },
+                                success: true,
+                            });
+                        }
                         channel.close();
                     }
                     catch (err) {
+                        // Propagate error to OTel span so traces show ERROR status
+                        span.recordException(err instanceof Error ? err : new Error(String(err)));
+                        span.setStatus({
+                            code: SpanStatusCode.ERROR,
+                            message: err instanceof Error ? err.message : String(err),
+                        });
+                        // Emit failure generation:end so Pipeline B records the failed stream
+                        const errorEmitter = this.neurolink?.getEventEmitter();
+                        if (errorEmitter) {
+                            errorEmitter.emit("generation:end", {
+                                provider: this.providerName,
+                                responseTime: Date.now() - startTime,
+                                timestamp: Date.now(),
+                                result: {
+                                    content: "",
+                                    usage: {
+                                        input: totalInputTokens,
+                                        output: totalOutputTokens,
+                                        total: totalInputTokens + totalOutputTokens,
+                                    },
+                                    model: modelName,
+                                    provider: this.providerName,
+                                    finishReason: "error",
+                                },
+                                success: false,
+                                error: err instanceof Error ? err.message : String(err),
+                            });
+                        }
                         channel.error(err);
                         analyticsReject(err);
                     }
@@ -876,6 +934,29 @@ export class GoogleAIStudioProvider extends BaseProvider {
                 span.setAttribute(ATTR.GEN_AI_INPUT_TOKENS, totalInputTokens);
                 span.setAttribute(ATTR.GEN_AI_OUTPUT_TOKENS, totalOutputTokens);
                 span.setAttribute(ATTR.GEN_AI_FINISH_REASON, step >= maxSteps ? "max_steps" : "stop");
+                // Emit generation:end so Pipeline B (Langfuse) creates a GENERATION
+                // observation. The native @google/genai path bypasses the Vercel AI SDK
+                // so experimental_telemetry is never injected; we emit the event manually.
+                const nativeGenerateEmitter = this.neurolink?.getEventEmitter();
+                if (nativeGenerateEmitter) {
+                    nativeGenerateEmitter.emit("generation:end", {
+                        provider: this.providerName,
+                        responseTime,
+                        timestamp: Date.now(),
+                        result: {
+                            content: finalText,
+                            usage: {
+                                input: totalInputTokens,
+                                output: totalOutputTokens,
+                                total: totalInputTokens + totalOutputTokens,
+                            },
+                            model: modelName,
+                            provider: this.providerName,
+                            finishReason: step >= maxSteps ? "max_steps" : "stop",
+                        },
+                        success: true,
+                    });
+                }
                 // Build EnhancedGenerateResult
                 return {
                     content: finalText,
@@ -964,6 +1045,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
         const model = this.modelName ||
             process.env.GOOGLE_VOICE_AI_MODEL ||
             "gemini-2.5-flash-preview-native-audio-dialog";
+        // Simple async queue for yielding audio events to the outer AsyncIterable
         const queue = [];
         let resolveNext = null;
         let done = false;

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

@@ -9,8 +9,7 @@
  * providers so they can share a single implementation.
  */
 import { type Tool } from "ai";
-import type { ThinkingConfig, CollectedChunkResult, NativeFunctionCall, NativeFunctionDeclaration, NativeFunctionResponse, NativeToolDeclarationsResult, NativeToolsConfig, TextChannel } from "../types/index.js";
-export type { CollectedChunkResult, NativeFunctionCall, NativeFunctionDeclaration, NativeFunctionResponse, NativeToolDeclarationsResult, NativeToolsConfig, TextChannel, };
+import type { ThinkingConfig, CollectedChunkResult, NativeFunctionCall, NativeFunctionResponse, NativeToolDeclarationsResult, NativeToolsConfig, TextChannel } from "../types/index.js";
 /**
  * Sanitize a JSON Schema for Gemini's proto-based API.
  *

package/dist/lib/providers/googleVertex.js

@@ -23,6 +23,7 @@ import { convertZodToJsonSchema, inlineJsonSchema, } from "../utils/schemaConver
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { estimateTokens } from "../utils/tokenEstimation.js";
 import { resolveToolChoice } from "../utils/toolChoice.js";
+import { emitToolEndFromStepFinish } from "../utils/toolEndEmitter.js";
 import { buildNativeConfig, buildNativeToolDeclarations, collectStreamChunks, collectStreamChunksIncremental, computeMaxSteps as computeMaxStepsShared, createTextChannel, executeNativeToolCalls, extractTextFromParts, handleMaxStepsTermination, normalizeToolsForJsonSchemaProvider, pushModelResponseToHistory, sanitizeToolsForGemini, } from "./googleNativeGemini3.js";
 import { getModelId } from "./providerTypeUtils.js";
 // Import proper types for multimodal message handling
@@ -1075,6 +1076,9 @@ export class GoogleVertexProvider extends BaseProvider {
                 id: toolResult.toolCallId ?? toolResult.toolName,
             });
         }
+        // Emit tool:end for each completed tool result so Pipeline B
+        // captures telemetry for AI-SDK-driven tool calls (gap S2).
+        emitToolEndFromStepFinish(this.neurolink?.getEventEmitter(), toolResults);
         this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {
             logger.warn("[GoogleVertexProvider] Failed to store tool executions", {
                 provider: this.providerName,
@@ -1516,6 +1520,31 @@ export class GoogleVertexProvider extends BaseProvider {
                 requestDuration: responseTime,
                 timestamp: new Date().toISOString(),
             });
+            // Emit generation:end so Pipeline B (Langfuse) creates a GENERATION
+            // observation. The native @google/genai stream path on Vertex bypasses the
+            // Vercel AI SDK so experimental_telemetry is never injected; we emit manually.
+            const vertexStreamEmitter = this.neurolink?.getEventEmitter();
+            if (vertexStreamEmitter) {
+                vertexStreamEmitter.emit("generation:end", {
+                    provider: this.providerName,
+                    responseTime,
+                    timestamp: Date.now(),
+                    result: {
+                        content: "",
+                        usage: {
+                            input: totalInputTokens,
+                            output: totalOutputTokens,
+                            total: totalInputTokens + totalOutputTokens,
+                        },
+                        model: params.modelName,
+                        provider: this.providerName,
+                        finishReason: step >= params.maxSteps && !completedWithFinalAnswer
+                            ? "max_steps"
+                            : "stop",
+                    },
+                    success: true,
+                });
+            }
             params.channel.close();
         }
         catch (error) {
@@ -1661,6 +1690,29 @@ export class GoogleVertexProvider extends BaseProvider {
             span.setAttribute(ATTR.GEN_AI_INPUT_TOKENS, totalInputTokens);
             span.setAttribute(ATTR.GEN_AI_OUTPUT_TOKENS, totalOutputTokens);
             span.setAttribute(ATTR.GEN_AI_FINISH_REASON, step >= maxSteps ? "max_steps" : "stop");
+            // Emit generation:end so Pipeline B (Langfuse) creates a GENERATION
+            // observation. The native @google/genai path on Vertex bypasses the Vercel
+            // AI SDK so experimental_telemetry is never injected; we emit manually.
+            const vertexGenerateEmitter = this.neurolink?.getEventEmitter();
+            if (vertexGenerateEmitter) {
+                vertexGenerateEmitter.emit("generation:end", {
+                    provider: this.providerName,
+                    responseTime,
+                    timestamp: Date.now(),
+                    result: {
+                        content: finalText,
+                        usage: {
+                            input: totalInputTokens,
+                            output: totalOutputTokens,
+                            total: totalInputTokens + totalOutputTokens,
+                        },
+                        model: modelName,
+                        provider: this.providerName,
+                        finishReason: step >= maxSteps ? "max_steps" : "stop",
+                    },
+                    success: true,
+                });
+            }
             // Build EnhancedGenerateResult
             return {
                 content: finalText,

package/dist/lib/providers/huggingFace.js

@@ -3,6 +3,7 @@ import { NoOutputGeneratedError, stepCountIs, streamText, } from "ai";
 import { BaseProvider } from "../core/baseProvider.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
+import { emitToolEndFromStepFinish } from "../utils/toolEndEmitter.js";
 import { logger } from "../utils/logger.js";
 import { createHuggingFaceConfig, getProviderModel, validateApiKey, } from "../utils/providerConfig.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
@@ -141,6 +142,7 @@ export class HuggingFaceProvider extends BaseProvider {
                 experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
                 experimental_repairToolCall: this.getToolCallRepairFn(options),
                 onStepFinish: ({ toolCalls, toolResults }) => {
+                    emitToolEndFromStepFinish(this.neurolink?.getEventEmitter(), toolResults);
                     this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {
                         logger.warn("[HuggingFaceProvider] Failed to store tool executions", {
                             provider: this.providerName,