@juspay/neurolink 7.33.2 → 7.33.4

package/dist/constants/tokens.d.ts

@@ -0,0 +1,234 @@
+/**
+ * Token Limit Constants for NeuroLink
+ *
+ * Centralized token configuration to replace magic numbers throughout the codebase.
+ * Includes model-specific token limits, use-case optimized limits, and provider constraints.
+ *
+ * @fileoverview Token constants for AI model interactions
+ * @author NeuroLink Team
+ * @version 1.0.0
+ */
+/**
+ * Standard token limit categories
+ * General-purpose token limits for different use cases
+ */
+export declare const TOKEN_LIMITS: {
+    /** Conservative limits (reliable across all models) */
+    readonly CONSERVATIVE: 4096;
+    /** Standard limits (most modern models) */
+    readonly STANDARD: 8192;
+    /** High-capacity limits (premium models) */
+    readonly HIGH_CAPACITY: 16384;
+    /** Large context windows (specialized models) */
+    readonly LARGE_CONTEXT: 100000;
+    /** Ultra-large context windows (latest models) */
+    readonly ULTRA_LARGE_CONTEXT: 200000;
+    /** Maximum context for any model */
+    readonly MAXIMUM_CONTEXT: 2097152;
+};
+/**
+ * Use-case specific token limits
+ * Optimized token limits for different application scenarios
+ */
+export declare const USE_CASE_TOKENS: {
+    /** Quick evaluation tasks */
+    readonly EVALUATION: 500;
+    /** Analysis operations */
+    readonly ANALYSIS: 800;
+    /** Summary generation */
+    readonly SUMMARY: 1000;
+    /** Documentation generation */
+    readonly DOCUMENTATION: 12000;
+    /** Code generation */
+    readonly CODE_GENERATION: 4000;
+    /** Creative writing */
+    readonly CREATIVE_WRITING: 6000;
+    /** Translation tasks */
+    readonly TRANSLATION: 2000;
+    /** Conversation responses */
+    readonly CONVERSATION: 2048;
+    /** Technical explanations */
+    readonly TECHNICAL_EXPLANATION: 3000;
+    /** Research tasks */
+    readonly RESEARCH: 8000;
+};
+/**
+ * Provider-specific token limits
+ * Safe token limits for each AI provider based on testing
+ */
+export declare const PROVIDER_TOKEN_LIMITS: {
+    /** Anthropic model limits */
+    readonly ANTHROPIC: {
+        readonly "claude-3-haiku-20240307": 4096;
+        readonly "claude-3-5-sonnet-20241022": 4096;
+        readonly "claude-3-opus-20240229": 4096;
+        readonly "claude-3-5-haiku-20241022": 4096;
+        readonly "claude-3-sonnet-20240229": 4096;
+        readonly default: 4096;
+    };
+    /** OpenAI model limits */
+    readonly OPENAI: {
+        readonly "gpt-4o": 16384;
+        readonly "gpt-4o-mini": 16384;
+        readonly "gpt-3.5-turbo": 4096;
+        readonly "gpt-4": 8192;
+        readonly "gpt-4-turbo": 4096;
+        readonly "o1-preview": 8192;
+        readonly "o1-mini": 8192;
+        readonly default: 8192;
+    };
+    /** Google AI model limits */
+    readonly GOOGLE_AI: {
+        readonly "gemini-1.5-pro": 8192;
+        readonly "gemini-1.5-flash": 8192;
+        readonly "gemini-1.5-flash-lite": 8192;
+        readonly "gemini-2.5-pro": 8192;
+        readonly "gemini-2.5-flash": 8192;
+        readonly "gemini-2.5-flash-lite": 8192;
+        readonly "gemini-2.0-flash-001": 8192;
+        readonly default: 4096;
+    };
+    /** Google Vertex AI model limits */
+    readonly VERTEX: {
+        readonly "gemini-1.5-pro": 8192;
+        readonly "gemini-1.5-flash": 8192;
+        readonly "gemini-2.5-pro": 8192;
+        readonly "gemini-2.5-flash": 8192;
+        readonly "gemini-2.5-flash-lite": 8192;
+        readonly "gemini-2.0-flash-001": 8192;
+        readonly "claude-sonnet-4@20250514": 4096;
+        readonly "claude-opus-4@20250514": 4096;
+        readonly "claude-3-5-sonnet-20241022": 4096;
+        readonly "claude-3-5-haiku-20241022": 4096;
+        readonly "claude-3-sonnet-20240229": 4096;
+        readonly "claude-3-haiku-20240307": 4096;
+        readonly "claude-3-opus-20240229": 4096;
+        readonly default: 4096;
+    };
+    /** AWS Bedrock model limits */
+    readonly BEDROCK: {
+        readonly "anthropic.claude-3-sonnet-20240229-v1:0": 4096;
+        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 "arn:aws:bedrock:us-east-2:225681119357:inference-profile/us.anthropic.claude-3-7-sonnet-20250219-v1:0": 4096;
+        readonly default: 4096;
+    };
+    /** Azure OpenAI model limits */
+    readonly AZURE: {
+        readonly "gpt-4o": 16384;
+        readonly "gpt-4o-mini": 16384;
+        readonly "gpt-4": 8192;
+        readonly "gpt-35-turbo": 4096;
+        readonly default: 8192;
+    };
+    /** Ollama model limits (local) */
+    readonly OLLAMA: {
+        readonly "llama3.2:latest": 8192;
+        readonly llama2: 4096;
+        readonly codellama: 8192;
+        readonly mistral: 4096;
+        readonly default: 8192;
+    };
+    /** Hugging Face model limits */
+    readonly HUGGINGFACE: {
+        readonly default: 2048;
+    };
+    /** Mistral model limits */
+    readonly MISTRAL: {
+        readonly "mistral-small-latest": 4096;
+        readonly "mistral-medium-latest": 4096;
+        readonly "mistral-large-latest": 8192;
+        readonly default: 4096;
+    };
+    /** LiteLLM proxy limits */
+    readonly LITELLM: {
+        readonly default: 4096;
+    };
+    /** Safe default across all providers */
+    readonly DEFAULT: 4096;
+};
+/**
+ * Context window sizes for different models
+ * Maximum input token limits (separate from output limits)
+ */
+export declare const CONTEXT_WINDOWS: {
+    /** Small context models */
+    readonly SMALL: 4096;
+    /** Medium context models */
+    readonly MEDIUM: 32768;
+    /** Large context models */
+    readonly LARGE: 128000;
+    /** Ultra-large context models */
+    readonly ULTRA_LARGE: 1048576;
+    /** Maximum theoretical context */
+    readonly MAXIMUM: 2097152;
+};
+/**
+ * Token estimation utilities
+ * Rough estimates for token counting without full tokenization
+ */
+export declare const TOKEN_ESTIMATION: {
+    /** Average characters per token (English) */
+    readonly CHARS_PER_TOKEN: 4;
+    /** Average words per token */
+    readonly WORDS_PER_TOKEN: 0.75;
+    /** Code characters per token (more compact) */
+    readonly CODE_CHARS_PER_TOKEN: 3;
+    /** Safety margin for token estimates */
+    readonly SAFETY_MARGIN: 0.8;
+};
+/**
+ * Token utility functions
+ */
+export declare const TokenUtils: {
+    /**
+     * Get safe token limit for a specific provider and model
+     * @param provider - Provider name
+     * @param model - Model name (optional)
+     * @returns Safe token limit for the provider/model
+     */
+    readonly getProviderTokenLimit: (provider: string, model?: string) => number;
+    /**
+     * Get token limit for specific use case
+     * @param useCase - Use case type
+     * @returns Appropriate token limit
+     */
+    readonly getUseCaseTokenLimit: (useCase: keyof typeof USE_CASE_TOKENS) => number;
+    /**
+     * Estimate token count from text
+     * @param text - Input text
+     * @param isCode - Whether the text is code (more compact tokenization)
+     * @returns Estimated token count
+     */
+    readonly estimateTokenCount: (text: string, isCode?: boolean) => number;
+    /**
+     * Check if text exceeds token limit
+     * @param text - Input text
+     * @param limit - Token limit to check against
+     * @param isCode - Whether the text is code
+     * @returns True if text exceeds limit
+     */
+    readonly exceedsTokenLimit: (text: string, limit: number, isCode?: boolean) => boolean;
+    /**
+     * Get appropriate token limit category
+     * @param estimatedTokens - Estimated token count
+     * @returns Token limit category
+     */
+    readonly getTokenLimitCategory: (estimatedTokens: number) => keyof typeof TOKEN_LIMITS;
+    /**
+     * Truncate text to fit within token limit
+     * @param text - Input text
+     * @param tokenLimit - Maximum tokens allowed
+     * @param isCode - Whether the text is code
+     * @returns Truncated text
+     */
+    readonly truncateToTokenLimit: (text: string, tokenLimit: number, isCode?: boolean) => string;
+};
+export declare const DEFAULT_MAX_TOKENS: 8192;
+export declare const DEFAULT_EVALUATION_MAX_TOKENS: 500;
+export declare const DEFAULT_ANALYSIS_MAX_TOKENS: 800;
+export declare const DEFAULT_DOCUMENTATION_MAX_TOKENS: 12000;
+export declare const ANTHROPIC_SAFE: 4096;
+export declare const OPENAI_STANDARD: 8192;
+export declare const GOOGLE_STANDARD: 4096;

