@juspay/neurolink 9.59.2 → 9.59.3

package/dist/lib/utils/noOutputSentinel.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Curator P3-6: shared builder for the `NoOutputGeneratedError` sentinel
+ * chunk. Each provider's stream-transformation generator catches the AI
+ * SDK's `NoOutputGeneratedError` and yields this sentinel so downstream
+ * telemetry has finish reason + token usage + provider error context
+ * instead of just `{ noOutput: true, errorType: "..." }`.
+ *
+ * The AI SDK rejects `result.finishReason` / `result.totalUsage` in this
+ * branch today (see `ai/src/generate-text/stream-text.ts` ~L1078); we
+ * still attempt to await them so a future SDK version surfacing partial
+ * values populates the sentinel automatically. When they reject we keep
+ * conservative defaults (`finishReason: "error"`, zero usage).
+ */
+import type { StreamNoOutputSentinel, StreamNoOutputSentinelResultLike } from "../types/index.js";
+export declare function buildNoOutputSentinel(error: unknown, result?: StreamNoOutputSentinelResultLike, 
+/**
+ * Reviewer follow-up: AI SDK v6 wraps the AI SDK's
+ * `NoOutputGeneratedError` without preserving the underlying provider
+ * error in `error.cause`, and rejects `result.finishReason` /
+ * `result.totalUsage` with the wrapped error too. To differentiate
+ * content-filter / stop-sequence / provider-crash, providers can
+ * capture the upstream error (e.g. via streamText's `onError`
+ * callback) and pass it here. When provided, it takes precedence
+ * over the AI SDK error for `providerError` and `modelResponseRaw`.
+ */
+underlyingError?: unknown): Promise<StreamNoOutputSentinel>;
+/**
+ * Curator P3-6 (round-2): the AI SDK v6 path that sets
+ * `NoOutputGeneratedError` does NOT throw it from `result.textStream`
+ * iteration — it sets the error as a *promise rejection* on
+ * `result.finishReason` / `result.totalUsage` / `result.steps` (see
+ * `ai/src/generate-text/stream-text.ts` ~L1078). Providers that only
+ * catch errors thrown from `for await (chunk of result.textStream)` will
+ * miss the production trigger entirely: the stream completes silently
+ * with 0 chunks and the rejection bubbles as an unhandled rejection.
+ *
+ * This helper surfaces the rejection by awaiting `result.finishReason`
+ * after the stream completes. Providers must call this AFTER iterating
+ * the textStream when 0 chunks were yielded — the returned sentinel
+ * (if non-null) carries the enriched metadata Curator's report needed.
+ */
+export declare function detectPostStreamNoOutput(result: StreamNoOutputSentinelResultLike, 
+/**
+ * Optional provider-captured underlying error (e.g. from streamText's
+ * `onError` callback). When provided, the resulting sentinel will carry
+ * the real provider error in `providerError` / `modelResponseRaw`
+ * instead of the AI SDK's generic "No output generated" message.
+ */
+underlyingError?: unknown): Promise<{
+    sentinel: StreamNoOutputSentinel;
+    error: Error;
+} | null>;
+/**
+ * Reviewer follow-up: every provider's post-stream NoOutput detect must
+ * stamp the active OTel span so Pipeline B (`ContextEnricher.onEnd()` →
+ * `applyNonErrorLangfuseLevel`) surfaces a WARNING-level Langfuse
+ * observation with the enriched status message. Without this, only
+ * `StreamHandler`-based providers produced the rich telemetry; the
+ * provider-specific paths (openAI, openaiCompatible, litellm,
+ * huggingFace, openRouter, anthropicBaseProvider) yielded the sentinel
+ * to direct stream consumers but Pipeline B saw nothing.
+ *
+ * Stamps three attributes:
+ *   - `neurolink.no_output = true` (Pipeline B trigger)
+ *   - `langfuse.status_message` (enriched, with finishReason + tokens)
+ *   - `neurolink.no_output.finish_reason` (raw finish reason)
+ *
+ * Safe to call when tracing isn't initialized — silently no-ops.
+ */
+export declare function stampNoOutputSpan(sentinel: StreamNoOutputSentinel): void;
+/**
+ * Build the OTel `langfuse.status_message` summary string for a no-output
+ * stream. Used by `StreamHandler.createTextStream` and any future provider
+ * that wants to stamp the active span with the same enriched message.
+ *
+ * Reviewer follow-up: AI SDK v4 used `promptTokens` / `completionTokens`,
+ * v6 uses `inputTokens` / `outputTokens`. Read both shapes so the message
+ * is correct whichever version surfaced partial usage data.
+ */
+export declare function buildNoOutputStatusMessage(finishReason: unknown, usage: unknown): string;

