@juspay/neurolink 7.33.0 → 7.33.2

package/dist/providers/googleVertex.js

@@ -1122,7 +1122,7 @@ export class GoogleVertexProvider extends BaseProvider {
             // Cache expired, refresh it with memory management
             GoogleVertexProvider.modelConfigCache.clear();
             const config = ModelConfigurationManager.getInstance();
-            const vertexConfig = config.getProviderConfig("google-vertex");
+            const vertexConfig = config.getProviderConfiguration("google-vertex");
             GoogleVertexProvider.modelConfigCache.set(cacheKey, vertexConfig);
             GoogleVertexProvider.modelConfigCacheTime = now;
         }

package/dist/providers/huggingFace.d.ts

@@ -1,6 +1,6 @@
 import type { ZodType, ZodTypeDef } from "zod";
 import { type Schema, type LanguageModelV1 } from "ai";
-import type { AIProviderName } from "../core/types.js";
+import type { AIProviderName } from "../types/index.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
 import { BaseProvider } from "../core/baseProvider.js";
 /**

package/dist/providers/index.d.ts

@@ -14,7 +14,7 @@ export { HuggingFaceProvider as HuggingFace } from "./huggingFace.js";
 export { OllamaProvider as Ollama } from "./ollama.js";
 export { MistralProvider as MistralAI } from "./mistral.js";
 export { LiteLLMProvider as LiteLLM } from "./litellm.js";
-export type { AIProvider } from "../core/types.js";
+export type { AIProvider } from "../types/index.js";
 /**
  * Provider registry for dynamic provider instantiation
  */

package/dist/providers/litellm.d.ts

@@ -1,6 +1,6 @@
 import type { ZodType, ZodTypeDef } from "zod";
 import { type Schema, type LanguageModelV1 } from "ai";
-import type { AIProviderName } from "../core/types.js";
+import type { AIProviderName } from "../types/index.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
 import { BaseProvider } from "../core/baseProvider.js";
 /**

package/dist/providers/mistral.d.ts

@@ -1,6 +1,6 @@
 import { type LanguageModelV1 } from "ai";
 import type { ValidationSchema } from "../types/typeAliases.js";
-import type { AIProviderName } from "../core/types.js";
+import type { AIProviderName } from "../types/index.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
 import { BaseProvider } from "../core/baseProvider.js";
 /**

package/dist/providers/ollama.d.ts

@@ -1,4 +1,4 @@
-import type { AIProviderName } from "../core/types.js";
+import type { AIProviderName } from "../types/index.js";
 import type { LanguageModelV1 } from "ai";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
 import type { ZodUnknownSchema } from "../types/typeAliases.js";

package/dist/providers/ollama.js

@@ -273,7 +273,7 @@ export class OllamaProvider extends BaseProvider {
     supportsTools() {
         const modelName = this.modelName.toLowerCase();
         // Get tool-capable models from configuration
-        const ollamaConfig = modelConfig.getProviderConfig("ollama");
+        const ollamaConfig = modelConfig.getProviderConfiguration("ollama");
         const toolCapableModels = ollamaConfig?.modelBehavior?.toolCapableModels || [];
         // Check if current model matches tool-capable model patterns
         const isToolCapable = toolCapableModels.some((capableModel) => modelName.includes(capableModel));

package/dist/providers/openAI.d.ts

@@ -1,6 +1,6 @@
 import { type LanguageModelV1 } from "ai";
 import type { ValidationSchema } from "../types/typeAliases.js";
-import { AIProviderName } from "../core/types.js";
+import { AIProviderName } from "../types/index.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import type { NeuroLink } from "../neurolink.js";

package/dist/providers/openAI.js

@@ -1,6 +1,6 @@
 import { createOpenAI } from "@ai-sdk/openai";
 import { streamText } from "ai";
-import { AIProviderName } from "../core/types.js";
+import { AIProviderName } from "../types/index.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import { logger } from "../utils/logger.js";
 import { createTimeoutController, TimeoutError } from "../utils/timeout.js";

package/dist/providers/openaiCompatible.d.ts

@@ -1,6 +1,6 @@
 import { type Schema, type LanguageModelV1 } from "ai";
 import type { ZodUnknownSchema } from "../types/typeAliases.js";
-import type { AIProviderName } from "../core/types.js";
+import type { AIProviderName } from "../types/index.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
 import { BaseProvider } from "../core/baseProvider.js";
 /**

package/dist/types/analytics.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Analytics-related type definitions for NeuroLink
+ * Comprehensive usage tracking, performance metrics, and cost analysis types
+ */
+import type { JsonValue, UnknownRecord } from "./common.js";
+/**
+ * Token usage information (consolidated from multiple sources)
+ */
+export type TokenUsage = {
+    input: number;
+    output: number;
+    total: number;
+};
+/**
+ * Error info type for analytics
+ */
+export type ErrorInfo = {
+    message: string;
+    code?: string | number;
+    stack?: string;
+    details?: UnknownRecord;
+};
+/**
+ * Analytics data structure (consolidated from core analytics)
+ */
+export type AnalyticsData = {
+    provider: string;
+    model?: string;
+    tokenUsage: TokenUsage;
+    requestDuration: number;
+    timestamp: string;
+    cost?: number;
+    context?: JsonValue;
+};
+/**
+ * Stream Analytics Data - Enhanced for performance tracking
+ */
+export type StreamAnalyticsData = {
+    /** Tool execution results with timing */
+    toolResults?: Promise<Array<unknown>>;
+    /** Tool calls made during stream */
+    toolCalls?: Promise<Array<unknown>>;
+    /** Stream performance metrics */
+    performance?: {
+        startTime: number;
+        endTime?: number;
+        chunkCount: number;
+        avgChunkSize: number;
+        totalBytes: number;
+    };
+    /** Provider analytics */
+    providerAnalytics?: AnalyticsData;
+};

