@juspay/neurolink 7.36.0 → 7.37.1

package/dist/core/constants.d.ts

@@ -4,8 +4,8 @@
  */
 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;
+export declare const DEFAULT_TIMEOUT = 60000;
+export declare const DEFAULT_MAX_STEPS = 200;
 export declare const STEP_LIMITS: {
     min: number;
     max: number;
@@ -31,49 +31,21 @@ export declare const PROVIDER_CONFIG: {
 };
 export declare const PROVIDER_MAX_TOKENS: {
     anthropic: {
-        "claude-3-haiku-20240307": number;
-        "claude-3-5-sonnet-20241022": number;
-        "claude-3-opus-20240229": number;
-        "claude-3-5-sonnet-20240620": number;
         default: number;
     };
     openai: {
-        "gpt-4o": number;
-        "gpt-4o-mini": number;
-        "gpt-3.5-turbo": number;
-        "gpt-4": number;
-        "gpt-4-turbo": number;
         default: number;
     };
     "google-ai": {
-        "gemini-1.5-pro": number;
-        "gemini-1.5-flash": number;
-        "gemini-2.5-pro": number;
-        "gemini-2.5-flash": number;
-        "gemini-pro": number;
         default: number;
     };
     vertex: {
-        "gemini-1.5-pro": number;
-        "gemini-1.5-flash": number;
-        "gemini-2.5-pro": number;
-        "gemini-2.5-flash": number;
-        "claude-4.0-sonnet": number;
         default: number;
     };
     bedrock: {
-        "anthropic.claude-3-sonnet-20240229-v1:0": number;
-        "anthropic.claude-3-haiku-20240307-v1:0": number;
-        "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: {

package/dist/core/constants.js

@@ -5,12 +5,12 @@
 // Core AI Generation Defaults
 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
+export const DEFAULT_TIMEOUT = 60000;
+export const DEFAULT_MAX_STEPS = 200;
 // Step execution limits
 export const STEP_LIMITS = {
     min: 1,
-    max: 20,
+    max: 500,
     default: DEFAULT_MAX_STEPS,
 };
 // Specialized Use Case Defaults
@@ -33,68 +33,40 @@ export const PROVIDER_CONFIG = {
         temperature: 0.4,
     },
 };
-// Provider-specific maxTokens limits (discovered through testing)
+// Provider-specific maxTokens limits
 export const PROVIDER_MAX_TOKENS = {
     anthropic: {
-        "claude-3-haiku-20240307": 4096,
-        "claude-3-5-sonnet-20241022": 4096,
-        "claude-3-opus-20240229": 4096,
-        "claude-3-5-sonnet-20240620": 4096,
-        default: 4096, // Conservative default for Anthropic
+        default: 64000,
     },
     openai: {
-        "gpt-4o": 16384,
-        "gpt-4o-mini": 16384,
-        "gpt-3.5-turbo": 4096,
-        "gpt-4": 8192,
-        "gpt-4-turbo": 4096,
-        default: 8192, // OpenAI generally supports higher limits
+        default: 500000,
     },
     "google-ai": {
-        "gemini-1.5-pro": 8192,
-        "gemini-1.5-flash": 8192,
-        "gemini-2.5-pro": 8192,
-        "gemini-2.5-flash": 8192,
-        "gemini-pro": 4096,
-        default: 4096, // Conservative default due to 500 errors at high limits
+        default: 64000,
     },
     vertex: {
-        "gemini-1.5-pro": 8192,
-        "gemini-1.5-flash": 8192,
-        "gemini-2.5-pro": 8192,
-        "gemini-2.5-flash": 8192,
-        "claude-4.0-sonnet": 4096,
-        default: 4096,
+        default: 64000,
     },
     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,
-        default: 4096,
+        default: 64000,
     },
     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
+        default: 64000,
     },
     ollama: {
-        default: 8192, // Ollama typically supports higher limits
+        default: 64000,
     },
     litellm: {
-        default: 4096, // Conservative default
+        default: 500000,
     },
-    default: 4096, // Safe default across all providers
+    default: 64000,
 };
 // CLI Validation Limits
 export const CLI_LIMITS = {
     maxTokens: {
         min: 1,
-        max: 50000,
-        default: undefined, // No default limit - unlimited by default
+        max: 64000,
+        default: DEFAULT_MAX_TOKENS,
     },
     temperature: {
         min: 0,

package/dist/factories/providerFactory.js

@@ -49,16 +49,33 @@ export class ProviderFactory {
             model = model || registration.defaultModel;
         }
         try {
+            if (typeof registration.constructor !== "function") {
+                throw new Error(`Invalid constructor for provider ${providerName}: not a function`);
+            }
             let result;
             try {
-                // Try as async factory function first (most providers are async functions)
-                result = await registration.constructor(model, providerName, sdk);
+                const factoryResult = registration.constructor(model, providerName, sdk);
+                // Handle both sync and async results
+                result =
+                    factoryResult instanceof Promise
+                        ? await factoryResult
+                        : factoryResult;
             }
-            catch {
-                // Fallback to constructor - ensure parameters are maintained
-                result = new registration.constructor(model, providerName, sdk);
+            catch (factoryError) {
+                if (registration.constructor.prototype &&
+                    registration.constructor.prototype.constructor ===
+                        registration.constructor) {
+                    try {
+                        result = new registration.constructor(model, providerName, sdk);
+                    }
+                    catch (constructorError) {
+                        throw new Error(`Both factory function and constructor failed. Factory error: ${factoryError}. Constructor error: ${constructorError}`);
+                    }
+                }
+                else {
+                    throw factoryError;
+                }
             }
-            // Return result (no need to await again if already awaited in try block)
             return result;
         }
         catch (error) {

package/dist/index.d.ts

@@ -17,7 +17,8 @@ export { BedrockModels, OpenAIModels, VertexModels, DEFAULT_PROVIDER_CONFIGS, }
 export { getBestProvider, getAvailableProviders, isValidProvider, } from "./utils/providerUtils.js";
 export { dynamicModelProvider } from "./core/dynamicModels.js";
 export type { DynamicModelConfig, ModelRegistry } from "./types/modelTypes.js";
-export { NeuroLink } from "./neurolink.js";
+import { NeuroLink } from "./neurolink.js";
+export { NeuroLink };
 export type { ProviderStatus, MCPStatus } from "./neurolink.js";
 export type { MCPServerInfo } from "./types/mcpTypes.js";
 export type { NeuroLinkMiddleware, MiddlewareContext, MiddlewareFactoryOptions, MiddlewarePreset, MiddlewareConfig, } from "./types/middlewareTypes.js";
@@ -102,4 +103,4 @@ export type { TextGenerationOptions, TextGenerationResult, AnalyticsData, Evalua
  * console.log(result.content);
  * ```
  */
-export declare function generateText(options: import("./types/index.js").TextGenerationOptions): Promise<import("./types/index.js").TextGenerationResult>;
+export declare function generateText(options: import("./core/types.js").TextGenerationOptions): Promise<import("./core/types.js").TextGenerationResult>;

package/dist/index.js

@@ -17,7 +17,8 @@ export { getBestProvider, getAvailableProviders, isValidProvider, } from "./util
 // Dynamic Models exports
 export { dynamicModelProvider } from "./core/dynamicModels.js";
 // Main NeuroLink wrapper class and diagnostic types
-export { NeuroLink } from "./neurolink.js";
+import { NeuroLink } from "./neurolink.js";
+export { NeuroLink };
 export { MiddlewareFactory } from "./middleware/factory.js";
 // Version
 export const VERSION = "1.0.0";
@@ -127,7 +128,7 @@ export function getTelemetryStatus() {
  * ```
  */
 export async function generateText(options) {
-    // Import neurolink instance to avoid circular dependencies
-    const { neurolink } = await import("./neurolink.js");
+    // Create instance on-demand without auto-instantiation
+    const neurolink = new NeuroLink();
     return await neurolink.generateText(options);
 }

package/dist/lib/config/taskClassificationConfig.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Task Classification Configuration
+ * Contains patterns, keywords, and scoring weights for task classification
+ */
+/**
+ * Regular expression patterns that indicate fast response tasks
+ */
+export declare const FAST_PATTERNS: RegExp[];
+/**
+ * Regular expression patterns that indicate reasoning tasks
+ */
+export declare const REASONING_PATTERNS: RegExp[];
+/**
+ * Keywords that indicate fast tasks regardless of context
+ */
+export declare const FAST_KEYWORDS: string[];
+/**
+ * Keywords that indicate reasoning tasks regardless of context
+ */
+export declare const REASONING_KEYWORDS: string[];
+/**
+ * Scoring weights for different classification factors
+ */
+export declare const SCORING_WEIGHTS: {
+    readonly SHORT_PROMPT_BONUS: 2;
+    readonly LONG_PROMPT_BONUS: 1;
+    readonly PATTERN_MATCH_SCORE: 3;
+    readonly KEYWORD_MATCH_SCORE: 1;
+    readonly MULTIPLE_QUESTIONS_BONUS: 1;
+    readonly MULTI_SENTENCE_BONUS: 1;
+    readonly TECHNICAL_DOMAIN_BONUS: 1;
+    readonly SIMPLE_DEFINITION_BONUS: 2;
+};
+/**
+ * Classification thresholds and constraints
+ */
+export declare const CLASSIFICATION_THRESHOLDS: {
+    readonly SHORT_PROMPT_LENGTH: 50;
+    readonly LONG_PROMPT_LENGTH: 200;
+    readonly SIMPLE_DEFINITION_LENGTH: 100;
+    readonly MIN_CONFIDENCE: 0.6;
+    readonly MAX_CONFIDENCE: 0.95;
+    readonly DEFAULT_CONFIDENCE: 0.5;
+};
+/**
+ * Domain-specific patterns for enhanced classification
+ */
+export declare const DOMAIN_PATTERNS: {
+    readonly TECHNICAL: RegExp;
+    readonly SIMPLE_DEFINITION: RegExp;
+};

package/dist/lib/config/taskClassificationConfig.js

@@ -0,0 +1,148 @@
+/**
+ * Task Classification Configuration
+ * Contains patterns, keywords, and scoring weights for task classification
+ */
+/**
+ * Regular expression patterns that indicate fast response tasks
+ */
+export const FAST_PATTERNS = [
+    // Greetings and social
+    /^(hi|hello|hey|good morning|good afternoon|good evening)/i,
+    /^(thanks?|thank you|thx)/i,
+    /^(yes|no|ok|okay|sure|fine)/i,
+    // Simple questions
+    /^what is\s+\w+\??$/i,
+    /^how are you/i,
+    /^tell me about\s+\w+$/i,
+    // Simple requests
+    /^(list|show|display)\s+/i,
+    /^give me\s+/i,
+    /^can you\s+(help|assist)/i,
+    // Simple definitions
+    /^define\s+/i,
+    /^meaning of\s+/i,
+    /^what does\s+\w+\s+mean/i,
+    // Quick facts
+    /^when (is|was|did)/i,
+    /^where (is|was)/i,
+    /^who (is|was)/i,
+    // Simple translations
+    /^translate\s+["'].*["']\s+to\s+\w+/i,
+    /^how do you say\s+/i,
+];
+/**
+ * Regular expression patterns that indicate reasoning tasks
+ */
+export const REASONING_PATTERNS = [
+    // Analysis and comparison
+    /\b(analyz|compar|evaluat|assess|examin)\w*/i,
+    /\b(pros and cons|advantages and disadvantages)/i,
+    /\b(better|worse|best|worst)\b.*\b(than|versus|vs)\b/i,
+    // Problem solving
+    /\b(solve|solution|problem|issue|challenge)\b/i,
+    /\b(how to|step by step|strategy|approach)\b/i,
+    /\b(optimize|improve|enhance|maximize|minimize)\b/i,
+    // Planning and design
+    /\b(plan|design|architect|structure|framework)\b/i,
+    /\b(implement|develop|build|create|construct)\b/i,
+    /\b(roadmap|timeline|schedule|phases)\b/i,
+    // Complex questions
+    /\b(why|explain|reason|cause|effect|impact)\b/i,
+    /\b(implications|consequences|considerations)\b/i,
+    /\b(should I|would you recommend|what if)\b/i,
+    // Research and investigation
+    /\b(research|investigate|explore|discover)\b/i,
+    /\b(evidence|proof|validate|verify)\b/i,
+    /\b(trends|patterns|insights|conclusions)\b/i,
+    // Business and strategy
+    /\b(business|strategy|market|competitive|financial)\b/i,
+    /\b(ROI|revenue|profit|investment|budget)\b/i,
+    /\b(stakeholder|customer|user experience|UX)\b/i,
+    // Technical complexity
+    /\b(algorithm|architecture|system|infrastructure)\b/i,
+    /\b(performance|scalability|security|reliability)\b/i,
+    /\b(integration|API|database|server)\b/i,
+];
+/**
+ * Keywords that indicate fast tasks regardless of context
+ */
+export const FAST_KEYWORDS = [
+    "quick",
+    "simple",
+    "brief",
+    "short",
+    "summary",
+    "overview",
+    "definition",
+    "meaning",
+    "list",
+    "show",
+    "display",
+    "name",
+    "tell",
+    "what",
+    "when",
+    "where",
+    "who",
+    "how many",
+    "count",
+];
+/**
+ * Keywords that indicate reasoning tasks regardless of context
+ */
+export const REASONING_KEYWORDS = [
+    "complex",
+    "detailed",
+    "comprehensive",
+    "thorough",
+    "in-depth",
+    "analyze",
+    "compare",
+    "evaluate",
+    "assess",
+    "research",
+    "investigate",
+    "strategy",
+    "plan",
+    "design",
+    "solve",
+    "optimize",
+    "recommend",
+    "explain",
+    "why",
+    "justify",
+    "pros",
+    "cons",
+    "trade-offs",
+];
+/**
+ * Scoring weights for different classification factors
+ */
+export const SCORING_WEIGHTS = {
+    SHORT_PROMPT_BONUS: 2,
+    LONG_PROMPT_BONUS: 1,
+    PATTERN_MATCH_SCORE: 3,
+    KEYWORD_MATCH_SCORE: 1,
+    MULTIPLE_QUESTIONS_BONUS: 1,
+    MULTI_SENTENCE_BONUS: 1,
+    TECHNICAL_DOMAIN_BONUS: 1,
+    SIMPLE_DEFINITION_BONUS: 2,
+};
+/**
+ * Classification thresholds and constraints
+ */
+export const CLASSIFICATION_THRESHOLDS = {
+    SHORT_PROMPT_LENGTH: 50,
+    LONG_PROMPT_LENGTH: 200,
+    SIMPLE_DEFINITION_LENGTH: 100,
+    MIN_CONFIDENCE: 0.6,
+    MAX_CONFIDENCE: 0.95,
+    DEFAULT_CONFIDENCE: 0.5,
+};
+/**
+ * Domain-specific patterns for enhanced classification
+ */
+export const DOMAIN_PATTERNS = {
+    TECHNICAL: /\b(code|programming|development|software)\b/i,
+    SIMPLE_DEFINITION: /\b(definition|meaning|what is)\b/i,
+};

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

@@ -34,6 +34,39 @@ export declare abstract class BaseProvider implements AIProvider {
      * When tools are involved, falls back to generate() with synthetic streaming
      */
     stream(optionsOrPrompt: StreamOptions | string, analysisSchema?: ValidationSchema): Promise<StreamResult>;
+    /**
+     * Prepare generation context including tools and model
+     */
+    private prepareGenerationContext;
+    /**
+     * Build messages array for generation
+     */
+    private buildMessages;
+    /**
+     * Execute the generation with AI SDK
+     */
+    private executeGeneration;
+    /**
+     * Log generation completion information
+     */
+    private logGenerationComplete;
+    /**
+     * Record performance metrics
+     */
+    private recordPerformanceMetrics;
+    /**
+     * Extract tool information from generation result
+     */
+    private extractToolInformation;
+    /**
+     * Format the enhanced result
+     */
+    private formatEnhancedResult;
+    /**
+     * Analyze AI response structure and log detailed debugging information
+     * Extracted from generate method to reduce complexity
+     */
+    private analyzeAIResponse;
     /**
      * Text generation method - implements AIProvider interface
      * Tools are always available unless explicitly disabled
@@ -85,12 +118,17 @@ export declare abstract class BaseProvider implements AIProvider {
     private isZodSchema;
     /**
      * Convert tool execution result from MCP format to standard format
+     * Handles tool failures gracefully to prevent stream termination
      */
     private convertToolResult;
     /**
      * Create a custom tool from tool definition
      */
     private createCustomToolFromDefinition;
+    /**
+     * Process direct tools with event emission wrapping
+     */
+    private processDirectTools;
     /**
      * Process custom tools from setupToolExecutor
      */
@@ -117,10 +155,9 @@ export declare abstract class BaseProvider implements AIProvider {
      */
     private calculateActualCost;
     /**
-     * Convert MCP JSON Schema to Zod schema for AI SDK tools
-     * Handles common MCP schema patterns safely
+     * Create a permissive Zod schema that accepts all parameters as-is
      */
-    private convertMCPSchemaToZod;
+    private createPermissiveZodSchema;
     /**
      * Set session context for MCP tools
      */