@juspay/neurolink 12.59.0 → 13.0.1

package/dist/cli/loop/session.js

@@ -115,7 +115,7 @@ export class LoopSession {
                 // The .fail() handler in cli.ts is now session-aware and will
                 // handle all parsing and validation errors without exiting the loop.
                 // We create a fresh instance for each command to prevent state pollution.
-                await tracers.sdk.startActiveSpan("neurolink.cli.turn", async (turnSpan) => {
+                await tracers.sdk.startActiveSpan("cli.turn", async (turnSpan) => {
                     try {
                         turnSpan.setAttribute("cli.command", typeof processedCommand === "string"
                             ? processedCommand.slice(0, 100)

package/dist/client/httpClient.js

@@ -187,7 +187,7 @@ export class NeuroLinkClient {
      */
     async request(method, path, body, options) {
         return withClientSpan({
-            name: "neurolink.client.http.request",
+            name: "client.http.request",
             tracer: tracers.http,
             attributes: {
                 "http.method": method,

package/dist/client/sseClient.js

@@ -73,7 +73,7 @@ export class NeuroLinkSSE {
      */
     async stream(path, options = {}, callbacks = {}) {
         return withClientSpan({
-            name: "neurolink.client.sse.stream",
+            name: "client.sse.stream",
             tracer: tracers.http,
             attributes: {
                 "http.method": options.body ? "POST" : "GET",

package/dist/client/streamingClient.js

@@ -64,7 +64,7 @@ export class SSEClient {
      */
     async connect(requestOptions = {}) {
         return withClientSpan({
-            name: "neurolink.client.streaming.sse.connect",
+            name: "client.streaming.sse.connect",
             tracer: tracers.http,
             attributes: {
                 "http.url": this.url,
@@ -406,7 +406,7 @@ export class WebSocketStreamingClient {
      */
     async connect() {
         return withClientSpan({
-            name: "neurolink.client.streaming.ws.connect",
+            name: "client.streaming.ws.connect",
             tracer: tracers.http,
             attributes: { "http.url": this.options.url },
         }, async () => this._connectWS());

package/dist/client/wsClient.js

@@ -111,7 +111,7 @@ export class NeuroLinkWebSocket {
         // Start an OTel span that tracks the lifetime of this connection attempt.
         // Ended in onclose/onerror/disconnect so metrics capture connection
         // duration and error attribution.
-        this.connectionSpan = tracers.http.startSpan("neurolink.client.ws.connect", {
+        this.connectionSpan = tracers.http.startSpan("client.ws.connect", {
             kind: SpanKind.CLIENT,
             attributes: {
                 "http.url": this.config.baseUrl,

package/dist/constants/langfuse.d.ts

@@ -0,0 +1,25 @@
+import { SpanStatus } from "../types/index.js";
+/** @description Langfuse OTLP ingestion endpoint path. */
+export declare const TRACES_PATH = "/api/public/otel/v1/traces";
+/** @description Langfuse health endpoint path. */
+export declare const HEALTH_PATH = "/api/public/health";
+/** @description Langfuse Cloud base URL used when none is configured. */
+export declare const DEFAULT_BASE_URL = "https://cloud.langfuse.com";
+/** @description Spans buffered before an automatic flush. */
+export declare const DEFAULT_FLUSH_AT = 15;
+/** @description Milliseconds between scheduled flushes. */
+export declare const DEFAULT_FLUSH_INTERVAL_MS = 5000;
+/** @description Milliseconds before an export request is aborted. */
+export declare const DEFAULT_TIMEOUT_MS = 30000;
+/** @description Maximum spans sent in one export request. */
+export declare const MAX_SPANS_PER_REQUEST = 500;
+/** @description Maximum serialized bytes sent in one export request. */
+export declare const MAX_BYTES_PER_REQUEST = 3500000;
+/** @description Placeholder that replaces a value fully removed by the user's mask. */
+export declare const FULLY_MASKED = "<fully masked>";
+/** @description Span attributes holding trace and observation input or output, which the mask applies to. */
+export declare const CONTENT_KEYS: Set<string>;
+/** @description Attribute prefixes whose values are metadata entries. */
+export declare const METADATA_PREFIXES: string[];
+/** @description OTLP numeric status code for each span status. */
+export declare const OTLP_STATUS_CODES: Record<SpanStatus, number>;

package/dist/constants/langfuse.js

@@ -0,0 +1,38 @@
+import { SpanStatus } from "../types/index.js";
+/** @description Langfuse OTLP ingestion endpoint path. */
+export const TRACES_PATH = "/api/public/otel/v1/traces";
+/** @description Langfuse health endpoint path. */
+export const HEALTH_PATH = "/api/public/health";
+/** @description Langfuse Cloud base URL used when none is configured. */
+export const DEFAULT_BASE_URL = "https://cloud.langfuse.com";
+/** @description Spans buffered before an automatic flush. */
+export const DEFAULT_FLUSH_AT = 15;
+/** @description Milliseconds between scheduled flushes. */
+export const DEFAULT_FLUSH_INTERVAL_MS = 5_000;
+/** @description Milliseconds before an export request is aborted. */
+export const DEFAULT_TIMEOUT_MS = 30_000;
+/** @description Maximum spans sent in one export request. */
+export const MAX_SPANS_PER_REQUEST = 500;
+/** @description Maximum serialized bytes sent in one export request. */
+export const MAX_BYTES_PER_REQUEST = 3_500_000;
+/** @description Placeholder that replaces a value fully removed by the user's mask. */
+export const FULLY_MASKED = "<fully masked>";
+/** @description Span attributes holding trace and observation input or output, which the mask applies to. */
+export const CONTENT_KEYS = new Set([
+    "langfuse.observation.input",
+    "langfuse.observation.output",
+    "langfuse.trace.input",
+    "langfuse.trace.output",
+]);
+/** @description Attribute prefixes whose values are metadata entries. */
+export const METADATA_PREFIXES = [
+    "langfuse.observation.metadata.",
+    "langfuse.trace.metadata.",
+];
+/** @description OTLP numeric status code for each span status. */
+export const OTLP_STATUS_CODES = {
+    [SpanStatus.UNSET]: 0,
+    [SpanStatus.WARNING]: 0,
+    [SpanStatus.OK]: 1,
+    [SpanStatus.ERROR]: 2,
+};

package/dist/constants/telemetry.d.ts

@@ -0,0 +1,20 @@
+/** @description Smallest per-string character budget when trimming span payloads. */
+export declare const MIN_STRING_BUDGET_CHARS = 64;
+/** @description Base64 payload length above which a value is treated as binary and replaced. */
+export declare const BINARY_PAYLOAD_MIN_CHARS = 1024;
+/** @description Placeholder written when a span value cannot be serialized. */
+export declare const UNSERIALIZABLE_VALUE = "[unserializable]";
+/** @description Object keys whose values are treated as binary payloads. */
+export declare const BINARY_KEYS: Set<string>;
+/** @description Placeholder that replaces a masked credential in span content. */
+export declare const REDACTED_VALUE = "[REDACTED]";
+/** @description Finish reasons that mark a completed model call as a Langfuse warning. */
+export declare const WARNING_FINISH_REASONS: Set<string>;
+/** @description Room for the "...[truncated N chars]" note, kept outside the opening a cap preserves. */
+export declare const TRUNCATION_NOTE_ALLOWANCE_CHARS = 48;
+/** @description Name of the OpenTelemetry context key that carries a trace's full metadata. */
+export declare const TRACE_METADATA_CONTEXT_KEY = "neurolink.trace.metadata";
+/** @description Log prefix for NeuroLink's OpenTelemetry setup. */
+export declare const OTEL_LOG_PREFIX = "[OpenTelemetry]";
+/** @description Most open and most ended spans the exporter span processor remembers for re-parenting; the oldest are forgotten first. */
+export declare const MAX_REMEMBERED_SPANS = 5000;

package/dist/constants/telemetry.js

@@ -0,0 +1,34 @@
+/** @description Smallest per-string character budget when trimming span payloads. */
+export const MIN_STRING_BUDGET_CHARS = 64;
+/** @description Base64 payload length above which a value is treated as binary and replaced. */
+export const BINARY_PAYLOAD_MIN_CHARS = 1_024;
+/** @description Placeholder written when a span value cannot be serialized. */
+export const UNSERIALIZABLE_VALUE = "[unserializable]";
+/** @description Object keys whose values are treated as binary payloads. */
+export const BINARY_KEYS = new Set([
+    "data",
+    "image",
+    "bytes",
+    "base64",
+    "b64json",
+]);
+/** @description Placeholder that replaces a masked credential in span content. */
+export const REDACTED_VALUE = "[REDACTED]";
+/** @description Finish reasons that mark a completed model call as a Langfuse warning. */
+export const WARNING_FINISH_REASONS = new Set([
+    "length",
+    "max_tokens",
+    "content-filter",
+    "content_filter",
+    "abort",
+    "aborted",
+    "no-output",
+]);
+/** @description Room for the "...[truncated N chars]" note, kept outside the opening a cap preserves. */
+export const TRUNCATION_NOTE_ALLOWANCE_CHARS = 48;
+/** @description Name of the OpenTelemetry context key that carries a trace's full metadata. */
+export const TRACE_METADATA_CONTEXT_KEY = "neurolink.trace.metadata";
+/** @description Log prefix for NeuroLink's OpenTelemetry setup. */
+export const OTEL_LOG_PREFIX = "[OpenTelemetry]";
+/** @description Most open and most ended spans the exporter span processor remembers for re-parenting; the oldest are forgotten first. */
+export const MAX_REMEMBERED_SPANS = 5_000;

package/dist/core/baseProvider.d.ts

@@ -3,6 +3,7 @@ import type { EvaluationData } from "../index.js";
 import type { NeuroLink } from "../neurolink.js";
 import type { FileToolRootPolicy, UnknownRecord, MiddlewareFactoryOptions, StreamOptions, StreamResult, AIProvider, AnalyticsData, EnhancedGenerateResult, TextGenerationOptions, TextGenerationResult, ValidationSchema, EmbedInput, DecisionRequest, DecisionResult, MemoryToolCallRecord, MemoryToolResultRecord, ToolExecutionSummaryInternal } from "../types/index.js";
 import { TelemetryHandler } from "./modules/TelemetryHandler.js";
+import { ToolsManager } from "./modules/ToolsManager.js";
 import type { LanguageModel, ModelMessage, RawUsageObject, Tool, ToolCallRepairFunction, ToolSet } from "../types/index.js";
 export declare abstract class BaseProvider implements AIProvider {
     protected modelName: string;
@@ -25,7 +26,7 @@ export declare abstract class BaseProvider implements AIProvider {
     private streamHandler;
     protected telemetryHandler: TelemetryHandler;
     private utilities;
-    private readonly toolsManager;
+    protected readonly toolsManager: ToolsManager;
     constructor(modelName?: string, providerName?: AIProviderName, neurolink?: NeuroLink, middleware?: MiddlewareFactoryOptions);
     /**
      * Update modelName and rebuild composition handlers with the new value.

package/dist/core/baseProvider.js

@@ -174,7 +174,7 @@ export class BaseProvider {
         this.modelName = model;
         trace
             .getSpan(context.active())
-            ?.setAttribute(ATTR.GEN_AI_MODEL, this.modelName);
+            ?.setAttribute(ATTR.NL_MODEL, this.modelName);
         this.messageBuilder = new MessageBuilder(this.providerName, this.modelName);
         this.streamHandler = new StreamHandler(this.providerName, this.modelName);
         this.telemetryHandler = new TelemetryHandler(this.providerName, this.modelName, this.neurolink);
@@ -1538,20 +1538,15 @@ export class BaseProvider {
         // model that failed rather than the one that served.
         const attempt = async () => {
             // OTEL span for provider-level generate tracing
-            // Use startActiveSpan pattern via context.with() so child spans become descendants
-            const otelSpan = tracers.provider.startSpan("neurolink.provider.generate", {
+            const otelSpan = tracers.provider.startSpan("provider.generate", {
                 kind: SpanKind.CLIENT,
                 attributes: {
-                    [ATTR.GEN_AI_SYSTEM]: this.providerName || "unknown",
-                    [ATTR.GEN_AI_MODEL]: this.modelName || options.model || "unknown",
-                    [ATTR.GEN_AI_OPERATION]: "generate",
+                    [ATTR.NL_MODEL]: this.modelName || options.model || "unknown",
                     [ATTR.NL_PROVIDER]: this.providerName || "unknown",
                 },
             });
-            // Set this span as the active context so child spans (provider calls, tool executions) become descendants
-            const activeCtx = trace.setSpan(context.active(), otelSpan);
             const otelSpanState = { ended: false };
-            return await context.with(activeCtx, async () => this.runGenerateInActiveContext(options, startTime, otelSpan, otelSpanState));
+            return await this.runGenerateInActiveContext(options, startTime, otelSpan, otelSpanState);
         };
         // Callers that own fallback order (providerFallback / modelChain callers,
         // or a router that retries on its own) pass the flag on both paths;
@@ -1761,7 +1756,6 @@ export class BaseProvider {
                 error,
                 latency,
             };
-            this.telemetryHandler.recordTTSFailure(ttsProvider, error, latency);
             logger.error(`TTS synthesis failed in Mode 1 (direct input synthesis):`, ttsError);
         }
         return this.enhanceResult(baseResult, options, startTime);
@@ -2119,7 +2113,6 @@ export class BaseProvider {
         catch (ttsError) {
             const latency = Date.now() - ttsStartTime;
             const error = this.getTTSErrorDetails(ttsError);
-            this.telemetryHandler.recordTTSFailure(ttsProvider, error, latency);
             logger.error(`TTS synthesis failed in Mode 2 (AI response synthesis):`, ttsError);
             return {
                 ...enhancedResult,

package/dist/core/conversationMemoryManager.js

@@ -6,7 +6,7 @@ import { randomUUID } from "crypto";
 import { DEFAULT_MAX_SESSIONS, MEMORY_THRESHOLD_PERCENTAGE, MESSAGES_PER_TURN, } from "../config/conversationMemory.js";
 import { TokenUtils } from "../constants/tokens.js";
 import { SummarizationEngine } from "../context/summarizationEngine.js";
-import { runWithCurrentLangfuseContext } from "../services/server/ai/observability/instrumentation.js";
+import { context } from "@opentelemetry/api";
 import { tracers, withSpan } from "../telemetry/index.js";
 import { ConversationMemoryError } from "../types/index.js";
 import { buildContextFromPointer, getEffectiveTokenThreshold, } from "../utils/conversationMemory.js";
@@ -67,7 +67,7 @@ export class ConversationMemoryManager {
      */
     async storeConversationTurn(options) {
         return withSpan({
-            name: "neurolink.memory.storeTurn",
+            name: "memory.storeTurn",
             tracer: tracers.memory,
             attributes: {
                 "memory.type": "in-memory",
@@ -114,10 +114,7 @@ export class ConversationMemoryManager {
                 if (shouldSummarize) {
                     // Only trigger summarization if not already in progress for this session
                     if (!this.summarizationInProgress.has(options.sessionId)) {
-                        // Capture the current Langfuse ALS context before setImmediate,
-                        // which breaks automatic AsyncLocalStorage propagation and would
-                        // otherwise cause orphaned traces in Langfuse.
-                        const summarizeWithContext = runWithCurrentLangfuseContext(async () => {
+                        const summarizeWithContext = context.bind(context.active(), async () => {
                             try {
                                 await this.checkAndSummarize(session, tokenThreshold, options.requestId);
                             }
@@ -229,7 +226,7 @@ export class ConversationMemoryManager {
      */
     async buildContextMessages(sessionId, _userId, _enableSummarization, requestId) {
         return withSpan({
-            name: "neurolink.memory.buildContext",
+            name: "memory.buildContext",
             tracer: tracers.memory,
             attributes: {
                 "memory.type": "in-memory",
@@ -345,7 +342,7 @@ export class ConversationMemoryManager {
     }
     async clearSession(sessionId) {
         return withSpan({
-            name: "neurolink.memory.clear",
+            name: "memory.clear",
             tracer: tracers.memory,
             attributes: {
                 "memory.type": "in-memory",

package/dist/core/factory.js

@@ -214,7 +214,7 @@ export class AIProviderFactory {
     static async createProvider(providerName, modelName, enableMCP = true, sdk, region, credentials) {
         const functionTag = "AIProviderFactory.createProvider";
         // Providers are registered via ProviderFactory.initialize() on first use
-        return factoryTracer.startActiveSpan("neurolink.factory.createProvider", {
+        return factoryTracer.startActiveSpan("factory.createProvider", {
             kind: SpanKind.INTERNAL,
             attributes: {
                 "provider.name": providerName,

package/dist/core/geminiLoopAdapter.d.ts

@@ -16,5 +16,12 @@
  * and original -> sanitized when writing `functionResponse` parts. Neither the
  * engine nor any other adapter needs to know sanitization happened.
  */
-import type { AgenticLoopAdapter, GeminiLoopAdapterConfig, GeminiStepRaw, GeminiTurnContent } from "../types/index.js";
+import type { AgenticLoopAdapter, GeminiLoopAdapterConfig, GeminiStepRaw, GeminiStepRequest, GeminiTurnContent, GenerationRecord } from "../types/index.js";
+/**
+ * @description Describes one Gemini request as the request half of a Langfuse generation.
+ * @param provider {string} - Provider name used to price the call.
+ * @param request {GeminiStepRequest} - Model, contents and generation config sent.
+ * @returns {GenerationRecord} Provider, model, sampling and thinking parameters, and the system instruction plus contents.
+ */
+export declare function describeGeminiRequest(provider: string, request: GeminiStepRequest): GenerationRecord;
 export declare function createGeminiLoopAdapter(config: GeminiLoopAdapterConfig): AgenticLoopAdapter<GeminiTurnContent[], GeminiStepRaw>;

package/dist/core/geminiLoopAdapter.js

@@ -19,6 +19,28 @@
 import { guardToolExecutor } from "./toolExecutionGuards.js";
 import { resolveLiveTool } from "../tools/toolDiscovery.js";
 import { collectStreamChunksIncremental, extractTextFromParts, mapGeminiFinishReason, pushModelResponseToHistory, refreshNativeToolDeclarations, } from "../providers/googleNativeGemini3/utils.js";
+/**
+ * @description Describes one Gemini request as the request half of a Langfuse generation.
+ * @param provider {string} - Provider name used to price the call.
+ * @param request {GeminiStepRequest} - Model, contents and generation config sent.
+ * @returns {GenerationRecord} Provider, model, sampling and thinking parameters, and the system instruction plus contents.
+ */
+export function describeGeminiRequest(provider, request) {
+    const settings = (request.config ?? {});
+    const thinking = settings.thinkingConfig;
+    return {
+        provider,
+        model: request.model,
+        modelParameters: {
+            temperature: settings.temperature,
+            maxTokens: settings.maxOutputTokens,
+            topP: settings.topP,
+            thinkingLevel: thinking?.thinkingLevel,
+            thinkingBudget: thinking?.thinkingBudget,
+        },
+        input: { system: settings.systemInstruction, messages: request.contents },
+    };
+}
 export function createGeminiLoopAdapter(config) {
     /**
      * Sanitized wire name -> the name the caller registered. Rebuilt per step
@@ -62,8 +84,10 @@ export function createGeminiLoopAdapter(config) {
             const hydratedToolNames = config.declarations
                 ? refreshNativeToolDeclarations(config.liveTools, config.declarations)
                 : [];
+            const raw = config.buildRequest(conversation, step);
             return {
-                raw: config.buildRequest(conversation, step),
+                raw,
+                generation: describeGeminiRequest(config.provider, raw),
                 ...(hydratedToolNames.length > 0 ? { hydratedToolNames } : {}),
             };
         },

package/dist/core/loopEngine.js

@@ -1,4 +1,6 @@
 import { createStreamChannel } from "./streamChannel.js";
+import { observeGeneration } from "../telemetry/observation.js";
+import { StepSpans, withGeneration } from "../telemetry/withSpan.js";
 import { logger } from "../utils/logger.js";
 import { withProviderRetry } from "../utils/providerRetry.js";
 import { resolveToolTimeoutMs } from "./constants.js";
@@ -266,6 +268,67 @@ async function dispatchStepTools(params) {
     }
     return { toolResults, executions, dispatched, abortedMidBatch };
 }
+async function executeObservedStep(adapter, request, channel, signal, span) {
+    // Pre-first-chunk 429/5xx retry: watch whether THIS attempt of
+    // THIS step pushes anything to the shared channel before it
+    // throws. `hasEmitted` resets at the top of every attempt
+    // withProviderRetry makes; the instant an attempt emits and then
+    // throws, the thrown error is rewrapped as a PostEmissionStepError
+    // (no status/branding info survives the rewrap), which
+    // isRetryableProviderError() duck-types as non-retryable — so
+    // withProviderRetry gives up immediately instead of sleeping and
+    // re-invoking executeStep, which would duplicate/interleave
+    // output already sent to the consumer. The original error (not
+    // the wrapper) is what the caller of runAgenticLoop ultimately
+    // sees, via the unwrap in the catch below.
+    let hasEmitted = false;
+    let firstChunkAt;
+    const watchedChannel = {
+        push: (chunk) => {
+            hasEmitted = true;
+            firstChunkAt ??= new Date();
+            channel.push(chunk);
+        },
+    };
+    return withGeneration(request.generation ?? {}, async (generationSpan) => {
+        let result;
+        try {
+            result = await withProviderRetry(async () => {
+                hasEmitted = false;
+                try {
+                    return await adapter.executeStep(request, watchedChannel, signal);
+                }
+                catch (err) {
+                    throw hasEmitted ? new PostEmissionStepError(err) : err;
+                }
+            }, span, `${adapter.providerLabel}.step`, undefined, signal);
+        }
+        catch (err) {
+            throw err instanceof PostEmissionStepError ? err.cause : err;
+        }
+        observeGeneration(generationSpan, {
+            provider: request.generation?.provider,
+            model: request.generation?.model,
+            responseModel: result.model,
+            output: {
+                text: result.text,
+                ...(result.reasoning ? { reasoning: result.reasoning } : {}),
+                ...(result.toolCalls.length > 0 ? { toolCalls: result.toolCalls } : {}),
+            },
+            usage: {
+                inputTokens: result.usage.inputTokens,
+                outputTokens: result.usage.outputTokens,
+                cacheReadTokens: result.usage.cacheReadTokens,
+                cacheCreationTokens: result.usage.cacheWriteTokens,
+                reasoningTokens: result.usage.reasoningTokens,
+            },
+            finishReason: result.rawStopReason,
+            aborted: signal.aborted,
+            completionStartTime: firstChunkAt,
+        });
+        return result;
+    });
+}
 /**
  * Run one adapter-parameterized agentic tool-calling turn. Owns the
  * maxSteps-bounded loop, generic tool dispatch (with an opt-in
@@ -307,11 +370,13 @@ export function runAgenticLoop(adapter, initialConversation, options) {
         // ever writes to it, so the loop is the same loop it was.
         let stepCap = adapter.maxSteps;
         const turnStartedAt = Date.now();
+        const stepSpans = new StepSpans();
         try {
             for (let step = 0; step < stepCap; step++) {
                 if (internalAbort.signal.aborted) {
                     break;
                 }
+                stepSpans.begin(step + 1);
                 if (adapter.planReclaim) {
                     const reclaimed = adapter.planReclaim(conversation, step);
                     if (reclaimed?.conversation !== undefined) {
@@ -333,44 +398,7 @@ export function runAgenticLoop(adapter, initialConversation, options) {
                 for (const name of request.hydratedToolNames ?? []) {
                     failedTools.delete(name);
                 }
-                // Pre-first-chunk 429/5xx retry: watch whether THIS attempt of
-                // THIS step pushes anything to the shared channel before it
-                // throws. `hasEmitted` resets at the top of every attempt
-                // withProviderRetry makes; the instant an attempt emits and then
-                // throws, the thrown error is rewrapped as a PostEmissionStepError
-                // (no status/branding info survives the rewrap), which
-                // isRetryableProviderError() duck-types as non-retryable — so
-                // withProviderRetry gives up immediately instead of sleeping and
-                // re-invoking executeStep, which would duplicate/interleave
-                // output already sent to the consumer. The original error (not
-                // the wrapper) is what the caller of runAgenticLoop ultimately
-                // sees, via the unwrap in the catch below.
-                let hasEmitted = false;
-                const watchedChannel = {
-                    push: (chunk) => {
-                        hasEmitted = true;
-                        channel.push(chunk);
-                    },
-                };
-                let stepResult;
-                try {
-                    stepResult = await withProviderRetry(async () => {
-                        hasEmitted = false;
-                        try {
-                            return await adapter.executeStep(request, watchedChannel, internalAbort.signal);
-                        }
-                        catch (err) {
-                            throw hasEmitted ? new PostEmissionStepError(err) : err;
-                        }
-                    }, 
-                    // The caller's span, when it passes one. withProviderRetry writes
-                    // gen_ai.provider.total_attempts here, so a loop that threaded a
-                    // span before it moved onto this engine keeps emitting it.
-                    options.span, `${adapter.providerLabel}.step`, undefined, internalAbort.signal);
-                }
-                catch (err) {
-                    throw err instanceof PostEmissionStepError ? err.cause : err;
-                }
+                const stepResult = await stepSpans.run(() => executeObservedStep(adapter, request, channel, internalAbort.signal, options.span));
                 usage = sumUsage(usage, stepResult.usage);
                 rawStopReason = stepResult.rawStopReason;
                 lastStepText = stepResult.text || lastStepText;
@@ -391,14 +419,14 @@ export function runAgenticLoop(adapter, initialConversation, options) {
                 if (step === stepCap - 1) {
                     hadToolCallsAtCap = true;
                 }
-                const dispatch = await dispatchStepTools({
+                const dispatch = await stepSpans.run(() => dispatchStepTools({
                     calls: stepResult.toolCalls,
                     adapter,
                     tools: options.tools,
                     failedTools,
                     abortSignal: internalAbort.signal,
                     toolTimeoutMs: resolveToolTimeoutMs(options.toolTimeoutMs),
-                });
+                }));
                 const toolResults = dispatch.toolResults;
                 allToolCalls.push(...dispatch.dispatched);
                 allToolExecutions.push(...dispatch.executions);
@@ -510,6 +538,7 @@ export function runAgenticLoop(adapter, initialConversation, options) {
             throw err;
         }
         finally {
+            stepSpans.end();
             // close() after error() is harmless: it only flips `done`, and
             // streamChannel.error() keeps its error state intact regardless of a
             // later close() call.

package/dist/core/modules/MessageBuilder.js

@@ -72,7 +72,7 @@ export class MessageBuilder {
      */
     async buildMessages(options) {
         return withSpan({
-            name: "neurolink.message.build",
+            name: "message.build",
             tracer: tracers.sdk,
             attributes: {
                 [ATTR.NL_PROVIDER]: this.providerName,
@@ -220,7 +220,7 @@ export class MessageBuilder {
      */
     async buildMessagesForStream(options) {
         return withSpan({
-            name: "neurolink.message.build_for_stream",
+            name: "message.build_for_stream",
             tracer: tracers.sdk,
             attributes: {
                 [ATTR.NL_PROVIDER]: this.providerName,

package/dist/core/modules/StreamHandler.js

@@ -35,7 +35,7 @@ export class StreamHandler {
      * Validate stream options - consolidates validation from 7/10 providers
      */
     validateStreamOptions(options) {
-        const span = tracers.stream.startSpan("neurolink.stream.validate", {
+        const span = tracers.stream.startSpan("stream.validate", {
             attributes: {
                 [ATTR.NL_PROVIDER]: this.providerName,
                 [ATTR.NL_MODEL]: this.modelName,
@@ -189,7 +189,7 @@ export class StreamHandler {
      */
     async createStreamAnalytics(result, startTime, options) {
         return withSpan({
-            name: "neurolink.stream.analytics",
+            name: "stream.analytics",
             tracer: tracers.stream,
             attributes: {
                 [ATTR.NL_PROVIDER]: this.providerName,

package/dist/core/modules/TelemetryHandler.d.ts

@@ -1,7 +1,7 @@
 /**
  * Telemetry Handler Module
  *
- * Handles analytics, evaluation, performance metrics, and telemetry configuration.
+ * Handles analytics, evaluation and performance metrics.
  * Extracted from BaseProvider to follow Single Responsibility Principle.
  *
  * Responsibilities:
@@ -9,12 +9,11 @@
  * - Evaluation generation
  * - Performance metrics recording
  * - Cost calculation
- * - Telemetry configuration
  *
  * @module core/modules/TelemetryHandler
  */
 import type { NeuroLink } from "../../neurolink.js";
-import type { StreamOptions, AIProviderName, AnalyticsData, EnhancedGenerateResult, EvaluationData, MemoryToolCallRecord, MemoryToolResultRecord, RawUsageObject, TextGenerationOptions, TokenUsage, TTSMetadata } from "../../types/index.js";
+import type { StreamOptions, AIProviderName, AnalyticsData, EnhancedGenerateResult, EvaluationData, MemoryToolCallRecord, MemoryToolResultRecord, RawUsageObject, TextGenerationOptions, TokenUsage } from "../../types/index.js";
 /**
  * TelemetryHandler class - Handles analytics and telemetry for AI providers
  */
@@ -35,26 +34,11 @@ export declare class TelemetryHandler {
      * Record performance metrics for a generation
      */
     recordPerformanceMetrics(usage: RawUsageObject | undefined, responseTime: number): Promise<void>;
-    /**
-     * Record a TTS synthesis failure without affecting the generation result.
-     */
-    recordTTSFailure(ttsProvider: string, error: NonNullable<TTSMetadata["error"]>, latency: number): void;
     /**
      * Estimate cost only from known per-model rates. Unknown pricing remains
      * absent from cost metrics instead of using another model's default rate.
      */
     calculateActualCost(usage: TokenUsage): Promise<number | undefined>;
-    /**
-     * Create telemetry configuration for Vercel AI SDK experimental_telemetry
-     * This enables automatic OpenTelemetry tracing when telemetry is enabled
-     */
-    getTelemetryConfig(options: StreamOptions | TextGenerationOptions, operationType?: "stream" | "generate"): {
-        isEnabled: boolean;
-        functionId?: string;
-        metadata?: Record<string, string | number | boolean>;
-        recordInputs?: boolean;
-        recordOutputs?: boolean;
-    } | undefined;
     /**
      * Handle tool execution storage if available
      */