@juspay/neurolink 6.1.0 → 6.2.1

package/dist/core/defaults.d.ts

@@ -1,19 +0,0 @@
-/**
- * Default value helper functions for NeuroLink
- * Centralized logic for applying defaults across the system
- */
-import type { UnknownRecord } from "../types/common.js";
-/**
- * Apply default values to options object
- * User-provided values take precedence over defaults
- */
-export declare function applyDefaults(options: UnknownRecord): UnknownRecord;
-/**
- * Get default max tokens for a specific provider
- * Can be extended for provider-specific overrides in the future
- */
-export declare function getDefaultMaxTokens(provider?: string): number;
-/**
- * Get default temperature for a specific use case
- */
-export declare function getDefaultTemperature(useCase?: string): number;

package/dist/core/defaults.js

@@ -1,29 +0,0 @@
-/**
- * Default value helper functions for NeuroLink
- * Centralized logic for applying defaults across the system
- */
-import { DEFAULT_MAX_TOKENS, DEFAULT_TEMPERATURE, ENV_DEFAULTS, } from "./constants.js";
-/**
- * Apply default values to options object
- * User-provided values take precedence over defaults
- */
-export function applyDefaults(options) {
-    return {
-        maxTokens: ENV_DEFAULTS.maxTokens,
-        temperature: ENV_DEFAULTS.temperature,
-        ...options, // User overrides take precedence
-    };
-}
-/**
- * Get default max tokens for a specific provider
- * Can be extended for provider-specific overrides in the future
- */
-export function getDefaultMaxTokens(provider) {
-    return ENV_DEFAULTS.maxTokens;
-}
-/**
- * Get default temperature for a specific use case
- */
-export function getDefaultTemperature(useCase) {
-    return ENV_DEFAULTS.temperature;
-}

package/dist/core/evaluation-config.d.ts

@@ -1,29 +0,0 @@
-import type { EvaluationConfig } from "./types.js";
-/**
- * Parse evaluation configuration from environment variables
- */
-export declare function parseEvaluationConfig(): EvaluationConfig;
-/**
- * Get intelligent provider fallback order
- */
-export declare function getProviderFallbackOrder(config: EvaluationConfig): string[];
-/**
- * Estimate evaluation cost
- */
-export declare function estimateEvaluationCost(providerName: string, mode: string, promptLength: number, expectedResponseLength?: number): number;
-/**
- * Validate evaluation configuration
- */
-export declare function validateEvaluationConfig(config: EvaluationConfig): string[];
-/**
- * Get configuration with validation and defaults
- */
-export declare function getValidatedEvaluationConfig(): EvaluationConfig;
-/**
- * Check if evaluation is enabled for the current configuration
- */
-export declare function isEvaluationEnabled(): boolean;
-/**
- * Get cost-optimized provider based on configuration
- */
-export declare function getCostOptimizedProvider(config: EvaluationConfig): string | null;

package/dist/core/evaluation-config.js

