@juspay/neurolink 9.54.6 → 9.54.7

package/dist/context/summarizationEngine.js

@@ -7,6 +7,8 @@
 import { TokenUtils } from "../constants/tokens.js";
 import { buildContextFromPointer, generateSummary, } from "../utils/conversationMemory.js";
 import { RECENT_MESSAGES_RATIO } from "../config/conversationMemory.js";
+import { withSpan } from "../telemetry/withSpan.js";
+import { tracers } from "../telemetry/tracers.js";
 import { logger } from "../utils/logger.js";
 /**
  * Centralized summarization engine for conversation memory.
@@ -22,22 +24,33 @@ export class SummarizationEngine {
      * @returns True if summarization was performed
      */
     async checkAndSummarize(session, threshold, config, logPrefix = "[SummarizationEngine]", requestId) {
-        const contextMessages = buildContextFromPointer(session, requestId);
-        const tokenCount = this.estimateTokens(contextMessages);
-        session.lastTokenCount = tokenCount;
-        session.lastCountedAt = Date.now();
-        logger.info("[Summarization] Check", {
-            requestId,
-            sessionId: session.sessionId,
-            tokenCount,
-            threshold,
-            willSummarize: tokenCount >= threshold,
-        });
-        if (tokenCount >= threshold) {
-            await this.summarizeSession(session, threshold, config, logPrefix, requestId);
-            return true;
-        }
-        return false;
+        return withSpan({
+            name: "neurolink.memory.summarize",
+            tracer: tracers.memory,
+            attributes: {
+                "memory.session_id": session.sessionId ?? "unknown",
+                "memory.threshold": threshold,
+            },
+        }, async (span) => {
+            const contextMessages = buildContextFromPointer(session, requestId);
+            const tokenCount = this.estimateTokens(contextMessages);
+            session.lastTokenCount = tokenCount;
+            session.lastCountedAt = Date.now();
+            logger.info("[Summarization] Check", {
+                requestId,
+                sessionId: session.sessionId,
+                tokenCount,
+                threshold,
+                willSummarize: tokenCount >= threshold,
+            });
+            if (tokenCount >= threshold) {
+                await this.summarizeSession(session, threshold, config, logPrefix, requestId);
+                span.setAttribute("memory.summarized", true);
+                return true;
+            }
+            span.setAttribute("memory.summarized", false);
+            return false;
+        }); // end withSpan
     }
     /**
      * Perform token-based summarization on a session.

package/dist/core/baseProvider.js

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

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

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

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

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

package/dist/core/modules/GenerationHandler.js

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

package/dist/core/modules/StreamHandler.js

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

package/dist/core/modules/ToolsManager.js

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