@juspay/neurolink 12.28.4 → 12.29.1

package/dist/core/baseProvider.js

@@ -30,7 +30,7 @@ import { logger } from "../utils/logger.js";
 import { interleaveTTSStream } from "../utils/ttsStream.js";
 import { attachStreamCancel, cancelStream, releaseIterator, } from "../utils/streamCancellation.js";
 import { TimeoutError as AsyncTimeoutError, withTimeoutFn, } from "../utils/async/withTimeout.js";
-import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
+import { composeAbortSignals, composeAbortSignalsScoped, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { shouldDisableBuiltinTools } from "../utils/toolUtils.js";
 import { getKeyCount, getKeysAsString, transformToolExecutions, } from "../utils/transformationUtils.js";
 import { ToolExecutionRecorder } from "./toolExecutionRecorder.js";
@@ -228,155 +228,195 @@ export class BaseProvider {
         await this.ensureModelLimits();
         let options = this.normalizeStreamOptions(optionsOrPrompt);
         this.applyFileToolRoots(options);
-        // Before anything else, and before a single byte leaves the process: an
-        // execution policy this provider cannot honour is an error, and a policy
-        // whose shape could be read two ways is an error. Both are silent bugs at
-        // the point they would otherwise matter.
-        validateExecutionControl(options.executionControl, this.providerName, this.supportsExecutionControl(), {
-            turnTimeoutMs: options.turnTimeoutMs,
-            toolTimeoutMs: options.toolTimeoutMs,
-        });
-        logger.info(`Starting stream`, {
-            provider: this.providerName,
-            hasTools: !options.disableTools && this.supportsTools(),
-            disableTools: !!options.disableTools,
-            supportsTools: this.supportsTools(),
-            inputLength: options.input?.text?.length || 0,
-            maxTokens: options.maxTokens,
-            temperature: options.temperature,
-            timestamp: Date.now(),
-        });
-        // ===== EARLY MULTIMODAL DETECTION =====
-        // #1259: audioFiles was missing here while videoFiles was present, so an
-        // audio-only stream skipped this branch entirely.
-        const hasFileInput = !!options.input?.files?.length ||
-            !!options.input?.videoFiles?.length ||
-            !!options.input?.audioFiles?.length;
-        if (hasFileInput) {
-            // ===== VIDEO ANALYSIS DETECTION =====
-            // Check if video frames are present and handle with fake streaming
-            const messages = await this.buildMessagesForStream(options);
-            if (hasVideoFrames(messages)) {
-                logger.info(`Video frames detected in stream, using fake streaming for video analysis`, {
-                    provider: this.providerName,
-                    model: this.modelName,
-                });
-                // Note: executeFakeStreaming() owns its own catch that fires the
-                // consumer-supplied onError before re-throwing through
-                // handleProviderError(), so we do not need to wrap again here —
-                // doing so would route the error through handleProviderError()
-                // twice (and risk a double-fire onError without the shared
-                // lifecycle-fired WeakSet mark).
-                const fakeResult = await this.executeFakeStreaming(options, analysisSchema);
-                return this.wrapStreamWithLifecycleCallbacks(fakeResult, options);
-            }
-        }
-        // CRITICAL: Image generation models don't support real streaming
-        // Force fake streaming for image models to ensure image output is yielded.
-        // resolveRequestKind() skips this path when the caller explicitly requests
-        // non-image output (e.g. JSON analysis) so dual-mode models like
-        // gemini-3.1-flash-image-preview can still perform text/structured
-        // generation — see its doc comment for the full precedence table.
-        const requestKind = resolveRequestKind(options, this.modelName);
-        if (requestKind === "image") {
-            logger.info(`Image model detected, forcing fake streaming`, {
-                provider: this.providerName,
-                model: this.modelName,
-                reason: "Image generation requires fake streaming to yield image output",
-            });
-            // Skip real streaming, go directly to fake streaming.
-            // executeFakeStreaming() owns its own catch + lifecycle fire, so
-            // wrapping again here would double-route through handleProviderError().
-            const fakeResult = await this.executeFakeStreaming(options, analysisSchema);
-            return this.wrapStreamWithLifecycleCallbacks(fakeResult, options);
-        }
-        // Central tool merge: Pre-merge base tools (MCP/built-in) with user-provided
-        // tools (e.g. RAG tools) into options.tools. This way, every provider's
-        // executeStream() can simply use options.tools (or getAllTools() + options.tools)
-        // and get the complete tool set without needing per-provider merge logic.
-        if (this.shouldUseTools(options, true)) {
-            const mergedTools = await this.getToolsForStream(options);
-            options = { ...options, tools: mergedTools };
-        }
-        else {
-            options = { ...options, tools: {} };
-        }
-        // CRITICAL FIX: Always prefer real streaming over fake streaming
-        // Try real streaming first, use fake streaming only as fallback
+        // Own an abort signal for this call so teardown can reach the transport.
+        //
+        // #1550 gave teardown a way to close the iterator chain, but closing an
+        // iterator does not cancel the HTTP request underneath it — the provider
+        // read stays pending and the connection stays open. Providers already
+        // honour `options.abortSignal` and pass it to their transport; nothing
+        // ever fired one on abandonment, because the only signal available was
+        // the caller's and the caller had simply walked away.
+        //
+        // Composed rather than substituted, so a caller's own signal keeps
+        // working exactly as before and either source can end the request.
+        // Scoped, not plain `composeAbortSignals`: that one is `AbortSignal.any`,
+        // whose registration on a source survives until the DERIVED signal is
+        // collected. A caller that reuses one long-lived `abortSignal` across many
+        // stream calls would accumulate a dependent per call on it, released only
+        // by GC — the exact hazard composeAbortSignalsScoped was written for (see
+        // its docstring: MaxListenersExceededWarning at 10+ compositions). It
+        // registers removable listeners and hands back a `dispose()`, which
+        // `teardown()` calls when the stream settles.
+        const teardownController = new AbortController();
+        const { signal: composedStreamSignal, dispose: disposeComposedSignal } = composeAbortSignalsScoped(options.abortSignal, teardownController.signal);
+        if (composedStreamSignal !== options.abortSignal) {
+            options = { ...options, abortSignal: composedStreamSignal };
+        }
+        // Ownership of the composed signal transfers to the returned wrapper,
+        // whose teardown() disposes it. Until that wrapper exists, this method
+        // owns it — and every throw between here and there (an execution-control
+        // rejection, a provider error with no tool fallback) would otherwise
+        // leave composeAbortSignalsScoped's once-listeners attached to a caller
+        // signal that may outlive this call by many more.
+        //
+        // catch, deliberately, not finally: dispose() only detaches listeners, so
+        // running it on the success path would sever the caller's abort from the
+        // composed signal the stream is still using.
         try {
-            logger.debug(`Attempting real streaming`, {
-                provider: this.providerName,
-                timestamp: Date.now(),
+            // Before anything else, and before a single byte leaves the process: an
+            // execution policy this provider cannot honour is an error, and a policy
+            // whose shape could be read two ways is an error. Both are silent bugs at
+            // the point they would otherwise matter.
+            validateExecutionControl(options.executionControl, this.providerName, this.supportsExecutionControl(), {
+                turnTimeoutMs: options.turnTimeoutMs,
+                toolTimeoutMs: options.toolTimeoutMs,
             });
-            const realStreamResult = await this.executeStream(options, analysisSchema);
-            logger.info(`Real streaming succeeded`, {
+            logger.info(`Starting stream`, {
                 provider: this.providerName,
+                hasTools: !options.disableTools && this.supportsTools(),
+                disableTools: !!options.disableTools,
+                supportsTools: this.supportsTools(),
+                inputLength: options.input?.text?.length || 0,
+                maxTokens: options.maxTokens,
+                temperature: options.temperature,
                 timestamp: Date.now(),
             });
-            // Wire lifecycle callbacks (onChunk/onFinish/onError) on the user-
-            // facing StreamResult.stream. The AI-SDK lifecycle middleware only
-            // sees AI-SDK-internal chunks via streamText/wrapLanguageModel, so
-            // providers with custom HTTP streaming (Ollama, llama.cpp's /api,
-            // anything that doesn't go through streamText) bypass it. Wrapping
-            // here makes the callbacks fire for every provider, regardless of
-            // streaming implementation.
-            return this.wrapStreamWithLifecycleCallbacks(this.withStreamModelFallback(realStreamResult, options, analysisSchema), options);
-        }
-        catch (realStreamError) {
-            // Retired-model fallback runs FIRST, before any lifecycle callback has
-            // fired and before a single chunk has reached the consumer: onChunk and
-            // onFinish are only wired on the success path above, and onError fires
-            // further down this same catch. That ordering is what makes retrying a
-            // stream safe at all — nothing observable has happened yet.
-            const recovered = await this.retryStreamWithFallbackModel(realStreamError, options, analysisSchema);
-            if (recovered) {
-                return recovered;
-            }
-            // The fallback is BROAD, not narrow: only the terminal errors listed
-            // below (abort, timeout, 401/403, quota, rate limit, authentication)
-            // re-throw. Every other failure — including a genuine configuration or
-            // programming error — is masked as a degraded fake stream whenever
-            // tools are enabled. Narrowing this to "streaming with tools is
-            // unsupported" failures would change behaviour for every provider at
-            // once, so it needs its own characterization PR first; until then this
-            // comment records what the code does, not what a narrower design would.
-            const errMsg = realStreamError instanceof Error
-                ? realStreamError.message
-                : String(realStreamError);
-            const errName = realStreamError instanceof Error ? realStreamError.name : "";
-            if (errName === "AbortError" ||
-                errMsg.includes("abort") ||
-                errMsg.includes("timeout") ||
-                errMsg.includes("401") ||
-                errMsg.includes("403") ||
-                errMsg.includes("quota") ||
-                errMsg.includes("rate limit") ||
-                errMsg.includes("authentication")) {
-                await this.fireLifecycleErrorCallback(options, realStreamError);
-                throw this.handleProviderError(realStreamError);
+            // ===== EARLY MULTIMODAL DETECTION =====
+            // #1259: audioFiles was missing here while videoFiles was present, so an
+            // audio-only stream skipped this branch entirely.
+            const hasFileInput = !!options.input?.files?.length ||
+                !!options.input?.videoFiles?.length ||
+                !!options.input?.audioFiles?.length;
+            if (hasFileInput) {
+                // ===== VIDEO ANALYSIS DETECTION =====
+                // Check if video frames are present and handle with fake streaming
+                const messages = await this.buildMessagesForStream(options);
+                if (hasVideoFrames(messages)) {
+                    logger.info(`Video frames detected in stream, using fake streaming for video analysis`, {
+                        provider: this.providerName,
+                        model: this.modelName,
+                    });
+                    // Note: executeFakeStreaming() owns its own catch that fires the
+                    // consumer-supplied onError before re-throwing through
+                    // handleProviderError(), so we do not need to wrap again here —
+                    // doing so would route the error through handleProviderError()
+                    // twice (and risk a double-fire onError without the shared
+                    // lifecycle-fired WeakSet mark).
+                    const fakeResult = await this.executeFakeStreaming(options, analysisSchema);
+                    return this.wrapStreamWithLifecycleCallbacks(fakeResult, options, teardownController, disposeComposedSignal);
+                }
             }
-            logger.warn(`Real streaming failed for ${this.providerName}, falling back to fake streaming:`, {
-                error: errMsg,
-                timestamp: Date.now(),
-            });
-            // Fallback to fake streaming only if real streaming fails AND tools
-            // are enabled. executeFakeStreaming() owns its own catch + lifecycle
-            // fire, so a fake-streaming failure here surfaces through that path
-            // without needing an outer wrap (which would double-route through
-            // handleProviderError()).
-            if (!options.disableTools && this.supportsTools()) {
+            // CRITICAL: Image generation models don't support real streaming
+            // Force fake streaming for image models to ensure image output is yielded.
+            // resolveRequestKind() skips this path when the caller explicitly requests
+            // non-image output (e.g. JSON analysis) so dual-mode models like
+            // gemini-3.1-flash-image-preview can still perform text/structured
+            // generation — see its doc comment for the full precedence table.
+            const requestKind = resolveRequestKind(options, this.modelName);
+            if (requestKind === "image") {
+                logger.info(`Image model detected, forcing fake streaming`, {
+                    provider: this.providerName,
+                    model: this.modelName,
+                    reason: "Image generation requires fake streaming to yield image output",
+                });
+                // Skip real streaming, go directly to fake streaming.
+                // executeFakeStreaming() owns its own catch + lifecycle fire, so
+                // wrapping again here would double-route through handleProviderError().
                 const fakeResult = await this.executeFakeStreaming(options, analysisSchema);
-                return this.wrapStreamWithLifecycleCallbacks(fakeResult, options);
+                return this.wrapStreamWithLifecycleCallbacks(fakeResult, options, teardownController, disposeComposedSignal);
+            }
+            // Central tool merge: Pre-merge base tools (MCP/built-in) with user-provided
+            // tools (e.g. RAG tools) into options.tools. This way, every provider's
+            // executeStream() can simply use options.tools (or getAllTools() + options.tools)
+            // and get the complete tool set without needing per-provider merge logic.
+            if (this.shouldUseTools(options, true)) {
+                const mergedTools = await this.getToolsForStream(options);
+                options = { ...options, tools: mergedTools };
             }
             else {
-                // If real streaming failed and no tools are enabled, fire onError
-                // before re-throwing so consumer-supplied callbacks see the failure.
-                await this.fireLifecycleErrorCallback(options, realStreamError);
-                // If real streaming failed and no tools are enabled, re-throw the original error
-                logger.error(`Real streaming failed for ${this.providerName}:`, realStreamError);
-                throw this.handleProviderError(realStreamError);
+                options = { ...options, tools: {} };
+            }
+            // CRITICAL FIX: Always prefer real streaming over fake streaming
+            // Try real streaming first, use fake streaming only as fallback
+            try {
+                logger.debug(`Attempting real streaming`, {
+                    provider: this.providerName,
+                    timestamp: Date.now(),
+                });
+                const realStreamResult = await this.executeStream(options, analysisSchema);
+                logger.info(`Real streaming succeeded`, {
+                    provider: this.providerName,
+                    timestamp: Date.now(),
+                });
+                // Wire lifecycle callbacks (onChunk/onFinish/onError) on the user-
+                // facing StreamResult.stream. The AI-SDK lifecycle middleware only
+                // sees AI-SDK-internal chunks via streamText/wrapLanguageModel, so
+                // providers with custom HTTP streaming (Ollama, llama.cpp's /api,
+                // anything that doesn't go through streamText) bypass it. Wrapping
+                // here makes the callbacks fire for every provider, regardless of
+                // streaming implementation.
+                return this.wrapStreamWithLifecycleCallbacks(this.withStreamModelFallback(realStreamResult, options, analysisSchema), options, teardownController, disposeComposedSignal);
+            }
+            catch (realStreamError) {
+                // Retired-model fallback runs FIRST, before any lifecycle callback has
+                // fired and before a single chunk has reached the consumer: onChunk and
+                // onFinish are only wired on the success path above, and onError fires
+                // further down this same catch. That ordering is what makes retrying a
+                // stream safe at all — nothing observable has happened yet.
+                const recovered = await this.retryStreamWithFallbackModel(realStreamError, options, analysisSchema, teardownController, disposeComposedSignal);
+                if (recovered) {
+                    return recovered;
+                }
+                // The fallback is BROAD, not narrow: only the terminal errors listed
+                // below (abort, timeout, 401/403, quota, rate limit, authentication)
+                // re-throw. Every other failure — including a genuine configuration or
+                // programming error — is masked as a degraded fake stream whenever
+                // tools are enabled. Narrowing this to "streaming with tools is
+                // unsupported" failures would change behaviour for every provider at
+                // once, so it needs its own characterization PR first; until then this
+                // comment records what the code does, not what a narrower design would.
+                const errMsg = realStreamError instanceof Error
+                    ? realStreamError.message
+                    : String(realStreamError);
+                const errName = realStreamError instanceof Error ? realStreamError.name : "";
+                if (errName === "AbortError" ||
+                    errMsg.includes("abort") ||
+                    errMsg.includes("timeout") ||
+                    errMsg.includes("401") ||
+                    errMsg.includes("403") ||
+                    errMsg.includes("quota") ||
+                    errMsg.includes("rate limit") ||
+                    errMsg.includes("authentication")) {
+                    await this.fireLifecycleErrorCallback(options, realStreamError);
+                    throw this.handleProviderError(realStreamError);
+                }
+                logger.warn(`Real streaming failed for ${this.providerName}, falling back to fake streaming:`, {
+                    error: errMsg,
+                    timestamp: Date.now(),
+                });
+                // Fallback to fake streaming only if real streaming fails AND tools
+                // are enabled. executeFakeStreaming() owns its own catch + lifecycle
+                // fire, so a fake-streaming failure here surfaces through that path
+                // without needing an outer wrap (which would double-route through
+                // handleProviderError()).
+                if (!options.disableTools && this.supportsTools()) {
+                    const fakeResult = await this.executeFakeStreaming(options, analysisSchema);
+                    return this.wrapStreamWithLifecycleCallbacks(fakeResult, options, teardownController, disposeComposedSignal);
+                }
+                else {
+                    // If real streaming failed and no tools are enabled, fire onError
+                    // before re-throwing so consumer-supplied callbacks see the failure.
+                    await this.fireLifecycleErrorCallback(options, realStreamError);
+                    // If real streaming failed and no tools are enabled, re-throw the original error
+                    logger.error(`Real streaming failed for ${this.providerName}:`, realStreamError);
+                    throw this.handleProviderError(realStreamError);
+                }
             }
         }
+        catch (streamSetupError) {
+            disposeComposedSignal();
+            throw streamSetupError;
+        }
     }
     /**
      * Swap in a fallback model when a stream dies on a retired id before it has
@@ -548,7 +588,7 @@ export class BaseProvider {
      * re-throw, the onError firing) is left exactly as it was, so behaviour
      * changes only when a fallback actually succeeds.
      */
-    async retryStreamWithFallbackModel(error, options, analysisSchema) {
+    async retryStreamWithFallbackModel(error, options, analysisSchema, teardownController, disposeComposedSignal) {
         if (options.disableInternalFallback === true) {
             return undefined;
         }
@@ -565,7 +605,7 @@ export class BaseProvider {
             this.refreshHandlersForModel(candidate);
             try {
                 const result = await this.executeStream(options, analysisSchema);
-                return this.wrapStreamWithLifecycleCallbacks(result, options);
+                return this.wrapStreamWithLifecycleCallbacks(result, options, teardownController, disposeComposedSignal);
             }
             catch {
                 // Any failure on a candidate — stale id or otherwise — just moves to
@@ -590,8 +630,17 @@ export class BaseProvider {
      * over /api/chat, custom OpenAI-compatible servers, etc). Wrapping the
      * user-facing stream here ensures the callbacks fire regardless of the
      * underlying transport.
-     */
-    wrapStreamWithLifecycleCallbacks(result, options) {
+     *
+     * `teardownController`, when supplied, is the call's own abort source (see
+     * `stream()`): the cancel hook fires it on abandonment so the transport's
+     * in-flight HTTP request is cancelled, not just this iterator chain.
+     */
+    wrapStreamWithLifecycleCallbacks(result, options, teardownController, 
+    // Releases the scoped composition in stream() that put this call's
+    // teardown signal alongside the caller's. Runs from teardown(), so the
+    // listeners come off the caller's (possibly long-lived) signal the
+    // moment this stream settles rather than whenever GC gets to it.
+    disposeComposedSignal) {
         const lifecycle = getLifecycleMiddlewareConfig(options);
         // No early return when there are no callbacks. This wrapper is the only point
         // every provider's stream passes through unconditionally (the real-streaming path
@@ -636,6 +685,29 @@ export class BaseProvider {
         const upstreamIterable = {
             [Symbol.asyncIterator]: () => upstreamIterator,
         };
+        // Set by teardown, read by the generator's catch. Distinguishes "the
+        // provider failed" from "we aborted the provider because the consumer
+        // abandoned this stream", which must not be reported as a failure.
+        let teardownRequested = false;
+        let teardownDone = false;
+        // Shared by both teardown entry points below (native `.return()` via the
+        // `finally`, and the `attachStreamCancel` hook for a consumer parked
+        // mid-`await` that a queued `.return()` cannot reach promptly). Guarded
+        // so whichever fires first does the work exactly once.
+        const teardown = () => {
+            if (teardownDone) {
+                return;
+            }
+            teardownDone = true;
+            teardownRequested = true;
+            // Abort before closing the iterators. The iterator close releases our
+            // side of the chain; this releases the provider's — the in-flight HTTP
+            // request that a closed iterator leaves running.
+            teardownController?.abort();
+            disposeComposedSignal?.();
+            cancelStream(originalStream);
+            releaseIterator(upstreamIterator);
+        };
         const wrappedStream = (async function* () {
             let accumulated = "";
             let seq = 0;
@@ -672,6 +744,14 @@ export class BaseProvider {
             }
             catch (error) {
                 const err = error instanceof Error ? error : new Error(String(error));
+                if (teardownRequested) {
+                    // Our own abort, from a consumer that already broke out of this
+                    // stream. Firing onError would report cleanup as a provider failure,
+                    // and rethrowing would surface an error nobody is left to catch —
+                    // an unhandled rejection, which terminates the process. Ending the
+                    // generator quietly is the correct outcome for an abandoned stream.
+                    return;
+                }
                 if (onError && !hasLifecycleErrorFired(err)) {
                     // Mark before firing so a higher layer that also routes through
                     // fireLifecycleErrorCallback (or its own lifecycle wrapper) with
@@ -686,16 +766,33 @@ export class BaseProvider {
                 }
                 throw classifyStreamError(err);
             }
+            finally {
+                // Unconditional and safe: `teardown()` is idempotent (guarded by
+                // `teardownDone`), and `cancelStream`/`releaseIterator` are
+                // documented as no-ops on an already-finished stream/iterator, so
+                // calling it again after normal completion or a real provider error
+                // (both of which reach here too) costs nothing. The path that
+                // actually needs it is a consumer breaking out of `for await` while
+                // this generator is parked right after a `yield` — that unwinds
+                // straight here, bypassing both the rest of the `try` and the
+                // `catch` above, since a native `.return()` is a "return"
+                // completion, not a thrown error. Closing the iterator chain (done
+                // automatically by `for-await-of`'s own `IteratorClose` on
+                // `upstreamIterable`) does not cancel the HTTP request underneath
+                // it, so the transport is aborted here explicitly.
+                teardown();
+            }
         })();
         // A consumer that breaks out of the stream cannot reach this generator
         // through `.return()` while it is parked awaiting the provider — that
         // request queues behind the in-flight `next()`. The hook closes the
         // upstream directly and forwards the request to any wrapper below, so
-        // abandoning a stream really does release the provider connection.
-        attachStreamCancel(wrappedStream, () => {
-            cancelStream(originalStream);
-            releaseIterator(upstreamIterator);
-        });
+        // abandoning a stream really does release the provider connection. This
+        // is the fallback path for that case; the common case (a consumer that
+        // breaks right after receiving a chunk, so this generator is parked at
+        // the `yield` rather than mid-`await`) is handled by the `finally`
+        // above, which reaches `.return()` synchronously.
+        attachStreamCancel(wrappedStream, teardown);
         // See the comment in withStreamModelFallback above: this spread must not
         // be allowed to freeze a provider's lazy toolsUsed/toolExecutions getters.
         return preserveLiveStreamAccessors(result, {

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

@@ -68,6 +68,33 @@ export declare function isToolsSchemaConflictError(error: unknown): boolean;
  * (same flow as isToolsSchemaConflictError).
  */
 export declare function isSchemaComplexityError(error: unknown): boolean;
+/**
+ * True when a provider error indicates the MODEL (not the provider as a
+ * whole) rejects `response_format` outright, independent of which mode was
+ * requested. The catalog schema declares `structuredOutput` per provider,
+ * not per model (`catalogCapabilitiesSchema`, `src/lib/providers/catalog/
+ * schema.ts` — there is no per-model override the way `tools:
+ * "model-dependent"` has one), so a provider can accurately claim the
+ * capability for its default model while a caller-selected fallback model
+ * rejects every `response_format` value. Novita's
+ * `meta-llama/llama-3.3-70b-instruct` is the recorded case: both
+ * `json_schema` ("does not support 'json_schema' response format.
+ * Supported formats: json_object") and `json_object` ("response format
+ * json_object is not supported") come back as 400s on that model, while
+ * the catalog's default model accepts both.
+ *
+ * This is intentionally a text match on the classified error, not a
+ * per-model catalog flag: it lets ANY vendor's per-model rejection recover
+ * the same way, mirroring `isToolsSchemaConflictError` /
+ * `isSchemaComplexityError` above. Recovery here means the same thing it
+ * means for those two — drop `response_format` and spell the JSON Schema
+ * into the prompt instead — which is exactly what CLAUDE.md's Critical
+ * Rule 3 requires unconditionally ("Regardless of provider,
+ * generate({ schema }) is guaranteed to return valid JSON in content plus
+ * a parsed structuredData object"): a model-specific capability gap must
+ * degrade to best-effort JSON, not throw.
+ */
+export declare function isResponseFormatUnsupportedError(error: unknown): boolean;
 /**
  * True when a provider error indicates the request was rejected because the
  * `temperature` parameter is deprecated / unsupported for the model. The newest

package/dist/core/modules/structuredOutputPolicy.js

@@ -102,6 +102,42 @@ export function isSchemaComplexityError(error) {
             : "";
     return /too many states/i.test(message);
 }
+/**
+ * True when a provider error indicates the MODEL (not the provider as a
+ * whole) rejects `response_format` outright, independent of which mode was
+ * requested. The catalog schema declares `structuredOutput` per provider,
+ * not per model (`catalogCapabilitiesSchema`, `src/lib/providers/catalog/
+ * schema.ts` — there is no per-model override the way `tools:
+ * "model-dependent"` has one), so a provider can accurately claim the
+ * capability for its default model while a caller-selected fallback model
+ * rejects every `response_format` value. Novita's
+ * `meta-llama/llama-3.3-70b-instruct` is the recorded case: both
+ * `json_schema` ("does not support 'json_schema' response format.
+ * Supported formats: json_object") and `json_object` ("response format
+ * json_object is not supported") come back as 400s on that model, while
+ * the catalog's default model accepts both.
+ *
+ * This is intentionally a text match on the classified error, not a
+ * per-model catalog flag: it lets ANY vendor's per-model rejection recover
+ * the same way, mirroring `isToolsSchemaConflictError` /
+ * `isSchemaComplexityError` above. Recovery here means the same thing it
+ * means for those two — drop `response_format` and spell the JSON Schema
+ * into the prompt instead — which is exactly what CLAUDE.md's Critical
+ * Rule 3 requires unconditionally ("Regardless of provider,
+ * generate({ schema }) is guaranteed to return valid JSON in content plus
+ * a parsed structuredData object"): a model-specific capability gap must
+ * degrade to best-effort JSON, not throw.
+ */
+export function isResponseFormatUnsupportedError(error) {
+    const message = error instanceof Error
+        ? error.message
+        : typeof error === "string"
+            ? error
+            : "";
+    return (/does not support[^.]{0,80}response[\s_-]?format/i.test(message) ||
+        /response[\s_-]?format[^.]{0,60}(?:is )?not support/i.test(message) ||
+        /unsupported response[\s_-]?format/i.test(message));
+}
 /**
  * True when a provider error indicates the request was rejected because the
  * `temperature` parameter is deprecated / unsupported for the model. The newest

package/dist/core/nativeGenerateLoop.js

@@ -80,7 +80,13 @@ const validateToolInput = (tool, input) => {
  * fallback would silently do nothing.
  */
 export const appendJsonSchemaInstruction = (conversation, schema) => {
-    const instruction = "When you give your final answer, respond with only a single JSON object " +
+    // "value", not "object": a ValidationSchema also accepts array and scalar
+    // roots (z.array(...), z.string()), and demanding an object told a
+    // compliant model to emit something those roots can never satisfy — so the
+    // fallback silently produced nothing for them however well the model
+    // complied. The generate path's own re-ask prompt was corrected for this
+    // reason; this shared helper, used by both paths, was missed.
+    const instruction = "When you give your final answer, respond with only a single JSON value " +
         "that conforms to the following JSON Schema. No prose before or after it, " +
         `and no markdown code fence. JSON Schema: ${JSON.stringify(schema)}`;
     const lastSystemIndex = conversation.reduce((found, message, index) => (message.role === "system" ? index : found), -1);

package/dist/neurolink.d.ts

@@ -66,6 +66,29 @@ export declare class NeuroLink {
     private mcpSkipped;
     private mcpInitPromise;
     private emitter;
+    /**
+     * Process-unique id used to attribute this instance's log events. The SDK
+     * entry points run their bodies inside `logger.runInInstanceScope(this.logInstanceId, …)`,
+     * which is what lets a worker's log bridge receive only the worker's own
+     * events instead of everything in the process.
+     */
+    private readonly logInstanceId;
+    /**
+     * Detach callbacks for scoped log bridges of workers this instance created
+     * via {@link createWorkerInstance} with `onLog`, that have not yet been
+     * removed by the worker's own `dispose()`. The scoped-emitter registry
+     * lives on the process-global logger, keyed by the WORKER's id — not this
+     * host's — so it survives this host being garbage collected. If a caller
+     * disposes the host but forgets an individual worker (the host is the
+     * long-lived object in most delegation patterns; the worker the
+     * short-lived one), the bridge — and everything its `onLog` closes over —
+     * would otherwise stay registered for the life of the process. `dispose()`
+     * sweeps whatever is still here so host cleanup is sufficient on its own,
+     * matching the pre-scoped-routing behavior where a worker's forward
+     * listener lived on the host's own emitter and was removed by
+     * `this.emitter.removeAllListeners()`.
+     */
+    private readonly ownedWorkerLogBridgeDetachers;
     private _taskManager?;
     private _taskManagerConfig?;
     private toolRegistry;
@@ -767,6 +790,11 @@ export declare class NeuroLink {
      * @since 1.0.0
      */
     generate(optionsOrPrompt: GenerateOptions | DynamicOptions | string): Promise<GenerateResult>;
+    /**
+     * Body of {@link generate}, always entered through the instance log scope
+     * so every log call beneath it is attributable to this instance.
+     */
+    private generateInInstanceScope;
     private fireConsumerOnErrorIfNotFired;
     /**
      * Curator P2-3: wraps a generate/stream call with the fallback
@@ -887,6 +915,10 @@ export declare class NeuroLink {
      * Internally calls generate() and converts result format
      */
     generateText(options: TextGenerationOptions): Promise<TextGenerationResult>;
+    /**
+     * Body of {@link generateText}, always entered through the instance log scope.
+     */
+    private generateTextInInstanceScope;
     /**
      * REDESIGNED INTERNAL GENERATION - NO CIRCULAR DEPENDENCIES
      *
@@ -1032,6 +1064,16 @@ export declare class NeuroLink {
      * @throws {Error} When conversation memory operations fail (if enabled)
      */
     stream(options: StreamOptions | DynamicOptions): Promise<StreamResult>;
+    /**
+     * Body of {@link stream}, always entered through the instance log scope.
+     *
+     * Note the scope covers setting the stream up, not draining it: logs
+     * emitted while the consumer iterates the returned stream run in the
+     * consumer's async context, so they are attributed to whatever scope the
+     * consumer is in. Provider loops that run to completion inside this call
+     * are covered.
+     */
+    private streamInInstanceScope;
     /**
      * Curator P2-3 / Reviewer Finding #2: stream-fallback that also covers
      * errors thrown during async iteration (e.g. LiteLLM throwing inside