@@ -1,144 +0,0 @@
-import { getAvailableProviders, sortProvidersByPreference, getProviderConfig, } from "./evaluation-providers.js";
-import { logger } from "../utils/logger.js";
-/**
- * Parse evaluation configuration from environment variables
- */
-export function parseEvaluationConfig() {
-    return {
-        provider: process.env.NEUROLINK_EVALUATION_PROVIDER || "google-ai",
-        model: process.env.NEUROLINK_EVALUATION_MODEL || "gemini-2.5-flash",
-        mode: process.env.NEUROLINK_EVALUATION_MODE || "fast",
-        fallbackEnabled: process.env.NEUROLINK_EVALUATION_FALLBACK_ENABLED !== "false",
-        fallbackProviders: (process.env.NEUROLINK_EVALUATION_FALLBACK_PROVIDERS ||
-            "openai,anthropic,vertex,bedrock").split(","),
-        timeout: parseInt(process.env.NEUROLINK_EVALUATION_TIMEOUT || "10000"),
-        maxTokens: parseInt(process.env.NEUROLINK_EVALUATION_MAX_TOKENS || "500"),
-        temperature: parseFloat(process.env.NEUROLINK_EVALUATION_TEMPERATURE || "0.1"),
-        preferCheap: process.env.NEUROLINK_EVALUATION_PREFER_CHEAP !== "false",
-        maxCostPerEval: parseFloat(process.env.NEUROLINK_EVALUATION_MAX_COST_PER_EVAL || "0.01"),
-        retryAttempts: parseInt(process.env.NEUROLINK_EVALUATION_RETRY_ATTEMPTS || "2"),
-    };
-}
-/**
- * Get intelligent provider fallback order
- */
-export function getProviderFallbackOrder(config) {
-    const available = getAvailableProviders();
-    const sorted = sortProvidersByPreference(available, config.preferCheap);
-    // Start with user's preferred provider
-    const fallbackOrder = [config.provider];
-    // Add configured fallbacks
-    config.fallbackProviders.forEach((provider) => {
-        if (!fallbackOrder.includes(provider)) {
-            fallbackOrder.push(provider);
-        }
-    });
-    // Add remaining available providers
-    sorted.forEach((providerConfig) => {
-        if (!fallbackOrder.includes(providerConfig.provider)) {
-            fallbackOrder.push(providerConfig.provider);
-        }
-    });
-    logger.debug("[EvaluationConfig] Provider fallback order:", fallbackOrder);
-    return fallbackOrder;
-}
-/**
- * Estimate evaluation cost
- */
-export function estimateEvaluationCost(providerName, mode, promptLength, expectedResponseLength = 200) {
-    const config = getProviderConfig(providerName);
-    if (!config || !config.costPerToken) {
-        return 0;
-    }
-    const inputTokens = Math.ceil(promptLength / 4); // Rough token estimation
-    const outputTokens = expectedResponseLength / 4;
-    return (inputTokens * config.costPerToken.input +
-        outputTokens * config.costPerToken.output);
-}
-/**
- * Validate evaluation configuration
- */
-export function validateEvaluationConfig(config) {
-    const errors = [];
-    // Validate provider
-    if (!getProviderConfig(config.provider)) {
-        errors.push(`Invalid provider: ${config.provider}`);
-    }
-    // Validate mode
-    if (!["fast", "balanced", "quality"].includes(config.mode)) {
-        errors.push(`Invalid mode: ${config.mode}. Must be 'fast', 'balanced', or 'quality'`);
-    }
-    // Validate timeout
-    if (config.timeout <= 0 || config.timeout > 60000) {
-        errors.push(`Invalid timeout: ${config.timeout}. Must be between 1 and 60000ms`);
-    }
-    // Validate max tokens
-    if (config.maxTokens <= 0 || config.maxTokens > 4000) {
-        errors.push(`Invalid maxTokens: ${config.maxTokens}. Must be between 1 and 4000`);
-    }
-    // Validate temperature
-    if (config.temperature < 0 || config.temperature > 2) {
-        errors.push(`Invalid temperature: ${config.temperature}. Must be between 0 and 2`);
-    }
-    // Validate max cost
-    if (config.maxCostPerEval <= 0) {
-        errors.push(`Invalid maxCostPerEval: ${config.maxCostPerEval}. Must be greater than 0`);
-    }
-    // Validate retry attempts
-    if (config.retryAttempts < 0 || config.retryAttempts > 5) {
-        errors.push(`Invalid retryAttempts: ${config.retryAttempts}. Must be between 0 and 5`);
-    }
-    return errors;
-}
-/**
- * Get configuration with validation and defaults
- */
-export function getValidatedEvaluationConfig() {
-    const config = parseEvaluationConfig();
-    const errors = validateEvaluationConfig(config);
-    if (errors.length > 0) {
-        logger.warn("[EvaluationConfig] Configuration validation errors:", errors);
-        // Return default configuration if validation fails
-        return {
-            provider: "google-ai",
-            model: "gemini-2.5-flash",
-            mode: "fast",
-            fallbackEnabled: true,
-            fallbackProviders: ["openai", "anthropic"],
-            timeout: 10000,
-            maxTokens: 500,
-            temperature: 0.1,
-            preferCheap: true,
-            maxCostPerEval: 0.01,
-            retryAttempts: 2,
-        };
-    }
-    return config;
-}
-/**
- * Check if evaluation is enabled for the current configuration
- */
-export function isEvaluationEnabled() {
-    // Check if at least one provider is available
-    const available = getAvailableProviders();
-    return available.length > 0;
-}
-/**
- * Get cost-optimized provider based on configuration
- */
-export function getCostOptimizedProvider(config) {
-    const available = getAvailableProviders();
-    if (available.length === 0) {
-        return null;
-    }
-    const sorted = sortProvidersByPreference(available, true); // Always prefer cheap for cost optimization
-    // Find the cheapest provider that meets cost requirements
-    for (const providerConfig of sorted) {
-        const estimatedCost = estimateEvaluationCost(providerConfig.provider, config.mode, 1000);
-        if (estimatedCost <= config.maxCostPerEval) {
-            return providerConfig.provider;
-        }
-    }
-    // If no provider meets cost requirements, return the cheapest one
-    return sorted[0].provider;
-}

