@juspay/neurolink 9.54.1 → 9.54.3

package/dist/cli/factories/commandFactory.js

@@ -20,6 +20,7 @@ import { initializeCliParser } from "../parser.js";
 import { formatFileSize, saveAudioToFile } from "../utils/audioFileUtils.js";
 import { resolveFilePaths } from "../utils/pathResolver.js";
 import { animatedWrite } from "../utils/typewriter.js";
+import { createStreamAbortHandler } from "../utils/abortHandler.js";
 import { formatVideoFileSize, getVideoMetadataSummary, saveVideoToFile, } from "../utils/videoFileUtils.js";
 import { OllamaCommandFactory } from "./ollamaCommandFactory.js";
 import { SageMakerCommandFactory } from "./sagemakerCommandFactory.js";
@@ -2176,6 +2177,11 @@ export class CLICommandFactory {
         let lastImageBase64;
         let contentReceived = false;
         const abortController = new AbortController();
+        // BZ-667: Wire SIGINT to abort stream gracefully
+        const abortHandler = createStreamAbortHandler();
+        abortHandler.signal.addEventListener("abort", () => {
+            abortController.abort();
+        }, { once: true });
         // Create timeout promise for stream consumption (default: 30 seconds, respects user-provided timeout)
         const streamTimeout = options.timeout && typeof options.timeout === "number"
             ? options.timeout * 1000
@@ -2197,22 +2203,37 @@ export class CLICommandFactory {
                 clearTimeout(timeoutId);
             });
         });
