@juspay/neurolink 9.59.1 → 9.59.3

package/dist/providers/azureOpenai.js

@@ -111,6 +111,9 @@ export class AzureOpenAIProvider extends BaseProvider {
             // Using protected helper from BaseProvider to eliminate code duplication
             const messages = await this.buildMessagesForStream(options);
             const model = await this.getAISDKModelWithMiddleware(options);
+            // Reviewer follow-up: capture upstream provider errors via onError
+            // so the post-stream NoOutput sentinel carries the real cause.
+            let capturedProviderError;
             const stream = await streamText({
                 model,
                 messages: messages,
@@ -126,6 +129,14 @@ export class AzureOpenAIProvider extends BaseProvider {
                 abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
                 experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
                 experimental_repairToolCall: this.getToolCallRepairFn(options),
+                onError: (event) => {
+                    capturedProviderError = event.error;
+                    logger.error("AzureOpenAI: Stream error", {
+                        error: event.error instanceof Error
+                            ? event.error.message
+                            : String(event.error),
+                    });
+                },
                 onStepFinish: (event) => {
                     emitToolEndFromStepFinish(this.neurolink?.getEventEmitter(), event.toolResults);
                     this.handleToolExecutionStorage([...event.toolCalls], [...event.toolResults], options, new Date()).catch((error) => {
@@ -138,7 +149,7 @@ export class AzureOpenAIProvider extends BaseProvider {
             });
             timeoutController?.cleanup();
             // Transform string stream to content object stream using BaseProvider method
-            const transformedStream = this.createTextStream(stream);
+            const transformedStream = this.createTextStream(stream, () => capturedProviderError);
             return {
                 stream: transformedStream,
                 provider: "azure",

package/dist/providers/googleAiStudio.js

@@ -466,6 +466,9 @@ export class GoogleAIStudioProvider extends BaseProvider {
             const messages = await this.buildMessagesForStream(options);
             const collectedToolCalls = [];
             const collectedToolResults = [];
+            // Reviewer follow-up: capture upstream provider errors via onError
+            // so the post-stream NoOutput sentinel carries the real cause.
+            let capturedProviderError;
             const result = await streamText({
                 model,
                 messages: messages,
@@ -477,6 +480,14 @@ export class GoogleAIStudioProvider extends BaseProvider {
                 abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
                 experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
                 experimental_repairToolCall: this.getToolCallRepairFn(options),
+                onError: (event) => {
+                    capturedProviderError = event.error;
+                    logger.error("GoogleAiStudio: Stream error", {
+                        error: event.error instanceof Error
+                            ? event.error.message
+                            : String(event.error),
+                    });
+                },
                 // Gemini 3: use thinkingLevel via providerOptions
                 // Gemini 2.5: use thinkingBudget via providerOptions
                 ...(options.thinkingConfig?.enabled && {
@@ -540,7 +551,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
             })
                 .finally(() => timeoutController?.cleanup());
             // Transform string stream to content object stream using BaseProvider method
-            const transformedStream = this.createTextStream(result);
+            const transformedStream = this.createTextStream(result, () => capturedProviderError);
             // Create analytics promise that resolves after stream completion
             const analyticsPromise = streamAnalyticsCollector.createAnalytics(this.providerName, this.modelName, toAnalyticsStreamResult(result), Date.now() - startTime, {
                 requestId: `google-ai-stream-${Date.now()}`,

package/dist/providers/googleVertex.js

@@ -877,10 +877,16 @@ export class GoogleVertexProvider extends BaseProvider {
     }
     async executeAISDKStream(options, analysisSchema, modelName) {
         const functionTag = "GoogleVertexProvider.executeStream";
+        // Reviewer follow-up: include `capturedProviderError` in the
+        // tracking object so the streamText `onError` callback (in
+        // buildAISDKStreamOptions) can write to it; the post-stream
+        // NoOutput sentinel reads it via the `getUnderlyingError` getter
+        // passed to createTextStream.
         const tracking = {
             chunkCount: 0,
             collectedToolCalls: [],
             collectedToolResults: [],
+            capturedProviderError: undefined,
         };
         const timeoutController = createTimeoutController(this.getTimeout(options), this.providerName, "stream");
         try {
@@ -909,7 +915,7 @@ export class GoogleVertexProvider extends BaseProvider {
                 timeoutController,
             });
             return {
-                stream: this.createTextStream(result),
+                stream: this.createTextStream(result, () => tracking.capturedProviderError),
                 provider: this.providerName,
                 model: this.modelName,
                 ...(shouldUseTools && {
@@ -1011,6 +1017,10 @@ export class GoogleVertexProvider extends BaseProvider {
                 const errorMessage = event.error instanceof Error
                     ? event.error.message
                     : String(event.error);
+                // Reviewer follow-up: capture the upstream error so the
+                // post-stream NoOutput sentinel can surface it via
+                // providerError / modelResponseRaw.
+                tracking.capturedProviderError = event.error;
                 logger.error(`${functionTag}: Stream error`, {
                     provider: this.providerName,
                     modelName: this.modelName,

package/dist/providers/huggingFace.js

@@ -5,6 +5,7 @@ import { DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
 import { emitToolEndFromStepFinish } from "../utils/toolEndEmitter.js";
 import { logger } from "../utils/logger.js";
+import { buildNoOutputSentinel, detectPostStreamNoOutput, stampNoOutputSpan, } from "../utils/noOutputSentinel.js";
 import { createHuggingFaceConfig, getProviderModel, validateApiKey, } from "../utils/providerConfig.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { resolveToolChoice } from "../utils/toolChoice.js";
@@ -128,6 +129,10 @@ export class HuggingFaceProvider extends BaseProvider {
                 ? { ...options, systemPrompt: streamOptions.system }
                 : options;
             const messages = await this.buildMessagesForStream(messagesOptions);
+            // Reviewer follow-up: capture upstream provider errors via onError
+            // so the post-stream NoOutput detect can propagate the real cause
+            // into the sentinel's providerError / modelResponseRaw.
+            let capturedProviderError;
             const result = await streamText({
                 model: this.model,
                 messages: messages,
@@ -141,6 +146,14 @@ export class HuggingFaceProvider extends BaseProvider {
                 abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
                 experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
                 experimental_repairToolCall: this.getToolCallRepairFn(options),
+                onError: (event) => {
+                    capturedProviderError = event.error;
+                    logger.error("HuggingFace: Stream error", {
+                        error: event.error instanceof Error
+                            ? event.error.message
+                            : String(event.error),
+                    });
+                },
                 onStepFinish: ({ toolCalls, toolResults }) => {
                     emitToolEndFromStepFinish(this.neurolink?.getEventEmitter(), toolResults);
                     this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {
@@ -154,19 +167,33 @@ export class HuggingFaceProvider extends BaseProvider {
             timeoutController?.cleanup();
             // Transform stream to match StreamResult interface with enhanced tool call parsing
             const transformedStream = async function* () {
+                let chunkCount = 0;
                 try {
                     for await (const chunk of result.textStream) {
+                        chunkCount++;
                         yield { content: chunk };
                     }
                 }
                 catch (streamError) {
-                    // AI SDK v6 throws NoOutputGeneratedError when the stream produced no output.
                     if (NoOutputGeneratedError.isInstance(streamError)) {
-                        logger.warn("HuggingFace: Stream produced no output (NoOutputGeneratedError)");
+                        logger.warn("HuggingFace: Stream produced no output (NoOutputGeneratedError) — caught from textStream");
+                        const sentinel = await buildNoOutputSentinel(streamError, result, capturedProviderError);
+                        stampNoOutputSpan(sentinel);
+                        yield sentinel;
                         return;
                     }
                     throw streamError;
                 }
+                // Curator P3-6 (round-2 fix): production trigger comes through
+                // the result.finishReason rejection, not textStream throws.
+                if (chunkCount === 0) {
+                    const detected = await detectPostStreamNoOutput(result, capturedProviderError);
+                    if (detected) {
+                        logger.warn("HuggingFace: Stream produced no output (NoOutputGeneratedError) — caught from finishReason rejection");
+                        stampNoOutputSpan(detected.sentinel);
+                        yield detected.sentinel;
+                    }
+                }
             };
             return {
                 stream: transformedStream(),

package/dist/providers/litellm.js

@@ -9,6 +9,7 @@ import { AuthenticationError, InvalidModelError, ModelAccessDeniedError, Network
 import { isAbortError } from "../utils/errorHandling.js";
 import { emitToolEndFromStepFinish } from "../utils/toolEndEmitter.js";
 import { logger } from "../utils/logger.js";
+import { buildNoOutputSentinel, detectPostStreamNoOutput, stampNoOutputSpan, } from "../utils/noOutputSentinel.js";
 import { calculateCost } from "../utils/pricing.js";
 import { getProviderModel } from "../utils/providerConfig.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
@@ -140,6 +141,11 @@ export class LiteLLMProvider extends BaseProvider {
         this.validateStreamOptions(options);
         const startTime = Date.now();
         let chunkCount = 0; // Track chunk count for debugging
+        // Reviewer follow-up: capture upstream provider errors via onError so
+        // the post-stream NoOutput detect can propagate the *real* cause
+        // (content_filter, provider crash, etc.) into the sentinel's
+        // providerError / modelResponseRaw instead of "No output generated".
+        let capturedProviderError;
         const timeout = this.getTimeout(options);
         const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
         try {
@@ -185,6 +191,10 @@ export class LiteLLMProvider extends BaseProvider {
                 onError: (event) => {
                     const error = event.error;
                     const errorMessage = error instanceof Error ? error.message : String(error);
+                    // Reviewer follow-up: propagate the captured error to the
+                    // post-stream NoOutput sentinel so telemetry sees the real
+                    // provider cause instead of "No output generated".
+                    capturedProviderError = error;
                     logger.error(`LiteLLM: Stream error`, {
                         provider: this.providerName,
                         modelName: this.modelName,
@@ -312,7 +322,7 @@ export class LiteLLMProvider extends BaseProvider {
                 streamSpan.end();
             });
             timeoutController?.cleanup();
-            const transformedStream = this.createLiteLLMTransformedStream(result);
+            const transformedStream = this.createLiteLLMTransformedStream(result, () => capturedProviderError);
             // Create analytics promise that resolves after stream completion
             const analyticsPromise = streamAnalyticsCollector.createAnalytics(this.providerName, this.modelName, result, Date.now() - startTime, {
                 requestId: options.requestId ??
@@ -339,7 +349,13 @@ export class LiteLLMProvider extends BaseProvider {
             throw this.handleProviderError(error);
         }
     }
-    async *createLiteLLMTransformedStream(result) {
+    async *createLiteLLMTransformedStream(result, getCapturedProviderError) {
+        // Reviewer follow-up: gate the post-stream NoOutput detect on
+        // *content yielded*, not raw chunk count. AI SDK fullStream emits
+        // control events ({ type: "start" }, "step-start", etc.) before any
+        // text-delta — those incremented chunkCount and made the post-stream
+        // detect dead even when zero text was produced.
+        let contentYielded = 0;
         try {
             const streamToUse = result.fullStream || result.textStream;
             for await (const chunk of streamToUse) {
@@ -355,6 +371,7 @@ export class LiteLLMProvider extends BaseProvider {
                     if ("textDelta" in chunk) {
                         const textDelta = chunk.textDelta;
                         if (textDelta) {
+                            contentYielded++;
                             yield { content: textDelta };
                         }
                     }
@@ -368,17 +385,40 @@ export class LiteLLMProvider extends BaseProvider {
                     }
                 }
                 else if (typeof chunk === "string") {
+                    contentYielded++;
                     yield { content: chunk };
                 }
             }
         }
         catch (streamError) {
             if (NoOutputGeneratedError.isInstance(streamError)) {
-                logger.warn("LiteLLM: Stream produced no output (NoOutputGeneratedError) — propagating to fallback chain");
-                throw streamError;
+                logger.warn("LiteLLM: Stream produced no output (NoOutputGeneratedError) — caught from textStream");
+                // Yield the enriched sentinel so downstream telemetry has
+                // finishReason / usage / providerError. Match the other
+                // providers' pattern: yield + return (no throw). NeuroLink's
+                // iteration fallback at neurolink.ts only fires for
+                // looksLikeModelAccessDenied errors, so a NoOutput throw here
+                // would NOT trigger any fallback — and it would mask the
+                // already-yielded sentinel from consumers expecting a clean
+                // stream. The sentinel itself signals the no-output condition.
+                const sentinel = await buildNoOutputSentinel(streamError, result, getCapturedProviderError?.());
+                stampNoOutputSpan(sentinel);
+                yield sentinel;
+                return;
             }
             throw streamError;
         }
+        // Curator P3-6 (round-2 fix): production trigger sets the error on
+        // result.finishReason rejection (NOT thrown from textStream).
+        // Surface that path here, matching the catch above (yield + return).
+        if (contentYielded === 0) {
+            const detected = await detectPostStreamNoOutput(result, getCapturedProviderError?.());
+            if (detected) {
+                logger.warn("LiteLLM: Stream produced no output (NoOutputGeneratedError) — caught from finishReason rejection");
+                stampNoOutputSpan(detected.sentinel);
+                yield detected.sentinel;
+            }
+        }
     }
     /**
      * Generate an embedding for a single text input

package/dist/providers/mistral.js

@@ -58,6 +58,9 @@ export class MistralProvider extends BaseProvider {
             // Using protected helper from BaseProvider to eliminate code duplication
             const messages = await this.buildMessagesForStream(options);
             const model = await this.getAISDKModelWithMiddleware(options); // This is where network connection happens!
+            // Reviewer follow-up: capture upstream provider errors via onError
+            // so the post-stream NoOutput sentinel carries the real cause.
+            let capturedProviderError;
             const result = await streamText({
                 model,
                 messages: messages,
@@ -69,6 +72,14 @@ export class MistralProvider extends BaseProvider {
                 abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
                 experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
                 experimental_repairToolCall: this.getToolCallRepairFn(options),
+                onError: (event) => {
+                    capturedProviderError = event.error;
+                    logger.error("Mistral: Stream error", {
+                        error: event.error instanceof Error
+                            ? event.error.message
+                            : String(event.error),
+                    });
+                },
                 onStepFinish: ({ toolCalls, toolResults }) => {
                     emitToolEndFromStepFinish(this.neurolink?.getEventEmitter(), toolResults);
                     this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {
@@ -81,7 +92,7 @@ export class MistralProvider extends BaseProvider {
             });
             timeoutController?.cleanup();
             // Transform string stream to content object stream using BaseProvider method
-            const transformedStream = this.createTextStream(result);
+            const transformedStream = this.createTextStream(result, () => capturedProviderError);
             // Create analytics promise that resolves after stream completion
             const analyticsPromise = streamAnalyticsCollector.createAnalytics(this.providerName, this.modelName, toAnalyticsStreamResult(result), Date.now() - startTime, {
                 requestId: `mistral-stream-${Date.now()}`,

package/dist/providers/openAI.js

@@ -8,6 +8,7 @@ import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
 import { AuthenticationError, InvalidModelError, NetworkError, ProviderError, RateLimitError, } from "../types/index.js";
 import { logger } from "../utils/logger.js";
+import { buildNoOutputSentinel, detectPostStreamNoOutput, stampNoOutputSpan, } from "../utils/noOutputSentinel.js";
 import { calculateCost } from "../utils/pricing.js";
 import { createOpenAIConfig, getProviderModel, validateApiKey, } from "../utils/providerConfig.js";
 import { isZodSchema } from "../utils/schemaConversion.js";
@@ -347,6 +348,10 @@ export class OpenAIProvider extends BaseProvider {
                     "gen_ai.request.model": getModelId(model) || this.modelName || "unknown",
                 },
             });
+            // Reviewer follow-up: capture upstream provider errors via onError
+            // so the post-stream NoOutput detect can propagate the *real* cause
+            // into the sentinel's providerError / modelResponseRaw.
+            let capturedProviderError;
             let result;
             try {
                 result = streamText({
@@ -361,6 +366,14 @@ export class OpenAIProvider extends BaseProvider {
                     abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
                     experimental_repairToolCall: this.getToolCallRepairFn(options),
                     experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
+                    onError: (event) => {
+                        capturedProviderError = event.error;
+                        logger.error("OpenAI: Stream error", {
+                            error: event.error instanceof Error
+                                ? event.error.message
+                                : String(event.error),
+                        });
+                    },
                     onStepFinish: ({ toolCalls, toolResults }) => {
                         logger.info("Tool execution completed", {
                             toolResults,
@@ -424,7 +437,7 @@ export class OpenAIProvider extends BaseProvider {
                 hasToolResults: !!result.toolResults,
                 resultType: typeof result,
             });
-            const transformedStream = this.createOpenAITransformedStream(result, shouldUseTools, tools);
+            const transformedStream = this.createOpenAITransformedStream(result, shouldUseTools, tools, () => capturedProviderError);
             // Create analytics promise that resolves after stream completion
             const analyticsPromise = streamAnalyticsCollector.createAnalytics(this.providerName, this.modelName, result, Date.now() - startTime, {
                 requestId: `openai-stream-${Date.now()}`,
@@ -446,7 +459,7 @@ export class OpenAIProvider extends BaseProvider {
             throw this.handleProviderError(error);
         }
     }
-    async *createOpenAITransformedStream(result, shouldUseTools, tools) {
+    async *createOpenAITransformedStream(result, shouldUseTools, tools, getCapturedProviderError) {
         try {
             logger.debug(`OpenAI: Starting stream transformation`, {
                 hasTextStream: !!result.textStream,
@@ -503,11 +516,29 @@ export class OpenAIProvider extends BaseProvider {
             });
             if (contentYielded === 0) {
                 logger.warn(`OpenAI: No content was yielded from stream despite processing ${chunkCount} chunks`);
+                // Curator P3-6 (round-2 fix): when no content was yielded, the
+                // production trigger sets NoOutputGeneratedError on
+                // result.finishReason rejection (NOT on the textStream itself).
+                // Surface that rejection here so the enriched sentinel actually
+                // fires for real-world no-output streams.
+                const detected = await detectPostStreamNoOutput(result, getCapturedProviderError?.());
+                if (detected) {
+                    logger.warn("OpenAI: Stream produced no output (NoOutputGeneratedError) — caught from finishReason rejection");
+                    stampNoOutputSpan(detected.sentinel);
+                    yield detected.sentinel;
+                }
             }
         }
         catch (streamError) {
             if (NoOutputGeneratedError.isInstance(streamError)) {
-                logger.warn("OpenAI: Stream produced no output (NoOutputGeneratedError)");
+                logger.warn("OpenAI: Stream produced no output (NoOutputGeneratedError) — caught from textStream");
+                // Defensive: AI SDK *can* throw this from textStream in some
+                // failure modes (catastrophic transform errors). Keep this path
+                // for completeness; the production trigger goes through the
+                // post-loop detect above.
+                const sentinel = await buildNoOutputSentinel(streamError, result, getCapturedProviderError?.());
+                stampNoOutputSpan(sentinel);
+                yield sentinel;
                 return;
             }
             logger.error(`OpenAI: Stream transformation error:`, streamError);

package/dist/providers/openRouter.js

@@ -8,6 +8,7 @@ import { createProxyFetch } from "../proxy/proxyFetch.js";
 import { isAbortError } from "../utils/errorHandling.js";
 import { emitToolEndFromStepFinish } from "../utils/toolEndEmitter.js";
 import { logger } from "../utils/logger.js";
+import { buildNoOutputSentinel, detectPostStreamNoOutput, stampNoOutputSpan, } from "../utils/noOutputSentinel.js";
 import { getProviderModel } from "../utils/providerConfig.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { resolveToolChoice } from "../utils/toolChoice.js";
@@ -218,6 +219,12 @@ export class OpenRouterProvider extends BaseProvider {
         this.validateStreamOptions(options);
         const startTime = Date.now();
         let chunkCount = 0; // Track chunk count for debugging
+        // Reviewer follow-up: capture upstream provider errors via onError so
+        // the post-stream NoOutput detect can propagate the *real* cause
+        // (e.g. content_filter, provider crash) into the sentinel's
+        // providerError / modelResponseRaw instead of the AI SDK's generic
+        // "No output generated" message.
+        let capturedProviderError;
         const timeout = this.getTimeout(options);
         const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
         try {
@@ -257,6 +264,10 @@ export class OpenRouterProvider extends BaseProvider {
                 onError: (event) => {
                     const error = event.error;
                     const errorMessage = error instanceof Error ? error.message : String(error);
+                    // Reviewer follow-up: propagate the captured error to the
+                    // post-stream NoOutput sentinel so telemetry sees the real
+                    // provider cause instead of "No output generated".
+                    capturedProviderError = error;
                     logger.error(`OpenRouter: Stream error`, {
                         provider: this.providerName,
                         modelName: this.modelName,
@@ -315,6 +326,12 @@ export class OpenRouterProvider extends BaseProvider {
                 .finally(() => timeoutController?.cleanup());
             // Transform stream to content object stream using fullStream (handles both text and tool calls)
             const transformedStream = (async function* () {
+                // Reviewer follow-up: gate the post-stream NoOutput detect on
+                // *content yielded*, not raw chunk count. AI SDK fullStream emits
+                // control events ({ type: "start" }, "step-start", etc.) before
+                // any text-delta — those incremented `chunkCount` and made the
+                // post-stream check dead even when zero text was produced.
+                let contentYielded = 0;
                 try {
                     // Try fullStream first (handles both text and tool calls), fallback to textStream
                     const streamToUse = result.fullStream || result.textStream;
@@ -335,6 +352,7 @@ export class OpenRouterProvider extends BaseProvider {
                                 // Text delta from fullStream
                                 const textDelta = chunk.textDelta;
                                 if (textDelta) {
+                                    contentYielded++;
                                     yield { content: textDelta };
                                 }
                             }
@@ -352,18 +370,31 @@ export class OpenRouterProvider extends BaseProvider {
                         }
                         else if (typeof chunk === "string") {
                             // Direct string chunk from textStream fallback
+                            contentYielded++;
                             yield { content: chunk };
                         }
                     }
                 }
                 catch (streamError) {
-                    // AI SDK v6 throws NoOutputGeneratedError when the stream produced no output.
                     if (NoOutputGeneratedError.isInstance(streamError)) {
-                        logger.warn("OpenRouter: Stream produced no output (NoOutputGeneratedError)");
+                        logger.warn("OpenRouter: Stream produced no output (NoOutputGeneratedError) — caught from textStream");
+                        const sentinel = await buildNoOutputSentinel(streamError, result, capturedProviderError);
+                        stampNoOutputSpan(sentinel);
+                        yield sentinel;
                         return;
                     }
                     throw streamError;
                 }
+                // Curator P3-6 (round-2 fix): production trigger comes through
+                // result.finishReason rejection, not textStream throws.
+                if (contentYielded === 0) {
+                    const detected = await detectPostStreamNoOutput(result, capturedProviderError);
+                    if (detected) {
+                        logger.warn("OpenRouter: Stream produced no output (NoOutputGeneratedError) — caught from finishReason rejection");
+                        stampNoOutputSpan(detected.sentinel);
+                        yield detected.sentinel;
+                    }
+                }
             })();
             // Create analytics promise that resolves after stream completion
             const analyticsPromise = streamAnalyticsCollector.createAnalytics(this.providerName, this.modelName, result, Date.now() - startTime, {

package/dist/providers/openaiCompatible.js

@@ -6,6 +6,7 @@ import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
 import { emitToolEndFromStepFinish } from "../utils/toolEndEmitter.js";
 import { logger } from "../utils/logger.js";
+import { buildNoOutputSentinel, detectPostStreamNoOutput, stampNoOutputSpan, } from "../utils/noOutputSentinel.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { resolveToolChoice } from "../utils/toolChoice.js";
 import { toAnalyticsStreamResult } from "./providerTypeUtils.js";
@@ -182,6 +183,10 @@ export class OpenAICompatibleProvider extends BaseProvider {
             // Using protected helper from BaseProvider to eliminate code duplication
             const messages = await this.buildMessagesForStream(options);
             const model = await this.getAISDKModelWithMiddleware(options); // This is where network connection happens!
+            // Reviewer follow-up: capture upstream provider errors via onError
+            // so the post-stream NoOutput detect can propagate the real cause
+            // into the sentinel's providerError / modelResponseRaw.
+            let capturedProviderError;
             const result = streamText({
                 model,
                 messages: messages,
@@ -197,6 +202,14 @@ export class OpenAICompatibleProvider extends BaseProvider {
                 abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
                 experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
                 experimental_repairToolCall: this.getToolCallRepairFn(options),
+                onError: (event) => {
+                    capturedProviderError = event.error;
+                    logger.error("OpenAI-compatible: Stream error", {
+                        error: event.error instanceof Error
+                            ? event.error.message
+                            : String(event.error),
+                    });
+                },
                 onStepFinish: (event) => {
                     emitToolEndFromStepFinish(this.neurolink?.getEventEmitter(), event.toolResults);
                     this.handleToolExecutionStorage([...event.toolCalls], [...event.toolResults], options, new Date()).catch((error) => {
@@ -210,19 +223,38 @@ export class OpenAICompatibleProvider extends BaseProvider {
             timeoutController?.cleanup();
             // Transform stream to match StreamResult interface
             const transformedStream = async function* () {
+                let chunkCount = 0;
                 try {
                     for await (const chunk of result.textStream) {
+                        chunkCount++;
                         yield { content: chunk };
                     }
                 }
                 catch (streamError) {
-                    // AI SDK v6 throws NoOutputGeneratedError when the stream produced no output.
+                    // AI SDK v6 *can* throw NoOutputGeneratedError from textStream
+                    // iteration in some failure modes (e.g. catastrophic transform
+                    // errors); keep this catch as a defensive path.
                     if (NoOutputGeneratedError.isInstance(streamError)) {
-                        logger.warn("OpenAI-compatible: Stream produced no output (NoOutputGeneratedError)");
+                        logger.warn("OpenAI-compatible: Stream produced no output (NoOutputGeneratedError) — caught from textStream");
+                        const sentinel = await buildNoOutputSentinel(streamError, result, capturedProviderError);
+                        stampNoOutputSpan(sentinel);
+                        yield sentinel;
                         return;
                     }
                     throw streamError;
                 }
+                // Curator P3-6 (round-2 fix): the production trigger doesn't
+                // throw from textStream — AI SDK rejects `result.finishReason`
+                // instead. Surface that rejection here so the enriched sentinel
+                // actually fires for real-world no-output streams.
+                if (chunkCount === 0) {
+                    const detected = await detectPostStreamNoOutput(result, capturedProviderError);
+                    if (detected) {
+                        logger.warn("OpenAI-compatible: Stream produced no output (NoOutputGeneratedError) — caught from finishReason rejection");
+                        stampNoOutputSpan(detected.sentinel);
+                        yield detected.sentinel;
+                    }
+                }
             };
             // Create analytics promise that resolves after stream completion
             const analyticsPromise = streamAnalyticsCollector.createAnalytics(this.providerName, this.modelName, toAnalyticsStreamResult(result), Date.now() - startTime, {

package/dist/services/server/ai/observability/instrumentation.js

@@ -181,8 +181,13 @@ function applyNonErrorLangfuseLevel(attrs) {
     }
     if (attrs["neurolink.no_output"] === true) {
         attrs["langfuse.level"] = "WARNING";
-        attrs["langfuse.status_message"] =
-            "Stream produced no output (NoOutputGeneratedError)";
+        // Preserve any enriched status message StreamHandler already set
+        // (carries finishReason / token counts via buildNoOutputStatusMessage).
+        // Only fall back to the generic message when none was set upstream.
+        if (typeof attrs["langfuse.status_message"] !== "string") {
+            attrs["langfuse.status_message"] =
+                "Stream produced no output (NoOutputGeneratedError)";
+        }
         return;
     }
     if (reasonStr === "aborted") {

package/dist/types/index.d.ts

@@ -58,3 +58,4 @@ export * from "./imageGen.js";
 export * from "./elicitation.js";
 export * from "./dynamic.js";
 export * from "./streamDedup.js";
+export * from "./noOutputSentinel.js";

package/dist/types/index.js

@@ -62,3 +62,5 @@ export * from "./elicitation.js";
 export * from "./dynamic.js";
 // Curator P2-4 dedup: per-stream AsyncLocalStorage context
 export * from "./streamDedup.js";
+// Curator P3-6: NoOutputGeneratedError sentinel chunk shape
+export * from "./noOutputSentinel.js";

package/dist/types/noOutputSentinel.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Curator P3-6: shape of the sentinel chunk yielded by every provider's
+ * stream-transformation generator when AI SDK throws
+ * `NoOutputGeneratedError`. Built by `buildNoOutputSentinel` in
+ * `src/lib/utils/noOutputSentinel.ts`.
+ */
+export type StreamNoOutputSentinel = {
+    content: "";
+    metadata: {
+        noOutput: true;
+        errorType: "NoOutputGeneratedError";
+        finishReason: unknown;
+        usage: unknown;
+        providerError: string;
+        modelResponseRaw: string | undefined;
+    };
+};
+/**
+ * Subset of AI SDK's `StreamTextResult` that the sentinel builder reads.
+ * Both fields are Promises in production but typed loosely so callers
+ * can pass either the Promise or a resolved value.
+ */
+export type StreamNoOutputSentinelResultLike = {
+    finishReason?: Promise<unknown> | unknown;
+    totalUsage?: Promise<unknown> | unknown;
+};

package/dist/types/noOutputSentinel.js

@@ -0,0 +1 @@
+export {};

package/dist/types/stream.d.ts

@@ -8,6 +8,7 @@ import type { TokenUsage } from "./analytics.js";
 import type { JsonValue, UnknownRecord } from "./common.js";
 import type { Content, ImageWithAltText } from "./content.js";
 import type { ChatMessage } from "./conversation.js";
+import type { StreamNoOutputSentinel } from "./noOutputSentinel.js";
 import type { AdditionalMemoryUser } from "./generate.js";
 import type { AIModelProviderConfig, NeurolinkCredentials } from "./providers.js";
 import type { TTSChunk, TTSOptions } from "./tts.js";
@@ -487,7 +488,7 @@ export type StreamOptions = {
 export type StreamResult = {
     stream: AsyncIterable<{
         content: string;
-    } | {
+    } | StreamNoOutputSentinel | {
         type: "audio";
         audio: AudioChunk;
     } | {