package/dist/factories/compatibility-factory.d.ts

@@ -1,35 +0,0 @@
-import type { GenerateOptions, GenerateResult } from "../types/generate-types.js";
-import type { TextGenerationOptions } from "../core/types.js";
-/**
- * Compatibility conversion factory for seamless migration
- * between generateText and generate functions
- */
-export declare class CompatibilityConversionFactory {
-    /**
-     * Convert TextGenerationOptions to GenerateOptions
-     */
-    static convertTextToGenerate(options: TextGenerationOptions): GenerateOptions;
-    /**
-     * Convert GenerateResult to legacy TextGenerationResult format
-     */
-    static convertGenerateToText(result: GenerateResult): {
-        content: string;
-        provider?: string;
-        model?: string;
-        usage?: {
-            inputTokens: number;
-            outputTokens: number;
-            totalTokens: number;
-        };
-        responseTime?: number;
-        toolsUsed?: number;
-        toolExecutions?: unknown[];
-        analytics?: unknown;
-        evaluation?: unknown;
-        [key: string]: unknown;
-    };
-    /**
-     * Convert GenerateOptions to TextGenerationOptions
-     */
-    static convertGenerateToText_Options(options: GenerateOptions): TextGenerationOptions;
-}

package/dist/factories/compatibility-factory.js

@@ -1,71 +0,0 @@
-/**
- * Compatibility conversion factory for seamless migration
- * between generateText and generate functions
- */
-export class CompatibilityConversionFactory {
-    /**
-     * Convert TextGenerationOptions to GenerateOptions
-     */
-    static convertTextToGenerate(options) {
-        const { prompt, ...rest } = options;
-        return {
-            input: { text: prompt || "" },
-            output: { format: "text" },
-            provider: rest.provider,
-            model: rest.model,
-            temperature: rest.temperature,
-            maxTokens: rest.maxTokens,
-            systemPrompt: rest.systemPrompt,
-            schema: rest.schema,
-            tools: rest.tools,
-            timeout: rest.timeout,
-            enableEvaluation: rest.enableEvaluation,
-            enableAnalytics: rest.enableAnalytics,
-            context: rest.context,
-            evaluationDomain: rest.evaluationDomain,
-            toolUsageContext: rest.toolUsageContext,
-            conversationHistory: rest.conversationHistory,
-        };
-    }
-    /**
-     * Convert GenerateResult to legacy TextGenerationResult format
-     */
-    static convertGenerateToText(result) {
-        return {
-            content: result.content,
-            provider: result.provider,
-            model: result.model,
-            usage: result.usage,
-            responseTime: result.responseTime,
-            toolsUsed: Array.isArray(result.toolsUsed)
-                ? result.toolsUsed.length
-                : result.toolsUsed,
-            toolExecutions: result.toolExecutions,
-            enhancedWithTools: result.enhancedWithTools,
-            availableTools: result.availableTools,
-            analytics: result.analytics,
-            evaluation: result.evaluation,
-        };
-    }
-    /**
-     * Convert GenerateOptions to TextGenerationOptions
-     */
-    static convertGenerateToText_Options(options) {
-        return {
-            prompt: options.input.text,
-            model: options.model,
-            temperature: options.temperature,
-            maxTokens: options.maxTokens,
-            systemPrompt: options.systemPrompt,
-            schema: options.schema,
-            tools: options.tools,
-            timeout: options.timeout,
-            enableEvaluation: options.enableEvaluation,
-            enableAnalytics: options.enableAnalytics,
-            context: options.context,
-            evaluationDomain: options.evaluationDomain,
-            toolUsageContext: options.toolUsageContext,
-            conversationHistory: options.conversationHistory,
-        };
-    }
-}

