@juspay/neurolink 8.2.0 → 8.4.0

package/dist/core/modules/Utilities.js

@@ -0,0 +1,329 @@
+/**
+ * Utilities Module
+ *
+ * Handles validation, normalization, schema conversion, and error handling utilities.
+ * Extracted from BaseProvider to follow Single Responsibility Principle.
+ *
+ * Responsibilities:
+ * - Options validation (text generation and stream options)
+ * - Options normalization (string to object conversion)
+ * - Provider information formatting
+ * - Timeout parsing and calculation
+ * - Schema utilities (Zod detection, permissive schema creation, OpenAI strict mode fixes)
+ * - Tool result conversion
+ * - Middleware options extraction
+ * - Common error pattern handling
+ *
+ * @module core/modules/Utilities
+ */
+import { z } from "zod";
+import { logger } from "../../utils/logger.js";
+import { getSafeMaxTokens } from "../../utils/tokenLimits.js";
+import { TimeoutError } from "../../utils/timeout.js";
+import { validateStreamOptions as validateStreamOpts, validateTextGenerationOptions, ValidationError, createValidationSummary, } from "../../utils/parameterValidation.js";
+import { STEP_LIMITS } from "../constants.js";
+/**
+ * Utilities class - Provides validation, normalization, and utility methods
+ */
+export class Utilities {
+    providerName;
+    modelName;
+    defaultTimeout;
+    middlewareOptions;
+    constructor(providerName, modelName, defaultTimeout = 30000, middlewareOptions) {
+        this.providerName = providerName;
+        this.modelName = modelName;
+        this.defaultTimeout = defaultTimeout;
+        this.middlewareOptions = middlewareOptions;
+    }
+    /**
+     * Validate text generation options
+     */
+    validateOptions(options) {
+        const validation = validateTextGenerationOptions(options);
+        if (!validation.isValid) {
+            const summary = createValidationSummary(validation);
+            throw new ValidationError(`Text generation options validation failed: ${summary}`, "options", "VALIDATION_FAILED", validation.suggestions);
+        }
+        // Log warnings if any
+        if (validation.warnings.length > 0) {
+            logger.warn("Text generation options validation warnings:", validation.warnings);
+        }
+        // Additional BaseProvider-specific validation
+        if (options.maxSteps !== undefined) {
+            if (options.maxSteps < STEP_LIMITS.min ||
+                options.maxSteps > STEP_LIMITS.max) {
+                throw new ValidationError(`maxSteps must be between ${STEP_LIMITS.min} and ${STEP_LIMITS.max}`, "maxSteps", "OUT_OF_RANGE", [
+                    `Use a value between ${STEP_LIMITS.min} and ${STEP_LIMITS.max} for optimal performance`,
+                ]);
+            }
+        }
+    }
+    /**
+     * Validate stream options
+     */
+    validateStreamOptions(options) {
+        const validation = validateStreamOpts(options);
+        if (!validation.isValid) {
+            const summary = createValidationSummary(validation);
+            throw new ValidationError(`Stream options validation failed: ${summary}`, "options", "VALIDATION_FAILED", validation.suggestions);
+        }
+        // Log warnings if any
+        if (validation.warnings.length > 0) {
+            logger.warn("Stream options validation warnings:", validation.warnings);
+        }
+        // Additional BaseProvider-specific validation
+        if (options.maxSteps !== undefined) {
+            if (options.maxSteps < STEP_LIMITS.min ||
+                options.maxSteps > STEP_LIMITS.max) {
+                throw new ValidationError(`maxSteps must be between ${STEP_LIMITS.min} and ${STEP_LIMITS.max}`, "maxSteps", "OUT_OF_RANGE", [
+                    `Use a value between ${STEP_LIMITS.min} and ${STEP_LIMITS.max} for optimal performance`,
+                ]);
+            }
+        }
+    }
+    /**
+     * Normalize text generation options from string or object
+     */
+    normalizeTextOptions(optionsOrPrompt) {
+        if (typeof optionsOrPrompt === "string") {
+            const safeMaxTokens = getSafeMaxTokens(this.providerName, this.modelName);
+            return {
+                prompt: optionsOrPrompt,
+                provider: this.providerName,
+                model: this.modelName,
+                maxTokens: safeMaxTokens,
+            };
+        }
+        // Handle both prompt and input.text formats
+        const prompt = optionsOrPrompt.prompt || optionsOrPrompt.input?.text || "";
+        const modelName = optionsOrPrompt.model || this.modelName;
+        const providerName = optionsOrPrompt.provider || this.providerName;
+        // Apply safe maxTokens based on provider and model
+        const safeMaxTokens = getSafeMaxTokens(providerName, modelName, optionsOrPrompt.maxTokens);
+        // CRITICAL FIX: Preserve the entire input object for multimodal support
+        // This ensures images and content arrays are not lost during normalization
+        const normalizedOptions = {
+            ...optionsOrPrompt,
+            prompt,
+            provider: providerName,
+            model: modelName,
+            maxTokens: safeMaxTokens,
+        };
+        // Ensure input object is preserved if it exists (for multimodal support)
+        if (optionsOrPrompt.input) {
+            normalizedOptions.input = {
+                ...optionsOrPrompt.input,
+                text: prompt, // Ensure text is consistent
+            };
+        }
+        return normalizedOptions;
+    }
+    /**
+     * Normalize stream options from string or object
+     */
+    normalizeStreamOptions(optionsOrPrompt) {
+        if (typeof optionsOrPrompt === "string") {
+            const safeMaxTokens = getSafeMaxTokens(this.providerName, this.modelName);
+            return {
+                input: { text: optionsOrPrompt },
+                provider: this.providerName,
+                model: this.modelName,
+                maxTokens: safeMaxTokens,
+            };
+        }
+        const modelName = optionsOrPrompt.model || this.modelName;
+        const providerName = optionsOrPrompt.provider || this.providerName;
+        // Apply safe maxTokens based on provider and model
+        const safeMaxTokens = getSafeMaxTokens(providerName, modelName, optionsOrPrompt.maxTokens);
+        return {
+            ...optionsOrPrompt,
+            provider: providerName,
+            model: modelName,
+            maxTokens: safeMaxTokens,
+        };
+    }
+    /**
+     * Get provider information
+     */
+    getProviderInfo() {
+        return {
+            provider: this.providerName,
+            model: this.modelName,
+        };
+    }
+    /**
+     * Get timeout value in milliseconds from options
+     * Supports number or string formats (e.g., '30s', '2m', '1h')
+     */
+    getTimeout(options) {
+        if (!options.timeout) {
+            return this.defaultTimeout;
+        }
+        if (typeof options.timeout === "number") {
+            return options.timeout;
+        }
+        // Parse string timeout (e.g., '30s', '2m', '1h')
+        const timeoutStr = options.timeout.toLowerCase();
+        const value = parseInt(timeoutStr);
+        if (timeoutStr.includes("h")) {
+            return value * 60 * 60 * 1000;
+        }
+        else if (timeoutStr.includes("m")) {
+            return value * 60 * 1000;
+        }
+        else if (timeoutStr.includes("s")) {
+            return value * 1000;
+        }
+        return this.defaultTimeout;
+    }
+    /**
+     * Check if a schema is a Zod schema
+     */
+    isZodSchema(schema) {
+        return (typeof schema === "object" &&
+            schema !== null &&
+            // Most Zod schemas have an internal _def and a parse method
+            typeof schema.parse === "function");
+    }
+    /**
+     * Convert tool execution result from MCP format to standard format
+     * Handles tool failures gracefully to prevent stream termination
+     */
+    async convertToolResult(result) {
+        // Handle MCP-style results
+        if (result && typeof result === "object" && "success" in result) {
+            const mcpResult = result;
+            if (mcpResult.success) {
+                return mcpResult.data;
+            }
+            else {
+                // Instead of throwing, return a structured error result
+                // This prevents tool failures from terminating streams
+                const errorMsg = typeof mcpResult.error === "string"
+                    ? mcpResult.error
+                    : "Tool execution failed";
+                // Log the error for debugging but don't throw
+                logger.warn(`Tool execution failed: ${errorMsg}`);
+                // Return error as structured data that can be processed by the AI
+                return {
+                    isError: true,
+                    error: errorMsg,
+                    content: [
+                        {
+                            type: "text",
+                            text: `Tool execution failed: ${errorMsg}`,
+                        },
+                    ],
+                };
+            }
+        }
+        return result;
+    }
+    /**
+     * Create a permissive Zod schema that accepts all parameters as-is
+     */
+    createPermissiveZodSchema() {
+        // Create a permissive record that accepts any object structure
+        // This allows all parameters to pass through without validation issues
+        return z.record(z.unknown()).transform((data) => {
+            // Return the data as-is to preserve all parameter information
+            return data;
+        });
+    }
+    /**
+     * Recursively fix JSON Schema for OpenAI strict mode compatibility
+     * OpenAI requires additionalProperties: false at ALL levels and preserves required array
+     */
+    fixSchemaForOpenAIStrictMode(schema) {
+        const fixedSchema = JSON.parse(JSON.stringify(schema));
+        if (fixedSchema.type === "object" &&
+            fixedSchema.properties &&
+            typeof fixedSchema.properties === "object") {
+            const allPropertyNames = Object.keys(fixedSchema.properties);
+            if (!fixedSchema.required || !Array.isArray(fixedSchema.required)) {
+                fixedSchema.required = [];
+            }
+            fixedSchema.additionalProperties = false;
+            for (const propName of allPropertyNames) {
+                const propValue = fixedSchema.properties[propName];
+                if (propValue && typeof propValue === "object") {
+                    if (propValue.type === "object") {
+                        fixedSchema.properties[propName] =
+                            this.fixSchemaForOpenAIStrictMode(propValue);
+                    }
+                    else if (propValue.type === "array" &&
+                        propValue.items &&
+                        typeof propValue.items === "object") {
+                        fixedSchema.properties[propName].items =
+                            this.fixSchemaForOpenAIStrictMode(propValue.items);
+                    }
+                }
+            }
+        }
+        return fixedSchema;
+    }
+    /**
+     * Extract middleware options from generation/stream options
+     * This is the single source of truth for deciding if middleware should be applied
+     */
+    extractMiddlewareOptions(options) {
+        // 1. Determine effective middleware config: per-request overrides global.
+        const middlewareOpts = options.middleware ??
+            this.middlewareOptions;
+        if (!middlewareOpts) {
+            return null;
+        }
+        // 2. The middleware property must be an object with configuration.
+        if (typeof middlewareOpts !== "object" ||
+            middlewareOpts === null ||
+            middlewareOpts instanceof Date ||
+            middlewareOpts instanceof RegExp) {
+            return null;
+        }
+        // 3. Check if the middleware object has any actual configuration keys.
+        const fullOpts = middlewareOpts;
+        const hasArray = (arr) => Array.isArray(arr) && arr.length > 0;
+        const hasConfig = !!fullOpts.middlewareConfig ||
+            hasArray(fullOpts.enabledMiddleware) ||
+            hasArray(fullOpts.disabledMiddleware) ||
+            !!fullOpts.preset ||
+            hasArray(fullOpts.middleware);
+        if (!hasConfig) {
+            return null;
+        }
+        // 4. Return the formatted options if configuration is present.
+        return {
+            ...fullOpts,
+            global: {
+                collectStats: true,
+                continueOnError: true,
+                ...(fullOpts.global || {}),
+            },
+        };
+    }
+    /**
+     * Handle common error patterns across providers
+     * Returns transformed error or null if not a common pattern
+     */
+    handleCommonErrors(error) {
+        if (error instanceof TimeoutError) {
+            return new Error(`${this.providerName} request timed out after ${error.timeout}ms. Consider increasing timeout or using a lighter model.`);
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        // Common API key errors
+        if (message.includes("API_KEY_INVALID") ||
+            message.includes("Invalid API key") ||
+            message.includes("authentication") ||
+            message.includes("unauthorized")) {
+            return new Error(`Invalid API key for ${this.providerName}. Please check your API key environment variable.`);
+        }
+        // Common rate limit errors
+        if (message.includes("rate limit") ||
+            message.includes("quota") ||
+            message.includes("429")) {
+            return new Error(`Rate limit exceeded for ${this.providerName}. Please wait before making more requests.`);
+        }
+        return null; // Not a common error, let provider handle it
+    }
+}

package/dist/factories/providerRegistry.js

@@ -24,7 +24,7 @@ export class ProviderRegistry {
             ProviderFactory.registerProvider(AIProviderName.GOOGLE_AI, async (modelName, _providerName, sdk) => {
                 const { GoogleAIStudioProvider } = await import("../providers/googleAiStudio.js");
                 return new GoogleAIStudioProvider(modelName, sdk);
-            }, GoogleAIModels.GEMINI_2_5_FLASH, ["googleAiStudio", "google", "gemini", "google-ai"]);
+            }, GoogleAIModels.GEMINI_2_5_FLASH, ["googleAiStudio", "google", "gemini", "google-ai", "google-ai-studio"]);
             // Register OpenAI provider
             ProviderFactory.registerProvider(AIProviderName.OPENAI, async (modelName, _providerName, sdk) => {
                 const { OpenAIProvider } = await import("../providers/openAI.js");

package/dist/lib/adapters/providerImageAdapter.d.ts

@@ -2,7 +2,7 @@
  * Provider Image Adapter - Smart routing for multimodal content
  * Handles provider-specific image formatting and vision capability validation
  */
-import type { Content } from "../types/content.js";
+import type { Content } from "../types/multimodal.js";
 /**
  * Simplified logger for essential error reporting only
  */

package/dist/lib/adapters/providerImageAdapter.js

@@ -53,6 +53,7 @@ const VISION_CAPABILITIES = {
     anthropic: [
         "claude-3-7-sonnet",
         "claude-3-5-sonnet",
+        "claude-haiku-4-5",
         "claude-3-opus",
         "claude-3-sonnet",
         "claude-3-haiku",
@@ -82,6 +83,7 @@ const VISION_CAPABILITIES = {
         "gemini-1.5-flash",
         // Claude 4.x models (versioned format)
         "claude-sonnet-4-5@",
+        "claude-haiku-4-5",
         "claude-sonnet-4@",
         "claude-opus-4-1@",
         "claude-opus-4@",
@@ -100,9 +102,12 @@ const VISION_CAPABILITIES = {
         "claude-sonnet-3",
         "claude-opus-3",
         "claude-haiku-3",
+        "claude-haiku-4",
         // Additional patterns for compatibility
         "claude-3.5-sonnet",
         "claude-3.5-haiku",
+        "claude-4.5-haiku",
+        "claude-haiku-4-5",
         "claude-3.0-sonnet",
         "claude-3.0-opus",
     ],
@@ -118,6 +123,25 @@ const VISION_CAPABILITIES = {
         "gpt-4.1",
         "gpt-5",
     ],
+    mistral: [
+        // Mistral Small 3.2 (vision support for images: PNG, JPEG, WEBP, GIF)
+        "mistral-small",
+        "mistral-small-latest",
+        "mistral-small-3.2",
+        "mistral-small-2506",
+        // Mistral Medium 3.1 (vision support)
+        "mistral-medium",
+        "mistral-medium-latest",
+        "mistral-medium-3.1",
+        // Magistral models (vision support)
+        "magistral-small",
+        "magistral-medium",
+        // Pixtral models (specialized vision models)
+        "pixtral-12b",
+        "pixtral-12b-latest",
+        "pixtral-large",
+        "pixtral-large-latest",
+    ],
     ollama: [
         // Llama 4 family (May 2025 - Best vision + tool calling)
         "llama4:scout",
@@ -137,6 +161,44 @@ const VISION_CAPABILITIES = {
         // LLaVA (vision-focused)
         "llava",
     ],
+    bedrock: [
+        // Claude Sonnet 4.5 family (supports vision, PDFs, images)
+        "claude-sonnet-4-5",
+        "claude-sonnet-4.5",
+        "anthropic.claude-sonnet-4-5",
+        // Claude Haiku 4.5 family (supports vision, PDFs, images)
+        "claude-haiku-4-5",
+        "claude-haiku-4.5",
+        "anthropic.claude-haiku-4-5",
+        // Claude Sonnet 4 family
+        "claude-sonnet-4",
+        "claude-sonnet-4@",
+        "anthropic.claude-sonnet-4",
+        // Claude Opus 4 family
+        "claude-opus-4",
+        "claude-opus-4-1",
+        "claude-opus-4@",
+        "anthropic.claude-opus-4",
+        // Claude 3.7 Sonnet
+        "claude-3-7-sonnet",
+        "claude-3.7-sonnet",
+        "anthropic.claude-3-7-sonnet",
+        // Claude 3.5 Sonnet
+        "claude-3-5-sonnet",
+        "claude-3.5-sonnet",
+        "anthropic.claude-3-5-sonnet",
+        // Claude 3 Opus
+        "claude-3-opus",
+        "anthropic.claude-3-opus",
+        // Claude 3 Sonnet
+        "claude-3-sonnet",
+        "anthropic.claude-3-sonnet",
+        // Claude 3 Haiku
+        "claude-3-haiku",
+        "anthropic.claude-3-haiku",
+        // Generic anthropic.claude prefix (catches all Claude models)
+        "anthropic.claude",
+    ],
 };
 /**
  * Provider Image Adapter - Smart routing and formatting

package/dist/lib/agent/directTools.d.ts

@@ -275,77 +275,6 @@ export declare const directAgentTools: {
             written?: undefined;
         }>;
     };
-    searchFiles: import("ai").Tool<z.ZodObject<{
-        directory: z.ZodString;
-        pattern: z.ZodString;
-        recursive: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    }, "strip", z.ZodTypeAny, {
-        directory: string;
-        pattern: string;
-        recursive: boolean;
-    }, {
-        directory: string;
-        pattern: string;
-        recursive?: boolean | undefined;
-    }>, {
-        success: boolean;
-        error: string;
-        directory?: undefined;
-        pattern?: undefined;
-        matches?: undefined;
-        count?: undefined;
-    } | {
-        success: boolean;
-        directory: string;
-        pattern: string;
-        matches: {
-            name: string;
-            path: string;
-            size: number;
-            lastModified: string;
-        }[];
-        count: number;
-        error?: undefined;
-    } | {
-        success: boolean;
-        error: string;
-        directory: string;
-        pattern: string;
-        matches?: undefined;
-        count?: undefined;
-    }> & {
-        execute: (args: {
-            directory: string;
-            pattern: string;
-            recursive: boolean;
-        }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
-            success: boolean;
-            error: string;
-            directory?: undefined;
-            pattern?: undefined;
-            matches?: undefined;
-            count?: undefined;
-        } | {
-            success: boolean;
-            directory: string;
-            pattern: string;
-            matches: {
-                name: string;
-                path: string;
-                size: number;
-                lastModified: string;
-            }[];
-            count: number;
-            error?: undefined;
-        } | {
-            success: boolean;
-            error: string;
-            directory: string;
-            pattern: string;
-            matches?: undefined;
-            count?: undefined;
-        }>;
-    };
     analyzeCSV: import("ai").Tool<z.ZodObject<{
         filePath: z.ZodEffects<z.ZodString, string, string>;
         operation: z.ZodEnum<["count_by_column", "sum_by_column", "average_by_column", "min_max_by_column", "describe"]>;
@@ -546,7 +475,6 @@ export type FilesystemToolsMap = {
     readFile: typeof directAgentTools.readFile;
     listDirectory: typeof directAgentTools.listDirectory;
     writeFile: typeof directAgentTools.writeFile;
-    searchFiles: typeof directAgentTools.searchFiles;
 };
 export type UtilityToolsMap = {
     getCurrentTime: typeof directAgentTools.getCurrentTime;

package/dist/lib/agent/directTools.js

@@ -264,79 +264,9 @@ export const directAgentTools = {
             }
         },
     }),
-    searchFiles: tool({
-        description: "Search for files by name pattern in a directory",
-        parameters: z.object({
-            directory: z.string().describe("Directory to search in"),
-            pattern: z
-                .string()
-                .describe("File name pattern to search for (supports wildcards like *.js)"),
-            recursive: z
-                .boolean()
-                .optional()
-                .default(true)
-                .describe("Search recursively in subdirectories"),
-        }),
-        execute: async ({ directory, pattern, recursive }) => {
-            try {
-                const resolvedDir = path.resolve(directory);
-                if (!fs.existsSync(resolvedDir)) {
-                    return {
-                        success: false,
-                        error: `Directory does not exist: ${resolvedDir}`,
-                    };
-                }
-                const matches = [];
-                const searchDir = (dir, depth = 0) => {
-                    if (!recursive && depth > 0) {
-                        return;
-                    }
-                    const items = fs.readdirSync(dir);
-                    for (const item of items) {
-                        const itemPath = path.join(dir, item);
-                        const stats = fs.statSync(itemPath);
-                        if (stats.isDirectory()) {
-                            if (recursive && depth < 10) {
-                                // Prevent infinite recursion
-                                searchDir(itemPath, depth + 1);
-                            }
-                        }
-                        else if (stats.isFile()) {
-                            // Simple pattern matching (convert * to regex)
-                            const regexPattern = pattern
-                                .replace(/\*/g, ".*")
-                                .replace(/\?/g, ".");
-                            const regex = new RegExp(`^${regexPattern}$`, "i");
-                            if (regex.test(item)) {
-                                matches.push({
-                                    name: item,
-                                    path: itemPath,
-                                    size: stats.size,
-                                    lastModified: stats.mtime.toISOString(),
-                                });
-                            }
-                        }
-                    }
-                };
-                searchDir(resolvedDir);
-                return {
-                    success: true,
-                    directory: resolvedDir,
-                    pattern,
-                    matches,
-                    count: matches.length,
-                };
-            }
-            catch (error) {
-                return {
-                    success: false,
-                    error: error instanceof Error ? error.message : String(error),
-                    directory,
-                    pattern,
-                };
-            }
-        },
-    }),
+    // NOTE: searchFiles was removed to avoid naming conflict with external MCP 'search_files' tool
+    // from @modelcontextprotocol/server-filesystem which provides the same functionality
+    // with parameters {path, pattern, excludePatterns}
     analyzeCSV: tool({
         description: "Analyze CSV file for accurate counting, aggregation, and statistical analysis. Use this for precise data operations like counting rows by column, calculating sums/averages, finding min/max values, etc. The tool reads the file directly - do NOT pass CSV content.",
         parameters: z.object({
@@ -740,7 +670,6 @@ export function getToolsForCategory(category = "all") {
                 readFile: directAgentTools.readFile,
                 listDirectory: directAgentTools.listDirectory,
                 writeFile: directAgentTools.writeFile,
-                searchFiles: directAgentTools.searchFiles,
             };
         case "utility":
             return {

package/dist/lib/constants/enums.d.ts

@@ -72,6 +72,7 @@ export declare enum GoogleAIModels {
  * Supported Models for Anthropic (Direct API)
  */
 export declare enum AnthropicModels {
+    CLAUDE_4_5_HAIKU = "claude-haiku-4-5-20251001",
     CLAUDE_3_5_SONNET = "claude-3-5-sonnet-20241022",
     CLAUDE_3_5_HAIKU = "claude-3-5-haiku-20241022",
     CLAUDE_3_SONNET = "claude-3-sonnet-20240229",

package/dist/lib/constants/enums.js

@@ -91,7 +91,9 @@ export var GoogleAIModels;
  */
 export var AnthropicModels;
 (function (AnthropicModels) {
-    // Claude 3.5 Series (Latest)
+    // Claude 4.5 Series (Latest - October 2025)
+    AnthropicModels["CLAUDE_4_5_HAIKU"] = "claude-haiku-4-5-20251001";
+    // Claude 3.5 Series
     AnthropicModels["CLAUDE_3_5_SONNET"] = "claude-3-5-sonnet-20241022";
     AnthropicModels["CLAUDE_3_5_HAIKU"] = "claude-3-5-haiku-20241022";
     // Claude 3 Series (Legacy support)

package/dist/lib/constants/tokens.d.ts

@@ -63,6 +63,7 @@ export declare const PROVIDER_TOKEN_LIMITS: {
         readonly "claude-3-5-sonnet-20241022": 4096;
         readonly "claude-3-opus-20240229": 4096;
         readonly "claude-3-5-haiku-20241022": 4096;
+        readonly "claude-haiku-4-5-20251001": 8192;
         readonly "claude-3-sonnet-20240229": 4096;
         readonly default: 4096;
     };
@@ -100,6 +101,7 @@ export declare const PROVIDER_TOKEN_LIMITS: {
         readonly "claude-opus-4@20250514": 4096;
         readonly "claude-3-5-sonnet-20241022": 4096;
         readonly "claude-3-5-haiku-20241022": 4096;
+        readonly "claude-haiku-4-5-20251001": 8192;
         readonly "claude-3-sonnet-20240229": 4096;
         readonly "claude-3-haiku-20240307": 4096;
         readonly "claude-3-opus-20240229": 4096;
@@ -111,6 +113,7 @@ export declare const PROVIDER_TOKEN_LIMITS: {
         readonly "anthropic.claude-3-haiku-20240307-v1:0": 4096;
         readonly "anthropic.claude-3-5-sonnet-20240620-v1:0": 4096;
         readonly "anthropic.claude-3-opus-20240229-v1:0": 4096;
+        readonly "anthropic.claude-haiku-4-5-20251001-v1:0": 8192;
         readonly "arn:aws:bedrock:us-east-2:225681119357:inference-profile/us.anthropic.claude-3-7-sonnet-20250219-v1:0": 4096;
         readonly default: 4096;
     };