package/dist/types/analytics.js

@@ -0,0 +1,5 @@
+/**
+ * Analytics-related type definitions for NeuroLink
+ * Comprehensive usage tracking, performance metrics, and cost analysis types
+ */
+export {};

package/dist/types/cli.d.ts

@@ -2,7 +2,7 @@
  * CLI-specific type definitions for NeuroLink
  */
 import type { UnknownRecord, JsonValue } from "./common.js";
-import type { AnalyticsData, TokenUsage } from "./providers.js";
+import type { AnalyticsData, TokenUsage } from "./analytics.js";
 import type { EvaluationData } from "../index.js";
 import type { ToolCall, ToolResult } from "./tools.js";
 /**

package/dist/types/evaluation.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Evaluation provider type definitions for NeuroLink
+ * Provider performance tracking, evaluation configurations, and provider optimization types
+ */
+/**
+ * Evaluation provider type as specified in core module refactoring
+ */
+export type EvaluationProvider = "openai" | "anthropic" | "vertex" | "google-ai" | "local";
+/**
+ * Evaluation modes
+ */
+export type EvaluationMode = "basic" | "detailed" | "domain-aware" | "disabled";
+/**
+ * Alert severity levels
+ */
+export type AlertSeverity = "low" | "medium" | "high" | "none";
+/**
+ * Response quality evaluation scores - Comprehensive evaluation type
+ */
+export type EvaluationData = {
+    relevance: number;
+    accuracy: number;
+    completeness: number;
+    overall: number;
+    domainAlignment?: number;
+    terminologyAccuracy?: number;
+    toolEffectiveness?: number;
+    isOffTopic: boolean;
+    alertSeverity: AlertSeverity;
+    reasoning: string;
+    suggestedImprovements?: string;
+    evaluationModel: string;
+    evaluationTime: number;
+    evaluationDomain?: string;
+    evaluationProvider?: string;
+    evaluationAttempt?: number;
+    evaluationConfig?: {
+        mode: string;
+        fallbackUsed: boolean;
+        costEstimate: number;
+    };
+    domainConfig?: {
+        domainName: string;
+        domainDescription: string;
+        keyTerms: string[];
+        failurePatterns: string[];
+        successPatterns: string[];
+        evaluationCriteria?: Record<string, unknown>;
+    };
+    domainEvaluation?: {
+        domainRelevance: number;
+        terminologyAccuracy: number;
+        domainExpertise: number;
+        domainSpecificInsights: string[];
+    };
+};
+/**
+ * Enhanced evaluation context for comprehensive response assessment
+ */
+export type EvaluationContext = {
+    userQuery: string;
+    aiResponse: string;
+    context?: Record<string, unknown>;
+    primaryDomain?: string;
+    assistantRole?: string;
+    conversationHistory?: Array<{
+        role: "user" | "assistant";
+        content: string;
+        timestamp?: string;
+    }>;
+    toolUsage?: Array<{
+        toolName: string;
+        input: unknown;
+        output: unknown;
+        executionTime: number;
+    }>;
+    expectedOutcome?: string;
+    evaluationCriteria?: string[];
+};
+/**
+ * Evaluation result type
+ * Extends EvaluationData with additional fields
+ */
+export type EnhancedEvaluationResult = EvaluationData & {
+    domainAlignment?: number;
+    terminologyAccuracy?: number;
+    toolEffectiveness?: number;
+    contextUtilization?: {
+        conversationUsed: boolean;
+        toolsUsed: boolean;
+        domainKnowledgeUsed: boolean;
+    };
+    evaluationContext?: {
+        domain: string;
+        toolsEvaluated: string[];
+        conversationTurns: number;
+    };
+    isOffTopic: boolean;
+    alertSeverity: AlertSeverity;
+    reasoning: string;
+};
+/**
+ * Evaluation request type as specified in core module refactoring
+ */
+export type EvaluationRequest = {
+    content: string;
+    context?: string;
+    domain?: string;
+    criteria: EvaluationCriteria;
+};
+/**
+ * Evaluation criteria type as specified in core module refactoring
+ */
+export type EvaluationCriteria = {
+    relevance: boolean;
+    accuracy: boolean;
+    completeness: boolean;
+    domainSpecific?: boolean;
+};