package/dist/lib/utils/noOutputSentinel.js

@@ -0,0 +1,193 @@
+/**
+ * Curator P3-6: shared builder for the `NoOutputGeneratedError` sentinel
+ * chunk. Each provider's stream-transformation generator catches the AI
+ * SDK's `NoOutputGeneratedError` and yields this sentinel so downstream
+ * telemetry has finish reason + token usage + provider error context
+ * instead of just `{ noOutput: true, errorType: "..." }`.
+ *
+ * The AI SDK rejects `result.finishReason` / `result.totalUsage` in this
+ * branch today (see `ai/src/generate-text/stream-text.ts` ~L1078); we
+ * still attempt to await them so a future SDK version surfacing partial
+ * values populates the sentinel automatically. When they reject we keep
+ * conservative defaults (`finishReason: "error"`, zero usage).
+ */
+import { NoOutputGeneratedError } from "ai";
+import { trace, context as otelContext } from "@opentelemetry/api";
+export async function buildNoOutputSentinel(error, result, 
+/**
+ * Reviewer follow-up: AI SDK v6 wraps the AI SDK's
+ * `NoOutputGeneratedError` without preserving the underlying provider
+ * error in `error.cause`, and rejects `result.finishReason` /
+ * `result.totalUsage` with the wrapped error too. To differentiate
+ * content-filter / stop-sequence / provider-crash, providers can
+ * capture the upstream error (e.g. via streamText's `onError`
+ * callback) and pass it here. When provided, it takes precedence
+ * over the AI SDK error for `providerError` and `modelResponseRaw`.
+ */
+underlyingError) {
+    let finishReason = "error";
+    // Reviewer follow-up: include both AI SDK v4 (promptTokens /
+    // completionTokens) and v6 (inputTokens / outputTokens) keys in the
+    // default usage so downstream consumers reading either shape see
+    // correct zeros instead of `undefined`. Also keep `totalTokens` for
+    // back-compat.
+    let usage = {
+        promptTokens: 0,
+        completionTokens: 0,
+        inputTokens: 0,
+        outputTokens: 0,
+        totalTokens: 0,
+    };
+    if (result) {
+        try {
+            if (result.finishReason !== undefined) {
+                finishReason = await Promise.resolve(result.finishReason);
+            }
+        }
+        catch {
+            // Expected: AI SDK rejects with the same NoOutputGeneratedError.
+        }
+        try {
+            if (result.totalUsage !== undefined) {
+                usage = await Promise.resolve(result.totalUsage);
+            }
+        }
+        catch {
+            // Expected: AI SDK rejects with the same NoOutputGeneratedError.
+        }
+    }
+    // Prefer the provider-captured underlying error for `providerError` /
+    // `modelResponseRaw` since the AI SDK NoOutputGeneratedError doesn't
+    // carry the actual upstream cause. Fall back to the AI SDK error.
+    const messageSource = underlyingError instanceof Error
+        ? underlyingError
+        : underlyingError !== undefined
+            ? new Error(String(underlyingError))
+            : error instanceof Error
+                ? error
+                : new Error(String(error));
+    const providerError = messageSource.message;
+    const causeFromSource = messageSource.cause;
+    // Reviewer follow-up: guard the `error.cause` access so it doesn't
+    // throw a TypeError when `error` is null/undefined (only valid object
+    // values can be indexed safely).
+    const causeFromError = error !== null && typeof error === "object"
+        ? error.cause
+        : undefined;
+    const cause = causeFromSource !== undefined ? causeFromSource : causeFromError;
+    // Reviewer follow-up: always populate `modelResponseRaw` so downstream
+    // telemetry consumers can rely on the field being a string. When neither
+    // an `underlyingError` nor a `cause` is available, fall back to error
+    // name + message so we still carry *something* about what the provider
+    // returned.
+    const modelResponseRaw = cause !== undefined
+        ? String(cause).slice(0, 500)
+        : `${messageSource.name}: ${messageSource.message}`.slice(0, 500);
+    return {
+        content: "",
+        metadata: {
+            noOutput: true,
+            errorType: "NoOutputGeneratedError",
+            finishReason,
+            usage,
+            providerError,
+            modelResponseRaw,
+        },
+    };
+}
+/**
+ * Curator P3-6 (round-2): the AI SDK v6 path that sets
+ * `NoOutputGeneratedError` does NOT throw it from `result.textStream`
+ * iteration — it sets the error as a *promise rejection* on
+ * `result.finishReason` / `result.totalUsage` / `result.steps` (see
+ * `ai/src/generate-text/stream-text.ts` ~L1078). Providers that only
+ * catch errors thrown from `for await (chunk of result.textStream)` will
+ * miss the production trigger entirely: the stream completes silently
+ * with 0 chunks and the rejection bubbles as an unhandled rejection.
+ *
+ * This helper surfaces the rejection by awaiting `result.finishReason`
+ * after the stream completes. Providers must call this AFTER iterating
+ * the textStream when 0 chunks were yielded — the returned sentinel
+ * (if non-null) carries the enriched metadata Curator's report needed.
+ */
+export async function detectPostStreamNoOutput(result, 
+/**
+ * Optional provider-captured underlying error (e.g. from streamText's
+ * `onError` callback). When provided, the resulting sentinel will carry
+ * the real provider error in `providerError` / `modelResponseRaw`
+ * instead of the AI SDK's generic "No output generated" message.
+ */
+underlyingError) {
+    if (result.finishReason === undefined) {
+        return null;
+    }
+    try {
+        await Promise.resolve(result.finishReason);
+        // No rejection — the stream completed normally with a valid finish
+        // reason; this is the empty-but-not-erroring case (e.g. AI SDK
+        // recorded a step with no text), not the no-output failure.
+        return null;
+    }
+    catch (err) {
+        if (NoOutputGeneratedError.isInstance(err)) {
+            return {
+                sentinel: await buildNoOutputSentinel(err, result, underlyingError),
+                error: err,
+            };
+        }
+        // Other rejection types (network errors, parse errors) are not the
+        // bug-confirmed scenario — let the caller's existing error handling
+        // surface them.
+        return null;
+    }
+}
+/**
+ * Reviewer follow-up: every provider's post-stream NoOutput detect must
+ * stamp the active OTel span so Pipeline B (`ContextEnricher.onEnd()` →
+ * `applyNonErrorLangfuseLevel`) surfaces a WARNING-level Langfuse
+ * observation with the enriched status message. Without this, only
+ * `StreamHandler`-based providers produced the rich telemetry; the
+ * provider-specific paths (openAI, openaiCompatible, litellm,
+ * huggingFace, openRouter, anthropicBaseProvider) yielded the sentinel
+ * to direct stream consumers but Pipeline B saw nothing.
+ *
+ * Stamps three attributes:
+ *   - `neurolink.no_output = true` (Pipeline B trigger)
+ *   - `langfuse.status_message` (enriched, with finishReason + tokens)
+ *   - `neurolink.no_output.finish_reason` (raw finish reason)
+ *
+ * Safe to call when tracing isn't initialized — silently no-ops.
+ */
+export function stampNoOutputSpan(sentinel) {
+    try {
+        const activeSpan = trace.getSpan(otelContext.active());
+        if (!activeSpan) {
+            return;
+        }
+        activeSpan.setAttribute("neurolink.no_output", true);
+        activeSpan.setAttribute("langfuse.status_message", buildNoOutputStatusMessage(sentinel.metadata.finishReason, sentinel.metadata.usage));
+        activeSpan.setAttribute("neurolink.no_output.finish_reason", String(sentinel.metadata.finishReason));
+    }
+    catch {
+        // Tracing not initialized — ignore.
+    }
+}
+/**
+ * Build the OTel `langfuse.status_message` summary string for a no-output
+ * stream. Used by `StreamHandler.createTextStream` and any future provider
+ * that wants to stamp the active span with the same enriched message.
+ *
+ * Reviewer follow-up: AI SDK v4 used `promptTokens` / `completionTokens`,
+ * v6 uses `inputTokens` / `outputTokens`. Read both shapes so the message
+ * is correct whichever version surfaced partial usage data.
+ */
+export function buildNoOutputStatusMessage(finishReason, usage) {
+    const u = usage;
+    const inputTokens = u?.inputTokens ?? u?.promptTokens ?? 0;
+    const outputTokens = u?.outputTokens ?? u?.completionTokens ?? 0;
+    return (`Stream produced no output (NoOutputGeneratedError): ` +
+        `finishReason=${String(finishReason)}, ` +
+        `inputTokens=${inputTokens}, ` +
+        `outputTokens=${outputTokens}`);
+}
+//# sourceMappingURL=noOutputSentinel.js.map