package/dist/factories/provider-generate-factory.d.ts

@@ -1,20 +0,0 @@
-import type { EnhancedProvider } from "../types/generate-types.js";
-import type { AIProvider } from "../core/types.js";
-/**
- * Factory for enhancing providers with generate() capability using Proxy pattern
- * Maintains 100% backward compatibility while adding new generate method
- */
-export declare class ProviderGenerateFactory {
-    /**
-     * Enhance any provider with generate() method using TypeScript Proxy
-     */
-    static enhanceProvider<T extends AIProvider>(provider: T): T & EnhancedProvider;
-    /**
-     * Create the generate() method that internally uses generateText for performance parity
-     */
-    private static createGenerateMethod;
-    /**
-     * Enhance all providers from a registry
-     */
-    static enhanceAllProviders(providers: Map<string, AIProvider>): Map<string, AIProvider & EnhancedProvider>;
-}

package/dist/factories/provider-generate-factory.js

@@ -1,93 +0,0 @@
-import { CompatibilityConversionFactory } from "./compatibility-factory.js";
-/**
- * Factory for enhancing providers with generate() capability using Proxy pattern
- * Maintains 100% backward compatibility while adding new generate method
- */
-export class ProviderGenerateFactory {
-    /**
-     * Enhance any provider with generate() method using TypeScript Proxy
-     */
-    static enhanceProvider(provider) {
-        return new Proxy(provider, {
-            get(target, prop, receiver) {
-                if (prop === "generate") {
-                    return ProviderGenerateFactory.createGenerateMethod(target);
-                }
-                return Reflect.get(target, prop, receiver);
-            },
-            has(target, prop) {
-                if (prop === "generate") {
-                    return true;
-                }
-                return Reflect.has(target, prop);
-            },
-        });
-    }
-    /**
-     * Create the generate() method that internally uses generateText for performance parity
-     */
-    static createGenerateMethod(provider) {
-        return async (options) => {
-            // Validate input
-            if (!options.input?.text) {
-                throw new Error("Generate options must include input.text");
-            }
-            // Convert GenerateOptions to TextGenerationOptions
-            const textOptions = CompatibilityConversionFactory.convertGenerateToText_Options(options);
-            try {
-                // Use existing generate method for identical performance
-                const textResult = await provider.generate(textOptions);
-                if (!textResult) {
-                    throw new Error("Generate method returned null result");
-                }
-                // Convert back to GenerateResult format with type safety
-                const generateResult = {
-                    content: textResult.content || "",
-                    outputs: { text: textResult.content || "" },
-                    provider: textResult.provider,
-                    model: textResult.model,
-                    usage: textResult.usage
-                        ? {
-                            inputTokens: textResult.usage.inputTokens || 0,
-                            outputTokens: textResult.usage.outputTokens || 0,
-                            totalTokens: textResult.usage.totalTokens || 0,
-                        }
-                        : undefined,
-                    responseTime: textResult.responseTime,
-                    toolsUsed: textResult.toolsUsed,
-                    toolExecutions: textResult.toolExecutions?.map((te) => {
-                        const toolExecution = te;
-                        return {
-                            name: toolExecution.toolName || toolExecution.name || "",
-                            input: toolExecution.input || {},
-                            output: toolExecution.output || toolExecution.result,
-                            duration: toolExecution.executionTime || toolExecution.duration || 0,
-                        };
-                    }),
-                    enhancedWithTools: textResult.enhancedWithTools,
-                    availableTools: textResult.availableTools?.map((at) => ({
-                        name: at.name || "",
-                        description: at.description || "",
-                        parameters: at.parameters || {},
-                    })),
-                    analytics: textResult.analytics,
-                    evaluation: textResult.evaluation,
-                };
-                return generateResult;
-            }
-            catch (error) {
-                throw new Error(`Generate method failed: ${error}`);
-            }
-        };
-    }
-    /**
-     * Enhance all providers from a registry
-     */
-    static enhanceAllProviders(providers) {
-        const enhancedProviders = new Map();
-        for (const [name, provider] of providers) {
-            enhancedProviders.set(name, this.enhanceProvider(provider));
-        }
-        return enhancedProviders;
-    }
-}

