@juspay/neurolink 12.14.8 → 12.14.9

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/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

package/dist/providers/googleVertex/client.js

@@ -977,9 +977,13 @@ export class GoogleVertexProvider extends BaseProvider {
     async createVertexGenAIClient(regionOverride) {
         warnGoogleSdkIgnoresProxy("GoogleVertex");
         const expressApiKey = this.resolveExpressApiKey();
-        // Resolved only on the ADC path: getVertexProjectId() throws when no
-        // project is configured, which an Express request legitimately has none of.
-        const project = expressApiKey ? "" : getVertexProjectId();
+        // Resolved only on the ADC path, and from the per-instance projectId the
+        // constructor already settled (credentials.projectId if supplied, else
+        // the same ambient getVertexProjectId() fallback) — not re-read from
+        // ambient env here, or a per-request projectId override would be built
+        // into the client with the wrong project while call sites elsewhere
+        // (generateContent's `project:` param) correctly used this.projectId.
+        const project = expressApiKey ? "" : this.projectId;
         const location = regionOverride || this.location || getVertexLocation();
         const mod = await import("@google/genai");
         const ctor = mod.GoogleGenAI;
@@ -1060,94 +1064,6 @@ export class GoogleVertexProvider extends BaseProvider {
         ].some((name) => (process.env[name] ?? "").trim().length > 0);
         return projectConfigured ? undefined : fromEnv;
     }
-    /**
-     * 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).
-     */
-    buildGeminiFunctionDeclaration(name, tool) {
-        const decl = {
-            name,
-            description: tool.description || `Tool: ${name}`,
-        };
-        // Access legacy `parameters` (AI SDK v3/v4) or current `inputSchema` (v6)
-        const legacyTool = tool;
-        const toolParams = legacyTool.parameters || tool.inputSchema;
-        if (toolParams) {
-            // Convert and inline schema to resolve $ref/definitions
-            const rawSchema = convertZodToJsonSchema(toolParams, "openApi3");
-            const inlinedSchema = inlineJsonSchema(rawSchema);
-            // Remove $schema if present - @google/genai doesn't need it
-            if (inlinedSchema.$schema) {
-                delete inlinedSchema.$schema;
-            }
-            // CRITICAL: Google Vertex AI requires ALL nested schemas to have a type field
-            // ensureNestedSchemaTypes recursively adds missing type fields to tool schemas
-            // Note: convertZodToJsonSchema now uses openApi3 target which produces nullable: true
-            const typedSchema = ensureNestedSchemaTypes(inlinedSchema);
-            // Strip `additionalProperties` recursively — Vertex Gemini's
-            // function-call validator rejects it on object schemas (returns
-            // 400 INVALID_ARGUMENT) even though it's valid OpenAPI 3. The
-            // field has no semantic meaning to the model, so dropping it
-            // before send is safe for every caller.
-            stripAdditionalPropertiesDeep(typedSchema);
-            decl.parametersJsonSchema = typedSchema;
-        }
-        return decl;
-    }
-    /**
-     * 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.
-     */
-    refreshGeminiToolDeclarations(liveTools, declarations, executeMap, failedTools) {
-        if (!liveTools || !declarations) {
-            return;
-        }
-        const declared = new Set(declarations.map((d) => d.name));
-        for (const [name, tool] of Object.entries(liveTools)) {
-            if (declared.has(name)) {
-                continue;
-            }
-            declarations.push(this.buildGeminiFunctionDeclaration(name, tool));
-            if (tool.execute) {
-                executeMap.set(name, tool.execute);
-            }
-            failedTools.delete(name);
-            logger.info(`[GoogleVertex] Tool "${name}" hydrated mid-turn via discovery — added to Gemini declarations.`);
-        }
-    }
-    /**
-     * 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.
-     */
-    resolveGeminiToolOnMiss(name, liveTools, declarations, executeMap, failedTools) {
-        if (!declarations) {
-            return undefined;
-        }
-        const tool = resolveLiveTool(liveTools, name);
-        if (!tool?.execute) {
-            return undefined;
-        }
-        if (!declarations.some((d) => d.name === name)) {
-            declarations.push(this.buildGeminiFunctionDeclaration(name, tool));
-        }
-        executeMap.set(name, tool.execute);
-        // NOT_FOUND strikes accrued while the tool was deferred are snapshot
-        // artifacts, not real failures — reset so the breaker starts clean.
-        failedTools.delete(name);
-        logger.info(`[GoogleVertex] Tool "${name}" resolved mid-turn via discovery — executing.`);
-        return executeMap.get(name);
-    }
     /**
      * Convert one AI-SDK tool into an Anthropic (Claude-on-Vertex) tool
      * declaration. Single source for the pre-loop snapshot AND the mid-turn
@@ -1179,8 +1095,7 @@ export class GoogleVertexProvider extends BaseProvider {
         return anthropicTool;
     }
     /**
-     * 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).
@@ -1203,8 +1118,7 @@ export class GoogleVertexProvider extends BaseProvider {
         }
     }
     /**
-     * Dispatch-miss recovery for the Claude-on-Vertex loops — the Anthropic
-     * counterpart of resolveGeminiToolOnMiss.
+     * Dispatch-miss recovery for the Claude-on-Vertex loops.
      */
     resolveAnthropicToolOnMiss(name, liveTools, declarations, executeMap, failedTools) {
         if (!declarations) {
@@ -1222,6 +1136,31 @@ export class GoogleVertexProvider extends BaseProvider {
         logger.info(`[GoogleVertex] Tool "${name}" resolved mid-turn via discovery — executing.`);
         return executeMap.get(name);
     }
+    /**
+     * 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.
+     */
+    buildFinalResultTool(schema) {
+        const schemaAsJson = convertZodToJsonSchema(schema);
+        const inlinedSchema = inlineJsonSchema(schemaAsJson);
+        if (inlinedSchema.$schema) {
+            delete inlinedSchema.$schema;
+        }
+        const typedSchema = ensureNestedSchemaTypes(inlinedSchema);
+        return {
+            name: "final_result",
+            description: "Return the final structured result. You MUST call this tool when you have gathered all information and are ready to provide the final answer. The arguments should contain the structured data matching the expected schema.",
+            input_schema: {
+                type: "object",
+                properties: typedSchema.properties || typedSchema,
+                required: typedSchema.required || [],
+            },
+        };
+    }
     /**
      * 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
@@ -3132,23 +3071,8 @@ export class GoogleVertexProvider extends BaseProvider {
         let schemaSystemPromptSuffix = "";
         if (streamOptions.schema) {
             useFinalResultTool = true;
-            // Convert schema to JSON schema format
-            const schemaAsJson = convertZodToJsonSchema(streamOptions.schema);
-            const inlinedSchema = inlineJsonSchema(schemaAsJson);
-            if (inlinedSchema.$schema) {
-                delete inlinedSchema.$schema;
-            }
-            const typedSchema = ensureNestedSchemaTypes(inlinedSchema);
             // Create final_result tool
-            const finalResultTool = {
-                name: "final_result",
-                description: "Return the final structured result. You MUST call this tool when you have gathered all information and are ready to provide the final answer. The arguments should contain the structured data matching the expected schema.",
-                input_schema: {
-                    type: "object",
-                    properties: typedSchema.properties || typedSchema,
-                    required: typedSchema.required || [],
-                },
-            };
+            const finalResultTool = this.buildFinalResultTool(streamOptions.schema);
             // Add to tools array or create new array
             if (!tools) {
                 tools = [];
@@ -3158,7 +3082,7 @@ export class GoogleVertexProvider extends BaseProvider {
             schemaSystemPromptSuffix =
                 "\n\nIMPORTANT: You MUST call the 'final_result' tool to return your response in the required structured format. Do not respond with plain text - always use the final_result tool.";
             logger.debug("[GoogleVertex] Added final_result tool for Anthropic structured output (stream)", {
-                schemaKeys: Object.keys(typedSchema),
+                schemaKeys: Object.keys(finalResultTool.input_schema.properties ?? {}),
                 totalTools: tools.length,
             });
         }
@@ -3719,10 +3643,19 @@ export class GoogleVertexProvider extends BaseProvider {
                     // with text in step 2 would look unfinished and fall into terminal
                     // handling. The finish reason is the per-turn signal — the engine
                     // reports "tool-calls" only when the cap was hit with tools still
-                    // pending.
+                    // pending. That signal is not enough on its own, though: Anthropic
+                    // reports stop_reason "tool_use" — which maps to finishReason
+                    // "tool-calls" — for ANY tool_use block, including a genuine
+                    // terminal `final_result` call. Without the third clause, a turn
+                    // that called a real tool earlier (toolCalls.length > 0) and then
+                    // legitimately finished via final_result reads as unfinished and
+                    // falls into the terminal-handling block below, which forces a
+                    // redundant second final_result call and pushes its JSON onto the
+                    // stream a second time.
                     modelFinished =
                         engineResult.toolCalls.length === 0 ||
-                            engineResult.finishReason !== "tool-calls";
+                            engineResult.finishReason !== "tool-calls" ||
+                            (useFinalResultTool && structuredOutputRef.value !== undefined);
                     // Replace in place: the terminal block and the finalization call both
                     // read `currentMessages`.
                     currentMessages.length = 0;
@@ -4361,23 +4294,8 @@ export class GoogleVertexProvider extends BaseProvider {
         let schemaSystemPromptSuffix = "";
         if (options.schema) {
             useFinalResultTool = true;
-            // Convert schema to JSON schema format
-            const schemaAsJson = convertZodToJsonSchema(options.schema);
-            const inlinedSchema = inlineJsonSchema(schemaAsJson);
-            if (inlinedSchema.$schema) {
-                delete inlinedSchema.$schema;
-            }
-            const typedSchema = ensureNestedSchemaTypes(inlinedSchema);
             // Create final_result tool
-            const finalResultTool = {
-                name: "final_result",
-                description: "Return the final structured result. You MUST call this tool when you have gathered all information and are ready to provide the final answer. The arguments should contain the structured data matching the expected schema.",
-                input_schema: {
-                    type: "object",
-                    properties: typedSchema.properties || typedSchema,
-                    required: typedSchema.required || [],
-                },
-            };
+            const finalResultTool = this.buildFinalResultTool(options.schema);
             // Add to tools array or create new array
             if (!tools) {
                 tools = [];
@@ -4387,7 +4305,7 @@ export class GoogleVertexProvider extends BaseProvider {
             schemaSystemPromptSuffix =
                 "\n\nIMPORTANT: You MUST call the 'final_result' tool to return your response in the required structured format. Do not respond with plain text - always use the final_result tool.";
             logger.debug("[GoogleVertex] Added final_result tool for Anthropic structured output (generate)", {
-                schemaKeys: Object.keys(typedSchema),
+                schemaKeys: Object.keys(finalResultTool.input_schema.properties ?? {}),
                 totalTools: tools.length,
             });
         }

package/dist/providers/huggingFace/client.js

@@ -97,6 +97,6 @@ export class HuggingFaceProvider extends OpenAIChatCompletionsProvider {
             },
             ...DEFAULT_ERROR_RULES,
         ];
-        return classifyProviderError(error, rules, "huggingface", this.modelName);
+        return classifyProviderError(error, rules, this.providerName, this.modelName);
     }
 }

package/dist/providers/llamaCpp.js

@@ -74,6 +74,6 @@ export class LlamaCppProvider extends OpenAIChatCompletionsProvider {
             },
             ...DEFAULT_ERROR_RULES,
         ];
-        return classifyProviderError(error, rules, "llamacpp", this.modelName);
+        return classifyProviderError(error, rules, this.providerName, this.modelName);
     }
 }