package/dist/neurolink.js

@@ -5218,9 +5218,36 @@ Current user's request: ${currentInput}`;
                 // single `generation:end` event with cost data. Cost listeners
                 // subscribe here; previously the stream path never fired it.
                 let resolvedUsage;
+                // Reviewer follow-up: track *non-sentinel output chunks* (text,
+                // audio, image — anything the SDK considers real output) so the
+                // fallback gate fires only when the stream produced nothing
+                // useful. Counting only text content here would have spuriously
+                // triggered fallback for valid audio-only (Google Live) and
+                // image-only streams. The sentinel is the only thing we exclude
+                // — that path can mask real provider failures (DNS, auth,
+                // retry-exhaustion) that AI SDK rejects with
+                // NoOutputGeneratedError, and we want fallback to fire there.
+                let realOutputChunks = 0;
                 try {
                     for await (const chunk of mcpStream) {
                         chunkCount++;
+                        const isNoOutputSentinel = chunk !== null &&
+                            typeof chunk === "object" &&
+                            "metadata" in chunk &&
+                            chunk.metadata
+                                ?.noOutput === true;
+                        const hasTextContent = chunk &&
+                            "content" in chunk &&
+                            typeof chunk.content === "string" &&
+                            chunk.content.length > 0;
+                        const hasMediaPayload = chunk !== null &&
+                            typeof chunk === "object" &&
+                            "type" in chunk &&
+                            (chunk.type === "audio" ||
+                                chunk.type === "image");
+                        if (!isNoOutputSentinel && (hasTextContent || hasMediaPayload)) {
+                            realOutputChunks++;
+                        }
                         if (chunk &&
                             "content" in chunk &&
                             typeof chunk.content === "string") {
@@ -5232,13 +5259,17 @@ Current user's request: ${currentInput}`;
                                 metadata: {
                                     chunkIndex: chunkCount,
                                     totalLength: accumulatedContent.length,
+                                    ...(isNoOutputSentinel && { noOutput: true }),
                                 },
                                 timestamp: Date.now(),
                             });
                         }
                         yield chunk;
                     }
