@juspay/neurolink 7.33.0 → 7.33.1

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";

package/dist/types/modelTypes.d.ts

@@ -0,0 +1,242 @@
+/**
+ * Model-related type definitions for NeuroLink
+ * Consolidates all model configuration, dynamic model, and provider model types
+ */
+import { z } from "zod";
+import type { JsonValue } from "./common.js";
+/**
+ * Model performance tier definition
+ */
+export type ModelTier = "fast" | "balanced" | "quality";
+/**
+ * Model configuration source type
+ */
+export type ConfigSource = "default" | "environment" | "file" | "dynamic";
+/**
+ * Model configuration for a specific provider
+ */
+export type ModelConfig = {
+    /** Model identifier */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Performance tier */
+    tier: ModelTier;
+    /** Cost per 1K tokens */
+    cost: {
+        input: number;
+        output: number;
+    };
+    /** Model capabilities */
+    capabilities: string[];
+    /** Model-specific options */
+    options?: Record<string, JsonValue>;
+};
+/**
+ * Provider configuration for model management
+ */
+export type ProviderConfiguration = {
+    /** Provider name */
+    provider: string;
+    /** Available models by tier */
+    models: Record<ModelTier, string>;
+    /** Default cost per token (fallback) */
+    defaultCost: {
+        input: number;
+        output: number;
+    };
+    /** Required environment variables */
+    requiredEnvVars: string[];
+    /** Provider-specific performance metrics */
+    performance: {
+        speed: number;
+        quality: number;
+        cost: number;
+    };
+    /** Provider-specific model configurations */
+    modelConfigs?: Record<string, ModelConfig>;
+    /** Provider-specific model behavior configurations */
+    modelBehavior?: {
+        /** Models that have issues with maxTokens parameter */
+        maxTokensIssues?: string[];
+        /** Models that require special handling */
+        specialHandling?: Record<string, JsonValue>;
+        /** Models that support tool calling (Ollama-specific) */
+        toolCapableModels?: string[];
+    };
+};
+/**
+ * Zod schema for model configuration validation
+ */
+export declare const ModelConfigSchema: z.ZodObject<{
+    id: z.ZodString;
+    displayName: z.ZodString;
+    capabilities: z.ZodArray<z.ZodString, "many">;
+    deprecated: z.ZodBoolean;
+    pricing: z.ZodObject<{
+        input: z.ZodNumber;
+        output: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        input: number;
+        output: number;
+    }, {
+        input: number;
+        output: number;
+    }>;
+    contextWindow: z.ZodNumber;
+    releaseDate: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    deprecated: boolean;
+    pricing: {
+        input: number;
+        output: number;
+    };
+    id: string;
+    displayName: string;
+    capabilities: string[];
+    contextWindow: number;
+    releaseDate: string;
+}, {
+    deprecated: boolean;
+    pricing: {
+        input: number;
+        output: number;
+    };
+    id: string;
+    displayName: string;
+    capabilities: string[];
+    contextWindow: number;
+    releaseDate: string;
+}>;
+/**
+ * Zod schema for model registry validation
+ */
+export declare const ModelRegistrySchema: z.ZodObject<{
+    version: z.ZodString;
+    lastUpdated: z.ZodString;
+    models: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        displayName: z.ZodString;
+        capabilities: z.ZodArray<z.ZodString, "many">;
+        deprecated: z.ZodBoolean;
+        pricing: z.ZodObject<{
+            input: z.ZodNumber;
+            output: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            input: number;
+            output: number;
+        }, {
+            input: number;
+            output: number;
+        }>;
+        contextWindow: z.ZodNumber;
+        releaseDate: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        deprecated: boolean;
+        pricing: {
+            input: number;
+            output: number;
+        };
+        id: string;
+        displayName: string;
+        capabilities: string[];
+        contextWindow: number;
+        releaseDate: string;
+    }, {
+        deprecated: boolean;
+        pricing: {
+            input: number;
+            output: number;
+        };
+        id: string;
+        displayName: string;
+        capabilities: string[];
+        contextWindow: number;
+        releaseDate: string;
+    }>>>;
+    aliases: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    defaults: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    version: string;
+    models: Record<string, Record<string, {
+        deprecated: boolean;
+        pricing: {
+            input: number;
+            output: number;
+        };
+        id: string;
+        displayName: string;
+        capabilities: string[];
+        contextWindow: number;
+        releaseDate: string;
+    }>>;
+    lastUpdated: string;
+    aliases?: Record<string, string> | undefined;
+    defaults?: Record<string, string> | undefined;
+}, {
+    version: string;
+    models: Record<string, Record<string, {
+        deprecated: boolean;
+        pricing: {
+            input: number;
+            output: number;
+        };
+        id: string;
+        displayName: string;
+        capabilities: string[];
+        contextWindow: number;
+        releaseDate: string;
+    }>>;
+    lastUpdated: string;
+    aliases?: Record<string, string> | undefined;
+    defaults?: Record<string, string> | undefined;
+}>;
+/**
+ * Dynamic model configuration type
+ */
+export type DynamicModelConfig = z.infer<typeof ModelConfigSchema>;
+/**
+ * Dynamic model registry type
+ */
+export type ModelRegistry = z.infer<typeof ModelRegistrySchema>;
+/**
+ * Model name constants structure
+ */
+export type ModelNameConstants = {
+    readonly [provider: string]: {
+        readonly FAST: string;
+        readonly BALANCED: string;
+        readonly QUALITY: string;
+    };
+};
+/**
+ * Model metadata for registry
+ */
+export type ModelMetadata = {
+    version: string;
+    lastUpdated: string;
+    modelCount: number;
+};
+/**
+ * Model search options
+ */
+export type ModelSearchOptions = {
+    provider?: string;
+    maxPrice?: number;
+    excludeDeprecated?: boolean;
+};
+/**
+ * Model search result
+ */
+export type ModelSearchResult = {
+    provider: string;
+    model: string;
+    config: DynamicModelConfig;
+};
+/**
+ * Cost information structure
+ */
+export type CostInfo = {
+    input: number;
+    output: number;
+};

package/dist/types/modelTypes.js

@@ -0,0 +1,30 @@
+/**
+ * Model-related type definitions for NeuroLink
+ * Consolidates all model configuration, dynamic model, and provider model types
+ */
+import { z } from "zod";
+/**
+ * Zod schema for model configuration validation
+ */
+export const ModelConfigSchema = z.object({
+    id: z.string(),
+    displayName: z.string(),
+    capabilities: z.array(z.string()),
+    deprecated: z.boolean(),
+    pricing: z.object({
+        input: z.number(),
+        output: z.number(),
+    }),
+    contextWindow: z.number(),
+    releaseDate: z.string(),
+});
+/**
+ * Zod schema for model registry validation
+ */
+export const ModelRegistrySchema = z.object({
+    version: z.string(),
+    lastUpdated: z.string(),
+    models: z.record(z.record(ModelConfigSchema)),
+    aliases: z.record(z.string()).optional(),
+    defaults: z.record(z.string()).optional(),
+});