@juspay/neurolink 12.14.8 → 12.14.10

package/dist/cli/commands/config.js

@@ -87,7 +87,7 @@ const ConfigSchema = z.object({
         huggingface: z
             .object({
             apiKey: z.string().optional(),
-            model: z.string().default("microsoft/DialoGPT-large"),
+            model: z.string().default("Qwen/Qwen2.5-72B-Instruct"),
         })
             .optional(),
         ollama: z
@@ -783,7 +783,7 @@ export class ConfigManager {
                 type: "input",
                 name: "model",
                 message: "Model name:",
-                default: "microsoft/DialoGPT-large",
+                default: "Qwen/Qwen2.5-72B-Instruct",
             },
         ]);
         this.config.providers.huggingface = answers;

package/dist/cli/commands/setup-huggingface.js

@@ -92,26 +92,34 @@ export const handleHuggingFaceSetup = async (argv) => {
                 type: "select",
                 name: "modelChoice",
                 message: "Select a Hugging Face model:",
+                // Router-served ids only. The previous five options
+                // (DialoGPT-large/medium/small, blenderbot-400M-distill) are all
+                // absent from the router catalogue and answer 400 on every request,
+                // so this wizard wrote a dead model into the user's .env.
                 choices: [
                     {
-                        name: "Skip - use default (microsoft/DialoGPT-large)",
+                        name: "Skip - use default (Qwen/Qwen2.5-72B-Instruct)",
                         value: "default",
                     },
                     {
-                        name: "microsoft/DialoGPT-large (Conversational AI - Recommended)",
-                        value: "microsoft/DialoGPT-large",
+                        name: "Qwen/Qwen2.5-72B-Instruct (Recommended - tool-capable)",
+                        value: "Qwen/Qwen2.5-72B-Instruct",
                     },
                     {
-                        name: "microsoft/DialoGPT-medium (Faster, smaller)",
-                        value: "microsoft/DialoGPT-medium",
+                        name: "meta-llama/Llama-3.1-8B-Instruct (Fastest)",
+                        value: "meta-llama/Llama-3.1-8B-Instruct",
                     },
                     {
-                        name: "facebook/blenderbot-400M-distill (General purpose)",
-                        value: "facebook/blenderbot-400M-distill",
+                        name: "meta-llama/Llama-3.3-70B-Instruct (Stronger reasoning)",
+                        value: "meta-llama/Llama-3.3-70B-Instruct",
                     },
                     {
-                        name: "microsoft/DialoGPT-small (Fastest)",
-                        value: "microsoft/DialoGPT-small",
+                        name: "deepseek-ai/DeepSeek-V3 (Highest quality)",
+                        value: "deepseek-ai/DeepSeek-V3",
+                    },
+                    {
+                        name: "Qwen/Qwen2.5-Coder-32B-Instruct (Code-focused)",
+                        value: "Qwen/Qwen2.5-Coder-32B-Instruct",
                     },
                     {
                         name: "Custom model name",
@@ -134,7 +142,7 @@ export const handleHuggingFaceSetup = async (argv) => {
                             return "Model name is required";
                         }
                         if (!trimmed.includes("/")) {
-                            return "Model name should include organization (e.g., 'microsoft/DialoGPT-large')";
+                            return "Model name should include organization (e.g., 'Qwen/Qwen2.5-72B-Instruct')";
                         }
                         return true;
                     },
@@ -173,7 +181,7 @@ export const handleHuggingFaceSetup = async (argv) => {
         }
         else {
             logger.always(chalk.gray('   neurolink generate "Tell me a story" --provider huggingface'));
-            logger.always(chalk.gray('   neurolink generate "Explain AI" --provider huggingface --model microsoft/DialoGPT-medium'));
+            logger.always(chalk.gray('   neurolink generate "Explain AI" --provider huggingface --model Qwen/Qwen2.5-72B-Instruct'));
         }
         logger.always(chalk.blue("\n🔗 Resources:"));
         logger.always(chalk.gray("   • Hugging Face Models: https://huggingface.co/models"));

package/dist/core/modelConfiguration.d.ts

@@ -51,9 +51,9 @@ export declare const MODEL_NAMES: {
         readonly QUALITY: "llama3.1:70b";
     };
     readonly HUGGINGFACE: {
-        readonly FAST: "microsoft/DialoGPT-medium";
-        readonly BALANCED: "microsoft/DialoGPT-large";
-        readonly QUALITY: "meta-llama/Llama-2-7b-chat-hf";
+        readonly FAST: "meta-llama/Llama-3.1-8B-Instruct";
+        readonly BALANCED: "Qwen/Qwen2.5-72B-Instruct";
+        readonly QUALITY: "deepseek-ai/DeepSeek-V3";
     };
     readonly MISTRAL: {
         readonly FAST: "mistral-small-latest";

package/dist/core/modelConfiguration.js

@@ -58,11 +58,13 @@ export const MODEL_NAMES = {
         BALANCED: "llama3.1:8b",
         QUALITY: "llama3.1:70b",
     },
-    // HuggingFace Models
+    // HuggingFace Models — router-served ids. The previous three
+    // (DialoGPT-medium / -large, Llama-2-7b-chat-hf) are absent from the
+    // router catalogue and answer 400 on every request.
     HUGGINGFACE: {
-        FAST: "microsoft/DialoGPT-medium",
-        BALANCED: "microsoft/DialoGPT-large",
-        QUALITY: "meta-llama/Llama-2-7b-chat-hf",
+        FAST: "meta-llama/Llama-3.1-8B-Instruct",
+        BALANCED: "Qwen/Qwen2.5-72B-Instruct",
+        QUALITY: "deepseek-ai/DeepSeek-V3",
     },
     // Mistral Models
     MISTRAL: {

package/dist/index.d.ts

@@ -46,6 +46,7 @@ export { createApiKeyAuthInterceptor, createBearerAuthInterceptor, createDynamic
 export { SSEClient, WebSocketStreamingClient, createStreamingClient, createAsyncStream, collectStream, } from "./client/streamingClient.js";
 export { OAuth2TokenManager, JWTTokenManager, createApiKeyMiddleware, createBearerTokenMiddleware, createTokenManagerMiddleware, createAuthWithRetryMiddleware, createMultiAuthMiddleware, OAuth2Error, OAuth2AuthenticationError as OAuth2AuthError, TokenRefreshError, decodeJWTPayload, isJWTExpired, getJWTExpiry, getApiKeyFromEnv, } from "./client/auth.js";
 export { ErrorCode as ClientErrorCode, NeuroLinkError as ClientNeuroLinkError, HttpError, ClientRateLimitError, ClientValidationError, ClientAuthenticationError, ClientAuthorizationError, NotFoundError, ClientNetworkError, ClientTimeoutError, ClientConnectionError, AbortError, ClientConfigurationError, StreamError, ClientProviderError, ContextLengthError, ContentFilterError, createErrorFromResponse, createErrorFromNative, mapStatusToErrorCode, isRetryableStatus, isRetryableError, isNeuroLinkError, isApiError, } from "./client/errors.js";
+export { BaseError, ProviderError, AuthenticationError, AuthorizationError, NetworkError, RateLimitError, InvalidModelError, } from "./types/index.js";
 export { AIProviderName, BedrockModels, OpenAIModels, VertexModels, } from "./constants/enums.js";
 export { dynamicModelProvider } from "./core/dynamicModels.js";
 export { validateTool } from "./sdk/toolRegistration.js";

package/dist/index.js

@@ -73,6 +73,17 @@ OAuth2TokenManager, JWTTokenManager, createApiKeyMiddleware, createBearerTokenMi
 export { 
 // Errors
 ErrorCode as ClientErrorCode, NeuroLinkError as ClientNeuroLinkError, HttpError, ClientRateLimitError, ClientValidationError, ClientAuthenticationError, ClientAuthorizationError, NotFoundError, ClientNetworkError, ClientTimeoutError, ClientConnectionError, AbortError, ClientConfigurationError, StreamError, ClientProviderError, ContextLengthError, ContentFilterError, createErrorFromResponse, createErrorFromNative, mapStatusToErrorCode, isRetryableStatus, isRetryableError, isNeuroLinkError, isApiError, } from "./client/errors.js";
+// The SDK-side error hierarchy `classifyProviderError()` actually throws
+// (as opposed to the unrelated `Client*` REST-client errors above). These
+// already reach consumers transitively through `export * from
+// "./types/index.js"` below, but that makes them public by accident of the
+// types barrel's shape — a future reshuffle of that barrel could drop them
+// silently. Exporting them here, explicitly, by name, makes the guarantee
+// intentional: `catch (e) { if (e instanceof RateLimitError) ... }` against
+// `@juspay/neurolink` is a supported, stable pattern, not an implementation
+// detail a caller happened to be able to reach. Imported from the barrel
+// (never the specific `types/errors.js` file) per Critical Rule 13.
+export { BaseError, ProviderError, AuthenticationError, AuthorizationError, NetworkError, RateLimitError, InvalidModelError, } from "./types/index.js";
 export { AIProviderName, BedrockModels, OpenAIModels, VertexModels, } from "./constants/enums.js";
 // Dynamic Models exports
 export { dynamicModelProvider } from "./core/dynamicModels.js";

package/dist/mcp/servers/aiProviders/aiAnalysisTools.js

@@ -185,41 +185,54 @@ const _benchmarkProviderPerformanceTool = {
             ];
             const benchmarkResults = [];
             for (const providerName of providersToTest) {
-                const provider = await AIProviderFactory.createProvider(providerName);
-                if (!provider) {
+                try {
+                    const provider = await AIProviderFactory.createProvider(providerName);
+                    if (!provider) {
+                        benchmarkResults.push({
+                            provider: providerName,
+                            error: "Failed to create provider.",
+                        });
+                        continue;
+                    }
+                    let totalLatency = 0, totalTokens = 0, successfulTests = 0;
+                    for (const prompt of testPrompts) {
+                        for (let i = 0; i < typedParams.iterations; i++) {
+                            const testStartTime = Date.now();
+                            const result = await provider.generate({
+                                prompt: prompt,
+                                maxTokens: typedParams.maxTokens,
+                            });
+                            if (result && result.usage) {
+                                totalLatency += Date.now() - testStartTime;
+                                totalTokens += result.usage.total || 0;
+                                successfulTests++;
+                            }
+                        }
+                    }
                     benchmarkResults.push({
                         provider: providerName,
-                        error: "Failed to create provider.",
+                        metrics: {
+                            avgLatency: successfulTests > 0
+                                ? Math.round(totalLatency / successfulTests)
+                                : 0,
+                            total: totalTokens,
+                            successRate: (successfulTests /
+                                (testPrompts.length * typedParams.iterations)) *
+                                100,
+                        },
                     });
-                    continue;
                 }
-                let totalLatency = 0, totalTokens = 0, successfulTests = 0;
-                for (const prompt of testPrompts) {
-                    for (let i = 0; i < typedParams.iterations; i++) {
-                        const testStartTime = Date.now();
-                        const result = await provider.generate({
-                            prompt: prompt,
-                            maxTokens: typedParams.maxTokens,
-                        });
-                        if (result && result.usage) {
-                            totalLatency += Date.now() - testStartTime;
-                            totalTokens += result.usage.total || 0;
-                            successfulTests++;
-                        }
-                    }
+                catch (providerError) {
+                    // A single provider's failure (network, auth, rate-limit, etc.)
+                    // must not abort the whole benchmark — record it and keep testing
+                    // the remaining providers, mirroring the null-provider branch above.
+                    benchmarkResults.push({
+                        provider: providerName,
+                        error: providerError instanceof Error
+                            ? providerError.message
+                            : String(providerError),
+                    });
                 }
-                benchmarkResults.push({
-                    provider: providerName,
-                    metrics: {
-                        avgLatency: successfulTests > 0
-                            ? Math.round(totalLatency / successfulTests)
-                            : 0,
-                        total: totalTokens,
-                        successRate: (successfulTests /
-                            (testPrompts.length * typedParams.iterations)) *
-                            100,
-                    },
-                });
             }
             const executionTime = Date.now() - startTime;
             return {

package/dist/models/manifests/huggingface.d.ts

@@ -1,8 +1,11 @@
 import type { ProviderModelManifest } from "../../types/index.js";
 /**
  * Minimal manifest: huggingface has no MODEL_REGISTRY entries today, so
- * only the provider-wide fallback is known. Named models can be added here
- * incrementally without touching any consumer — see Task 5 of the model
- * metadata consolidation plan.
+ * only the provider-wide fallback is known. `functionCalling` is true
+ * because the router serves tool-calling models and returns `tool_calls` for
+ * them; it previously claimed false, contradicting the wire.
+ *
+ * Named models can be added here incrementally without touching any
+ * consumer — see Task 5 of the model metadata consolidation plan.
  */
 export declare const huggingfaceManifest: ProviderModelManifest;

package/dist/models/manifests/huggingface.js

@@ -1,8 +1,11 @@
 /**
  * Minimal manifest: huggingface has no MODEL_REGISTRY entries today, so
- * only the provider-wide fallback is known. Named models can be added here
- * incrementally without touching any consumer — see Task 5 of the model
- * metadata consolidation plan.
+ * only the provider-wide fallback is known. `functionCalling` is true
+ * because the router serves tool-calling models and returns `tool_calls` for
+ * them; it previously claimed false, contradicting the wire.
+ *
+ * Named models can be added here incrementally without touching any
+ * consumer — see Task 5 of the model metadata consolidation plan.
  */
 export const huggingfaceManifest = {
     defaultContextWindow: 32000,
@@ -12,7 +15,7 @@ export const huggingfaceManifest = {
             contextWindow: 32000,
             maxOutputTokens: 32000,
             vision: false,
-            functionCalling: false,
+            functionCalling: true,
         },
     },
 };

package/dist/neurolink.d.ts

@@ -1648,7 +1648,10 @@ export declare class NeuroLink {
      */
     testProvider(providerName: string): Promise<boolean>;
     /**
-     * Internal method to test provider connection with minimal generation call
+     * Internal method to test provider connection with minimal generation call.
+     * `signal` lets a caller (getProviderStatus's per-provider race) cancel the
+     * underlying request once it has already lost the race against its
+     * timeout, instead of leaving it running unobserved.
      */
     private testProviderConnection;
     /**

package/dist/neurolink.js

@@ -6490,6 +6490,14 @@ Current user's request: ${currentInput}`;
         if (lastError instanceof ContextBudgetExceededError) {
             throw lastError;
         }
+        // A single-candidate list (an explicit provider, or
+        // disableInternalFallback) never actually tried "all providers" —
+        // naming the one provider that failed is clearer than the generic
+        // multi-provider wording. The multi-provider prefix is left untouched
+        // so existing message-matching suites keep passing.
+        if (providersToTry.length === 1) {
+            throw new Error(`Provider ${providersToTry[0]} failed: ${lastError?.message || "Unknown error"}`);
+        }
         throw new Error(`Failed to generate text with all providers. Last error: ${lastError?.message || "Unknown error"}`);
     }
     /**
@@ -10863,13 +10871,36 @@ Current user's request: ${currentInput}`;
                         };
                     }
                 }
-                // Test other providers with actual generation call
+                // Test other providers with actual generation call. The losing
+                // side of the race is aborted in `finally` below — previously the
+                // timeout promise alone rejected while the still-running
+                // testProviderConnection() call (and the provider request inside
+                // it) kept executing to completion unobserved, wasting quota and
+                // holding the connection open past the 5s status check.
                 const testTimeout = 5000;
-                const testPromise = this.testProviderConnection(providerName);
+                const abortController = new AbortController();
+                const testPromise = this.testProviderConnection(providerName, abortController.signal);
+                let timeoutHandle;
                 const timeoutPromise = new Promise((_, reject) => {
-                    setTimeout(() => reject(new Error("Provider test timeout (5s)")), testTimeout);
+                    timeoutHandle = setTimeout(() => {
+                        reject(new Error("Provider test timeout (5s)"));
+                    }, testTimeout);
                 });
-                await Promise.race([testPromise, timeoutPromise]);
+                try {
+                    await Promise.race([testPromise, timeoutPromise]);
+                }
+                finally {
+                    // Runs on both outcomes: clears the timer so it can't fire after
+                    // a fast success, and aborts the signal so a timed-out
+                    // generate() call stops instead of finishing unobserved.
+                    clearTimeout(timeoutHandle);
+                    // The aborted generate() resolves/rejects after the race is
+                    // decided; swallow that settlement so it can't surface as an
+                    // unhandledRejection, mirroring raceWithAbort's handling of the
+                    // losing side.
+                    testPromise.catch(() => undefined);
+                    abortController.abort();
+                }
                 return {
                     provider: providerName,
                     status: "working",
@@ -10919,15 +10950,19 @@ Current user's request: ${currentInput}`;
         }
     }
     /**
-     * Internal method to test provider connection with minimal generation call
+     * Internal method to test provider connection with minimal generation call.
+     * `signal` lets a caller (getProviderStatus's per-provider race) cancel the
+     * underlying request once it has already lost the race against its
+     * timeout, instead of leaving it running unobserved.
      */
-    async testProviderConnection(providerName) {
+    async testProviderConnection(providerName, signal) {
         const { AIProviderFactory } = await import("./core/factory.js");
         const provider = await AIProviderFactory.createProvider(providerName, null);
         await provider.generate({
             prompt: "test",
             maxTokens: 1,
             disableTools: true,
+            abortSignal: signal,
         });
     }
     /**

package/dist/providers/azureOpenai.js

@@ -172,7 +172,7 @@ export class AzureOpenAIProvider extends OpenAIChatCompletionsProvider {
             },
             ...DEFAULT_ERROR_RULES,
         ];
-        return classifyProviderError(error, rules, "azure", this.modelName);
+        return classifyProviderError(error, rules, this.providerName, this.modelName);
     }
     // ===========================================================================
     // New overridable hooks (provided by the base-enhancement branch)

package/dist/providers/catalog/loader.d.ts

@@ -2,5 +2,5 @@ import type { OpenAICompatCatalogEntry, ProviderCatalogJson, ProviderConfigOptio
 export declare function catalogCredentialsKey(entry: ProviderCatalogJson): string;
 export declare function catalogEnvVar(entry: ProviderCatalogJson, kind: "apiKey" | "baseURL" | "model"): string;
 export declare function buildCatalogConfigOptions(entry: ProviderCatalogJson): ProviderConfigOptions;
-export declare function getCatalogJsonEntries(): ProviderCatalogJson[];
+export declare function getCatalogJsonEntries(): readonly ProviderCatalogJson[];
 export declare function buildCatalogEntries(): OpenAICompatCatalogEntry[];

package/dist/providers/catalog/loader.js

@@ -70,8 +70,37 @@ function buildErrorRules(entry) {
     });
     return [...bespoke, ...DEFAULT_ERROR_RULES];
 }
+// Recursively freezes a value in place and returns it. Used only on a
+// structuredClone()d graph below — never on CATALOG_JSON_ENTRIES itself —
+// so this never touches the module-level singleton.
+function deepFreeze(value) {
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            deepFreeze(item);
+        }
+        return Object.freeze(value);
+    }
+    if (value !== null && typeof value === "object") {
+        for (const key of Object.keys(value)) {
+            deepFreeze(value[key]);
+        }
+        return Object.freeze(value);
+    }
+    return value;
+}
+// Returns a deep clone of the catalog graph, frozen at every level, never
+// the module-level singleton by reference or anything sharing its nested
+// objects/arrays — CATALOG_JSON_ENTRIES is reused on every call, so handing
+// out (a shallow copy of) the live array would let any one caller's
+// mutation corrupt catalog state for the rest of the process, and freezing
+// only the outer array left `entry.aliases`, `entry.models.fallbacks`,
+// `entry.models.catalog` etc. shared and mutable despite the `readonly`
+// return type. structuredClone() first (so the frozen graph never aliases
+// CATALOG_JSON_ENTRIES's own objects), then deepFreeze() the clone. All
+// current callers only .find/.map/.flatMap/.filter/iterate, so this is
+// behavior-preserving for them.
 export function getCatalogJsonEntries() {
-    return CATALOG_JSON_ENTRIES;
+    return deepFreeze(structuredClone(CATALOG_JSON_ENTRIES));
 }
 export function buildCatalogEntries() {
     return CATALOG_JSON_ENTRIES.map((entry) => {

package/dist/providers/cohere.js

@@ -87,7 +87,7 @@ export class CohereProvider extends OpenAIChatCompletionsProvider {
             },
             ...DEFAULT_ERROR_RULES,
         ];
-        return classifyProviderError(error, rules, "cohere", this.modelName);
+        return classifyProviderError(error, rules, this.providerName, this.modelName);
     }
     async validateConfiguration() {
         return (typeof this.config.apiKey === "string" &&

package/dist/providers/deepseek.js

@@ -89,7 +89,7 @@ export class DeepSeekProvider extends OpenAIChatCompletionsProvider {
             },
             ...DEFAULT_ERROR_RULES,
         ];
-        return classifyProviderError(error, rules, "deepseek", this.modelName);
+        return classifyProviderError(error, rules, this.providerName, this.modelName);
     }
     // ===========================================================================
     // Optional hooks — provider-specific quirks

package/dist/providers/googleAiStudio/client.js

@@ -1289,12 +1289,13 @@ export class GoogleAIStudioProvider extends BaseProvider {
             ...options,
             tools: baseTools,
         };
-        // Check for tools + JSON schema conflict (Gemini limitation)
+        // Check for tools + JSON schema conflict, via the shared predicate (same
+        // gate executeStream() and executeNativeGemini3Generate() use) so this
+        // path also honors isGeminiProvider/isNativeAnthropicProvider instead of
+        // hand-rolling its own tools+schema condition.
         const wantsJsonOutput = options.output?.format === "json" || options.schema;
-        if (wantsJsonOutput &&
-            mergedOptions.tools &&
-            Object.keys(mergedOptions.tools).length > 0 &&
-            !mergedOptions.disableTools) {
+        const exclusionInForce = isToolsSchemaExclusionInForce(this.providerName, modelName, !mergedOptions.disableTools, Object.keys(mergedOptions.tools ?? {}).length);
+        if (wantsJsonOutput && exclusionInForce) {
             logger.warn("[GoogleAIStudio] Gemini does not support tools and JSON schema output simultaneously. Disabling tools for this request.");
             mergedOptions = { ...mergedOptions, disableTools: true, tools: {} };
         }

package/dist/providers/googleVertex/client.d.ts

@@ -138,32 +138,6 @@ export declare class GoogleVertexProvider extends BaseProvider {
      * this purpose.
      */
     private resolveExpressApiKey;
-    /**
-     * Convert one AI-SDK tool into a Vertex Gemini function declaration.
-     * Single source for the pre-loop snapshot AND the mid-turn discovery
-     * refresh, so tools hydrated by search_tools get the exact same schema
-     * treatment (inline, typed, additionalProperties stripped).
-     */
-    private buildGeminiFunctionDeclaration;
-    /**
-     * Mid-turn tool sync for the native Gemini loops. `search_tools` hydrates
-     * discovered tools into the live `options.tools` record between steps, but
-     * the loop's declarations + executeMap are a pre-loop snapshot — without
-     * this refresh, a tool discovered this turn stays invisible to the rest of
-     * the turn and every call to it dies as TOOL_NOT_FOUND. Mutates the
-     * declaration array in place (the request config holds it by reference)
-     * and clears breaker strikes accrued while the tool was still deferred.
-     */
-    private refreshGeminiToolDeclarations;
-    /**
-     * Dispatch-miss recovery for the native Gemini loops: the model called a
-     * name missing from the executeMap snapshot. Re-read the live record (a
-     * tool hydrated by search_tools in this very step batch) or auto-hydrate a
-     * deferred catalog tool the model called directly by its advertised name.
-     * Returns the dedup-wrapped executor, or undefined when the name is
-     * genuinely unknown — callers keep TOOL_NOT_FOUND for that case.
-     */
-    private resolveGeminiToolOnMiss;
     /**
      * Convert one AI-SDK tool into an Anthropic (Claude-on-Vertex) tool
      * declaration. Single source for the pre-loop snapshot AND the mid-turn
@@ -174,18 +148,25 @@ export declare class GoogleVertexProvider extends BaseProvider {
      */
     private buildAnthropicToolDeclaration;
     /**
-     * Mid-turn tool sync for the Claude-on-Vertex loops — the Anthropic
-     * counterpart of refreshGeminiToolDeclarations. Claude only calls tools
+     * Mid-turn tool sync for the Claude-on-Vertex loops. Claude only calls tools
      * present in the request's `tools` array, so without this per-step refresh
      * a tool discovered via search_tools is unreachable for the rest of the
      * turn. Mutates the array in place (requestParams holds it by reference).
      */
     private refreshAnthropicToolDeclarations;
     /**
-     * Dispatch-miss recovery for the Claude-on-Vertex loops — the Anthropic
-     * counterpart of resolveGeminiToolOnMiss.
+     * Dispatch-miss recovery for the Claude-on-Vertex loops.
      */
     private resolveAnthropicToolOnMiss;
+    /**
+     * Build the synthetic `final_result` tool used to force structured output
+     * on Claude-on-Vertex. Anthropic has no native responseSchema, so a schema
+     * is instead enforced by requiring the model to call this tool with
+     * matching arguments. Single source for the non-streaming and streaming
+     * paths — both previously built this object independently from their own
+     * schema variable, byte-identical apart from that variable's name.
+     */
+    private buildFinalResultTool;
     /**
      * Execute stream using native @google/genai SDK for Gemini 3 models on Vertex AI
      * This bypasses @ai-sdk/google-vertex to properly handle thought_signature