@juspay/neurolink 9.59.2 → 9.59.4

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;
     } | {

package/dist/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;