@juspay/neurolink 6.1.0 → 6.2.1

package/dist/providers/analytics-helper.js

@@ -1,216 +0,0 @@
-/**
- * Enhanced Analytics Helper for All Providers
- * Ensures consistent analytics data format across providers
- * Integrates with Universal Evaluation System
- */
-// Type guard for checking if an unknown value is a number
-function isNumber(value) {
-    return typeof value === "number" && !isNaN(value);
-}
-// Type guard for checking if an unknown value is an object
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-/**
- * Create standardized analytics data from provider response
- */
-export function createAnalytics(provider, model, result, responseTime, context) {
-    // Handle different token usage formats across providers
-    const tokenUsage = result?.usage || {};
-    // Standardize token field names across providers
-    const inputTokens = (typeof tokenUsage.promptTokens === "number"
-        ? tokenUsage.promptTokens
-        : 0) ||
-        (typeof tokenUsage.input_tokens === "number"
-            ? tokenUsage.input_tokens
-            : 0) ||
-        (typeof tokenUsage.inputTokens === "number" ? tokenUsage.inputTokens : 0) ||
-        0;
-    const outputTokens = (typeof tokenUsage.completionTokens === "number"
-        ? tokenUsage.completionTokens
-        : 0) ||
-        (typeof tokenUsage.output_tokens === "number"
-            ? tokenUsage.output_tokens
-            : 0) ||
-        (typeof tokenUsage.outputTokens === "number"
-            ? tokenUsage.outputTokens
-            : 0) ||
-        0;
-    const totalTokens = (typeof tokenUsage.totalTokens === "number" ? tokenUsage.totalTokens : 0) ||
-        (typeof tokenUsage.total_tokens === "number"
-            ? tokenUsage.total_tokens
-            : 0) ||
-        inputTokens + outputTokens ||
-        0;
-    // Simple cost estimation for synchronous use
-    const estimatedCost = totalTokens > 0 ? totalTokens * 0.00001 : 0;
-    return {
-        provider,
-        model,
-        tokens: {
-            input: inputTokens,
-            output: outputTokens,
-            total: totalTokens,
-        },
-        cost: estimatedCost,
-        responseTime,
-        timestamp: new Date().toISOString(),
-        context: context,
-    };
-}
-/**
- * Create enhanced analytics data with accurate cost calculations (async version)
- */
-export async function createEnhancedAnalytics(provider, model, result, responseTime, context) {
-    // Handle different token usage formats across providers
-    const tokenUsage = result?.usage || {};
-    // Standardize token field names across providers
-    const inputTokens = (typeof tokenUsage.promptTokens === "number"
-        ? tokenUsage.promptTokens
-        : 0) ||
-        (typeof tokenUsage.input_tokens === "number"
-            ? tokenUsage.input_tokens
-            : 0) ||
-        (typeof tokenUsage.inputTokens === "number" ? tokenUsage.inputTokens : 0) ||
-        0;
-    const outputTokens = (typeof tokenUsage.completionTokens === "number"
-        ? tokenUsage.completionTokens
-        : 0) ||
-        (typeof tokenUsage.output_tokens === "number"
-            ? tokenUsage.output_tokens
-            : 0) ||
-        (typeof tokenUsage.outputTokens === "number"
-            ? tokenUsage.outputTokens
-            : 0) ||
-        0;
-    const totalTokens = (typeof tokenUsage.totalTokens === "number" ? tokenUsage.totalTokens : 0) ||
-        (typeof tokenUsage.total_tokens === "number"
-            ? tokenUsage.total_tokens
-            : 0) ||
-        inputTokens + outputTokens ||
-        0;
-    // Enhanced cost calculation using provider configuration
-    const { costDetails, estimatedCost } = await calculateEnhancedCost(provider, inputTokens, outputTokens);
-    return {
-        provider,
-        model,
-        tokens: {
-            input: inputTokens,
-            output: outputTokens,
-            total: totalTokens,
-        },
-        cost: estimatedCost,
-        responseTime,
-        timestamp: new Date().toISOString(),
-        context: context,
-        costDetails,
-    };
-}
-/**
- * Calculate enhanced cost details using provider configurations
- */
-export async function calculateEnhancedCost(provider, inputTokens, outputTokens) {
-    try {
-        // Import provider configuration dynamically
-        const { getProviderConfig } = await import("../core/evaluation-providers.js");
-        const providerConfig = getProviderConfig(provider);
-        if (!providerConfig?.costPerToken) {
-            // Fallback to rough estimation
-            const estimatedCost = (inputTokens + outputTokens) * 0.00001;
-            return {
-                costDetails: {
-                    inputCost: inputTokens * 0.00001,
-                    outputCost: outputTokens * 0.00001,
-                    totalCost: estimatedCost,
-                    currency: "USD",
-                },
-                estimatedCost,
-            };
-        }
-        // Use accurate provider costs
-        const inputCost = inputTokens * providerConfig.costPerToken.input;
-        const outputCost = outputTokens * providerConfig.costPerToken.output;
-        const totalCost = inputCost + outputCost;
-        return {
-            costDetails: {
-                inputCost,
-                outputCost,
-                totalCost,
-                currency: "USD",
-            },
-            estimatedCost: totalCost,
-        };
-    }
-    catch (error) {
-        // Fallback on error
-        const estimatedCost = (inputTokens + outputTokens) * 0.00001;
-        return {
-            costDetails: {
-                inputCost: inputTokens * 0.00001,
-                outputCost: outputTokens * 0.00001,
-                totalCost: estimatedCost,
-                currency: "USD",
-            },
-            estimatedCost,
-        };
-    }
-}
-/**
- * Enhance analytics with evaluation data
- */
-export function enhanceAnalyticsWithEvaluation(analytics, evaluationResult) {
-    // Helper function to safely extract number values with fallback
-    const getNumberValue = (obj, ...keys) => {
-        for (const key of keys) {
-            const value = obj[key];
-            if (isNumber(value)) {
-                return value;
-            }
-        }
-        return 1; // Default minimum score
-    };
-    // Helper function to safely extract evaluation config cost
-    const getEvaluationCost = (obj) => {
-        const evaluationConfig = obj.evaluationConfig;
-        if (isRecord(evaluationConfig)) {
-            const costEstimate = evaluationConfig.costEstimate;
-            return isNumber(costEstimate) ? costEstimate : 0;
-        }
-        return 0;
-    };
-    // Helper function to safely get existing total cost
-    const getExistingTotalCost = (costDetails) => {
-        if (!costDetails) {
-            return 0;
-        }
-        const totalCost = costDetails.totalCost;
-        return isNumber(totalCost) ? totalCost : 0;
-    };
-    const evaluationCost = getEvaluationCost(evaluationResult);
-    return {
-        ...analytics,
-        evaluation: {
-            relevanceScore: getNumberValue(evaluationResult, "relevance", "relevanceScore"),
-            accuracyScore: getNumberValue(evaluationResult, "accuracy", "accuracyScore"),
-            completenessScore: getNumberValue(evaluationResult, "completeness", "completenessScore"),
-            overall: getNumberValue(evaluationResult, "overall"),
-            evaluationProvider: typeof evaluationResult.evaluationProvider === "string"
-                ? evaluationResult.evaluationProvider
-                : undefined,
-            evaluationTime: isNumber(evaluationResult.evaluationTime)
-                ? evaluationResult.evaluationTime
-                : undefined,
-            evaluationAttempt: isNumber(evaluationResult.evaluationAttempt)
-                ? evaluationResult.evaluationAttempt
-                : undefined,
-        },
-        // Add evaluation cost if available
-        costDetails: analytics.costDetails
-            ? {
-                ...analytics.costDetails,
-                evaluationCost,
-                totalCost: getExistingTotalCost(analytics.costDetails) + evaluationCost,
-            }
-            : undefined,
-    };
-}