package/dist/lib/chat/client-utils.d.ts

@@ -1,95 +0,0 @@
-/**
- * Phase 3: SSE Chat Utilities
- * Client-side utilities for SSE chat integration
- */
-import type { ChatMessage } from "./types.js";
-export interface ChatClientOptions {
-    endpoint: string;
-    sessionId: string;
-    onMessage?: (message: ChatMessage) => void;
-    onError?: (error: Error) => void;
-    onConnect?: () => void;
-    onDisconnect?: () => void;
-    reconnectAttempts?: number;
-    reconnectDelay?: number;
-}
-export interface ChatStreamHook {
-    messages: ChatMessage[];
-    isConnected: boolean;
-    isReconnecting: boolean;
-    sendMessage: (content: string) => Promise<void>;
-    disconnect: () => void;
-    reconnect: () => void;
-    clearHistory: () => void;
-}
-/**
- * Client for SSE chat communication
- */
-export declare class ChatClient {
-    private eventSource?;
-    private options;
-    private messages;
-    private reconnectCount;
-    private isConnected;
-    private isReconnecting;
-    private reconnectTimeout?;
-    constructor(options: ChatClientOptions);
-    /**
-     * Connect to SSE endpoint
-     */
-    connect(): void;
-    /**
-     * Send message to chat
-     */
-    sendMessage(content: string): Promise<void>;
-    /**
-     * Disconnect from SSE endpoint
-     */
-    disconnect(): void;
-    /**
-     * Get message history
-     */
-    getMessages(): ChatMessage[];
-    /**
-     * Clear message history
-     */
-    clearMessages(): void;
-    /**
-     * Check connection status
-     */
-    getConnectionStatus(): {
-        connected: boolean;
-        reconnecting: boolean;
-        reconnectCount: number;
-    };
-    private handleSSEEvent;
-    private isDataEventData;
-    private isErrorEventData;
-    private isCompleteEventData;
-    private handleDataEvent;
-    private handleErrorEvent;
-    private handleCompleteEvent;
-    private scheduleReconnect;
-}
-/**
- * Create chat client instance
- */
-export declare function createChatClient(options: ChatClientOptions): ChatClient;
-/**
- * React-style hook for chat streaming (can be adapted for other frameworks)
- */
-export declare function useChatStream(options: ChatClientOptions): ChatStreamHook;
-/**
- * Utility for creating SSE EventSource with automatic reconnection
- */
-export declare function createSSEConnection(url: string, options?: {
-    onMessage?: (event: MessageEvent) => void;
-    onError?: (error: Error) => void;
-    onOpen?: () => void;
-    reconnect?: boolean;
-    maxReconnectAttempts?: number;
-}): {
-    connect: () => void;
-    disconnect: () => void;
-    isConnected: () => boolean;
-};