@juspay/neurolink 12.58.1 → 13.0.0

package/dist/providers/amazonSagemaker.js

@@ -1,3 +1,4 @@
+import { context, SpanKind, SpanStatusCode, trace } from "@opentelemetry/api";
 import { BaseProvider } from "../core/baseProvider.js";
 import { createStreamChannel } from "../core/streamChannel.js";
 import { logger } from "../utils/logger.js";
@@ -9,7 +10,8 @@ import { withProviderRetry } from "../utils/providerRetry.js";
 import { resolveToolChoice } from "../utils/toolChoice.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { hasNativeDoGenerate, runNativeGenerateLoop, } from "../core/nativeGenerateLoop.js";
-import { withSpan } from "../telemetry/withSpan.js";
+import { generationName } from "../telemetry/observationNames.js";
+import { observeGeneration } from "../telemetry/observation.js";
 import { tracers } from "../telemetry/tracers.js";
 // SageMaker-specific imports
 import { getDefaultSageMakerEndpoint, getSageMakerConfig, getSageMakerModel, getSageMakerModelConfig, } from "./sagemaker/config.js";
@@ -230,6 +232,7 @@ export class AmazonSageMakerProvider extends BaseProvider {
         const toolExecutionSummaries = [];
         const loop = await runNativeGenerateLoop({
             doGenerate,
+            provider: this.providerName,
             conversation,
             ...(responseFormat ? { responseFormat } : {}),
             ...(v3Tools.length > 0 ? { tools: v3Tools } : {}),
@@ -292,94 +295,129 @@ export class AmazonSageMakerProvider extends BaseProvider {
      * detached pump, so they settle whether or not the caller reads a chunk.
      */
     async doStream(options) {
-        return withSpan({
-            name: "neurolink.provider.sagemaker.stream",
-            tracer: tracers.stream,
+        const span = tracers.generation.startSpan(generationName("stream"), {
+            kind: SpanKind.CLIENT,
             attributes: {
-                "provider.name": "sagemaker",
-                "model.name": this.modelName,
                 "sagemaker.endpoint": this.modelConfig.endpointName,
                 "sagemaker.region": this.sagemakerConfig.region,
             },
-        }, async () => {
-            try {
-                const messages = await this.buildMessagesForStream(options);
-                const result = await this.sagemakerModel.doStream({
-                    prompt: messages,
-                    maxTokens: options.maxTokens,
+        });
+        const call = {
+            provider: this.providerName,
+            model: this.modelName,
+        };
+        try {
+            const messages = await this.buildMessagesForStream(options);
+            observeGeneration(span, {
+                ...call,
+                modelParameters: {
                     temperature: options.temperature,
-                });
-                // Settled from the `finish` part below. A turn that ends without one
-                // — a truncated or errored stream — still settles, so a caller
-                // awaiting either promise cannot hang.
-                let settleFinishReason;
-                let settleUsage;
-                const finishReason = new Promise((resolve) => {
-                    settleFinishReason = resolve;
-                });
-                const usage = new Promise((resolve) => {
-                    settleUsage = resolve;
-                });
-                // The source is drained by a detached pump rather than lazily by the
-                // consumer. Resolving `finishReason`/`usage` from inside a generator
-                // ties them to somebody iterating it, and the inherited
-                // `executeStream` chains analytics off exactly those promises — so a
-                // caller that awaits `result.analytics` without consuming the stream
-                // would wait forever. Pumping here means the turn completes, and
-                // both promises settle, whether or not anyone reads a chunk.
-                const channel = createStreamChannel();
-                void (async () => {
-                    const reader = result.stream.getReader();
-                    let sawFinish = false;
-                    try {
-                        while (true) {
-                            const { done, value } = await reader.read();
-                            if (done) {
-                                break;
-                            }
-                            const part = value;
-                            if (part.type === "text-delta" && part.textDelta) {
-                                channel.push({ content: part.textDelta });
-                                continue;
-                            }
-                            if (part.type === "finish") {
-                                sawFinish = true;
-                                settleFinishReason(part.finishReason ?? "stop");
-                                settleUsage({
-                                    inputTokens: part.usage?.inputTokens ?? part.usage?.promptTokens ?? 0,
-                                    outputTokens: part.usage?.outputTokens ??
-                                        part.usage?.completionTokens ??
-                                        0,
-                                });
-                            }
+                    maxTokens: options.maxTokens,
+                },
+                input: { messages },
+            });
+            const result = await context.with(trace.setSpan(context.active(), span), () => this.sagemakerModel.doStream({
+                prompt: messages,
+                maxTokens: options.maxTokens,
+                temperature: options.temperature,
+            }));
+            // Settled from the `finish` part below. A turn that ends without one
+            // — a truncated or errored stream — still settles, so a caller
+            // awaiting either promise cannot hang.
+            let settleFinishReason;
+            let settleUsage;
+            const finishReason = new Promise((resolve) => {
+                settleFinishReason = resolve;
+            });
+            const usage = new Promise((resolve) => {
+                settleUsage = resolve;
+            });
+            // The source is drained by a detached pump rather than lazily by the
+            // consumer. Resolving `finishReason`/`usage` from inside a generator
+            // ties them to somebody iterating it, and the inherited
+            // `executeStream` chains analytics off exactly those promises — so a
+            // caller that awaits `result.analytics` without consuming the stream
+            // would wait forever. Pumping here means the turn completes, and
+            // both promises settle, whether or not anyone reads a chunk.
+            const channel = createStreamChannel();
+            void (async () => {
+                const reader = result.stream.getReader();
+                let sawFinish = false;
+                let text = "";
+                let firstChunkAt;
+                let finish = "unknown";
+                let tokens = { inputTokens: 0, outputTokens: 0 };
+                try {
+                    while (true) {
+                        const { done, value } = await reader.read();
+                        if (done) {
+                            break;
                         }
-                        channel.close();
-                    }
-                    catch (error) {
-                        channel.error(error);
-                    }
-                    finally {
-                        reader.releaseLock();
-                        // A stream that ended without a finish part — truncated or
-                        // errored — must still settle both promises, or the same hang
-                        // returns by a different route.
-                        if (!sawFinish) {
-                            settleFinishReason("unknown");
-                            settleUsage({ inputTokens: 0, outputTokens: 0 });
+                        const part = value;
+                        if (part.type === "text-delta" && part.textDelta) {
+                            firstChunkAt ??= new Date();
+                            text += part.textDelta;
+                            channel.push({ content: part.textDelta });
+                            continue;
+                        }
+                        if (part.type === "finish") {
+                            sawFinish = true;
+                            finish = part.finishReason ?? "stop";
+                            tokens = {
+                                inputTokens: part.usage?.inputTokens ?? part.usage?.promptTokens ?? 0,
+                                outputTokens: part.usage?.outputTokens ?? part.usage?.completionTokens ?? 0,
+                            };
+                            settleFinishReason(finish);
+                            settleUsage(tokens);
                         }
                     }
-                })();
-                return {
-                    stream: channel.iterable,
-                    finishReason,
-                    usage,
-                    warnings: (result.warnings ?? []).map((warning) => warning.message ?? String(warning)),
-                };
-            }
-            catch (error) {
-                throw this.handleProviderError(error);
+                    channel.close();
+                    span.setStatus({ code: SpanStatusCode.OK });
+                }
+                catch (error) {
+                    span.setStatus({
+                        code: SpanStatusCode.ERROR,
+                        message: error instanceof Error ? error.message : String(error),
+                    });
+                    channel.error(error);
+                }
+                finally {
+                    reader.releaseLock();
+                    // A stream that ended without a finish part — truncated or
+                    // errored — must still settle both promises, or the same hang
+                    // returns by a different route.
+                    if (!sawFinish) {
+                        settleFinishReason("unknown");
+                        settleUsage({ inputTokens: 0, outputTokens: 0 });
+                    }
+                    observeGeneration(span, {
+                        ...call,
+                        output: text,
+                        usage: tokens,
+                        finishReason: finish,
+                        completionStartTime: firstChunkAt,
+                    });
+                    span.end();
+                }
+            })();
+            return {
+                stream: channel.iterable,
+                finishReason,
+                usage,
+                warnings: (result.warnings ?? []).map((warning) => warning.message ?? String(warning)),
+            };
+        }
+        catch (error) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: error instanceof Error ? error.message : String(error),
+            });
+            if (error instanceof Error) {
+                span.recordException(error);
             }
-        });
+            span.end();
+            throw this.handleProviderError(error);
+        }
     }
     formatProviderError(error) {
         if (error instanceof SageMakerError) {

package/dist/providers/anthropic/client.js

@@ -1,5 +1,5 @@
 import Anthropic from "@anthropic-ai/sdk";
-import { SpanKind, trace } from "@opentelemetry/api";
+import { trace } from "@opentelemetry/api";
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync, } from "fs";
 import { homedir } from "os";
 import { join } from "path";
@@ -21,7 +21,6 @@ import { getAvailableInputTokens } from "../../constants/contextWindows.js";
 import { estimateTokens, serializeForEstimate, } from "../../utils/tokenEstimation.js";
 import { redactUrlCredentials } from "../../utils/logSanitize.js";
 import { ANTHROPIC_MAX_CACHE_BREAKPOINTS, applyAnthropicHistoryCacheBreakpoints, countAnthropicCacheMarkers, } from "../../utils/anthropicCacheBreakpoints.js";
-import { calculateCost } from "../../utils/pricing.js";
 import { stringifyAnthropicToolOutput } from "./toolOutput.js";
 import { createAnthropicLoopAdapter } from "./loopAdapter.js";
 import { DEFAULT_BEFORE_STEP_TIMEOUT_MS } from "../../utils/parameterValidation.js";
@@ -82,7 +81,6 @@ function normalizeAnthropicBaseURL(raw) {
     }
     return stripped;
 }
-const streamTracer = trace.getTracer("neurolink.provider.anthropic");
 /**
  * Get OAuth token from stored credentials file or environment.
  * Priority:
@@ -1587,6 +1585,7 @@ export class AnthropicProvider extends BaseProvider {
         const toolExecutionSummaries = [];
         const loop = await runNativeGenerateLoop({
             doGenerate,
+            provider: this.providerName,
             ...createNativeGenerateGuard({
                 provider: "anthropic",
                 availableInputTokens: getAvailableInputTokens("anthropic", modelId, options.maxTokens ?? undefined),
@@ -1810,53 +1809,10 @@ export class AnthropicProvider extends BaseProvider {
                 : undefined;
         // See the generate path: `disabled` is sent, but only ON constrains sampling.
         const thinkingOn = thinking?.type === "enabled";
-        // Wrap the native stream in an OTel span to capture provider-level
-        // latency and token usage (same span name as the pre-migration path so
-        // dashboards stay continuous).
-        const streamSpan = streamTracer.startSpan("neurolink.provider.streamText", {
-            kind: SpanKind.CLIENT,
-            attributes: {
-                "gen_ai.system": "anthropic",
-                "gen_ai.request.model": modelId,
-            },
-        });
         const maxSteps = options.maxSteps || DEFAULT_MAX_STEPS;
         const channel = createStreamChannel();
         const { push: pushChunk } = channel;
         const { usagePromise, finishPromise, resolveUsage, resolveFinish } = createDeferredAnalytics();
-        usagePromise
-            .then((usage) => {
-            streamSpan.setAttribute("gen_ai.usage.input_tokens", usage.promptTokens || 0);
-            streamSpan.setAttribute("gen_ai.usage.output_tokens", usage.completionTokens || 0);
-            if (usage.cacheReadTokens) {
-                streamSpan.setAttribute("gen_ai.usage.cached_input_tokens", usage.cacheReadTokens);
-            }
-            const cost = calculateCost(this.providerName, this.modelName, {
-                input: usage.promptTokens || 0,
-                output: usage.completionTokens || 0,
-                total: usage.totalTokens || 0,
-                ...(usage.cacheReadTokens
-                    ? { cacheReadTokens: usage.cacheReadTokens }
-                    : {}),
-                ...(usage.cacheCreationTokens
-                    ? { cacheCreationTokens: usage.cacheCreationTokens }
-                    : {}),
-            });
-            if (cost && cost > 0) {
-                streamSpan.setAttribute("neurolink.cost", cost);
-            }
-        })
-            .catch(() => {
-            // usage may never resolve if the stream is aborted before completion
-        });
-        finishPromise
-            .then((reason) => {
-            streamSpan.setAttribute("gen_ai.response.finish_reason", reason || "unknown");
-            streamSpan.end();
-        })
-            .catch(() => {
-            streamSpan.end();
-        });
         let capturedProviderError;
         const client = this.client;
         // Every attempted call, for the no-output sentinel below; the result
@@ -2068,6 +2024,7 @@ export class AnthropicProvider extends BaseProvider {
             };
             const baseAdapter = createAnthropicLoopAdapter({
                 client,
+                provider: this.providerName,
                 maxSteps,
                 toolsRecord,
                 buildParams,
@@ -2204,12 +2161,6 @@ export class AnthropicProvider extends BaseProvider {
                     },
                 };
             }
-            // The active span goes with it. Before this loop moved onto the shared
-            // engine it called
-            //   withProviderRetry(fn, trace.getActiveSpan() ?? undefined, label)
-            // and that span is where gen_ai.provider.total_attempts is recorded.
-            // The engine passed `undefined` in its place, so the attribute silently
-            // stopped being emitted for every native Anthropic turn.
             const activeSpan = trace.getActiveSpan();
             // The caller's step-boundary callback, made finite and cancellable
             // before the engine ever sees it. The engine's contract is "already

package/dist/providers/anthropic/loopAdapter.js

@@ -25,6 +25,7 @@ import { resolveDeferredTool } from "../../tools/toolDiscovery.js";
 import { stringifyAnthropicToolOutput } from "./toolOutput.js";
 import { stringifyFinalResultInput } from "./structuredOutput.js";
 import { composeAbortSignalsScoped, createTimeoutController, } from "../../utils/timeout.js";
+import { sanitizeAnthropicMessagesForTrace } from "../../utils/anthropicTraceSanitizer.js";
 import { NeuroLinkError } from "../../utils/errorHandling.js";
 import { ErrorCategory, ErrorSeverity } from "../../constants/enums.js";
 /** Map Anthropic's stop_reason onto the unified finish reason. */
@@ -86,6 +87,7 @@ async function readAnthropicStep({ params, client, channel, stepSignal, requestT
     // absence is the only signal that the response ended early, because the
     // content blocks that DID arrive are syntactically complete.
     let sawTerminalEvent = false;
+    let responseModel;
     for await (const rawEvent of events) {
         if (stepSignal.aborted) {
             break;
@@ -96,6 +98,7 @@ async function readAnthropicStep({ params, client, channel, stepSignal, requestT
         // asserted.
         const event = rawEvent;
         if (event.type === "message_start") {
+            responseModel = event.message?.model ?? responseModel;
             const usage = event.message?.usage;
             inputTokens += usage?.input_tokens ?? 0;
             const startOutput = usage?.output_tokens ?? 0;
@@ -342,6 +345,7 @@ async function readAnthropicStep({ params, client, channel, stepSignal, requestT
             ...(reasoningTokens ? { reasoningTokens } : {}),
         },
         rawStopReason,
+        ...(responseModel ? { model: responseModel } : {}),
         raw: blocks,
     };
 }
@@ -383,7 +387,26 @@ export function createAnthropicLoopAdapter(config) {
             };
         },
         async buildStepRequest(conversation, step) {
-            return { raw: await config.buildParams(conversation, step) };
+            const params = await config.buildParams(conversation, step);
+            return {
+                raw: params,
+                generation: {
+                    provider: config.provider,
+                    model: params.model,
+                    modelParameters: {
+                        temperature: params.temperature,
+                        maxTokens: params.max_tokens,
+                        topP: params.top_p,
+                        thinkingBudget: params.thinking?.type === "enabled"
+                            ? params.thinking.budget_tokens
+                            : undefined,
+                    },
+                    input: {
+                        system: params.system,
+                        messages: sanitizeAnthropicMessagesForTrace(params.messages),
+                    },
+                },
+            };
         },
         async executeStep(request, channel, signal) {
             const params = request.raw;

package/dist/providers/anthropic/rateLimitCapture.js

@@ -268,18 +268,15 @@ export function setLimitSpanAttributes(snapshot) {
     }
     const { rateLimit } = snapshot;
     const attrs = [
-        ["neurolink.claude.quota.session_left_pct", rateLimit.sessionLeftPct],
-        ["neurolink.claude.quota.weekly_left_pct", rateLimit.weeklyLeftPct],
-        ["neurolink.claude.quota.requests_remaining", rateLimit.requestsRemaining],
-        ["neurolink.claude.quota.tokens_remaining", rateLimit.tokensRemaining],
-        ["neurolink.claude.quota.source", snapshot.quotaSource],
-        ["neurolink.claude.account", snapshot.account],
-        ["neurolink.claude.served_by", snapshot.servedBy],
-        ["neurolink.claude.pool.available", snapshot.pool?.available],
-        [
-            "neurolink.claude.pool.best_session_left_pct",
-            snapshot.pool?.bestSessionLeftPct,
-        ],
+        ["claude.quota.session_left_pct", rateLimit.sessionLeftPct],
+        ["claude.quota.weekly_left_pct", rateLimit.weeklyLeftPct],
+        ["claude.quota.requests_remaining", rateLimit.requestsRemaining],
+        ["claude.quota.tokens_remaining", rateLimit.tokensRemaining],
+        ["claude.quota.source", snapshot.quotaSource],
+        ["claude.account", snapshot.account],
+        ["claude.served_by", snapshot.servedBy],
+        ["claude.pool.available", snapshot.pool?.available],
+        ["claude.pool.best_session_left_pct", snapshot.pool?.bestSessionLeftPct],
     ];
     for (const [key, value] of attrs) {
         if (value !== undefined) {

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

@@ -23,6 +23,7 @@ export declare class GoogleAIStudioProvider extends BaseProvider {
      * @returns A promise that resolves to the generation result, including the image data.
      */
     protected executeImageGeneration(options: TextGenerationOptions): Promise<EnhancedGenerateResult>;
+    private generateImage;
     /**
      * Detect image MIME type from buffer
      */
@@ -64,12 +65,10 @@ export declare class GoogleAIStudioProvider extends BaseProvider {
      */
     generate(optionsOrPrompt: TextGenerationOptions | string): Promise<EnhancedGenerateResult | null>;
     /**
-     * Emit `generation:end` so the Pipeline B observability listener creates
-     * a `model.generation` span for native Google AI Studio generate calls.
-     * Without this hand-off the native path silently disappears from
-     * Pipeline B exporters (Langfuse, custom OTEL collectors).
+     * Emit `generation:end` for native Google AI Studio generate calls, so
+     * analytics listeners see them.
      */
-    private emitPipelineBGenerationEvent;
+    private emitGenerationEnd;
     private executeAudioStreamViaGeminiLive;
     protected getDefaultEmbeddingModel(): string;
     /**

package/dist/providers/googleAiStudio/client.js

@@ -8,6 +8,8 @@ import { ERROR_CODES, NeuroLinkError } from "../../utils/errorHandling.js";
 import { logger } from "../../utils/logger.js";
 import { drainDetachedPump } from "../../utils/drainDetachedPump.js";
 import { attachStreamCancel, cancelStream, releaseIterator, } from "../../utils/streamCancellation.js";
+import { observeGeneration } from "../../telemetry/observation.js";
+import { withGeneration } from "../../telemetry/withSpan.js";
 import { createGeminiLoopAdapter } from "../../core/geminiLoopAdapter.js";
 import { isDirectTTSRequest } from "../../core/resolveRequestKind.js";
 import { runAgenticLoop } from "../../core/loopEngine.js";
@@ -360,6 +362,13 @@ export class GoogleAIStudioProvider extends BaseProvider {
      * @returns A promise that resolves to the generation result, including the image data.
      */
     async executeImageGeneration(options) {
+        return withGeneration({
+            provider: this.providerName,
+            model: options.model || this.modelName,
+            input: { prompt: options.prompt || options.input?.text || "" },
+        }, (span) => this.generateImage(options, span));
+    }
+    async generateImage(options, span) {
         // Image-to-image generation takes reference images through the same
         // `input.images` array, and generate() routes here BEFORE reaching its own
         // normalization call — so a reference photo in HEIC/BMP/AVIF would arrive
@@ -518,6 +527,12 @@ export class GoogleAIStudioProvider extends BaseProvider {
                                         total: this.estimateTokenCount(prompt),
                                     },
                                 };
+                                observeGeneration(span, {
+                                    responseModel: imageModelName,
+                                    output: result.content,
+                                    usage: result.usage,
+                                    finishReason: "stop",
+                                });
                                 return await this.enhanceResult(result, options, startTime);
                             }
                             // Check for text content
@@ -577,6 +592,12 @@ export class GoogleAIStudioProvider extends BaseProvider {
                                     total: this.estimateTokenCount(prompt),
                                 },
                             };
+                            observeGeneration(span, {
+                                responseModel: imageModelName,
+                                output: result.content,
+                                usage: result.usage,
+                                finishReason: "stop",
+                            });
                             return await this.enhanceResult(result, options, startTime);
                         }
                         if ("text" in part && part.text) {
@@ -747,12 +768,11 @@ export class GoogleAIStudioProvider extends BaseProvider {
     async executeNativeGemini3Stream(options) {
         const modelName = options.model || this.modelName;
         return withClientStreamSpan({
-            name: "neurolink.provider.stream",
+            name: "provider.stream",
             tracer: tracers.provider,
+            detached: true,
             attributes: {
-                [ATTR.GEN_AI_SYSTEM]: "google-ai",
-                [ATTR.GEN_AI_MODEL]: modelName,
-                [ATTR.GEN_AI_OPERATION]: "stream",
+                [ATTR.NL_MODEL]: modelName,
                 [ATTR.NL_PROVIDER]: this.providerName,
             },
         }, async (span) => {
@@ -927,6 +947,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
                         // performed inline.
                         const baseAdapter = createGeminiLoopAdapter({
                             providerLabel: "GoogleAIStudio",
+                            provider: this.providerName,
                             maxSteps,
                             // Same threshold the hand-rolled dispatcher used, which is
                             // what makes an always-failing tool dispatch exactly twice.
@@ -1210,10 +1231,6 @@ export class GoogleAIStudioProvider extends BaseProvider {
                         if (lastFinishReason !== undefined) {
                             metadata.rawFinishReason = lastFinishReason;
                         }
-                        // Set token usage and finish reason on the span
-                        span.setAttribute(ATTR.GEN_AI_INPUT_TOKENS, totalInputTokens);
-                        span.setAttribute(ATTR.GEN_AI_OUTPUT_TOKENS, totalOutputTokens);
-                        span.setAttribute(ATTR.GEN_AI_FINISH_REASON, hitStepLimitWithoutFinalAnswer ? "max_steps" : "stop");
                         // Gemini promptTokenCount is OVERLAPPING: it already includes
                         // cachedContentTokenCount. Subtract once here so calculateCost
                         // bills the cached portion at the cheaper cacheRead rate without
@@ -1454,12 +1471,11 @@ export class GoogleAIStudioProvider extends BaseProvider {
     async executeNativeGemini3Generate(options) {
         const modelName = options.model || this.modelName;
         return withClientSpan({
-            name: "neurolink.provider.generate",
+            name: "provider.generate",
             tracer: tracers.provider,
+            detached: true,
             attributes: {
-                [ATTR.GEN_AI_SYSTEM]: "google-ai",
-                [ATTR.GEN_AI_MODEL]: modelName,
-                [ATTR.GEN_AI_OPERATION]: "generate",
+                [ATTR.NL_MODEL]: modelName,
                 [ATTR.NL_PROVIDER]: this.providerName,
             },
         }, async (span) => {
@@ -1614,6 +1630,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
                     // the turn's text comes from the result.
                     const baseAdapter = createGeminiLoopAdapter({
                         providerLabel: "GoogleAIStudio",
+                        provider: this.providerName,
                         maxSteps,
                         toolFailureBreaker: { maxRetries: DEFAULT_TOOL_MAX_RETRIES },
                         liveTools: options.tools ?? {},
@@ -1819,10 +1836,6 @@ export class GoogleAIStudioProvider extends BaseProvider {
                             elapsedMs: turnClock.elapsedMs(),
                         });
                     }
-                    // Set token usage and finish reason on the span
-                    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");
                     // Build EnhancedGenerateResult and route through enhanceResult so
                     // analytics / evaluation / tracing stay attached. The native AI
                     // Studio generate path bypasses BaseProvider.generate(), so
@@ -2082,10 +2095,6 @@ export class GoogleAIStudioProvider extends BaseProvider {
             });
         }
         // Route ALL models through native @google/genai SDK (no more @ai-sdk/google dependency).
-        // Emit Pipeline B `generation:end` so the observability listener
-        // creates a `model.generation` span — AI Studio's native path bypasses
-        // the AI SDK + experimental_telemetry plumbing the same way Vertex's
-        // does, so the event has to be emitted manually.
         const generateStartTime = Date.now();
         const inputPrompt = mergedOptions.input?.text ||
             mergedOptions.prompt ||
@@ -2096,32 +2105,30 @@ export class GoogleAIStudioProvider extends BaseProvider {
             // native @google/genai path. This provider overrides generate() instead
             // of using BaseProvider's shared flow, so the span is added here.
             let result = await withSpan({
-                name: "neurolink.executeGeneration",
+                name: "executeGeneration",
                 tracer: tracers.provider,
+                detached: true,
                 attributes: {
-                    [ATTR.GEN_AI_SYSTEM]: this.providerName,
-                    [ATTR.GEN_AI_MODEL]: modelName,
-                    "neurolink.path": "native.google-genai",
+                    [ATTR.NL_MODEL]: modelName,
+                    path: "native.google-genai",
                 },
             }, async () => this.executeNativeGemini3Generate(mergedOptions));
             // Pipe through TTS-of-AI-response when caller asks for it. No-op when
             // tts is disabled or useAiResponse is false.
             result = await this.synthesizeAIResponseIfNeeded(result, options);
-            this.emitPipelineBGenerationEvent(modelName, result, generateStartTime, true, undefined, inputPrompt);
+            this.emitGenerationEnd(modelName, result, generateStartTime, true, undefined, inputPrompt);
             return result;
         }
         catch (error) {
-            this.emitPipelineBGenerationEvent(modelName, null, generateStartTime, false, error, inputPrompt);
+            this.emitGenerationEnd(modelName, null, generateStartTime, false, error, inputPrompt);
             throw error;
         }
     }
     /**
-     * Emit `generation:end` so the Pipeline B observability listener creates
-     * a `model.generation` span for native Google AI Studio generate calls.
-     * Without this hand-off the native path silently disappears from
-     * Pipeline B exporters (Langfuse, custom OTEL collectors).
+     * Emit `generation:end` for native Google AI Studio generate calls, so
+     * analytics listeners see them.
      */
-    emitPipelineBGenerationEvent(modelName, result, startTime, success, error, prompt) {
+    emitGenerationEnd(modelName, result, startTime, success, error, prompt) {
         const emitter = this.neurolink?.getEventEmitter();
         if (!emitter) {
             return;
@@ -2137,12 +2144,6 @@ export class GoogleAIStudioProvider extends BaseProvider {
             result._generationEndEmitted =
                 true;
         }
-        // The failure path has no result to carry that flag — `result` is null —
-        // so mark the error instead. Without this the provider's own
-        // `generation:end` (success: false) and the SDK's emitGenerateErrorEvent
-        // both fire for one failed native generate, double-counting every failure
-        // in analytics and as two Pipeline B spans. The success path above was
-        // already deduplicated; only the catch branch was missed.
         if (!success && error && typeof error === "object") {
             error._generationEndEmitted =
                 true;
@@ -2151,9 +2152,6 @@ export class GoogleAIStudioProvider extends BaseProvider {
             provider: this.providerName,
             responseTime: Date.now() - startTime,
             timestamp: Date.now(),
-            // The Pipeline B listener reads `data.prompt` to populate the
-            // `input` span attribute. Without this, the Observability Spans
-            // test fails with "input capture not working".
             prompt: prompt || "",
             result: {
                 content: result?.content || "",