@juspay/neurolink 7.29.1 → 7.29.3

package/dist/lib/types/cli.d.ts

@@ -2,7 +2,8 @@
  * CLI-specific type definitions for NeuroLink
  */
 import type { UnknownRecord, JsonValue } from "./common.js";
-import type { AnalyticsData, EvaluationData, TokenUsage } from "./providers.js";
+import type { AnalyticsData, TokenUsage } from "./providers.js";
+import type { EvaluationData } from "../index.js";
 import type { ToolCall, ToolResult } from "./tools.js";
 /**
  * Base command arguments interface
@@ -16,6 +17,8 @@ export interface BaseCommandArgs {
     verbose?: boolean;
     /** Quiet mode */
     quiet?: boolean;
+    /** Index signature to allow additional properties */
+    [key: string]: unknown;
 }
 /**
  * Generate command arguments
@@ -65,6 +68,29 @@ export interface StreamCommandArgs extends BaseCommandArgs {
     /** Disable tools */
     disableTools?: boolean;
 }
+/**
+ * Batch command arguments
+ */
+export interface BatchCommandArgs extends BaseCommandArgs {
+    /** Input file path */
+    file?: string;
+    /** AI provider to use */
+    provider?: string;
+    /** Model name */
+    model?: string;
+    /** System prompt */
+    system?: string;
+    /** Temperature setting */
+    temperature?: number;
+    /** Maximum tokens */
+    maxTokens?: number;
+    /** Delay between requests (ms) */
+    delay?: number;
+    /** Output file */
+    output?: string;
+    /** Disable tools */
+    disableTools?: boolean;
+}
 /**
  * MCP command arguments - Enhanced with transport and server management
  */