package/dist/types/evaluation.js

@@ -0,0 +1,5 @@
+/**
+ * Evaluation provider type definitions for NeuroLink
+ * Provider performance tracking, evaluation configurations, and provider optimization types
+ */
+export {};

package/dist/types/evaluationProviders.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Evaluation provider type definitions for NeuroLink
+ * Provider performance tracking, evaluation configurations, and provider optimization types
+ */
+/**
+ * Performance optimization priority
+ */
+export type PerformancePriority = "speed" | "cost" | "reliability";
+/**
+ * Legacy provider model configuration for evaluation
+ */
+export type ProviderModelConfig = {
+    provider: string;
+    models: string[];
+    costPerToken?: number | {
+        input: number;
+        output: number;
+    };
+    requiresApiKey?: string[];
+    performance?: {
+        averageLatency?: number;
+        reliability?: number;
+        speed?: number;
+        quality?: number;
+        cost?: number;
+    };
+};
+/**
+ * Real-time provider performance tracking metrics
+ */
+export type ProviderPerformanceMetrics = {
+    responseTime: number[];
+    successRate: number;
+    tokenThroughput: number;
+    costEfficiency: number;
+    lastUpdated: Date;
+    sampleCount: number;
+};
+/**
+ * Provider performance recording data
+ */
+export type ProviderPerformanceData = {
+    responseTime: number;
+    tokensGenerated: number;
+    cost: number;
+    success: boolean;
+};
+/**
+ * Provider performance analytics result
+ */
+export type ProviderPerformanceAnalytics = {
+    avgResponseTime: number;
+    successRate: number;
+    tokenThroughput: number;
+    costEfficiency: number;
+    recommendation: string;
+    sampleCount: number;
+};
+/**
+ * Performance thresholds for evaluation
+ */
+export type PerformanceThresholds = {
+    EXCELLENT_SUCCESS_RATE: number;
+    EXCELLENT_RESPONSE_TIME_MS: number;
+    GOOD_SUCCESS_RATE: number;
+    FAIR_SUCCESS_RATE: number;
+};
+/**
+ * Provider scoring result
+ */
+export type ProviderScoringResult = {
+    provider: ProviderModelConfig;
+    score: number;
+    metrics: ProviderPerformanceMetrics | null;
+};
+/**
+ * Provider availability status
+ */
+export type ProviderAvailabilityStatus = {
+    provider: string;
+    available: boolean;
+    reason?: string;
+    lastChecked: Date;
+};
+/**
+ * Provider cost estimation parameters
+ */
+export type CostEstimationParams = {
+    provider: string;
+    inputTokens: number;
+    outputTokens: number;
+    model?: string;
+};
+/**
+ * Provider selection criteria
+ */
+export type ProviderSelectionCriteria = {
+    priority: PerformancePriority;
+    maxCost?: number;
+    minSuccessRate?: number;
+    maxResponseTime?: number;
+    excludeProviders?: string[];
+    requireCapabilities?: string[];
+};

