@juspay/neurolink 9.59.2 → 9.59.4

package/dist/cli/commands/proxy.js

@@ -1443,27 +1443,32 @@ export const proxyGuardCommand = {
                     return;
                 }
                 logger.always(`[guard] update available: ${runningVersion} → ${result.latestVersion}`);
-                // 2. Wait for quiet traffic
-                const maxQuietWaitMs = 60 * 60 * 1000; // 1 hour max wait
+                // 2. Best-effort quiet wait — try for a brief window, but proceed
+                //    regardless. The install (pnpm add -g) is non-disruptive; only the
+                //    restart causes a ~1-3s blip. Blocking updates for hours/days because
+                //    traffic never goes silent is worse than a brief interruption.
+                const maxQuietWaitMs = 5 * 60 * 1000; // 5 minutes max, then proceed
                 const quietPollMs = 10_000; // check every 10s
                 const quietStart = Date.now();
                 while (Date.now() - quietStart < maxQuietWaitMs) {
-                    // Bail out if parent proxy died during the wait
                     if (getProcessStatus(parentPid) === "not_running") {
                         logger.always(`[guard] parent process died during quiet-wait, aborting update`);
                         return;
                     }
                     const quietStatus = checkTrafficQuiet(QUIET_THRESHOLD_MS);
                     if (quietStatus.isQuiet) {
+                        logger.always(`[guard] traffic quiet, proceeding with update`);
                         break;
                     }
                     logger.debug(`[guard] traffic active (last activity ${Math.round(quietStatus.silenceDurationMs / 1000)}s ago), waiting...`);
                     await new Promise((r) => setTimeout(r, quietPollMs));
                 }
+                // Proceed with install regardless — don't block updates indefinitely.
+                // The install itself (pnpm add -g) doesn't affect the running process.
+                // Only the restart afterwards causes a brief interruption.
                 const finalQuiet = checkTrafficQuiet(QUIET_THRESHOLD_MS);
                 if (!finalQuiet.isQuiet) {
-                    logger.always(`[guard] traffic didn't quiet down within 1 hour, skipping update cycle`);
-                    return;
+                    logger.always(`[guard] traffic still active after ${Math.round(maxQuietWaitMs / 1000)}s wait, proceeding with update anyway (restart will briefly interrupt in-flight requests)`);
                 }
                 // 3. Install update (validate version string before passing to shell)
                 if (!/^\d+\.\d+\.\d+$/.test(result.latestVersion)) {

package/dist/core/baseProvider.d.ts

@@ -279,13 +279,20 @@ export declare abstract class BaseProvider implements AIProvider {
      */
     protected validateStreamOptions(options: StreamOptions): void;
     /**
-     * Create text stream transformation - delegated to StreamHandler
+     * Create text stream transformation - delegated to StreamHandler.
+     * Reviewer follow-up: forwards the optional `getUnderlyingError`
+     * callback so providers can capture upstream errors via
+     * `streamText`'s `onError` and have them flow into the
+     * NoOutputGeneratedError sentinel's `providerError` /
+     * `modelResponseRaw`.
      */
     protected createTextStream(result: {
         textStream: AsyncIterable<string>;
-    }): AsyncGenerator<{
+        finishReason?: Promise<unknown> | unknown;
+        totalUsage?: Promise<unknown> | unknown;
+    }, getUnderlyingError?: () => unknown): AsyncGenerator<{
         content: string;
-    }>;
+    } | import("../types/index.js").StreamNoOutputSentinel>;
     /**
      * Create standardized stream result - delegated to StreamHandler
      */

package/dist/core/baseProvider.js

@@ -1019,10 +1019,15 @@ export class BaseProvider {
         this.streamHandler.validateStreamOptions(options);
     }
     /**
-     * Create text stream transformation - delegated to StreamHandler
+     * Create text stream transformation - delegated to StreamHandler.
+     * Reviewer follow-up: forwards the optional `getUnderlyingError`
+     * callback so providers can capture upstream errors via
+     * `streamText`'s `onError` and have them flow into the
+     * NoOutputGeneratedError sentinel's `providerError` /
+     * `modelResponseRaw`.
      */
