@juspay/neurolink 12.28.3 → 12.29.0

package/dist/neurolink.js

@@ -350,6 +350,8 @@ function createTypedEmitter() {
     const emitter = new EventEmitter();
     return emitter;
 }
+/** Monotonic source for {@link NeuroLink.logInstanceId}. Process-local by design. */
+let neuroLinkInstanceCounter = 0;
 export class NeuroLink {
     /** @internal Brand for cross-module identification — see {@link isNeuroLink}. */
     [NEUROLINK_BRAND] = true;
@@ -357,6 +359,29 @@ export class NeuroLink {
     mcpSkipped = false;
     mcpInitPromise = null;
     emitter = createTypedEmitter();
+    /**
+     * 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.
+     */
+    logInstanceId = `nl-${++neuroLinkInstanceCounter}`;
+    /**
+     * 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()`.
+     */
+    ownedWorkerLogBridgeDetachers = new Set();
     // TaskManager — lazy-initialized on first access via `this.tasks`
     _taskManager;
     _taskManagerConfig;
@@ -3300,6 +3325,13 @@ Current user's request: ${currentInput}`;
      * @since 1.0.0
      */
     async generate(optionsOrPrompt) {
+        return logger.runInInstanceScope(this.logInstanceId, () => this.generateInInstanceScope(optionsOrPrompt));
+    }
+    /**
+     * Body of {@link generate}, always entered through the instance log scope
+     * so every log call beneath it is attributable to this instance.
+     */
+    async generateInInstanceScope(optionsOrPrompt) {
         // Host-loop delegation (registerAgentTool): enter a per-turn scope so
         // delegation caps count against THIS top-level generate, and withhold
         // depth-limited agent tools from the request. beginDelegationTurn
@@ -4248,6 +4280,10 @@ Current user's request: ${currentInput}`;
             csvOptions: options.csvOptions,
             pdfOptions: options.pdfOptions,
             imageOptions: options.imageOptions,
+            // videoOptions belongs in that same list and was never in it, so no SDK
+            // caller's video settings have ever reached a provider -- frames and
+            // quality included, not just the native-video flags added alongside.
+            videoOptions: options.videoOptions,
             region: options.region,
             tts: options.tts,
             stt: options.stt,
@@ -4968,6 +5004,12 @@ Current user's request: ${currentInput}`;
      * Internally calls generate() and converts result format
      */
     async generateText(options) {
+        return logger.runInInstanceScope(this.logInstanceId, () => this.generateTextInInstanceScope(options));
+    }
+    /**
+     * Body of {@link generateText}, always entered through the instance log scope.
+     */
+    async generateTextInInstanceScope(options) {
         // Validate required parameters for backward compatibility
         if (!options.prompt ||
             typeof options.prompt !== "string" ||
@@ -6835,6 +6877,18 @@ Current user's request: ${currentInput}`;
      * @throws {Error} When conversation memory operations fail (if enabled)
      */
     async stream(options) {
+        return logger.runInInstanceScope(this.logInstanceId, () => this.streamInInstanceScope(options));
+    }
+    /**
+     * 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.
+     */
+    async streamInInstanceScope(options) {
         // Host-loop delegation (registerAgentTool): the same per-turn scope as
         // generate() — delegation caps count against THIS streamed turn and
         // depth-limited agent tools are withheld from the request. The provider
@@ -13326,10 +13380,32 @@ Current user's request: ${currentInput}`;
                     // Log-bridge listener errors never disrupt the worker.
                 }
             };
-            hostEmitter.on("log-event", forward);
+            // Bridge the WORKER's own scoped sink, not the host's process-wide one.
+            // Subscribing to hostEmitter would deliver every log event in the
+            // process — host, sibling workers, MCP — stamped with this worker's
+            // tag. The scoped registration delivers only events logged inside the
+            // worker's own generate/stream/generateText calls.
+            const bridgeEmitter = {
+                emit: (event, ...args) => {
+                    if (event === "log-event") {
+                        forward(args[0]);
+                    }
+                    return true;
+                },
+            };
+            const workerLogInstanceId = worker.logInstanceId;
+            logger.addScopedEventEmitter(workerLogInstanceId, bridgeEmitter);
+            // Tracked on the HOST so that disposing the host — not just the
+            // worker — is enough to remove this bridge if the caller never
+            // disposes the worker itself. See `ownedWorkerLogBridgeDetachers`.
+            const detachBridge = () => {
+                logger.removeScopedEventEmitter(workerLogInstanceId, bridgeEmitter);
+                this.ownedWorkerLogBridgeDetachers.delete(detachBridge);
+            };
+            this.ownedWorkerLogBridgeDetachers.add(detachBridge);
             const originalDispose = worker.dispose.bind(worker);
             worker.dispose = async () => {
-                hostEmitter.off("log-event", forward);
+                detachBridge();
                 await originalDispose();
             };
         }
@@ -14007,6 +14083,10 @@ Current user's request: ${currentInput}`;
                     // Clear only if this instance's emitter is the active log sink —
                     // disposing a worker instance must not yank the host's bridge.
                     logger.clearEventEmitter(this.emitter);
+                    // Scoped sinks live on the process-global logger, keyed by this
+                    // instance's id — they outlive `this.emitter` and must be dropped
+                    // explicitly or the sink (and its closure) leaks for the process.
+                    logger.clearScopedEventEmitters(this.logInstanceId);
                     logger.debug("[NeuroLink] Event listeners removed successfully");
                 }
                 catch (error) {
@@ -14017,6 +14097,26 @@ Current user's request: ${currentInput}`;
                     logger.warn("[NeuroLink] Error removing event listeners:", error);
                 }
             }
+            // 4a. Detach any worker log bridges this instance created (via
+            // createWorkerInstance({ onLog })) that the caller never disposed
+            // individually. Their scoped sink lives on the process-global logger
+            // keyed by the WORKER's id, so it would otherwise outlive this host.
+            if (this.ownedWorkerLogBridgeDetachers.size > 0) {
+                try {
+                    const count = this.ownedWorkerLogBridgeDetachers.size;
+                    for (const detach of [...this.ownedWorkerLogBridgeDetachers]) {
+                        detach();
+                    }
+                    logger.debug(`[NeuroLink] Detached ${count} undisposed worker log bridge(s)`);
+                }
+                catch (error) {
+                    const err = error instanceof Error
+                        ? error
+                        : new Error(`Worker log bridge cleanup error: ${String(error)}`);
+                    cleanupErrors.push(err);
+                    logger.warn("[NeuroLink] Error detaching worker log bridges:", error);
+                }
+            }
             // 5. Clear all circuit breakers
             if (this.toolCircuitBreakers && this.toolCircuitBreakers.size > 0) {
                 try {

package/dist/providers/catalog/index.generated.d.ts

@@ -1,3 +1,3 @@
 import type { ProviderCatalogJson } from "../../types/index.js";
 export declare const CATALOG_JSON_ENTRIES: ProviderCatalogJson[];
-export declare const CATALOG_PROVIDER_IDS: readonly ["api-route", "baseten", "cerebras", "cloudflare", "deepseek", "fireworks", "friendli", "gmicloud", "groq", "huggingface", "inception-labs", "io-intelligence", "mancer", "mistral", "perplexity", "sambanova", "together-ai", "upstage", "xai"];
+export declare const CATALOG_PROVIDER_IDS: readonly ["api-route", "baseten", "cerebras", "cloudflare", "deepseek", "fireworks", "friendli", "gmicloud", "groq", "huggingface", "inception-labs", "io-intelligence", "mancer", "mistral", "morph", "novita", "perplexity", "sambanova", "together-ai", "upstage", "xai"];

package/dist/providers/catalog/index.generated.js

@@ -14,6 +14,8 @@ import inceptionLabsJson from "./inception-labs.json" with { type: "json" };
 import ioIntelligenceJson from "./io-intelligence.json" with { type: "json" };
 import mancerJson from "./mancer.json" with { type: "json" };
 import mistralJson from "./mistral.json" with { type: "json" };
+import morphJson from "./morph.json" with { type: "json" };
+import novitaJson from "./novita.json" with { type: "json" };
 import perplexityJson from "./perplexity.json" with { type: "json" };
 import sambanovaJson from "./sambanova.json" with { type: "json" };
 import togetherAiJson from "./together-ai.json" with { type: "json" };
@@ -34,6 +36,8 @@ export const CATALOG_JSON_ENTRIES = [
     ioIntelligenceJson,
     mancerJson,
     mistralJson,
+    morphJson,
+    novitaJson,
     perplexityJson,
     sambanovaJson,
     togetherAiJson,
@@ -55,6 +59,8 @@ export const CATALOG_PROVIDER_IDS = [
     "io-intelligence",
     "mancer",
     "mistral",
+    "morph",
+    "novita",
     "perplexity",
     "sambanova",
     "together-ai",

package/dist/providers/catalog/morph.json

@@ -0,0 +1,97 @@
+{
+    "$schema": "./provider-catalog.schema.json",
+    "id": "morph",
+    "displayName": "Morph",
+    "aliases": ["morphllm"],
+    "tier": 2,
+    "wire": {
+        "baseURL": "https://api.morphllm.com/v1"
+    },
+    "models": {
+        "default": "morph-v3-large",
+        "fallbacks": ["morph-v3-large", "morph-v3-fast"],
+        "defaultContextWindow": 262144,
+        "defaultMaxOutputTokens": 131072,
+        "catalog": {
+            "morph-v3-large": {
+                "contextWindow": 262144,
+                "maxOutputTokens": 131072,
+                "pricingPerMTok": {
+                    "input": 0.9,
+                    "output": 1.9
+                },
+                "vision": false,
+                "status": "production",
+                "description": "Recommended - Morph's high-accuracy Fast Apply model for complex code edits (2500+ tok/sec, 98% accuracy); the general-purpose choice of Morph's two chat-usable models. Does not honour the OpenAI tool-calling contract: with tools attached it emits the call as literal <tool_call> text in message.content instead of a tool_calls array"
+            },
+            "morph-v3-fast": {
+                "contextWindow": 262144,
+                "maxOutputTokens": 131072,
+                "pricingPerMTok": {
+                    "input": 0.8,
+                    "output": 1.2
+                },
+                "vision": false,
+                "status": "production",
+                "description": "Morph's fastest Fast Apply model, purpose-built for applying code edits (10,500+ tok/sec, 96% accuracy) rather than general chat. Ignores the tools parameter outright and returns unrelated generated text instead of a tool call"
+            }
+        },
+        "topModels": ["morph-v3-large", "morph-v3-fast"]
+    },
+    "capabilities": {
+        "text": true,
+        "streaming": true,
+        "tools": false,
+        "toolsWithStreaming": false,
+        "structuredOutput": true,
+        "structuredOutputWithTools": false,
+        "embeddings": false,
+        "thinking": false
+    },
+    "errorRules": [
+        {
+            "status": 401,
+            "pattern": "API key required",
+            "class": "authentication",
+            "message": "Invalid or missing Morph API key. Check {apiKeyEnvVar}. Get one at https://morphllm.com/dashboard"
+        },
+        {
+            "status": 400,
+            "pattern": "is not served by this endpoint",
+            "class": "invalid-model",
+            "message": "Morph model '{model}' is not served by this endpoint. Pick a current model from the authenticated GET /v1/models roster or https://morphllm.com/dashboard."
+        }
+    ],
+    "setup": {
+        "url": "https://morphllm.com/dashboard",
+        "apiKeyFormat": null,
+        "billingPolicy": "free-with-card",
+        "description": "API key",
+        "instructions": [
+            "1. Visit: https://morphllm.com/dashboard and sign in",
+            "2. A card on file is required; the account is rate-limited (5 req/min) until one is added",
+            "3. Create an API key on the dashboard",
+            "4. Set {apiKeyEnvVar} in your .env file"
+        ]
+    },
+    "quirks": {
+        "messageContentFormat": "string"
+    },
+    "evidence": {
+        "rosterVerified": {
+            "date": "2026-09-05",
+            "method": "authenticated GET /v1/models",
+            "status": 200
+        },
+        "authProbe": {
+            "date": "2026-09-05",
+            "status": 401,
+            "code": "invalid_api_key"
+        },
+        "liveMatrix": {
+            "date": "2026-09-05",
+            "result": "Full wire probe on morph-v3-fast plus a focused tool-calling re-probe on both chat models. Non-tool basics all 200: chat, max_completion_tokens, system role, sampling params, SSE streaming (content deltas, usage chunk, [DONE]), json_schema (valid JSON matching schema) and json_object. Array-shaped message content is REJECTED with HTTP 500 'Request processing failed: text.charCodeAt is not a function' — same class of quirk as Cloudflare (PR #1587); messageContentFormat is set to 'string' and vision is false because the vision probe sends array parts and hits the identical 500. Tool calling does NOT work despite HTTP 200: morph-v3-large echoes the call as literal '<tool_call>{...}</tool_call>' text in message.content, and morph-v3-fast ignores the tools parameter and returns unrelated generated text (Python source) with finish_reason=length. tools and toolsWithStreaming are declared false on that basis; tools_plus_schema returning 200 is not evidence of structuredOutputWithTools since tools do not actually work. structuredOutput is true and strong (schema-conformant JSON, json_object accepted). The GET /v1/models roster lists 22 ids (morph-v3-fast, morph-v3-large, auto, morph-compactor, morph-warp-grep-v2.1, and passthrough ids for GLM/DeepSeek/Kimi/Qwen/MiniMax/Gemma/computer-use), but a deliberately invalid model name on /chat/completions came back 'is not served by this endpoint; accepted models: morph-v0, morph-v2, morph-v3-fast, morph-v3-large' — none of those other 18 roster ids were live-verified against chat/completions, so only the two confirmed working chat models are catalogued; context window (262144) and max output tokens (131072) for both come from Morph's public model metadata (https://www.morphllm.com/api/models/json), which also supplied pricing. Morph is a code-application (Fast Apply) specialist, not a general chat vendor: morph-v3-large is catalogued as the default because it is the general-purpose one of the pair, while morph-v3-fast is purpose-built for edit application rather than open-ended conversation."
+        },
+        "addedInPR": "pending"
+    }
+}

package/dist/providers/catalog/novita.json

@@ -0,0 +1,114 @@
+{
+    "$schema": "./provider-catalog.schema.json",
+    "id": "novita",
+    "displayName": "Novita AI",
+    "aliases": [],
+    "tier": 2,
+    "wire": {
+        "baseURL": "https://api.novita.ai/openai/v1"
+    },
+    "models": {
+        "default": "zai-org/glm-5.3-flash",
+        "testModel": "zai-org/glm-5.3-flash",
+        "fallbacks": [
+            "meta-llama/llama-3.3-70b-instruct",
+            "deepseek/deepseek-v3-0324",
+            "qwen/qwen-2.5-72b-instruct",
+            "google/gemma-3-27b-it"
+        ],
+        "defaultContextWindow": 128000,
+        "defaultMaxOutputTokens": 4096,
+        "catalog": {
+            "meta-llama/llama-3.3-70b-instruct": {
+                "vision": false,
+                "status": "production",
+                "description": "Meta Llama 3.3 70B Instruct; a plain non-reasoning chat model. Kept as a fallback for plain chat because it does not support structured output; the runtime/default model is zai-org/glm-5.3-flash (see evidence.liveMatrix)"
+            },
+            "zai-org/glm-5.3-flash": {
+                "pricingPerMTok": {
+                    "input": 0.075,
+                    "output": 0.25,
+                    "cachedInput": 0.015
+                },
+                "vision": false,
+                "status": "production",
+                "description": "Zhipu GLM-5.3 Flash \u2014 Novita's own served default and the model exercised end-to-end by NeuroLink's live capability probe (chat, streaming, tool calling, tools+streaming, tools+schema together). Reasons internally via `reasoning_content` before answering, so it needs a generous max_tokens budget or replies get cut mid-thought \u2014 pin `testModel` here for the capability matrix. Pricing from the authenticated roster, 2026-09-05"
+            },
+            "deepseek/deepseek-v3-0324": {
+                "vision": false,
+                "status": "production",
+                "description": "DeepSeek V3 (0324 snapshot) \u2014 the non-reasoning DeepSeek chat line (the reasoning variant is deepseek/deepseek-r1); fallback"
+            },
+            "qwen/qwen-2.5-72b-instruct": {
+                "vision": false,
+                "status": "production",
+                "description": "Qwen 2.5 72B Instruct \u2014 plain (non-thinking) Alibaba Qwen chat model; fallback"
+            },
+            "google/gemma-3-27b-it": {
+                "vision": false,
+                "status": "production",
+                "description": "Google Gemma 3 27B IT \u2014 non-reasoning instruct chat model; fallback"
+            }
+        },
+        "topModels": [
+            "meta-llama/llama-3.3-70b-instruct",
+            "zai-org/glm-5.3-flash",
+            "deepseek/deepseek-v3-0324",
+            "qwen/qwen-2.5-72b-instruct",
+            "google/gemma-3-27b-it"
+        ]
+    },
+    "capabilities": {
+        "text": true,
+        "streaming": true,
+        "tools": true,
+        "toolsWithStreaming": true,
+        "structuredOutput": true,
+        "structuredOutputWithTools": true,
+        "embeddings": false,
+        "thinking": false
+    },
+    "errorRules": [
+        {
+            "status": 401,
+            "pattern": "failed to authenticate API key|FAILED_TO_AUTH",
+            "class": "authentication",
+            "message": "Invalid Novita API key. Check {apiKeyEnvVar}. Get one at https://novita.ai/settings/key-management"
+        },
+        {
+            "status": 404,
+            "pattern": "model not found|MODEL_NOT_FOUND",
+            "class": "invalid-model",
+            "message": "Novita model '{model}' not found. Pick a current model from the authenticated /openai/v1/models roster or https://novita.ai/models"
+        }
+    ],
+    "setup": {
+        "url": "https://novita.ai/settings/key-management",
+        "apiKeyFormat": "^sk_[A-Za-z0-9_-]+$",
+        "billingPolicy": "free-tier",
+        "instructions": [
+            "1. Visit: https://novita.ai/settings/key-management and sign in (Google, GitHub, Hugging Face, or email)",
+            "2. Choose Create API Key, name it, and copy it immediately \u2014 it is shown in full only once and starts with sk_",
+            "3. New accounts start on a small trial voucher (a few dollars of Model API credit); manual top-ups go through Stripe with a $10 minimum, so keep early test calls small",
+            "4. Set {apiKeyEnvVar} in your .env file"
+        ],
+        "description": "OpenAI-compatible endpoint at https://api.novita.ai/openai/v1. New accounts start on a small trial voucher; the roster spans 150+ open-weight chat, reasoning and vision-named models."
+    },
+    "evidence": {
+        "rosterVerified": {
+            "date": "2026-09-05",
+            "method": "authenticated GET /openai/v1/models \u2014 156 ids, e.g. zai-org/glm-5.3-flash, zai-org/glm-5.3, deepseek/deepseek-v4-pro-0813, moonshotai/kimi-k3",
+            "status": 200
+        },
+        "authProbe": {
+            "date": "2026-09-05",
+            "status": 401,
+            "code": "FAILED_TO_AUTH"
+        },
+        "liveMatrix": {
+            "date": "2026-09-05",
+            "result": "18-probe harness against zai-org/glm-5.3-flash (Novita's own served default) via https://api.novita.ai/openai/v1. Wire mechanics: chat, system role, array content parts, sampling params and max_completion_tokens all 200; SSE streaming 200 with a usage chunk and a terminal [DONE]. Reasoning is genuinely heavy on this model \u2014 several 200 responses show finish_reason=length with only 8 completion tokens, entirely spent on an unfinished reasoning_content and an empty visible content \u2014 but `default` and `testModel` are both pinned to the probed model itself (zai-org/glm-5.3-flash, Novita's own served default), which is exactly what the capability matrix below exercises — see the structured-output findings further down for why the reasoning-heavy default is still the right choice over the plain meta-llama/llama-3.3-70b-instruct fallback. Tool calling: a real tool_call (get_time, parsed tz argument) on the first turn, a null-content assistant tool_calls turn accepted on replay, and a tool_call surfacing mid-SSE-stream \u2014 tools and toolsWithStreaming true; tool_choice is tolerated even with no tools declared. response_format json_object returns 200 cleanly \u2014 structuredOutput true. response_format json_schema also returns 200, but at this token budget the content is unfinished reasoning text rather than schema-conformant JSON, same reasoning-budget effect as above \u2014 NeuroLink's coerceJsonToSchema repair layer is the safety net here, as for other reasoning-heavy vendors. Sending tools and a JSON schema together in one request succeeds (200, real tool_call returned) at the wire level. That single-shot result alone does not demonstrate the combined capability \u2014 the follow-up turn where the model must answer the original JSON-schema question from a tool result was untested at raw-probe time. It was proved separately through the SDK's public surface: `generate({ provider: 'novita', schema, ...})` with a registered getTime tool called end-to-end via dist/index.js \u2014 the model invoked getTime(tz='Asia/Tokyo') (toolsUsed=['getTime'], stepsUsed=2), then answered `{\"city\":\"Tokyo\",\"time\":\"09:00\"}`, which parsed against the request schema with no repair needed (jsonRepaired/jsonTruncated both unset) \u2014 passed 1/1 in the final live proof. structuredOutputWithTools is declared true on that basis. Vision: a 64x64 PNG sent to glm-5.3-flash (not a vision-tagged model; Novita has no live-verified vision model) returns 200 with reasoning_content correctly describing 'a solid blue rectangle' but an EMPTY final content \u2014 not a working, schema-usable vision reply, so no catalog entry is marked vision:true and models.visionModel is left unset. bad key -> 401 {\"code\":401,\"reason\":\"FAILED_TO_AUTH\",\"message\":\"failed to authenticate API key\"}; bad model -> 404 {\"code\":404,\"reason\":\"MODEL_NOT_FOUND\",\"message\":\"model not found\"}. Novita funds this account with a $1 Model API voucher, so only this one model was live-probed end-to-end; the other four catalog entries are roster-verified by id only, not capability-probed. Structured output on Novita is per-model, and the catalog schema can only express it per provider. Verified 2026-09-05 at the wire: meta-llama/llama-3.3-70b-instruct returns HTTP 400 for response_format json_schema (\"does not support 'json_schema' response format. Supported formats: json_object\") and also 400 for json_object, while zai-org/glm-5.3-flash returns 200 for json_object, json_schema and tools+json_schema together. The default is therefore zai-org/glm-5.3-flash, which is also Novita's own served default, so the provider-level structuredOutput and structuredOutputWithTools flags are true for the model a default-configuration caller actually gets. meta-llama/llama-3.3-70b-instruct remains a fallback for plain chat. Tool calling was verified separately on both models (finish_reason=tool_calls with a structured call). Note that glm-5.3-flash is a reasoning model: at very small max_tokens (observed at 40) the budget is consumed by reasoning and content comes back empty; the entry's defaultMaxOutputTokens of 4096 is well clear of that."
+        },
+        "addedInPR": "pending"
+    }
+}

package/dist/providers/openaiChatCompletionsBase.d.ts

@@ -265,6 +265,28 @@ export declare abstract class OpenAIChatCompletionsProvider extends BaseProvider
      * degrade one.
      */
     private reformatWithoutTools;
+    /**
+     * Resolve the parsed object for a `stream({ schema })` turn, after the
+     * stream has been drained.
+     *
+     * Before this, streaming never sent `response_format` under any condition —
+     * unlike the generate path, where the gap is only tools-dependent (see
+     * suppressResponseFormatWithTools), so `structuredData` was never available
+     * to a streaming caller at all. `executeStream` now sends `response_format`
+     * on the wire whenever a schema is present and tools aren't suppressing it;
+     * this method covers what's left: the common case where the streamed text
+     * already parses against the schema, and the tools-suppressed case, which is
+     * re-asked once without tools — the same recovery `reformatWithoutTools`
+     * performs for generate(), reusing its acceptance rule
+     * (`yieldsSchemaValidObject`) and its two-strategy fallback (native
+     * `response_format` first, the schema spelled into the prompt if a vendor
+     * rejects that).
+     *
+     * Returns `undefined` on every failure path rather than throwing: a turn
+     * whose text the caller has already consumed and streamed to their UI must
+     * not be turned into an error by a follow-up they never asked for.
+     */
+    private resolveStreamStructuredData;
     protected executeStream(options: StreamOptions, _analysisSchema?: ZodUnknownSchema | Schema<unknown>): Promise<StreamResult>;
     private runStreamLoop;
     private streamOneStep;