package/dist/constants/tokens.js

@@ -0,0 +1,314 @@
+/**
+ * Token Limit Constants for NeuroLink
+ *
+ * Centralized token configuration to replace magic numbers throughout the codebase.
+ * Includes model-specific token limits, use-case optimized limits, and provider constraints.
+ *
+ * @fileoverview Token constants for AI model interactions
+ * @author NeuroLink Team
+ * @version 1.0.0
+ */
+/**
+ * Standard token limit categories
+ * General-purpose token limits for different use cases
+ */
+export const TOKEN_LIMITS = {
+    /** Conservative limits (reliable across all models) */
+    CONSERVATIVE: 4096, // 4K - Safe for all providers
+    /** Standard limits (most modern models) */
+    STANDARD: 8192, // 8K - Modern model standard
+    /** High-capacity limits (premium models) */
+    HIGH_CAPACITY: 16384, // 16K - High-capacity models
+    /** Large context windows (specialized models) */
+    LARGE_CONTEXT: 100000, // 100K - Large context models
+    /** Ultra-large context windows (latest models) */
+    ULTRA_LARGE_CONTEXT: 200000, // 200K - Ultra-large context
+    /** Maximum context for any model */
+    MAXIMUM_CONTEXT: 2097152, // 2M - Theoretical maximum
+};
+/**
+ * Use-case specific token limits
+ * Optimized token limits for different application scenarios
+ */
+export const USE_CASE_TOKENS = {
+    /** Quick evaluation tasks */
+    EVALUATION: 500, // 500 - Keep evaluation fast
+    /** Analysis operations */
+    ANALYSIS: 800, // 800 - Analysis operations
+    /** Summary generation */
+    SUMMARY: 1000, // 1K - Summary generation
+    /** Documentation generation */
+    DOCUMENTATION: 12000, // 12K - Documentation generation
+    /** Code generation */
+    CODE_GENERATION: 4000, // 4K - Code generation tasks
+    /** Creative writing */
+    CREATIVE_WRITING: 6000, // 6K - Creative writing tasks
+    /** Translation tasks */
+    TRANSLATION: 2000, // 2K - Translation tasks
+    /** Conversation responses */
+    CONVERSATION: 2048, // 2K - Conversation responses
+    /** Technical explanations */
+    TECHNICAL_EXPLANATION: 3000, // 3K - Technical explanations
+    /** Research tasks */
+    RESEARCH: 8000, // 8K - Research and analysis
+};
+/**
+ * Provider-specific token limits
+ * Safe token limits for each AI provider based on testing
+ */
+export const PROVIDER_TOKEN_LIMITS = {
+    /** Anthropic model limits */
+    ANTHROPIC: {
+        "claude-3-haiku-20240307": 4096,
+        "claude-3-5-sonnet-20241022": 4096,
+        "claude-3-opus-20240229": 4096,
+        "claude-3-5-haiku-20241022": 4096,
+        "claude-3-sonnet-20240229": 4096,
+        default: 4096, // Conservative default for Anthropic
+    },
+    /** OpenAI model limits */
+    OPENAI: {
+        "gpt-4o": 16384,
+        "gpt-4o-mini": 16384,
+        "gpt-3.5-turbo": 4096,
+        "gpt-4": 8192,
+        "gpt-4-turbo": 4096,
+        "o1-preview": 8192,
+        "o1-mini": 8192,
+        default: 8192, // OpenAI generally supports higher limits
+    },
+    /** Google AI model limits */
+    GOOGLE_AI: {
+        "gemini-1.5-pro": 8192,
+        "gemini-1.5-flash": 8192,
+        "gemini-1.5-flash-lite": 8192,
+        "gemini-2.5-pro": 8192,
+        "gemini-2.5-flash": 8192,
+        "gemini-2.5-flash-lite": 8192,
+        "gemini-2.0-flash-001": 8192,
+        default: 4096, // Conservative default due to 500 errors at high limits
+    },
+    /** Google Vertex AI model limits */
+    VERTEX: {
+        "gemini-1.5-pro": 8192,
+        "gemini-1.5-flash": 8192,
+        "gemini-2.5-pro": 8192,
+        "gemini-2.5-flash": 8192,
+        "gemini-2.5-flash-lite": 8192,
+        "gemini-2.0-flash-001": 8192,
+        "claude-sonnet-4@20250514": 4096,
+        "claude-opus-4@20250514": 4096,
+        "claude-3-5-sonnet-20241022": 4096,
+        "claude-3-5-haiku-20241022": 4096,
+        "claude-3-sonnet-20240229": 4096,
+        "claude-3-haiku-20240307": 4096,
+        "claude-3-opus-20240229": 4096,
+        default: 4096,
+    },
+    /** AWS Bedrock model limits */
+    BEDROCK: {
+        "anthropic.claude-3-sonnet-20240229-v1:0": 4096,
+        "anthropic.claude-3-haiku-20240307-v1:0": 4096,
+        "anthropic.claude-3-5-sonnet-20240620-v1:0": 4096,
+        "anthropic.claude-3-opus-20240229-v1:0": 4096,
+        "arn:aws:bedrock:us-east-2:225681119357:inference-profile/us.anthropic.claude-3-7-sonnet-20250219-v1:0": 4096,
+        default: 4096,
+    },
+    /** Azure OpenAI model limits */
+    AZURE: {
+        "gpt-4o": 16384,
+        "gpt-4o-mini": 16384,
+        "gpt-4": 8192,
+        "gpt-35-turbo": 4096,
+        default: 8192,
+    },
+    /** Ollama model limits (local) */
+    OLLAMA: {
+        "llama3.2:latest": 8192,
+        llama2: 4096,
+        codellama: 8192,
+        mistral: 4096,
+        default: 8192, // Ollama typically supports higher limits
+    },
+    /** Hugging Face model limits */
+    HUGGINGFACE: {
+        default: 2048, // Conservative default for HuggingFace
+    },
+    /** Mistral model limits */
+    MISTRAL: {
+        "mistral-small-latest": 4096,
+        "mistral-medium-latest": 4096,
+        "mistral-large-latest": 8192,
+        default: 4096,
+    },
+    /** LiteLLM proxy limits */
+    LITELLM: {
+        default: 4096, // Conservative default
+    },
+    /** Safe default across all providers */
+    DEFAULT: 4096,
+};
+/**
+ * Context window sizes for different models
+ * Maximum input token limits (separate from output limits)
+ */
+export const CONTEXT_WINDOWS = {
+    /** Small context models */
+    SMALL: 4096, // 4K - Small context
+    /** Medium context models */
+    MEDIUM: 32768, // 32K - Medium context
+    /** Large context models */
+    LARGE: 128000, // 128K - Large context
+    /** Ultra-large context models */
+    ULTRA_LARGE: 1048576, // 1M - Ultra-large context
+    /** Maximum theoretical context */
+    MAXIMUM: 2097152, // 2M - Maximum context
+};
+/**
+ * Token estimation utilities
+ * Rough estimates for token counting without full tokenization
+ */
+export const TOKEN_ESTIMATION = {
+    /** Average characters per token (English) */
+    CHARS_PER_TOKEN: 4, // 4 chars - English average
+    /** Average words per token */
+    WORDS_PER_TOKEN: 0.75, // 0.75 words - English average
+    /** Code characters per token (more compact) */
+    CODE_CHARS_PER_TOKEN: 3, // 3 chars - Code is more compact
+    /** Safety margin for token estimates */
+    SAFETY_MARGIN: 0.8, // 80% - Safety margin for estimates
+};
+/**
+ * Token utility functions
+ */
+export const TokenUtils = {
+    /**
+     * Get safe token limit for a specific provider and model
+     * @param provider - Provider name
+     * @param model - Model name (optional)
+     * @returns Safe token limit for the provider/model
+     */
+    getProviderTokenLimit: (provider, model) => {
+        const normalizedProvider = provider.toLowerCase().replace(/[-_]/g, "");
+        let providerLimits;
+        switch (normalizedProvider) {
+            case "anthropic":
+                providerLimits = PROVIDER_TOKEN_LIMITS.ANTHROPIC;
+                break;
+            case "openai":
+                providerLimits = PROVIDER_TOKEN_LIMITS.OPENAI;
+                break;
+            case "googleai":
+                providerLimits = PROVIDER_TOKEN_LIMITS.GOOGLE_AI;
+                break;
+            case "vertex":
+                providerLimits = PROVIDER_TOKEN_LIMITS.VERTEX;
+                break;
+            case "bedrock":
+                providerLimits = PROVIDER_TOKEN_LIMITS.BEDROCK;
+                break;
+            case "azure":
+                providerLimits = PROVIDER_TOKEN_LIMITS.AZURE;
+                break;
+            case "ollama":
+                providerLimits = PROVIDER_TOKEN_LIMITS.OLLAMA;
+                break;
+            case "huggingface":
+                providerLimits = PROVIDER_TOKEN_LIMITS.HUGGINGFACE;
+                break;
+            case "mistral":
+                providerLimits = PROVIDER_TOKEN_LIMITS.MISTRAL;
+                break;
+            case "litellm":
+                providerLimits = PROVIDER_TOKEN_LIMITS.LITELLM;
+                break;
+            default:
+                return PROVIDER_TOKEN_LIMITS.DEFAULT;
+        }
+        if (model && providerLimits[model]) {
+            return providerLimits[model];
+        }
+        return providerLimits.default || PROVIDER_TOKEN_LIMITS.DEFAULT;
+    },
+    /**
+     * Get token limit for specific use case
+     * @param useCase - Use case type
+     * @returns Appropriate token limit
+     */
+    getUseCaseTokenLimit: (useCase) => {
+        return USE_CASE_TOKENS[useCase] || TOKEN_LIMITS.STANDARD;
+    },
+    /**
+     * Estimate token count from text
+     * @param text - Input text
+     * @param isCode - Whether the text is code (more compact tokenization)
+     * @returns Estimated token count
+     */
+    estimateTokenCount: (text, isCode = false) => {
+        const charsPerToken = isCode
+            ? TOKEN_ESTIMATION.CODE_CHARS_PER_TOKEN
+            : TOKEN_ESTIMATION.CHARS_PER_TOKEN;
+        const estimatedTokens = Math.ceil(text.length / charsPerToken);
+        // Apply safety margin
+        return Math.ceil(estimatedTokens / TOKEN_ESTIMATION.SAFETY_MARGIN);
+    },
+    /**
+     * Check if text exceeds token limit
+     * @param text - Input text
+     * @param limit - Token limit to check against
+     * @param isCode - Whether the text is code
+     * @returns True if text exceeds limit
+     */
+    exceedsTokenLimit: (text, limit, isCode = false) => {
+        const estimatedTokens = TokenUtils.estimateTokenCount(text, isCode);
+        return estimatedTokens > limit;
+    },
+    /**
+     * Get appropriate token limit category
+     * @param estimatedTokens - Estimated token count
+     * @returns Token limit category
+     */
+    getTokenLimitCategory: (estimatedTokens) => {
+        if (estimatedTokens <= TOKEN_LIMITS.CONSERVATIVE) {
+            return "CONSERVATIVE";
+        }
+        if (estimatedTokens <= TOKEN_LIMITS.STANDARD) {
+            return "STANDARD";
+        }
+        if (estimatedTokens <= TOKEN_LIMITS.HIGH_CAPACITY) {
+            return "HIGH_CAPACITY";
+        }
+        if (estimatedTokens <= TOKEN_LIMITS.LARGE_CONTEXT) {
+            return "LARGE_CONTEXT";
+        }
+        return "ULTRA_LARGE_CONTEXT";
+    },
+    /**
+     * Truncate text to fit within token limit
+     * @param text - Input text
+     * @param tokenLimit - Maximum tokens allowed
+     * @param isCode - Whether the text is code
+     * @returns Truncated text
+     */
+    truncateToTokenLimit: (text, tokenLimit, isCode = false) => {
+        const charsPerToken = isCode
+            ? TOKEN_ESTIMATION.CODE_CHARS_PER_TOKEN
+            : TOKEN_ESTIMATION.CHARS_PER_TOKEN;
+        // Apply safety margin
+        const maxChars = Math.floor(tokenLimit * charsPerToken * TOKEN_ESTIMATION.SAFETY_MARGIN);
+        if (text.length <= maxChars) {
+            return text;
+        }
+        // Truncate and add ellipsis
+        return text.substring(0, maxChars - 3) + "...";
+    },
+};
+// Legacy compatibility exports from existing constants
+export const DEFAULT_MAX_TOKENS = TOKEN_LIMITS.STANDARD;
+export const DEFAULT_EVALUATION_MAX_TOKENS = USE_CASE_TOKENS.EVALUATION;
+export const DEFAULT_ANALYSIS_MAX_TOKENS = USE_CASE_TOKENS.ANALYSIS;
+export const DEFAULT_DOCUMENTATION_MAX_TOKENS = USE_CASE_TOKENS.DOCUMENTATION;
+// Provider-specific safe defaults (from existing PROVIDER_MAX_TOKENS)
+export const ANTHROPIC_SAFE = PROVIDER_TOKEN_LIMITS.ANTHROPIC.default;
+export const OPENAI_STANDARD = PROVIDER_TOKEN_LIMITS.OPENAI.default;
+export const GOOGLE_STANDARD = PROVIDER_TOKEN_LIMITS.GOOGLE_AI.default;