-    createTextStream(result) {
-        return this.streamHandler.createTextStream(result);
+    createTextStream(result, getUnderlyingError) {
+        return this.streamHandler.createTextStream(result, getUnderlyingError);
     }
     /**
      * Create standardized stream result - delegated to StreamHandler

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

@@ -12,7 +12,7 @@
  *
  * @module core/modules/StreamHandler
  */
-import type { StreamOptions, StreamResult, UnknownRecord, AIProviderName } from "../../types/index.js";
+import type { StreamOptions, StreamResult, UnknownRecord, AIProviderName, StreamNoOutputSentinel } from "../../types/index.js";
 /**
  * StreamHandler class - Handles streaming operations for AI providers
  */
@@ -30,9 +30,28 @@ export declare class StreamHandler {
      */
     createTextStream(result: {
         textStream: AsyncIterable<string>;
-    }): AsyncGenerator<{
+        /**
+         * Optional metadata getters from the AI SDK's StreamTextResult. These
+         * reject with NoOutputGeneratedError when no output is produced, which
+         * is exactly the path Curator's P3-6 fix needs to enrich. We attempt
+         * to await them in the catch block; whichever resolve get included in
+         * the sentinel chunk metadata.
+         */
+        finishReason?: Promise<unknown> | unknown;
+        totalUsage?: Promise<unknown> | unknown;
+    }, 
+    /**
+     * Reviewer follow-up: optional getter for the provider's captured
+     * upstream error (typically wired from `streamText`'s `onError`
+     * callback). When set, the sentinel's `providerError` /
+     * `modelResponseRaw` reflect the real upstream cause instead of the
+     * AI SDK's generic "No output generated" message. Callers that don't
+     * capture upstream errors can omit this — the sentinel still
+     * populates with the AI SDK error.
+     */
+    getUnderlyingError?: () => unknown): AsyncGenerator<{
         content: string;
-    }>;
+    } | StreamNoOutputSentinel>;
     /**
      * Create standardized stream result - consolidates result structure
      */

package/dist/core/modules/StreamHandler.js

@@ -16,6 +16,7 @@ import { trace, context as otelContext, SpanStatusCode, } from "@opentelemetry/a
 import { tracers, ATTR, withSpan } from "../../telemetry/index.js";
 import { logger } from "../../utils/logger.js";
 import { validateStreamOptions as validateStreamOpts, ValidationError, createValidationSummary, } from "../../utils/parameterValidation.js";
+import { buildNoOutputSentinel, detectPostStreamNoOutput, stampNoOutputSpan, } from "../../utils/noOutputSentinel.js";
 import { STEP_LIMITS } from "../constants.js";
 import { createAnalytics } from "../analytics.js";
 import { nanoid } from "nanoid";