package/dist/providers/function-calling-provider.d.ts

@@ -1,142 +0,0 @@
-/**
- * Enhanced AI Provider with Real Function Calling Support
- * Integrates MCP tools directly with AI SDK's function calling capabilities
- * This is the missing piece that enables true AI function calling!
- */
-import type { AIProvider, TextGenerationOptions, EnhancedGenerateResult } from "../core/types.js";
-import { type Schema } from "ai";
-import type { GenerateResult } from "../types/generate-types.js";
-import type { ZodType, ZodTypeDef } from "zod";
-import type { StreamOptions, StreamResult } from "../types/stream-types.js";
-/**
- * Enhanced provider that enables real function calling with MCP tools
- */
-export declare class FunctionCallingProvider implements AIProvider {
-    private baseProvider;
-    private enableFunctionCalling;
-    private sessionId;
-    private userId;
-    private cachedToolsObject;
-    private cachedToolMap;
-    private cacheTimestamp;
-    private readonly cacheExpiryMs;
-    constructor(baseProvider: AIProvider, options?: {
-        enableFunctionCalling?: boolean;
-        sessionId?: string;
-        userId?: string;
-        cacheExpiryMs?: number;
-    });
-    /**
-     * PRIMARY METHOD: Stream content using AI (recommended for new code)
-     * Future-ready for multi-modal capabilities with current text focus
-     */
-    stream(optionsOrPrompt: StreamOptions | string, analysisSchema?: Schema): Promise<StreamResult>;
-    /**
-     * Generate text with real function calling support
-     */
-    generate(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<GenerateResult>;
-    /**
-     * Generate text with tools using the AI SDK's generate function (with tools object)
-     */
-    private generateWithToolsObject;
-    /**
-     * Generate text using AI SDK's native function calling (legacy array-based)
-     */
-    private generateWithTools;
-    /**
-     * Get the model from the base provider
-     * This is a temporary solution - ideally we'd have a getModel() method on AIProvider
-     */
-    private getModelFromProvider;
-    /**
-     * Sanitize tool name to comply with AI provider requirements
-     */
-    private sanitizeToolName;
-    /**
-     * Wrap tools with proper execution context (for object-based tools)
-     */
-    private wrapToolsWithExecution;
-    /**
-     * Convert our tools to AI SDK format with proper execution (legacy array-based)
-     */
-    private convertToAISDKTools;
-    /**
-     * Create function-aware system prompt
-     */
-    private createFunctionAwareSystemPrompt;
-    /**
-     * Alias for generate() - CLI-SDK consistency
-     */
-    /**
-     * Clear cached tools - Cache Invalidation Strategy
-     *
-     * WHEN TO CALL clearToolsCache():
-     *
-     * 1. **MCP Server Changes**: When MCP servers are added, removed, or restarted
-     *    - After calling unifiedRegistry.addServer() or removeServer()
-     *    - When MCP server configurations change
-     *    - After MCP server restart or reconnection
-     *
-     * 2. **Tool Registration Changes**: When custom tools are modified
-     *    - After registering new SDK tools via registerTool()
-     *    - When tool implementations change
-     *    - After unregistering tools
-     *
-     * 3. **Provider Reinitialization**: When the provider context changes
-     *    - Before switching between different AI providers
-     *    - When session context changes significantly
-     *    - After provider authentication refresh
-     *
-     * 4. **Error Recovery**: When tool execution encounters systematic failures
-     *    - After MCP connection errors are resolved
-     *    - When tool discovery needs to be re-run
-     *    - During error recovery workflows
-     *
-     * 5. **Development/Testing**: During development and testing cycles
-     *    - Between test cases that modify tool availability
-     *    - When testing different tool configurations
-     *    - During hot reloading scenarios
-     *
-     * CACHE LIFECYCLE:
-     * - Cache is populated on first generate() call via getAvailableFunctionTools()
-     * - Cache persists across multiple generate() calls for performance
-     * - Cache is invalidated by calling this method
-     * - Next generate() call will rebuild cache from current tool state
-     *
-     * PERFORMANCE IMPACT:
-     * - Clearing cache forces tool discovery on next usage (~100-500ms overhead)
-     * - Recommended to clear cache proactively rather than reactively
-     * - Consider batching tool changes before clearing cache
-     *
-     * THREAD SAFETY:
-     * - This method is not thread-safe
-     * - Avoid calling during active generate() operations
-     * - Safe to call between separate AI generation requests
-     */
-    clearToolsCache(): void;
-    /**
-     * Short alias for generate() - CLI-SDK consistency
-     */
-    gen(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: Schema): Promise<EnhancedGenerateResult | null>;
-}
-/**
- * Create a function-calling enhanced version of any AI provider
- */
-export declare function createFunctionCallingProvider(baseProvider: AIProvider, options?: {
-    enableFunctionCalling?: boolean;
-    sessionId?: string;
-    userId?: string;
-    cacheExpiryMs?: number;
-}): AIProvider;
-/**
- * Enhanced MCP Provider Factory that creates function-calling enabled providers
- */
-export declare function createMCPAwareProviderV3(baseProvider: AIProvider, options?: {
-    providerName?: string;
-    modelName?: string;
-    enableMCP?: boolean;
-    enableFunctionCalling?: boolean;
-    sessionId?: string;
-    userId?: string;
-    cacheExpiryMs?: number;
-}): AIProvider;