-                    if (chunkCount === 0 &&
+                    // Reviewer follow-up: fire fallback when no *non-sentinel*
+                    // output was produced — sentinel-only and truly empty streams
+                    // both qualify, but media-only streams (audio/image) do not.
+                    if (realOutputChunks === 0 &&
                         !metadata.fallbackAttempted &&
                         !enhancedOptions.disableInternalFallback &&
                         streamState.toolCalls.length === 0 &&
@@ -5735,9 +5766,32 @@ Current user's request: ${currentInput}`;
                 streamState.finishReason =
                     fallbackResult.finishReason ?? streamState.finishReason;
             }
+            // Reviewer follow-up: count *real* output chunks for the fallback
+            // success gate, mirroring the primary stream wrapper. A fallback
+            // that yields only the NoOutputSentinel must not be treated as
+            // success — that's the same masked-failure scenario as the primary.
             let fallbackChunkCount = 0;
+            let fallbackRealOutputChunks = 0;
             for await (const fallbackChunk of fallbackResult.stream) {
                 fallbackChunkCount++;
+                const isFallbackNoOutputSentinel = fallbackChunk !== null &&
+                    typeof fallbackChunk === "object" &&
+                    "metadata" in fallbackChunk &&
+                    fallbackChunk.metadata
+                        ?.noOutput === true;
+                const fallbackHasTextContent = fallbackChunk &&
+                    "content" in fallbackChunk &&
+                    typeof fallbackChunk.content === "string" &&
+                    fallbackChunk.content.length > 0;
+                const fallbackHasMediaPayload = fallbackChunk !== null &&
+                    typeof fallbackChunk === "object" &&
+                    "type" in fallbackChunk &&
+                    (fallbackChunk.type === "audio" ||
+                        fallbackChunk.type === "image");
+                if (!isFallbackNoOutputSentinel &&
+                    (fallbackHasTextContent || fallbackHasMediaPayload)) {
+                    fallbackRealOutputChunks++;
+                }
                 if (fallbackChunk &&
                     "content" in fallbackChunk &&
                     typeof fallbackChunk.content === "string") {
@@ -5746,10 +5800,10 @@ Current user's request: ${currentInput}`;
                 }
                 yield fallbackChunk;
             }
-            if (fallbackChunkCount === 0 &&
+            if (fallbackRealOutputChunks === 0 &&
                 fallbackToolCalls.length === 0 &&
                 fallbackToolResults.length === 0) {
-                throw new Error(`Fallback provider ${fallbackRoute.provider} also returned 0 chunks`);
+                throw new Error(`Fallback provider ${fallbackRoute.provider} also returned 0 real output chunks (chunkCount=${fallbackChunkCount}, sentinel-only or empty)`);
             }
             // Fallback succeeded - likely guardrails blocked primary
             metadata.fallbackProvider = fallbackRoute.provider;

package/dist/providers/anthropic.js

@@ -790,6 +790,10 @@ export class AnthropicProvider 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 sentinel carries the real cause in
+            // providerError / modelResponseRaw.
+            let capturedProviderError;
             let result;
             try {
                 result = streamText({
@@ -802,6 +806,14 @@ export class AnthropicProvider extends BaseProvider {
                     stopWhen: stepCountIs(options.maxSteps || DEFAULT_MAX_STEPS),
                     toolChoice: resolveToolChoice(options, tools, shouldUseTools),
                     abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
+                    onError: (event) => {
+                        capturedProviderError = event.error;
+                        logger.error("Anthropic: Stream error", {
+                            error: event.error instanceof Error
+                                ? event.error.message
+                                : String(event.error),
+                        });
+                    },
                     experimental_repairToolCall: this.getToolCallRepairFn(options),
                     experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
                     onStepFinish: ({ toolCalls, toolResults }) => {
@@ -868,7 +880,7 @@ export class AnthropicProvider extends BaseProvider {
                 streamSpan.end();
             });
             timeoutController?.cleanup();
-            const transformedStream = this.createTextStream(result);
+            const transformedStream = this.createTextStream(result, () => capturedProviderError);
             // ✅ Note: Vercel AI SDK's streamText() method limitations with tools
             // The streamText() function doesn't provide the same tool result access as generateText()
             // Full tool support is now available with real streaming

package/dist/providers/anthropicBaseProvider.js

@@ -5,6 +5,7 @@ import { AnthropicModels } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import { AuthenticationError, 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 { createAnthropicBaseConfig, validateApiKey, } from "../utils/providerConfig.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
@@ -81,6 +82,10 @@ export class AnthropicProviderV2 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({
@@ -95,6 +100,14 @@ export class AnthropicProviderV2 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("AnthropicBaseProvider: Stream error", {
+                            error: event.error instanceof Error
+                                ? event.error.message
+                                : String(event.error),
+                        });
+                    },
                     onStepFinish: ({ toolCalls, toolResults }) => {
                         this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {
                             logger.warn("[AnthropicBaseProvider] Failed to store tool executions", {
@@ -153,19 +166,34 @@ export class AnthropicProviderV2 extends BaseProvider {
             timeoutController?.cleanup();
             // Transform string stream to content object stream (match Google AI pattern)
             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("AnthropicBaseProvider: Stream produced no output (NoOutputGeneratedError)");
+                        logger.warn("AnthropicBaseProvider: 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 sets the error
+                // on result.finishReason rejection, not on textStream iteration.
+                // Surface that path here so the sentinel actually fires.
+                if (chunkCount === 0) {
+                    const detected = await detectPostStreamNoOutput(result, capturedProviderError);
+                    if (detected) {
+                        logger.warn("AnthropicBaseProvider: Stream produced no output (NoOutputGeneratedError) — caught from finishReason rejection");
+                        stampNoOutputSpan(detected.sentinel);
+                        yield detected.sentinel;
+                    }
+                }
             };
             return {
                 stream: transformedStream(),

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(),