@@ -83,7 +84,17 @@ export class StreamHandler {
      * Create text stream transformation - consolidates identical logic from 7/10 providers
      * Tracks TTFC (Time To First Chunk), chunk count, and total bytes streamed.
      */
-    createTextStream(result) {
+    createTextStream(result, 
+    /**
+     * Reviewer follow-up: optional getter for the provider's captured
+     * upstream error (typically wired from `streamText`'s `onError`
+     * callback). When set, the sentinel's `providerError` /
+     * `modelResponseRaw` reflect the real upstream cause instead of the
+     * AI SDK's generic "No output generated" message. Callers that don't
+     * capture upstream errors can omit this — the sentinel still
+     * populates with the AI SDK error.
+     */
+    getUnderlyingError) {
         const providerName = this.providerName;
         return (async function* () {
             let chunkCount = 0;
@@ -113,32 +124,43 @@ 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`);
-                    // Curator P2-5: stamp the active OTel span so ContextEnricher.onEnd()
-                    // surfaces a WARNING-level Langfuse observation instead of defaulting
-                    // to DEFAULT with no status message.
-                    try {
-                        const activeSpan = trace.getSpan(otelContext.active());
-                        if (activeSpan) {
-                            activeSpan.setAttribute("neurolink.no_output", true);
-                        }
-                    }
-                    catch {
-                        // Tracing not initialized — ignore.
-                    }
+                    // Curator P3-6: build the enriched sentinel using the shared
+                    // helper so every provider yields the same shape. Pass the
+                    // captured upstream error (if any) so providerError /
+                    // modelResponseRaw carry the real cause.
+                    const sentinel = await buildNoOutputSentinel(error, result, getUnderlyingError?.());
+                    // Curator P2-5 + P3-6: stamp the active OTel span so
+                    // ContextEnricher.onEnd() surfaces a WARNING-level Langfuse
+                    // observation with finishReason + token usage. Centralized in
+                    // stampNoOutputSpan so every wired site stamps consistently.
+                    stampNoOutputSpan(sentinel);
                     // 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",
-                        },
-                    };
+                    yield sentinel;
+                    // Reviewer follow-up: must return here. Falling through to the
+                    // post-stream detection block below would yield a SECOND sentinel
+                    // chunk (verified with synthetic NoOutputGeneratedError stream:
+                    // count=2 sentinels). The catch block's yield is sufficient.
+                    return;
                 }
                 else {
                     throw error;
                 }
             }
+            // Curator P3-6 (round-2 fix): the production trigger sets
+            // NoOutputGeneratedError on `result.finishReason` rejection — NOT
+            // thrown from textStream iteration. Surface that path here so the
+            // sentinel actually fires for real-world no-output streams. The
+            // catch above remains as a defensive path for failure modes that
+            // do throw from textStream.
+            if (chunkCount === 0) {
+                const detected = await detectPostStreamNoOutput(result, getUnderlyingError?.());
+                if (detected) {
+                    logger.warn(`${providerName}: Stream produced no output (NoOutputGeneratedError) — caught from finishReason rejection`);
+                    stampNoOutputSpan(detected.sentinel);
+                    yield detected.sentinel;
+                }
+            }
             // Record completion metrics on the active span
             const activeSpan = trace.getSpan(otelContext.active());
             if (activeSpan) {

package/dist/lib/core/baseProvider.d.ts

@@ -279,13 +279,20 @@ export declare abstract class BaseProvider implements AIProvider {
      */
     protected validateStreamOptions(options: StreamOptions): void;
     /**
-     * Create text stream transformation - delegated to StreamHandler
+     * Create text stream transformation - delegated to StreamHandler.
+     * Reviewer follow-up: forwards the optional `getUnderlyingError`
+     * callback so providers can capture upstream errors via
+     * `streamText`'s `onError` and have them flow into the
+     * NoOutputGeneratedError sentinel's `providerError` /
+     * `modelResponseRaw`.
      */
     protected createTextStream(result: {
         textStream: AsyncIterable<string>;
-    }): AsyncGenerator<{
+        finishReason?: Promise<unknown> | unknown;
+        totalUsage?: Promise<unknown> | unknown;
+    }, getUnderlyingError?: () => unknown): AsyncGenerator<{
         content: string;
-    }>;
+    } | import("../types/index.js").StreamNoOutputSentinel>;
     /**
      * Create standardized stream result - delegated to StreamHandler
      */

package/dist/lib/core/baseProvider.js

@@ -1019,10 +1019,15 @@ export class BaseProvider {
         this.streamHandler.validateStreamOptions(options);
     }
     /**
-     * Create text stream transformation - delegated to StreamHandler
+     * Create text stream transformation - delegated to StreamHandler.
+     * Reviewer follow-up: forwards the optional `getUnderlyingError`
+     * callback so providers can capture upstream errors via
+     * `streamText`'s `onError` and have them flow into the
+     * NoOutputGeneratedError sentinel's `providerError` /
+     * `modelResponseRaw`.
      */
-    createTextStream(result) {
-        return this.streamHandler.createTextStream(result);
+    createTextStream(result, getUnderlyingError) {
+        return this.streamHandler.createTextStream(result, getUnderlyingError);
     }
     /**
      * Create standardized stream result - delegated to StreamHandler

package/dist/lib/core/modules/StreamHandler.d.ts

@@ -12,7 +12,7 @@
  *
  * @module core/modules/StreamHandler
  */
-import type { StreamOptions, StreamResult, UnknownRecord, AIProviderName } from "../../types/index.js";
+import type { StreamOptions, StreamResult, UnknownRecord, AIProviderName, StreamNoOutputSentinel } from "../../types/index.js";
 /**
  * StreamHandler class - Handles streaming operations for AI providers
  */
@@ -30,9 +30,28 @@ export declare class StreamHandler {
      */
     createTextStream(result: {
         textStream: AsyncIterable<string>;
-    }): AsyncGenerator<{
+        /**
+         * Optional metadata getters from the AI SDK's StreamTextResult. These
+         * reject with NoOutputGeneratedError when no output is produced, which
+         * is exactly the path Curator's P3-6 fix needs to enrich. We attempt
+         * to await them in the catch block; whichever resolve get included in
+         * the sentinel chunk metadata.
+         */
+        finishReason?: Promise<unknown> | unknown;
+        totalUsage?: Promise<unknown> | unknown;
+    }, 
+    /**
+     * Reviewer follow-up: optional getter for the provider's captured
+     * upstream error (typically wired from `streamText`'s `onError`
+     * callback). When set, the sentinel's `providerError` /
+     * `modelResponseRaw` reflect the real upstream cause instead of the
+     * AI SDK's generic "No output generated" message. Callers that don't
+     * capture upstream errors can omit this — the sentinel still
+     * populates with the AI SDK error.
+     */
+    getUnderlyingError?: () => unknown): AsyncGenerator<{
         content: string;
-    }>;
+    } | StreamNoOutputSentinel>;
     /**
      * Create standardized stream result - consolidates result structure
      */

package/dist/lib/core/modules/StreamHandler.js

@@ -16,6 +16,7 @@ import { trace, context as otelContext, SpanStatusCode, } from "@opentelemetry/a
 import { tracers, ATTR, withSpan } from "../../telemetry/index.js";
 import { logger } from "../../utils/logger.js";
 import { validateStreamOptions as validateStreamOpts, ValidationError, createValidationSummary, } from "../../utils/parameterValidation.js";
+import { buildNoOutputSentinel, detectPostStreamNoOutput, stampNoOutputSpan, } from "../../utils/noOutputSentinel.js";
 import { STEP_LIMITS } from "../constants.js";
 import { createAnalytics } from "../analytics.js";
 import { nanoid } from "nanoid";
@@ -83,7 +84,17 @@ export class StreamHandler {
      * Create text stream transformation - consolidates identical logic from 7/10 providers
      * Tracks TTFC (Time To First Chunk), chunk count, and total bytes streamed.
      */
-    createTextStream(result) {
+    createTextStream(result, 
+    /**
+     * Reviewer follow-up: optional getter for the provider's captured
+     * upstream error (typically wired from `streamText`'s `onError`
+     * callback). When set, the sentinel's `providerError` /
+     * `modelResponseRaw` reflect the real upstream cause instead of the
+     * AI SDK's generic "No output generated" message. Callers that don't
+     * capture upstream errors can omit this — the sentinel still
+     * populates with the AI SDK error.
+     */
+    getUnderlyingError) {
         const providerName = this.providerName;
         return (async function* () {
             let chunkCount = 0;
@@ -113,32 +124,43 @@ 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`);
-                    // Curator P2-5: stamp the active OTel span so ContextEnricher.onEnd()
-                    // surfaces a WARNING-level Langfuse observation instead of defaulting
-                    // to DEFAULT with no status message.
-                    try {
-                        const activeSpan = trace.getSpan(otelContext.active());
-                        if (activeSpan) {
-                            activeSpan.setAttribute("neurolink.no_output", true);
-                        }
-                    }
-                    catch {
-                        // Tracing not initialized — ignore.
-                    }
+                    // Curator P3-6: build the enriched sentinel using the shared
+                    // helper so every provider yields the same shape. Pass the
+                    // captured upstream error (if any) so providerError /
+                    // modelResponseRaw carry the real cause.
+                    const sentinel = await buildNoOutputSentinel(error, result, getUnderlyingError?.());
+                    // Curator P2-5 + P3-6: stamp the active OTel span so
+                    // ContextEnricher.onEnd() surfaces a WARNING-level Langfuse
+                    // observation with finishReason + token usage. Centralized in
+                    // stampNoOutputSpan so every wired site stamps consistently.
+                    stampNoOutputSpan(sentinel);
                     // 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",
-                        },
-                    };
+                    yield sentinel;
+                    // Reviewer follow-up: must return here. Falling through to the
+                    // post-stream detection block below would yield a SECOND sentinel
+                    // chunk (verified with synthetic NoOutputGeneratedError stream:
+                    // count=2 sentinels). The catch block's yield is sufficient.
+                    return;
                 }
                 else {
                     throw error;
                 }
             }
+            // Curator P3-6 (round-2 fix): the production trigger sets
+            // NoOutputGeneratedError on `result.finishReason` rejection — NOT
+            // thrown from textStream iteration. Surface that path here so the
+            // sentinel actually fires for real-world no-output streams. The
+            // catch above remains as a defensive path for failure modes that
+            // do throw from textStream.
+            if (chunkCount === 0) {
+                const detected = await detectPostStreamNoOutput(result, getUnderlyingError?.());
+                if (detected) {
+                    logger.warn(`${providerName}: Stream produced no output (NoOutputGeneratedError) — caught from finishReason rejection`);
+                    stampNoOutputSpan(detected.sentinel);
+                    yield detected.sentinel;
+                }
+            }
             // Record completion metrics on the active span
             const activeSpan = trace.getSpan(otelContext.active());
             if (activeSpan) {

package/dist/lib/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/lib/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/lib/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/lib/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",