package/dist/types/evaluationProviders.js

@@ -0,0 +1,5 @@
+/**
+ * Evaluation provider type definitions for NeuroLink
+ * Provider performance tracking, evaluation configurations, and provider optimization types
+ */
+export {};

package/dist/types/generateTypes.d.ts

@@ -1,12 +1,16 @@
-import type { Tool } from "ai";
-import type { ValidationSchema, StandardRecord } from "./typeAliases.js";
-import type { AIProviderName, AnalyticsData, EvaluationData } from "../core/types.js";
-import type { TokenUsage } from "./providers.js";
+import type { Tool, Schema } from "ai";
+import type { ValidationSchema, StandardRecord, ZodUnknownSchema } from "./typeAliases.js";
+import type { AIProviderName } from "./providers.js";
+import type { AnalyticsData, TokenUsage } from "./analytics.js";
+import type { EvaluationData } from "./evaluation.js";
+import type { ChatMessage, ConversationMemoryConfig } from "./conversationTypes.js";
+import type { MiddlewareFactoryOptions } from "./middlewareTypes.js";
+import type { JsonValue } from "./common.js";
 /**
- * Generate function options interface - Primary method for content generation
+ * Generate function options type - Primary method for content generation
  * Future-ready for multi-modal capabilities while maintaining text focus
  */
-export interface GenerateOptions {
+export type GenerateOptions = {
     input: {
         text: string;
     };
@@ -45,12 +49,12 @@ export interface GenerateOptions {
         enableProgress?: boolean;
         fallbackToGenerate?: boolean;
     };
-}
+};
 /**
- * Generate function result interface - Primary output format
+ * Generate function result type - Primary output format
  * Future-ready for multi-modal outputs while maintaining text focus
  */