package/dist/core/baseProvider.js

@@ -168,6 +168,31 @@ export class BaseProvider {
                     ...(options.tools || {}), // Include external tools passed from NeuroLink
                 }
                 : {};
+            // DEBUG: Log detailed tool information for generate
+            logger.debug("BaseProvider Generate - Tool Loading Debug", {
+                provider: this.providerName,
+                shouldUseTools,
+                baseToolsProvided: !!baseTools,
+                baseToolCount: baseTools ? Object.keys(baseTools).length : 0,
+                finalToolCount: tools ? Object.keys(tools).length : 0,
+                toolNames: tools ? Object.keys(tools).slice(0, 10) : [],
+                disableTools: options.disableTools,
+                supportsTools: this.supportsTools(),
+                externalToolsCount: options.tools
+                    ? Object.keys(options.tools).length
+                    : 0,
+            });
+            if (tools && Object.keys(tools).length > 0) {
+                logger.debug("BaseProvider Generate - First 5 Tools Detail", {
+                    provider: this.providerName,
+                    tools: Object.keys(tools)
+                        .slice(0, 5)
+                        .map((name) => ({
+                        name,
+                        description: tools[name]?.description?.substring(0, 100),
+                    })),
+                });
+            }
             logger.debug(`[BaseProvider.generate] Tools for ${this.providerName}:`, {
                 directTools: getKeyCount(baseTools),
                 directToolNames: getKeysAsString(baseTools),
@@ -187,7 +212,7 @@ export class BaseProvider {
                 maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
                 toolChoice: shouldUseTools ? "auto" : "none",
                 temperature: options.temperature,
-                maxTokens: options.maxTokens || 8192,
+                maxTokens: options.maxTokens, // No default limit - unlimited unless specified
             });
             // Accumulate the streamed content
             let accumulatedContent = "";

package/dist/core/constants.d.ts

@@ -2,7 +2,7 @@
  * Central configuration constants for NeuroLink
  * Single source of truth for all default values
  */
-export declare const DEFAULT_MAX_TOKENS = 8192;
+export declare const DEFAULT_MAX_TOKENS: undefined;
 export declare const DEFAULT_TEMPERATURE = 0.7;
 export declare const DEFAULT_TIMEOUT = 30000;
 export declare const DEFAULT_MAX_STEPS = 5;
@@ -67,6 +67,15 @@ export declare const PROVIDER_MAX_TOKENS: {
         "anthropic.claude-3-5-sonnet-20240620-v1:0": number;
         default: number;
     };
+    azure: {
+        "gpt-4o": number;
+        "gpt-4o-mini": number;
+        "gpt-4.1": number;
+        "gpt-3.5-turbo": number;
+        "gpt-4": number;
+        "gpt-4-turbo": number;
+        default: number;
+    };
     ollama: {
         default: number;
     };
@@ -79,7 +88,7 @@ export declare const CLI_LIMITS: {
     maxTokens: {
         min: number;
         max: number;
-        default: number;
+        default: undefined;
     };
     temperature: {
         min: number;
@@ -99,6 +108,6 @@ export declare const SYSTEM_LIMITS: {
     DEFAULT_BACKOFF_MULTIPLIER: number;
 };
 export declare const ENV_DEFAULTS: {
-    maxTokens: number;
+    maxTokens: number | undefined;
     temperature: number;
 };

package/dist/core/constants.js

@@ -3,7 +3,7 @@
  * Single source of truth for all default values
  */
 // Core AI Generation Defaults
-export const DEFAULT_MAX_TOKENS = 8192; // Changed from 10000 to fix Anthropic error
+export const DEFAULT_MAX_TOKENS = undefined; // Unlimited by default - let providers decide their own limits
 export const DEFAULT_TEMPERATURE = 0.7;
 export const DEFAULT_TIMEOUT = 30000;
 export const DEFAULT_MAX_STEPS = 5; // Default multi-turn tool execution steps
@@ -72,6 +72,15 @@ export const PROVIDER_MAX_TOKENS = {
         "anthropic.claude-3-5-sonnet-20240620-v1:0": 4096,
         default: 4096,
     },
+    azure: {
+        "gpt-4o": 16384,
+        "gpt-4o-mini": 16384,
+        "gpt-4.1": 16384,
+        "gpt-3.5-turbo": 4096,
+        "gpt-4": 8192,
+        "gpt-4-turbo": 4096,
+        default: 8192, // Azure OpenAI generally supports similar limits to OpenAI
+    },
     ollama: {
         default: 8192, // Ollama typically supports higher limits
     },
@@ -85,7 +94,7 @@ export const CLI_LIMITS = {
     maxTokens: {
         min: 1,
         max: 50000,
-        default: DEFAULT_MAX_TOKENS,
+        default: undefined, // No default limit - unlimited by default
     },
     temperature: {
         min: 0,
@@ -112,10 +121,17 @@ export const SYSTEM_LIMITS = {
 };
 // Environment Variable Support (for future use)
 export const ENV_DEFAULTS = {
-    maxTokens: process.env.NEUROLINK_DEFAULT_MAX_TOKENS
-        ? parseInt(process.env.NEUROLINK_DEFAULT_MAX_TOKENS, 10)
-        : DEFAULT_MAX_TOKENS,
+    maxTokens: (() => {
+        if (!process.env.NEUROLINK_DEFAULT_MAX_TOKENS) {
+            return undefined;
+        }
+        const n = parseInt(process.env.NEUROLINK_DEFAULT_MAX_TOKENS, 10);
+        return Number.isFinite(n) ? n : undefined;
+    })(),
     temperature: process.env.NEUROLINK_DEFAULT_TEMPERATURE
-        ? parseFloat(process.env.NEUROLINK_DEFAULT_TEMPERATURE)
+        ? (() => {
+            const t = parseFloat(process.env.NEUROLINK_DEFAULT_TEMPERATURE);
+            return Number.isFinite(t) ? t : DEFAULT_TEMPERATURE;
+        })()
         : DEFAULT_TEMPERATURE,
 };