@@ -113,17 +139,65 @@ export interface MCPCommandArgs extends BaseCommandArgs {
 /**
  * Models command arguments - Enhanced for model management
  */
-export interface ModelsCommandArgs extends BaseCommandArgs {
-    /** AI provider to query */
-    provider?: string;
-    /** Model capability filter */
+export interface ModelsCommandArgs extends Omit<BaseCommandArgs, "format"> {
+    /** AI provider to query (single or array) */
+    provider?: string | string[];
+    /** Model category filter */
+    category?: string;
+    /** Model capability filter (array) */
+    capability?: string[];
+    /** Include deprecated models */
+    deprecated?: boolean;
+    /** Search query (capability, use case, or model name) */
     query?: string;
     /** Model use case filter */
     useCase?: string;
-    /** Require vision capability */
+    /** Maximum cost per 1K tokens (USD) */
+    maxCost?: number;
+    /** Minimum context window size (tokens) */
+    minContext?: number;
+    /** Maximum context window size (tokens) */
+    maxContext?: number;
+    /** Required performance level */
+    performance?: "fast" | "medium" | "slow" | "high" | "low";
+    /** Optimize for code generation and programming */
+    coding?: boolean;
+    /** Optimize for creative writing and content */
+    creative?: boolean;
+    /** Optimize for data analysis and research */
+    analysis?: boolean;
+    /** Optimize for conversational interactions */
+    conversation?: boolean;
+    /** Optimize for logical reasoning tasks */
+    reasoning?: boolean;
+    /** Optimize for language translation */
+    translation?: boolean;
+    /** Optimize for text summarization */
+    summarization?: boolean;
+    /** Prioritize cost-effectiveness */
+    costEffective?: boolean;
+    /** Prioritize output quality over cost */
+    highQuality?: boolean;
+    /** Prioritize response speed */
+    fast?: boolean;
+    /** Require vision/image processing capability */
     requireVision?: boolean;
     /** Require function calling capability */
     requireFunctionCalling?: boolean;
+    /** Exclude specific providers */
+    excludeProviders?: string[];
+    /** Prefer local/offline models */
+    preferLocal?: boolean;
+    /** Model name, alias, or partial match to resolve */
+    model?: string;
+    /** Enable fuzzy matching for partial names */
+    fuzzy?: boolean;
+    /** Model IDs or aliases to compare */
+    models?: string[];
+    /** Show detailed statistics breakdown */
+    detailed?: boolean;
+    /** Output format for models command */
+    format?: "table" | "json" | "compact";
     /** List all available models */
     list?: boolean;
     /** Show model statistics */
@@ -132,8 +206,6 @@ export interface ModelsCommandArgs extends BaseCommandArgs {
     pricing?: boolean;
     /** Resolve best model for criteria */
     resolve?: boolean;
-    /** Maximum cost filter */
-    maxCost?: number;
     /** Maximum tokens filter */
     maxTokens?: number;
 }

package/dist/lib/types/contextTypes.js

@@ -284,7 +284,7 @@ export class ContextFactory {
 /**
  * Type guard to check if value is valid context
  */
-function isValidContext(value) {
+function _isValidContext(value) {
     return ContextFactory.validateContext(value) !== null;
 }
 export class ContextConverter {
@@ -293,7 +293,7 @@ export class ContextConverter {
      * Based on business context patterns
      */
     static convertBusinessContext(legacyContext, domainType, options = {}) {
-        const { preserveLegacyFields = false, validateDomainData = true, includeMetadata = true, } = options;
+        const { preserveLegacyFields = false, validateDomainData: _validateDomainData = true, includeMetadata = true, } = options;
         return {
             sessionId: legacyContext.sessionId,
             userId: legacyContext.userId,

package/dist/lib/types/generateTypes.d.ts

@@ -1,6 +1,8 @@
 import type { Tool } from "ai";
 import type { ValidationSchema, StandardRecord } from "./typeAliases.js";
-import type { AIProviderName, AnalyticsData, EvaluationData } from "../core/types.js";
+import type { AIProviderName, AnalyticsData } from "../core/types.js";
+import type { EvaluationData } from "../index.js";
+import type { TokenUsage } from "./providers.js";
 /**
  * Generate function options interface - Primary method for content generation
  * Future-ready for multi-modal capabilities while maintaining text focus
@@ -56,11 +58,7 @@ export interface GenerateResult {
     };
     provider?: string;
     model?: string;
-    usage?: {
-        inputTokens: number;
-        outputTokens: number;
-        totalTokens: number;
-    };
+    usage?: TokenUsage;
     responseTime?: number;
     toolCalls?: Array<{
         toolCallId: string;

package/dist/lib/types/providers.d.ts

@@ -21,25 +21,64 @@ export interface ProviderError extends Error {
  * Token usage information
  */
 export interface TokenUsage {
-    inputTokens: number;
-    outputTokens: number;
-    totalTokens: number;
+    input: number;
+    output: number;
+    total: number;
 }
 /**
  * Analytics data structure
  */
 export interface AnalyticsData {
     provider: string;
-    model: string;
+    model?: string;
+    tokenUsage: TokenUsage;
     requestDuration: number;
-    tokenUsage: {
-        inputTokens: number;
-        outputTokens: number;
-        totalTokens: number;
-    };
-    timestamp: number;
+    timestamp: string;
+    cost?: number;
     context?: JsonValue;
-    [key: string]: JsonValue | undefined;
+}
+/**
+ * AWS Credential Configuration for Bedrock provider
+ */
+export interface AWSCredentialConfig {
+    region?: string;
+    profile?: string;
+    roleArn?: string;
+    roleSessionName?: string;
+    timeout?: number;
+    /** @deprecated Prefer maxAttempts to match AWS SDK v3 config */
+    maxRetries?: number;
+    /** Number of attempts as per AWS SDK v3 ("retry-mode") */
+    maxAttempts?: number;
+    enableDebugLogging?: boolean;
+    /** Optional service endpoint override (e.g., VPC/Gov endpoints) */
+    endpoint?: string;
+}
+/**
+ * AWS Credential Validation Result
+ */
+export interface CredentialValidationResult {
+    isValid: boolean;
+    credentialSource: string;
+    region: string;
+    hasExpiration: boolean;
+    expirationTime?: Date;
+    error?: string;
+    debugInfo: {
+        accessKeyId: string;
+        hasSessionToken: boolean;
+        providerConfig: Readonly<Required<AWSCredentialConfig>>;
+    };
+}
+/**
+ * Service Connectivity Test Result
+ */
+export interface ServiceConnectivityResult {
+    bedrockAccessible: boolean;
+    availableModels: number;
+    responseTimeMs: number;
+    error?: string;
+    sampleModels: string[];
 }
 /**
  * Model Capabilities - Maximally Reusable
@@ -123,16 +162,82 @@ export interface ModelPricing {
     free?: boolean;
 }
 /**
- * Evaluation data structure
+ * Response quality evaluation scores - Comprehensive evaluation interface
  */
 export interface EvaluationData {
-    relevance?: number;
-    accuracy?: number;
-    completeness?: number;
-    coherence?: number;
-    overall?: number;
-    feedback?: string;
-    [key: string]: JsonValue | undefined;
+    relevance: number;
+    accuracy: number;
+    completeness: number;
+    overall: number;
+    domainAlignment?: number;
+    terminologyAccuracy?: number;
+    toolEffectiveness?: number;
+    isOffTopic: boolean;
+    alertSeverity: "low" | "medium" | "high" | "none";
+    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 interface 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 interface that extends EvaluationData with additional context
+ */
+export interface EvaluationResult extends EvaluationData {
+    contextUtilization?: {
+        conversationUsed: boolean;
+        toolsUsed: boolean;
+        domainKnowledgeUsed: boolean;
+    };
+    evaluationContext?: {
+        domain: string;
+        toolsEvaluated: string[];
+        conversationTurns: number;
+    };
 }
 /**
  * Provider capabilities

package/dist/lib/types/providers.js

@@ -13,10 +13,10 @@ export function isProviderError(error) {
 export function isTokenUsage(value) {
     return (typeof value === "object" &&
         value !== null &&
-        "inputTokens" in value &&
-        "outputTokens" in value &&
-        "totalTokens" in value &&
-        typeof value.inputTokens === "number" &&
-        typeof value.outputTokens === "number" &&
-        typeof value.totalTokens === "number");
+        "input" in value &&
+        "output" in value &&
+        "total" in value &&
+        typeof value.input === "number" &&
+        typeof value.output === "number" &&
+        typeof value.total === "number");
 }

package/dist/lib/types/streamTypes.d.ts

@@ -1,6 +1,8 @@
 import type { Tool } from "ai";
 import type { ValidationSchema, StandardRecord } from "./typeAliases.js";
-import type { AIProviderName, AnalyticsData, EvaluationData } from "../core/types.js";
+import type { AIProviderName, AnalyticsData } from "../core/types.js";
+import type { EvaluationData } from "../index.js";
+import type { TokenUsage } from "./providers.js";
 import type { UnknownRecord, JsonValue } from "./common.js";
 import type { ChatMessage } from "./conversationTypes.js";
 /**
@@ -120,11 +122,7 @@ export interface StreamResult {
     }>;
     provider?: string;
     model?: string;
-    usage?: {
-        inputTokens?: number;
-        outputTokens?: number;
-        totalTokens?: number;
-    };
+    usage?: TokenUsage;
     finishReason?: string;
     toolCalls?: ToolCall[];
     toolResults?: ToolResult[];

package/dist/lib/types/typeAliases.d.ts

@@ -382,7 +382,7 @@ export type NetworkTransportResult = {
  * Re-export commonly used types from other modules
  * Provides one-stop shop for type imports
  */
-export type { JsonValue, JsonObject, UnknownRecord } from "./common.js";
+export type { JsonValue, JsonObject } from "./common.js";
 /**
  * Type guard for checking if value is a StandardRecord
  *

package/dist/lib/utils/analyticsUtils.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Analytics utility functions for TokenUsage and AnalyticsData
+ * Provides helper functions to avoid manual field access patterns
+ */
+import type { TokenUsage, AnalyticsData } from "../types/providers.js";
+/**
+ * Format token usage as a human-readable string
+ */
+export declare function formatTokenUsage(usage: TokenUsage): string;
+/**
+ * Calculate cost based on token usage and cost per token
+ */
+export declare function calculateTokenCost(usage: TokenUsage, costPerToken: number): number;
+/**
+ * Combine multiple token usage objects into a single total
+ */
+export declare function combineTokenUsage(usages: TokenUsage[]): TokenUsage;
+/**
+ * Format analytics data for display
+ */
+export declare function formatAnalyticsForDisplay(analytics: AnalyticsData): string;
+/**
+ * Check if analytics data contains valid token usage
+ */
+export declare function hasValidTokenUsage(analytics: AnalyticsData): boolean;
+/**
+ * Extract summary metrics from analytics data
+ */
+export declare function getAnalyticsSummary(analytics: AnalyticsData): {
+    totalTokens: number;
+    costPerToken: number | null;
+    requestsPerSecond: number;
+};

package/dist/lib/utils/analyticsUtils.js

@@ -0,0 +1,76 @@
+/**
+ * Analytics utility functions for TokenUsage and AnalyticsData
+ * Provides helper functions to avoid manual field access patterns
+ */
+/**
+ * Format token usage as a human-readable string
+ */
+export function formatTokenUsage(usage) {
+    return `${usage.input}/${usage.output}/${usage.total}`;
+}
+/**
+ * Calculate cost based on token usage and cost per token
+ */
+export function calculateTokenCost(usage, costPerToken) {
+    return usage.total * costPerToken;
+}
+/**
+ * Combine multiple token usage objects into a single total
+ */
+export function combineTokenUsage(usages) {
+    return usages.reduce((total, current) => ({
+        input: total.input + current.input,
+        output: total.output + current.output,
+        total: total.total + current.total,
+    }), { input: 0, output: 0, total: 0 });
+}
+/**
+ * Format analytics data for display
+ */
+export function formatAnalyticsForDisplay(analytics) {
+    const parts = [];
+    // Provider and model
+    parts.push(`Provider: ${analytics.provider}`);
+    if (analytics.model) {
+        parts.push(`Model: ${analytics.model}`);
+    }
+    // Token usage
+    parts.push(`Tokens: ${formatTokenUsage(analytics.tokenUsage)}`);
+    // Cost
+    if (analytics.cost !== undefined) {
+        parts.push(`Cost: $${analytics.cost.toFixed(5)}`);
+    }
+    // Duration
+    const timeInSeconds = (analytics.requestDuration / 1000).toFixed(1);
+    parts.push(`Time: ${timeInSeconds}s`);
+    return parts.join(" | ");
+}
+/**
+ * Check if analytics data contains valid token usage
+ */
+export function hasValidTokenUsage(analytics) {
+    return !!(analytics.tokenUsage &&
+        typeof analytics.tokenUsage.input === "number" &&
+        typeof analytics.tokenUsage.output === "number" &&
+        typeof analytics.tokenUsage.total === "number");
+}
+/**
+ * Extract summary metrics from analytics data
+ */
+export function getAnalyticsSummary(analytics) {
+    const totalTokens = analytics.tokenUsage.total;
+    let costPerToken = null;
+    if (analytics.cost !== null &&
+        analytics.cost !== undefined &&
+        Number.isFinite(analytics.cost) &&
+        totalTokens > 0) {
+        const computed = analytics.cost / (totalTokens / 1000);
+        costPerToken = Number.isFinite(computed) ? computed : null;
+    }
+    const requestsPerSecond = analytics.requestDuration > 0 ? 1000 / analytics.requestDuration : 0;
+    return {
+        totalTokens,
+        costPerToken,
+        requestsPerSecond,
+    };
+}

package/dist/lib/utils/errorHandling.js

@@ -218,7 +218,10 @@ export async function withRetry(operation, options) {
             await new Promise((resolve) => setTimeout(resolve, delayMs));
         }
     }
-    throw lastError;
+    if (lastError) {
+        throw lastError;
+    }
+    throw new Error("Retry operation failed with no error information");
 }
 /**
  * Circuit breaker for preventing cascading failures

package/dist/lib/utils/evaluationUtils.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Evaluation utilities for normalizing EvaluationData objects
+ * Provides helper functions to handle partial evaluation data and ensure
+ * complete EvaluationData objects with safe defaults
+ */
+import type { EvaluationData } from "../types/providers.js";
+/**
+ * Normalize partial EvaluationData into a complete EvaluationData object
+ * with safe defaults for missing required fields
+ */
+export declare function normalizeEvaluationData(partial: Partial<EvaluationData>): EvaluationData;
+/**
+ * Create a default EvaluationData object for cases where no evaluation was performed
+ */
+export declare function createDefaultEvaluationData(overrides?: Partial<EvaluationData>): EvaluationData;
+/**
+ * Check if EvaluationData indicates a successful evaluation
+ */
+export declare function isValidEvaluation(evaluation: EvaluationData): boolean;
+/**
+ * Create EvaluationData for a failed evaluation attempt
+ */
+export declare function createFailedEvaluationData(error: string, overrides?: Partial<EvaluationData>): EvaluationData;
+/**
+ * Merge multiple partial evaluation data objects into a normalized result
+ */
+export declare function mergeEvaluationData(...partials: Partial<EvaluationData>[]): EvaluationData;

package/dist/lib/utils/evaluationUtils.js

@@ -0,0 +1,131 @@
+/**
+ * Evaluation utilities for normalizing EvaluationData objects
+ * Provides helper functions to handle partial evaluation data and ensure
+ * complete EvaluationData objects with safe defaults
+ */
+/**
+ * Default values for required EvaluationData fields
+ */
+const DEFAULT_EVALUATION_DATA = {
+    // Core scores (1-10 scale)
+    relevance: 0,
+    accuracy: 0,
+    completeness: 0,
+    overall: 0,
+    // Advanced insights
+    isOffTopic: false,
+    alertSeverity: "none",
+    reasoning: "",
+    // Metadata
+    evaluationModel: "unknown",
+    evaluationTime: 0,
+    // Enhanced metadata defaults
+    evaluationProvider: "unknown",
+    evaluationAttempt: 0,
+    evaluationConfig: {
+        mode: "default",
+        fallbackUsed: false,
+        costEstimate: 0,
+    },
+};
+/**
+ * Normalize partial EvaluationData into a complete EvaluationData object
+ * with safe defaults for missing required fields
+ */
+export function normalizeEvaluationData(partial) {
+    const normalized = {
+        ...DEFAULT_EVALUATION_DATA,
+        ...partial,
+    };
+    // Ensure scores are within valid range (0-10)
+    normalized.relevance = Math.max(0, Math.min(10, normalized.relevance));
+    normalized.accuracy = Math.max(0, Math.min(10, normalized.accuracy));
+    normalized.completeness = Math.max(0, Math.min(10, normalized.completeness));
+    normalized.overall = Math.max(0, Math.min(10, normalized.overall));
+    // Optional scores
+    if (normalized.domainAlignment !== undefined) {
+        normalized.domainAlignment = Math.max(0, Math.min(10, normalized.domainAlignment));
+    }
+    if (normalized.terminologyAccuracy !== undefined) {
+        normalized.terminologyAccuracy = Math.max(0, Math.min(10, normalized.terminologyAccuracy));
+    }
+    if (normalized.toolEffectiveness !== undefined) {
+        normalized.toolEffectiveness = Math.max(0, Math.min(10, normalized.toolEffectiveness));
+    }
+    // Validate alertSeverity enum
+    const validSeverities = ["low", "medium", "high", "none"];
+    if (!validSeverities.includes(normalized.alertSeverity)) {
+        normalized.alertSeverity = "none";
+    }
+    // Truncate reasoning and suggestedImprovements to enforce length constraints
+    normalized.reasoning = truncateString(normalized.reasoning, 150);
+    if (normalized.suggestedImprovements) {
+        normalized.suggestedImprovements = truncateString(normalized.suggestedImprovements, 100);
+    }
+    // Ensure evaluationTime is non-negative
+    normalized.evaluationTime = Math.max(0, normalized.evaluationTime);
+    // Ensure evaluationAttempt is positive
+    if (normalized.evaluationAttempt !== undefined) {
+        normalized.evaluationAttempt = Math.max(0, normalized.evaluationAttempt);
+    }
+    // Ensure evaluationConfig has required fields
+    if (normalized.evaluationConfig) {
+        normalized.evaluationConfig = {
+            mode: normalized.evaluationConfig.mode || "default",
+            fallbackUsed: Boolean(normalized.evaluationConfig.fallbackUsed),
+            costEstimate: Math.max(0, normalized.evaluationConfig.costEstimate || 0),
+        };
+    }
+    return normalized;
+}
+/**
+ * Create a default EvaluationData object for cases where no evaluation was performed
+ */
+export function createDefaultEvaluationData(overrides = {}) {
+    return normalizeEvaluationData({
+        ...overrides,
+        reasoning: overrides.reasoning || "No evaluation performed",
+        evaluationModel: overrides.evaluationModel || "none",
+    });
+}
+/**
+ * Check if EvaluationData indicates a successful evaluation
+ */
+export function isValidEvaluation(evaluation) {
+    return (evaluation.evaluationModel !== "unknown" &&
+        evaluation.evaluationModel !== "none" &&
+        evaluation.reasoning.length > 0 &&
+        evaluation.overall > 0);
+}
+/**
+ * Create EvaluationData for a failed evaluation attempt
+ */
+export function createFailedEvaluationData(error, overrides = {}) {
+    return normalizeEvaluationData({
+        ...overrides,
+        reasoning: `Evaluation failed: ${truncateString(error, 100)}`,
+        alertSeverity: "medium",
+        evaluationModel: overrides.evaluationModel || "error",
+        evaluationConfig: {
+            mode: "error",
+            fallbackUsed: true,
+            costEstimate: 0,
+        },
+    });
+}
+/**
+ * Helper function to truncate strings to a maximum length
+ */
+function truncateString(str, maxLength) {
+    if (str.length <= maxLength) {
+        return str;
+    }
+    return str.substring(0, maxLength - 3) + "...";
+}
+/**
+ * Merge multiple partial evaluation data objects into a normalized result
+ */
+export function mergeEvaluationData(...partials) {
+    const merged = partials.reduce((acc, partial) => ({ ...acc, ...partial }), {});
+    return normalizeEvaluationData(merged);
+}