-export interface GenerateResult {
+export type GenerateResult = {
     content: string;
     outputs?: {
         text: string;
@@ -96,28 +100,28 @@ export interface GenerateResult {
         streamId?: string;
         bufferOptimization?: boolean;
     };
-}
+};
 /**
  * Unified options for both generation and streaming
  * Supports factory patterns and domain configuration
  */
-export interface UnifiedGenerationOptions extends GenerateOptions {
+export type UnifiedGenerationOptions = GenerateOptions & {
     preferStreaming?: boolean;
     streamingFallback?: boolean;
-}
+};
 /**
- * Enhanced provider interface with generate method
+ * Enhanced provider type with generate method
  */
-export interface EnhancedProvider {
+export type EnhancedProvider = {
     generate(options: GenerateOptions): Promise<GenerateResult>;
     getName(): string;
     isAvailable(): Promise<boolean>;
-}
+};
 /**
- * Factory-enhanced provider interface
+ * Factory-enhanced provider type
  * Supports domain configuration and streaming optimizations
  */
-export interface FactoryEnhancedProvider extends EnhancedProvider {
+export type FactoryEnhancedProvider = EnhancedProvider & {
     generateWithFactory(options: UnifiedGenerationOptions): Promise<GenerateResult>;
     getDomainSupport(): string[];
     getStreamingCapabilities(): {
@@ -125,4 +129,71 @@ export interface FactoryEnhancedProvider extends EnhancedProvider {
         maxChunkSize: number;
         bufferOptimizations: boolean;
     };
-}
+};
+/**
+ * Text generation options type (consolidated from core types)
+ */
+export type TextGenerationOptions = {
+    prompt?: string;
+    input?: {
+        text: string;
+    };
+    provider?: AIProviderName;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    systemPrompt?: string;
+    schema?: ZodUnknownSchema | Schema<unknown>;
+    tools?: Record<string, Tool>;
+    timeout?: number | string;
+    disableTools?: boolean;
+    maxSteps?: number;
+    enableEvaluation?: boolean;
+    enableAnalytics?: boolean;
+    context?: Record<string, JsonValue>;
+    evaluationDomain?: string;
+    toolUsageContext?: string;
+    conversationHistory?: Array<{
+        role: string;
+        content: string;
+    }>;
+    conversationMessages?: ChatMessage[];
+    conversationMemoryConfig?: Partial<ConversationMemoryConfig>;
+    originalPrompt?: string;
+    middleware?: MiddlewareFactoryOptions;
+    expectedOutcome?: string;
+    evaluationCriteria?: string[];
+};
+/**
+ * Text generation result (consolidated from core types)
+ */
+export type TextGenerationResult = {
+    content: string;
+    provider?: string;
+    model?: string;
+    usage?: TokenUsage;
+    responseTime?: number;
+    toolsUsed?: string[];
+    toolExecutions?: Array<{
+        toolName: string;
+        executionTime: number;
+        success: boolean;
+        serverId?: string;
+    }>;
+    enhancedWithTools?: boolean;
+    availableTools?: Array<{
+        name: string;
+        description: string;
+        server: string;
+        category?: string;
+    }>;
+    analytics?: AnalyticsData;
+    evaluation?: EvaluationData;
+};
+/**
+ * Enhanced result type with optional analytics/evaluation
+ */
+export type EnhancedGenerateResult = GenerateResult & {
+    analytics?: AnalyticsData;
+    evaluation?: EvaluationData;
+};

package/dist/types/index.d.ts

@@ -7,10 +7,18 @@ export * from "./providers.js";
 export * from "./cli.js";
 export type { Unknown, UnknownRecord, UnknownArray, JsonValue, JsonObject, JsonArray, ErrorInfo, Result, FunctionParameters, } from "./common.js";
 export type { ToolArgs, ToolContext, ToolResult, ToolDefinition, SimpleTool, AvailableTool, ToolExecution, } from "./tools.js";
-export type { AISDKModel, ProviderError, TokenUsage, AnalyticsData, EvaluationData, ProviderConfig, } from "./providers.js";
+export type { AISDKModel, ProviderError, ProviderConfig } from "./providers.js";
 export type { BaseCommandArgs, GenerateCommandArgs, MCPCommandArgs, ModelsCommandArgs, CommandResult, GenerateResult, StreamChunk, } from "./cli.js";
 export type { MCPTransportType, MCPServerConnectionStatus, MCPServerCategory, MCPServerStatus, MCPDiscoveredServer, MCPConnectedServer, MCPToolInfo, MCPExecutableTool, MCPServerMetadata, MCPToolMetadata, MCPServerRegistryEntry, } from "./mcpTypes.js";
 export type { ExternalMCPServerInstance, ExternalMCPServerStatus, ExternalMCPToolInfo, ExternalMCPServerHealth, ExternalMCPConfigValidation, ExternalMCPOperationResult, ExternalMCPToolContext, ExternalMCPToolResult, ExternalMCPServerEvents, ExternalMCPManagerConfig, } from "./externalMcp.js";
 export type { ModelCapability, ModelUseCase, ModelFilter, ModelResolutionContext, ModelStats, ModelPricing, } from "./providers.js";
-export type { ToolCallResults, ToolCalls, StreamAnalyticsData, } from "./streamTypes.js";
 export type { DomainType, DomainConfig, DomainTemplate, DomainConfigOptions, DomainEvaluationCriteria, DomainValidationRule, } from "./domainTypes.js";
+export * from "./generateTypes.js";
+export type { StreamingProgressData, StreamingMetadata, ProgressCallback, ToolCall as StreamToolCall, // Renamed to avoid conflict with tools.js ToolCall
+ToolResult as StreamToolResult, // Renamed to avoid conflict with tools.js ToolResult
+ToolCallResults, ToolCalls, StreamOptions, StreamingOptions, StreamResult, EnhancedStreamProvider, } from "./streamTypes.js";
+export * from "./analytics.js";
+export * from "./evaluation.js";
+export * from "./modelTypes.js";
+export * from "./serviceTypes.js";
+export * from "./evaluationProviders.js";

package/dist/types/index.js

@@ -9,3 +9,15 @@ export * from "./tools.js";
 export * from "./providers.js";
 // CLI types
 export * from "./cli.js";
+// Generate types - NEW
+export * from "./generateTypes.js";
+// Analytics types - NEW
+export * from "./analytics.js";
+// Evaluation types - NEW
+export * from "./evaluation.js";
+// Model types - NEW
+export * from "./modelTypes.js";
+// Service types - NEW
+export * from "./serviceTypes.js";
+// Evaluation provider types - NEW
+export * from "./evaluationProviders.js";