@juspay/neurolink 7.29.2 → 7.29.3

package/dist/lib/providers/sagemaker/parsers.js

@@ -262,7 +262,11 @@ export class HuggingFaceStreamParser extends BaseStreamingParser {
         // Error format
         if (data.error) {
             const errorMessage = extractApiErrorMessage(data.error);
-            throw new SageMakerError(`HuggingFace streaming error: ${errorMessage}`, "MODEL_ERROR", 500);
+            throw new SageMakerError(`HuggingFace streaming error: ${errorMessage}`, {
+                code: "MODEL_ERROR",
+                statusCode: 500,
+                retryable: false,
+            });
         }
         return null;
     }
@@ -274,7 +278,7 @@ export class HuggingFaceStreamParser extends BaseStreamingParser {
         return {
             promptTokens: Number(tokens.input) || 0,
             completionTokens: Number(tokens.generated) || 0,
-            totalTokens: Number(tokens.total) || 0,
+            total: Number(tokens.total) || 0,
         };
     }
     mapFinishReason(reason) {
@@ -379,7 +383,11 @@ export class LlamaStreamParser extends BaseStreamingParser {
         if (data.error) {
             const errorData = data.error;
             const errorMessage = extractApiErrorMessage(errorData);
-            throw new SageMakerError(`LLaMA streaming error: ${errorMessage}`, "MODEL_ERROR", 500);
+            throw new SageMakerError(`LLaMA streaming error: ${errorMessage}`, {
+                code: "MODEL_ERROR",
+                statusCode: 500,
+                retryable: false,
+            });
         }
         return null;
     }
@@ -441,7 +449,7 @@ export class LlamaStreamParser extends BaseStreamingParser {
         return {
             promptTokens: Number(usage.prompt_tokens) || 0,
             completionTokens: Number(usage.completion_tokens) || 0,
-            totalTokens: Number(usage.total_tokens) || 0,
+            total: Number(usage.total_tokens) || 0,
         };
     }
     mapFinishReason(reason) {
@@ -563,7 +571,7 @@ export class CustomStreamParser extends BaseStreamingParser {
         return {
             promptTokens: Number(usage.prompt_tokens || usage.input_tokens) || 0,
             completionTokens: Number(usage.completion_tokens || usage.output_tokens) || 0,
-            totalTokens: Number(usage.total_tokens) || 0,
+            total: Number(usage.total_tokens) || 0,
         };
     }
 }
@@ -621,6 +629,6 @@ export function estimateTokenUsage(prompt, completion) {
     return {
         promptTokens,
         completionTokens,
-        totalTokens: promptTokens + completionTokens,
+        total: promptTokens + completionTokens,
     };
 }

package/dist/lib/providers/sagemaker/streaming.js

@@ -69,7 +69,18 @@ async function createProtocolSpecificStream(responseStream, parser, capability,
                 while (true) {
                     // Check for abort signal
                     if (options.abortSignal?.aborted) {
-                        throw new SageMakerError("Stream aborted by user", "NETWORK_ERROR", 499);
+                        // Clean up upstream iterator before throwing
+                        try {
+                            await reader.return?.();
+                        }
+                        catch {
+                            // Ignore cleanup errors, still propagate original abort
+                        }
+                        throw new SageMakerError("Stream aborted by user", {
+                            code: "NETWORK_ERROR",
+                            statusCode: 499,
+                            retryable: false,
+                        });
                     }
                     const { done, value } = await reader.next();
                     if (done) {
@@ -86,7 +97,7 @@ async function createProtocolSpecificStream(responseStream, parser, capability,
                         options.onComplete?.(finalUsage || {
                             promptTokens: 0,
                             completionTokens: 0,
-                            totalTokens: 0,
+                            total: 0,
                         });
                         controller.close();
                         break;
@@ -315,6 +326,6 @@ export function estimateTokenUsage(prompt, completion) {
     return {
         promptTokens,
         completionTokens,
-        totalTokens: promptTokens + completionTokens,
+        total: promptTokens + completionTokens,
     };
 }

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

@@ -96,7 +96,7 @@ export interface SageMakerUsage {
     /** Number of completion tokens */
     completionTokens: number;
     /** Total tokens used */
-    totalTokens: number;
+    total: number;
     /** Request processing time in milliseconds */
     requestTime?: number;
     /** Model inference time in milliseconds */

package/dist/lib/proxy/awsProxyIntegration.js

@@ -87,7 +87,7 @@ async function configureSocksAgents(proxyUrl) {
 /**
  * Minimal HTTP agent configuration (fallback)
  */
-async function configureMinimalHttpAgents(_proxyUrl) {
+async function _configureMinimalHttpAgents(_proxyUrl) {
     // Remove broken fallback. Use explicit proxy-aware HttpHandler instead.
     logger.warn("[AWS Proxy] Minimal agent fallback removed; a proper proxy agent is required.");
 }

package/dist/lib/sdk/toolRegistration.d.ts

@@ -88,7 +88,7 @@ export declare function createMCPServerFromTools(serverId: string, tools: Record
 /**
  * Helper to create a tool with type safety
  */
-export declare function createTool<TParams = ToolArgs>(config: SimpleTool): SimpleTool;
+export declare function createTool(config: SimpleTool): SimpleTool;
 /**
  * Helper to create a validated tool with suggested improvements
  */

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,21 @@ 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
@@ -166,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;