+        const streamIterator = stream.stream[Symbol.asyncIterator]();
         try {
             // Process the stream with timeout handling
-            const streamIterator = stream.stream[Symbol.asyncIterator]();
             let timeoutActive = true;
+            // BZ-667: Create an abort promise that rejects when the user presses Ctrl+C,
+            // so we can race it against streamIterator.next() and unblock pending reads.
+            const abortPromise = new Promise((_, reject) => {
+                if (abortHandler.signal.aborted) {
+                    reject(new DOMException("Stream aborted", "AbortError"));
+                    return;
+                }
+                abortHandler.signal.addEventListener("abort", () => {
+                    reject(new DOMException("Stream aborted", "AbortError"));
+                }, { once: true });
+            });
             while (true) {
                 let nextResult;
                 if (timeoutActive && !contentReceived) {
-                    // Race between next chunk and timeout for first chunk only
+                    // Race between next chunk, timeout, and abort signal
                     nextResult = await Promise.race([
                         streamIterator.next(),
                         timeoutPromise,
+                        abortPromise,
                     ]);
                 }
                 else {
-                    // No timeout for subsequent chunks
-                    nextResult = await streamIterator.next();
+                    // Race between next chunk and abort signal
+                    nextResult = await Promise.race([
+                        streamIterator.next(),
+                        abortPromise,
+                    ]);
                 }
                 if (nextResult.done) {
                     break;
@@ -2266,8 +2287,26 @@ export class CLICommandFactory {
         }
         catch (error) {
             abortController.abort(); // Clean up timeout
+            // BZ-667: Close the stream iterator so the provider connection is released.
+            // Wrap in try/catch to prevent cleanup failures from masking the original error.
+            try {
+                await streamIterator.return?.();
+            }
+            catch {
+                // Iterator cleanup failed — swallow so the original error propagates
+            }
+            abortHandler.cleanup();
+            // BZ-667: Handle graceful abort — return partial content instead of throwing
+            if (abortHandler.signal.aborted ||
+                (error instanceof Error && error.name === "AbortError")) {
+                if (!options.quiet) {
+                    process.stdout.write("\n");
+                }
+                return { content: fullContent, imageBase64: lastImageBase64 };
+            }
             throw error;
         }
+        abortHandler.cleanup();
         if (!contentReceived) {
             throw new Error("\n❌ No content received from stream\n" +
                 "Check your credentials and provider configuration");

package/dist/cli/utils/abortHandler.d.ts

@@ -0,0 +1,22 @@
+/**
+ * CLI Abort Handler (BZ-667)
+ *
+ * Bridges SIGINT (Ctrl+C) to an AbortController for graceful stream cancellation.
+ * First Ctrl+C aborts the stream and shows "Stream cancelled."
+ * Second Ctrl+C within 1 second force-exits the process.
+ *
+ * Uses `prependListener` so the stream handler fires BEFORE the top-level
+ * SIGINT handler in cli/index.ts (which calls process.exit). The listener
+ * remains registered until `cleanup()` removes it. On the first Ctrl+C the
+ * stream is cancelled gracefully; only a rapid second press exits.
+ *
+ * @module cli/utils/abortHandler
+ */
+/**
+ * Create an abort handler that wires SIGINT to an AbortController.
+ * Call cleanup() when the stream finishes (success or error) to remove listeners.
+ */
+export declare function createStreamAbortHandler(): {
+    signal: AbortSignal;
+    cleanup: () => void;
+};

package/dist/cli/utils/abortHandler.js

@@ -0,0 +1,53 @@
+/**
+ * CLI Abort Handler (BZ-667)
+ *
+ * Bridges SIGINT (Ctrl+C) to an AbortController for graceful stream cancellation.
+ * First Ctrl+C aborts the stream and shows "Stream cancelled."
+ * Second Ctrl+C within 1 second force-exits the process.
+ *
+ * Uses `prependListener` so the stream handler fires BEFORE the top-level
+ * SIGINT handler in cli/index.ts (which calls process.exit). The listener
+ * remains registered until `cleanup()` removes it. On the first Ctrl+C the
+ * stream is cancelled gracefully; only a rapid second press exits.
+ *
+ * @module cli/utils/abortHandler
+ */
+import chalk from "chalk";
+/**
+ * Create an abort handler that wires SIGINT to an AbortController.
+ * Call cleanup() when the stream finishes (success or error) to remove listeners.
+ */
+export function createStreamAbortHandler() {
+    const controller = new AbortController();
+    let aborted = false;
+    let forceExitTimer = null;
+    const sigintHandler = () => {
+        if (aborted) {
+            // Second Ctrl+C — force exit
+            if (forceExitTimer) {
+                clearTimeout(forceExitTimer);
+            }
+            // Let the top-level SIGINT handler in cli/index.ts handle the exit
+            return;
+        }
+        aborted = true;
+        controller.abort();
+        process.stderr.write(chalk.yellow("\nStream cancelled.\n"));
+        // Allow force exit on second Ctrl+C within 1 second
+        forceExitTimer = setTimeout(() => {
+            forceExitTimer = null;
+        }, 1000);
+    };
+    // Use prependListener so our handler fires before the top-level
+    // SIGINT handler in cli/index.ts. cleanup() removes it after the stream ends.
+    process.prependListener("SIGINT", sigintHandler);
+    const cleanup = () => {
+        process.removeListener("SIGINT", sigintHandler);
+        if (forceExitTimer) {
+            clearTimeout(forceExitTimer);
+            forceExitTimer = null;
+        }
+    };
+    return { signal: controller.signal, cleanup };
+}
+//# sourceMappingURL=abortHandler.js.map

package/dist/core/baseProvider.d.ts

@@ -1,4 +1,4 @@
-import type { LanguageModel, ModelMessage, Tool } from "ai";
+import type { LanguageModel, ModelMessage, Tool, ToolCallRepairFunction, ToolSet } from "ai";
 import type { AIProviderName } from "../constants/enums.js";
 import type { EvaluationData } from "../index.js";
 import type { NeuroLink } from "../neurolink.js";
@@ -189,6 +189,12 @@ export declare abstract class BaseProvider implements AIProvider {
      * @returns The default embedding model name, or undefined if not supported
      */
     protected getDefaultEmbeddingModel(): string | undefined;
+    /**
+     * Create an `experimental_repairToolCall` handler for streamText/generateText.
+     * Dynamically reads the tool's JSON schema to repair wrong names and params.
+     * Returns undefined when repair is disabled via options.
+     */
+    protected getToolCallRepairFn(options?: StreamOptions | TextGenerationOptions): ToolCallRepairFunction<ToolSet> | undefined;
     /**
      * Provider-specific streaming implementation (only used when tools are disabled)
      */

package/dist/core/baseProvider.js

@@ -861,6 +861,25 @@ export class BaseProvider {
         // Default implementation returns undefined - providers override this
         return undefined;
     }
+    // ===================
+    // ===================
+    // BZ-665: Schema-driven tool call repair
+    // ===================
+    /**
+     * Create an `experimental_repairToolCall` handler for streamText/generateText.
+     * Dynamically reads the tool's JSON schema to repair wrong names and params.
+     * Returns undefined when repair is disabled via options.
+     */
+    getToolCallRepairFn(options) {
+        if (options?.disableToolCallRepair) {
+            return undefined;
+        }
+        // Lazy import to avoid circular dependency at module load time
+        return (async (...args) => {
+            const { createToolCallRepair } = await import("../utils/toolCallRepair.js");
+            return createToolCallRepair()(...args);
+        });
+    }
     /**
      * Get AI SDK model with middleware applied
      * This method wraps the base model with any configured middleware

package/dist/lib/core/baseProvider.d.ts

@@ -1,4 +1,4 @@
-import type { LanguageModel, ModelMessage, Tool } from "ai";
+import type { LanguageModel, ModelMessage, Tool, ToolCallRepairFunction, ToolSet } from "ai";
 import type { AIProviderName } from "../constants/enums.js";
 import type { EvaluationData } from "../index.js";
 import type { NeuroLink } from "../neurolink.js";
@@ -189,6 +189,12 @@ export declare abstract class BaseProvider implements AIProvider {
      * @returns The default embedding model name, or undefined if not supported
      */
     protected getDefaultEmbeddingModel(): string | undefined;
+    /**
+     * Create an `experimental_repairToolCall` handler for streamText/generateText.
+     * Dynamically reads the tool's JSON schema to repair wrong names and params.
+     * Returns undefined when repair is disabled via options.
+     */
+    protected getToolCallRepairFn(options?: StreamOptions | TextGenerationOptions): ToolCallRepairFunction<ToolSet> | undefined;
     /**
      * Provider-specific streaming implementation (only used when tools are disabled)
      */

package/dist/lib/core/baseProvider.js

@@ -861,6 +861,25 @@ export class BaseProvider {
         // Default implementation returns undefined - providers override this
         return undefined;
     }
+    // ===================
+    // ===================
+    // BZ-665: Schema-driven tool call repair
+    // ===================
+    /**
+     * Create an `experimental_repairToolCall` handler for streamText/generateText.
+     * Dynamically reads the tool's JSON schema to repair wrong names and params.
+     * Returns undefined when repair is disabled via options.
+     */
+    getToolCallRepairFn(options) {
+        if (options?.disableToolCallRepair) {
+            return undefined;
+        }
+        // Lazy import to avoid circular dependency at module load time
+        return (async (...args) => {
+            const { createToolCallRepair } = await import("../utils/toolCallRepair.js");
+            return createToolCallRepair()(...args);
+        });
+    }
     /**
      * Get AI SDK model with middleware applied
      * This method wraps the base model with any configured middleware

package/dist/lib/neurolink.js

@@ -4831,15 +4831,31 @@ Current user's request: ${currentInput}`;
         catch {
             /* non-blocking */
         }
-        const fallbackRoute = ModelRouter.getFallbackRoute(originalPrompt || enhancedOptions.input.text || "", {
+        // BZ-1341: Support fallback provider override via options or env vars
+        const optFallbackProvider = enhancedOptions.fallbackProvider?.trim() || undefined;
+        const optFallbackModel = enhancedOptions.fallbackModel?.trim() || undefined;
+        const envFallbackProvider = process.env.FALLBACK_PROVIDER?.trim() || undefined;
+        const envFallbackModel = process.env.FALLBACK_MODEL?.trim() || undefined;
+        const modelConfigRoute = ModelRouter.getFallbackRoute(originalPrompt || enhancedOptions.input.text || "", {
             provider: providerName,
             model: enhancedOptions.model || "gpt-4o",
             reasoning: "primary failed",
             confidence: 0.5,
         }, { fallbackStrategy: "auto" });
+        const fallbackRoute = {
+            ...modelConfigRoute,
+            provider: optFallbackProvider ?? envFallbackProvider ?? modelConfigRoute.provider,
+            model: optFallbackModel ?? envFallbackModel ?? modelConfigRoute.model,
+        };
         logger.warn("Retrying with fallback provider", {
             originalProvider: providerName,
             fallbackProvider: fallbackRoute.provider,
+            fallbackModel: fallbackRoute.model,
+            fallbackSource: optFallbackProvider || optFallbackModel
+                ? "options"
+                : envFallbackProvider || envFallbackModel
+                    ? "env"
+                    : "model_config",
             reason: errorMsg,
         });
         try {

package/dist/lib/providers/anthropic.js

@@ -799,6 +799,7 @@ export class AnthropicProvider extends BaseProvider {
                     stopWhen: stepCountIs(options.maxSteps || DEFAULT_MAX_STEPS),
                     toolChoice: resolveToolChoice(options, tools, shouldUseTools),
                     abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
+                    experimental_repairToolCall: this.getToolCallRepairFn(options),
                     experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
                     onStepFinish: ({ toolCalls, toolResults }) => {
                         this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {

package/dist/lib/providers/anthropicBaseProvider.js

@@ -94,6 +94,7 @@ export class AnthropicProviderV2 extends BaseProvider {
                     toolChoice: resolveToolChoice(options, tools, shouldUseTools),
                     abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
                     experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
+                    experimental_repairToolCall: this.getToolCallRepairFn(options),
                     onStepFinish: ({ toolCalls, toolResults }) => {
                         this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {
                             logger.warn("[AnthropicBaseProvider] Failed to store tool executions", {

package/dist/lib/providers/azureOpenai.js

@@ -124,6 +124,7 @@ export class AzureOpenAIProvider extends BaseProvider {
                 stopWhen: stepCountIs(options.maxSteps || DEFAULT_MAX_STEPS),
                 abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
                 experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
+                experimental_repairToolCall: this.getToolCallRepairFn(options),
                 onStepFinish: (event) => {
                     this.handleToolExecutionStorage([...event.toolCalls], [...event.toolResults], options, new Date()).catch((error) => {
                         logger.warn("[AzureOpenaiProvider] Failed to store tool executions", {

package/dist/lib/providers/googleAiStudio.js

@@ -478,6 +478,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
                 toolChoice: resolveToolChoice(options, tools, shouldUseTools),
                 abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
                 experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
+                experimental_repairToolCall: this.getToolCallRepairFn(options),
                 // Gemini 3: use thinkingLevel via providerOptions
                 // Gemini 2.5: use thinkingBudget via providerOptions
                 ...(options.thinkingConfig?.enabled && {

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

@@ -5,6 +5,20 @@ import { BaseProvider } from "../core/baseProvider.js";
 import type { EnhancedGenerateResult, TextGenerationOptions } from "../types/generateTypes.js";
 import type { NeurolinkCredentials } from "../types/providers.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
+/**
+ * Resolve the correct Vertex AI location for a given model.
+ *
+ * Google-published models (gemini-*) require the global endpoint
+ * (`aiplatform.googleapis.com`), not regional endpoints like
+ * `us-east5-aiplatform.googleapis.com`. Regional endpoints return
+ * "model not found" for these models.
+ *
+ * Anthropic-on-Vertex models (claude-*) require regional endpoints
+ * and are handled separately by `createVertexAnthropicSettings`.
+ *
+ * Embedding models and custom models use the configured location as-is.
+ */
+export declare const resolveVertexLocation: (modelName: string | undefined, configuredLocation: string) => string;
 /**
  * Vertex Model Aliases
  *

package/dist/lib/providers/googleVertex.js

@@ -79,7 +79,36 @@ const getVertexLocation = () => {
     return (process.env.GOOGLE_CLOUD_LOCATION ||
         process.env.VERTEX_LOCATION ||
         process.env.GOOGLE_VERTEX_LOCATION ||
-        "us-central1");
+        "global");
+};
+/**
+ * Resolve the correct Vertex AI location for a given model.
+ *
+ * Google-published models (gemini-*) require the global endpoint
+ * (`aiplatform.googleapis.com`), not regional endpoints like
+ * `us-east5-aiplatform.googleapis.com`. Regional endpoints return
+ * "model not found" for these models.
+ *
+ * Anthropic-on-Vertex models (claude-*) require regional endpoints
+ * and are handled separately by `createVertexAnthropicSettings`.
+ *
+ * Embedding models and custom models use the configured location as-is.
+ */
+export const resolveVertexLocation = (modelName, configuredLocation) => {
+    if (!modelName) {
+        return configuredLocation;
+    }
+    const normalized = modelName.toLowerCase();
+    // Google-published models always use the global endpoint.
+    // Hardcoded because Google's Vertex AI serves Gemini models exclusively
+    // from the global endpoint — regional endpoints like us-east5 return
+    // "Publisher Model was not found" errors. The env var GOOGLE_VERTEX_LOCATION
+    // is typically set for Anthropic-on-Vertex (which needs regional), so we
+    // cannot rely on it for Gemini routing.
+    if (normalized.startsWith("gemini-")) {
+        return "global";
+    }
+    return configuredLocation;
 };
 const getDefaultVertexModel = () => {
     // Use gemini-2.5-flash as default - latest and best price-performance model
@@ -96,8 +125,9 @@ const hasGoogleCredentials = () => {
 // Module-level cache for runtime-created credentials file to avoid per-request writes
 let cachedCredentialsPath = null;
 // Enhanced Vertex settings creation with authentication fallback and proxy support
-const createVertexSettings = async (region, credentials) => {
-    const location = credentials?.location || region || getVertexLocation();
+const createVertexSettings = async (region, credentials, modelName) => {
+    const configuredLocation = credentials?.location || region || getVertexLocation();
+    const location = resolveVertexLocation(modelName, configuredLocation);
     const project = credentials?.projectId || getVertexProjectId();
     const baseSettings = {
         project,
@@ -326,7 +356,12 @@ const createVertexAnthropicSettings = async (region, credentials) => {
     // which is invalid. The correct global endpoint omits the region prefix entirely.
     // Since the SDK doesn't handle this, redirect "global" to "us-east5" for Anthropic.
     const anthropicRegion = !region || region === "global" ? "us-east5" : region;
-    const baseVertexSettings = await createVertexSettings(anthropicRegion, credentials);
+    // Override credentials.location so it cannot conflict with the redirected
+    // region — createVertexSettings checks credentials.location first.
+    const anthropicCredentials = credentials?.location
+        ? { ...credentials, location: anthropicRegion }
+        : credentials;
+    const baseVertexSettings = await createVertexSettings(anthropicRegion, anthropicCredentials);
     // GoogleVertexAnthropicProviderSettings extends GoogleVertexProviderSettings
     // so we can use the same settings with proper typing
     return {
@@ -570,7 +605,9 @@ export class GoogleVertexProvider extends BaseProvider {
             networkConfig: {
                 projectId: this.projectId,
                 location: this.location,
-                expectedEndpoint: `https://${this.location}-aiplatform.googleapis.com`,
+                expectedEndpoint: this.location === "global"
+                    ? "https://aiplatform.googleapis.com"
+                    : `https://${this.location}-aiplatform.googleapis.com`,
                 httpProxy: process.env.HTTP_PROXY || process.env.http_proxy,
                 httpsProxy: process.env.HTTPS_PROXY || process.env.https_proxy,
                 noProxy: process.env.NO_PROXY || process.env.no_proxy,
@@ -582,7 +619,7 @@ export class GoogleVertexProvider extends BaseProvider {
             message: "Starting Vertex settings creation with network configuration analysis",
         });
         try {
-            const vertexSettings = await createVertexSettings(this.location, this.credentials);
+            const vertexSettings = await createVertexSettings(this.location, this.credentials, modelName);
             const vertexSettingsEndTime = process.hrtime.bigint();
             const vertexSettingsDurationNs = vertexSettingsEndTime - vertexSettingsStartTime;
             logger.debug(`[GoogleVertexProvider] ✅ LOG_POINT_V009_VERTEX_SETTINGS_SUCCESS`, {
@@ -957,6 +994,7 @@ export class GoogleVertexProvider extends BaseProvider {
             }),
             abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
             experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
+            experimental_repairToolCall: this.getToolCallRepairFn(options),
             ...(options.thinkingConfig?.enabled && {
                 providerOptions: {
                     vertex: {
@@ -1116,12 +1154,13 @@ export class GoogleVertexProvider extends BaseProvider {
     /**
      * Create @google/genai client configured for Vertex AI
      */
-    async createVertexGenAIClient(regionOverride) {
+    async createVertexGenAIClient(regionOverride, modelName) {
         const project = this.credentials?.projectId || getVertexProjectId();
-        const location = this.credentials?.location ||
+        const configuredLocation = this.credentials?.location ||
             regionOverride ||
             this.location ||
             getVertexLocation();
+        const location = resolveVertexLocation(modelName, configuredLocation);
         const mod = await import("@google/genai");
         const ctor = mod.GoogleGenAI;
         if (!ctor) {
@@ -1308,8 +1347,8 @@ export class GoogleVertexProvider extends BaseProvider {
         }, (span) => this.executeNativeGemini3StreamWithSpan(options, modelName, span));
     }
     async executeNativeGemini3StreamWithSpan(options, modelName, span) {
-        const client = await this.createVertexGenAIClient(options.region);
-        const effectiveLocation = options.region || this.location || getVertexLocation();
+        const client = await this.createVertexGenAIClient(options.region, modelName);
+        const effectiveLocation = resolveVertexLocation(modelName, options.region || this.location || getVertexLocation());
         logger.debug("[GoogleVertex] Using native @google/genai for Gemini 3", {
             model: modelName,
             hasTools: !!options.tools && Object.keys(options.tools).length > 0,
@@ -1503,8 +1542,8 @@ export class GoogleVertexProvider extends BaseProvider {
                 [ATTR.NL_PROVIDER]: this.providerName,
             },
         }, async (span) => {
-            const client = await this.createVertexGenAIClient(options.region);
-            const effectiveLocation = options.region || this.location || getVertexLocation();
+            const client = await this.createVertexGenAIClient(options.region, modelName);
+            const effectiveLocation = resolveVertexLocation(modelName, options.region || this.location || getVertexLocation());
             logger.debug("[GoogleVertex] Using native @google/genai for Gemini 3 generate", {
                 model: modelName,
                 project: this.projectId,

package/dist/lib/providers/huggingFace.js

@@ -139,6 +139,7 @@ export class HuggingFaceProvider extends BaseProvider {
                 toolChoice: resolveToolChoice(options, (shouldUseTools ? streamOptions.tools || allTools : {}), shouldUseTools),
                 abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
                 experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
+                experimental_repairToolCall: this.getToolCallRepairFn(options),
                 onStepFinish: ({ toolCalls, toolResults }) => {
                     this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {
                         logger.warn("[HuggingFaceProvider] Failed to store tool executions", {

package/dist/lib/providers/litellm.js

@@ -169,6 +169,7 @@ export class LiteLLMProvider extends BaseProvider {
                 }),
                 abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
                 experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
+                experimental_repairToolCall: this.getToolCallRepairFn(options),
                 onError: (event) => {
                     const error = event.error;
                     const errorMessage = error instanceof Error ? error.message : String(error);

package/dist/lib/providers/mistral.js

@@ -67,6 +67,7 @@ export class MistralProvider extends BaseProvider {
                 toolChoice: resolveToolChoice(options, tools, shouldUseTools),
                 abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
                 experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
+                experimental_repairToolCall: this.getToolCallRepairFn(options),
                 onStepFinish: ({ toolCalls, toolResults }) => {
                     this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {
                         logger.warn("[MistralProvider] Failed to store tool executions", {

package/dist/lib/providers/openAI.js

@@ -330,6 +330,7 @@ export class OpenAIProvider extends BaseProvider {
                     stopWhen: stepCountIs(options.maxSteps || DEFAULT_MAX_STEPS),
                     toolChoice: resolvedToolChoice,
                     abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
+                    experimental_repairToolCall: this.getToolCallRepairFn(options),
                     experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
                     onStepFinish: ({ toolCalls, toolResults }) => {
                         logger.info("Tool execution completed", {

package/dist/lib/providers/openRouter.js

@@ -252,6 +252,7 @@ export class OpenRouterProvider extends BaseProvider {
                 }),
                 abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
                 experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
+                experimental_repairToolCall: this.getToolCallRepairFn(options),
                 onError: (event) => {
                     const error = event.error;
                     const errorMessage = error instanceof Error ? error.message : String(error);

package/dist/lib/providers/openaiCompatible.js

@@ -195,6 +195,7 @@ export class OpenAICompatibleProvider extends BaseProvider {
                 stopWhen: stepCountIs(options.maxSteps || DEFAULT_MAX_STEPS),
                 abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
                 experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
+                experimental_repairToolCall: this.getToolCallRepairFn(options),
                 onStepFinish: (event) => {
                     this.handleToolExecutionStorage([...event.toolCalls], [...event.toolResults], options, new Date()).catch((error) => {
                         logger.warn("[OpenAiCompatibleProvider] Failed to store tool executions", {

package/dist/lib/proxy/routingPolicy.d.ts

@@ -1,33 +1,43 @@
-import type { ClaudeProxyModelTier, ClaudeProxyRequestClass, ClaudeProxyRequestProfile, CooldownScope, CooldownSkippedAccount, FallbackEligibilityDecision, FallbackEntry, ParsedClaudeRequest, ProxyTranslationAttempt, ProxyTranslationPlan, RuntimeAccountState } from "../types/index.js";
-export type { ClaudeProxyModelTier, ClaudeProxyRequestClass, ClaudeProxyRequestProfile, CooldownScope, CooldownSkippedAccount, FallbackEligibilityDecision, ProxyTranslationAttempt, ProxyTranslationPlan, };
+import type { ClaudeProxyModelTier, CooldownSkippedAccount, FallbackEntry, ParsedClaudeRequest, ProxyTranslationAttempt, ProxyTranslationPlan, RuntimeAccountState } from "../types/index.js";
+export type { ClaudeProxyModelTier, ProxyTranslationAttempt, ProxyTranslationPlan, };
 export declare function inferClaudeProxyModelTier(modelName: string): ClaudeProxyModelTier;
-export declare function classifyClaudeProxyRequest(requestedModel: string, parsed: ParsedClaudeRequest): ClaudeProxyRequestProfile;
-export declare function getRequestClassCooldownKey(profile: ClaudeProxyRequestProfile): string;
-export declare function getModelTierCooldownKey(profile: ClaudeProxyRequestProfile): string;
-export declare function evaluateFallbackEligibility(profile: ClaudeProxyRequestProfile, candidate: {
-    provider?: string;
-    model?: string;
-}): FallbackEligibilityDecision;
+/**
+ * Build a translation plan for a Claude-compatible proxy request.
+ * The plan lists the primary provider followed by eligible fallback targets.
+ * All configured fallback entries are always eligible — no contract-based gating.
+ * When no fallback chain is configured, an "auto-provider" entry is appended.
+ */
 export declare function buildProxyTranslationPlan(primary: {
     provider: string;
     model?: string;
-}, fallbackChain: FallbackEntry[], requestedModel: string, parsed: ParsedClaudeRequest): ProxyTranslationPlan;
-export declare function summarizeSkippedFallbacks(plan: Pick<ProxyTranslationPlan, "profile" | "skipped">): string | null;
-export declare function getActiveCooldownScope(state: RuntimeAccountState, profile: ClaudeProxyRequestProfile, now?: number): CooldownScope | null;
+}, fallbackChain: FallbackEntry[], requestedModel: string, _parsed: ParsedClaudeRequest): ProxyTranslationPlan;
+/**
+ * Check whether an account is currently cooling down.
+ * Returns the cooldown timestamp if active, null otherwise.
+ */
+export declare function getAccountCooldownUntil(state: RuntimeAccountState, now?: number): number | null;
+/**
+ * Partition accounts into eligible (no cooldown) and skipped (cooling down).
+ */
 export declare function partitionAccountsByCooldown<T extends {
     key: string;
-}>(accounts: T[], getState: (account: T) => RuntimeAccountState, profile: ClaudeProxyRequestProfile, now?: number): {
+}>(accounts: T[], getState: (account: T) => RuntimeAccountState, now?: number): {
     eligible: T[];
     skipped: CooldownSkippedAccount<T>[];
 };
-export declare function applyRateLimitCooldownScope(args: {
+/**
+ * Apply a rate-limit cooldown to an account.
+ * Uses simple exponential backoff with a floor and cap.
+ */
+export declare function applyRateLimitCooldown(args: {
     state: RuntimeAccountState;
-    profile: ClaudeProxyRequestProfile;
     retryAfterMs?: number;
     now?: number;
     capMs: number;
 }): {
     backoffMs: number;
-    requestClassKey: string;
-    modelTierKey: string;
 };
+/**
+ * Clear cooldown state for an account after a successful request.
+ */
+export declare function clearAccountCooldown(state: RuntimeAccountState): void;