@juspay/neurolink 7.51.1 → 7.51.2

package/dist/types/middlewareTypes.d.ts

@@ -3,10 +3,10 @@ import type { JsonValue } from "../types/common.js";
 import type { EvaluationData } from "./evaluation.js";
 import type { GetPromptFunction } from "./evaluationTypes.js";
 /**
- * Metadata interface for NeuroLink middleware
+ * Metadata type for NeuroLink middleware
  * Provides additional information about middleware without affecting execution
  */
-export interface NeuroLinkMiddlewareMetadata {
+export type NeuroLinkMiddlewareMetadata = {
     /** Unique identifier for the middleware */
     id: string;
     /** Human-readable name */
@@ -19,30 +19,30 @@ export interface NeuroLinkMiddlewareMetadata {
     defaultEnabled?: boolean;
     /** Configuration schema for the middleware */
     configSchema?: Record<string, unknown>;
-}
+};
 /**
  * NeuroLink middleware with metadata
  * Combines standard AI SDK middleware with NeuroLink-specific metadata
  */
-export interface NeuroLinkMiddleware extends LanguageModelV1Middleware {
+export type NeuroLinkMiddleware = LanguageModelV1Middleware & {
     /** Middleware metadata */
     readonly metadata: NeuroLinkMiddlewareMetadata;
-}
+};
 /**
  * Middleware configuration options
  */
-export interface MiddlewareConfig {
+export type MiddlewareConfig = {
     /** Whether the middleware is enabled */
     enabled?: boolean;
     /** Middleware-specific configuration */
     config?: Record<string, unknown>;
     /** Conditions under which to apply this middleware */
     conditions?: MiddlewareConditions;
-}
+};
 /**
  * Conditions for applying middleware
  */
-export interface MiddlewareConditions {
+export type MiddlewareConditions = {
     /** Apply only to specific providers */
     providers?: string[];
     /** Apply only to specific models */
@@ -51,11 +51,11 @@ export interface MiddlewareConditions {
     options?: Record<string, unknown>;
     /** Custom condition function */
     custom?: (context: MiddlewareContext) => boolean;
-}
+};
 /**
  * Context passed to middleware for decision making
  */
-export interface MiddlewareContext {
+export type MiddlewareContext = {
     /** Provider name */
     provider: string;
     /** Model name */
@@ -69,22 +69,22 @@ export interface MiddlewareContext {
     };
     /** Additional metadata */
     metadata?: Record<string, JsonValue>;
-}
+};
 /**
  * Middleware registration options
  */
-export interface MiddlewareRegistrationOptions {
+export type MiddlewareRegistrationOptions = {
     /** Whether to replace existing middleware with same ID */
     replace?: boolean;
     /** Whether to enable the middleware by default */
     defaultEnabled?: boolean;
     /** Global configuration for the middleware */
     globalConfig?: Record<string, JsonValue>;
-}
+};
 /**
  * Middleware execution result
  */
-export interface MiddlewareExecutionResult {
+export type MiddlewareExecutionResult = {
     /** Whether the middleware was applied */
     applied: boolean;
     /** Execution time in milliseconds */
@@ -93,11 +93,11 @@ export interface MiddlewareExecutionResult {
     error?: Error;
     /** Additional metadata from the middleware */
     metadata?: Record<string, JsonValue>;
-}
+};
 /**
  * Middleware chain execution statistics
  */
-export interface MiddlewareChainStats {
+export type MiddlewareChainStats = {
     /** Total number of middleware in the chain */
     totalMiddleware: number;
     /** Number of middleware that were applied */
@@ -106,7 +106,7 @@ export interface MiddlewareChainStats {
     totalExecutionTime: number;
     /** Individual middleware execution results */
     results: Record<string, MiddlewareExecutionResult>;
-}
+};
 /**
  * Built-in middleware types
  */
@@ -114,18 +114,18 @@ export type BuiltInMiddlewareType = "analytics" | "guardrails" | "logging" | "ca
 /**
  * Middleware preset configurations
  */
-export interface MiddlewarePreset {
+export type MiddlewarePreset = {
     /** Preset name */
     name: string;
     /** Description of the preset */
     description: string;
     /** Middleware configurations in the preset */
     config: Record<string, MiddlewareConfig>;
-}
+};
 /**
  * Factory options for middleware
  */
-export interface MiddlewareFactoryOptions {
+export type MiddlewareFactoryOptions = {
     /** Custom middleware to register on initialization */
     middleware?: NeuroLinkMiddleware[];
     /** Enable specific middleware */
@@ -145,11 +145,11 @@ export interface MiddlewareFactoryOptions {
         /** Whether to collect execution statistics */
         collectStats?: boolean;
     };
-}
+};
 /**
  * Configuration for the Auto-Evaluation Middleware.
  */
-export interface AutoEvaluationConfig {
+export type AutoEvaluationConfig = {
     /** The minimum score (1-10) for a response to be considered passing. */
     threshold?: number;
     /** The maximum number of retry attempts before failing. */
@@ -169,4 +169,67 @@ export interface AutoEvaluationConfig {
     highSeverityThreshold?: number;
     promptGenerator?: GetPromptFunction;
     provider?: string;
-}
+};
+/**
+ * Middleware factory configuration options
+ */
+export type MiddlewareFactoryConfig = {
+    enabled: boolean;
+    type: string;
+    priority?: number;
+    config?: Record<string, unknown>;
+};
+/**
+ * Middleware registry entry
+ */
+export type MiddlewareRegistryEntry = {
+    name: string;
+    factory: MiddlewareFactory;
+    defaultConfig: Record<string, unknown>;
+    description?: string;
+    version?: string;
+};
+/**
+ * Middleware factory function type
+ */
+export type MiddlewareFactory = (config: Record<string, unknown>) => LanguageModelV1Middleware;
+/**
+ * Middleware validation result
+ */
+export type MiddlewareValidationResult = {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+};
+/**
+ * Middleware execution context
+ */
+export type MiddlewareExecutionContext = {
+    requestId: string;
+    timestamp: number;
+    provider: string;
+    model: string;
+    userId?: string;
+    sessionId?: string;
+    metadata?: Record<string, unknown>;
+};
+/**
+ * Middleware performance metrics
+ */
+export type MiddlewareMetrics = {
+    name: string;
+    executionTime: number;
+    status: "success" | "error" | "skipped";
+    error?: string;
+    inputSize: number;
+    outputSize: number;
+};
+/**
+ * Middleware chain configuration
+ */
+export type MiddlewareChainConfig = {
+    middlewares: MiddlewareFactoryConfig[];
+    errorHandling: "continue" | "stop" | "rollback";
+    timeout?: number;
+    retries?: number;
+};

package/dist/types/providers.d.ts

@@ -7,12 +7,6 @@ import type { ValidationSchema } from "./typeAliases.js";
 import type { EnhancedGenerateResult, GenerateResult, TextGenerationOptions } from "./generateTypes.js";
 import type { StreamOptions, StreamResult } from "./streamTypes.js";
 import type { ExternalMCPToolInfo } from "./externalMcp.js";
-/**
- * Generic AI SDK model interface
- */
-export type AISDKModel = {
-    [key: string]: unknown;
-};
 /**
  * Supported AI Provider Names
  */
@@ -105,6 +99,12 @@ export declare enum APIVersions {
     GOOGLE_AI_BETA = "v1beta",
     ANTHROPIC_CURRENT = "2023-06-01"
 }
+/**
+ * Generic AI SDK model interface
+ */
+export type AISDKModel = {
+    [key: string]: unknown;
+};
 /**
  * Union type of all supported model names
  */
@@ -284,7 +284,18 @@ export type IndividualProviderConfig = {
     [key: string]: unknown;
 };
 /**
- * AI Provider interface with flexible parameter support (converted from interface)
+ * Configuration options for provider validation
+ */
+export type ProviderConfigOptions = {
+    providerName: string;
+    envVarName: string;
+    setupUrl: string;
+    description: string;
+    instructions: string[];
+    fallbackEnvVars?: string[];
+};
+/**
+ * AI Provider type with flexible parameter support
  */
 export type AIProvider = {
     stream(optionsOrPrompt: StreamOptions | string, analysisSchema?: ValidationSchema): Promise<StreamResult>;
@@ -314,59 +325,6 @@ export type ProviderCreationError = {
     provider: string;
     details?: Record<string, unknown>;
 };
-/**
- * Amazon Bedrock specific types
- */
-export declare namespace BedrockTypes {
-    interface Client {
-        send(command: unknown): Promise<unknown>;
-        config: {
-            region?: string;
-            credentials?: unknown;
-        };
-    }
-    interface InvokeModelCommand {
-        input: {
-            modelId: string;
-            body: string;
-            contentType?: string;
-        };
-    }
-}
-/**
- * Mistral specific types
- */
-export declare namespace MistralTypes {
-    interface Client {
-        chat?: {
-            complete?: (options: unknown) => Promise<unknown>;
-            stream?: (options: unknown) => AsyncIterable<unknown>;
-        };
-    }
-}
-/**
- * OpenTelemetry specific types (for telemetry service)
- */
-export declare namespace TelemetryTypes {
-    interface Meter {
-        createCounter(name: string, options?: unknown): Counter;
-        createHistogram(name: string, options?: unknown): Histogram;
-    }
-    interface Tracer {
-        startSpan(name: string, options?: unknown): Span;
-    }
-    interface Counter {
-        add(value: number, attributes?: UnknownRecord): void;
-    }
-    interface Histogram {
-        record(value: number, attributes?: UnknownRecord): void;
-    }
-    interface Span {
-        end(): void;
-        setStatus(status: unknown): void;
-        recordException(exception: unknown): void;
-    }
-}
 /**
  * Provider factory function type
  */
@@ -1028,7 +986,7 @@ export type EndpointMetrics = {
     memoryUtilization?: number;
     /** Instance count */
     instanceCount: number;
-    /** Timestamp of metrics */
+    /** Timestamp of metrics as ISO 8601 date string */
     timestamp: string;
 };
 /**
@@ -1102,3 +1060,56 @@ export type SageMakerGenerateResult = {
     toolCalls?: SageMakerToolCall[];
     object?: unknown;
 };
+/**
+ * Amazon Bedrock specific types
+ */
+export declare namespace BedrockTypes {
+    interface Client {
+        send(command: unknown): Promise<unknown>;
+        config: {
+            region?: string;
+            credentials?: unknown;
+        };
+    }
+    interface InvokeModelCommand {
+        input: {
+            modelId: string;
+            body: string;
+            contentType?: string;
+        };
+    }
+}
+/**
+ * Mistral specific types
+ */
+export declare namespace MistralTypes {
+    interface Client {
+        chat?: {
+            complete?: (options: unknown) => Promise<unknown>;
+            stream?: (options: unknown) => AsyncIterable<unknown>;
+        };
+    }
+}
+/**
+ * OpenTelemetry specific types (for telemetry service)
+ */
+export declare namespace TelemetryTypes {
+    interface Meter {
+        createCounter(name: string, options?: unknown): Counter;
+        createHistogram(name: string, options?: unknown): Histogram;
+    }
+    interface Tracer {
+        startSpan(name: string, options?: unknown): Span;
+    }
+    interface Counter {
+        add(value: number, attributes?: UnknownRecord): void;
+    }
+    interface Histogram {
+        record(value: number, attributes?: UnknownRecord): void;
+    }
+    interface Span {
+        end(): void;
+        setStatus(status: unknown): void;
+        recordException(exception: unknown): void;
+    }
+}

package/dist/types/providers.js

@@ -1,6 +1,9 @@
 /**
  * Provider-specific type definitions for NeuroLink
  */
+// ============================================================================
+// ENUMS
+// ============================================================================
 /**
  * Supported AI Provider Names
  */

package/dist/types/sdkTypes.d.ts

@@ -8,9 +8,9 @@
 export type { StreamResult, StreamingProgressData, StreamingMetadata, ProgressCallback, ToolCall as StreamToolCall, // Note: Renamed in main index to avoid conflict with tools.js ToolCall
 ToolResult as StreamToolResult, // Note: Renamed in main index to avoid conflict with tools.js ToolResult
 ToolCallResults, ToolCalls, StreamOptions, StreamingOptions, EnhancedStreamProvider, StreamTextResult, AISDKUsage, StreamAnalyticsCollector, ResponseMetadata, AudioInputSpec, AudioChunk, PCMEncoding, } from "./streamTypes.js";
-export type { ToolExecutionEvent, ToolExecutionSummary, TypedEventEmitter, NeuroLinkEvents, StreamEvent, ToolExecutionContext, AsyncFunction, SyncFunction, AnyFunction, } from "./common.js";
+export type { TypedEventEmitter, NeuroLinkEvents, StreamEvent, AsyncFunction, SyncFunction, AnyFunction, } from "./common.js";
 export type { NeuroLinkConfig, ProviderConfig, PerformanceConfig, CacheConfig, FallbackConfig, RetryConfig, AnalyticsConfig, ToolConfig, BackupInfo, BackupMetadata, ConfigValidationResult, ConfigUpdateOptions, } from "./configTypes.js";
-export type { ToolArgs, ToolContext, ToolResult, ToolDefinition, SimpleTool, AvailableTool, ToolExecution, BaseToolArgs, ToolExecutionMetadata, ToolParameterSchema, ZodUnknownSchema, ZodAnySchema, ZodObjectSchema, ZodStringSchema, } from "./tools.js";
+export type { ToolArgs, ToolContext, ToolResult, ToolDefinition, SimpleTool, AvailableTool, ToolExecution, BaseToolArgs, ToolExecutionEvent, ToolExecutionSummary, ToolExecutionContext, ToolExecutionMetadata, ToolParameterSchema, ZodUnknownSchema, ZodAnySchema, ZodObjectSchema, ZodStringSchema, } from "./tools.js";
 export type { AISDKModel, ProviderError, AIModelProviderConfig, AIProviderName, ProviderName, ModelCapability, ModelUseCase, ModelFilter, ModelResolutionContext, ModelStats, ModelPricing, ProviderCapabilities, } from "./providers.js";
 export type { GenerateOptions, GenerateResult, UnifiedGenerationOptions, EnhancedProvider, FactoryEnhancedProvider, TextGenerationOptions, TextGenerationResult, EnhancedGenerateResult, } from "./generateTypes.js";
 export type { TokenUsage, AnalyticsData } from "./analytics.js";

package/dist/types/streamTypes.d.ts

@@ -2,10 +2,10 @@ import type { Tool } from "ai";
 import type { ValidationSchema, StandardRecord } from "./typeAliases.js";
 import type { AIModelProviderConfig } from "./providers.js";
 import type { TextContent, ImageContent } from "./content.js";
-import type { AIProviderName, AnalyticsData } from "../types/index.js";
+import type { AIProviderName, AnalyticsData, ToolExecutionEvent, ToolExecutionSummary } from "../types/index.js";
 import type { TokenUsage } from "./analytics.js";
 import type { EvaluationData } from "../index.js";
-import type { UnknownRecord, JsonValue, ToolExecutionEvent, ToolExecutionSummary } from "./common.js";
+import type { UnknownRecord, JsonValue } from "./common.js";
 import type { MiddlewareFactoryOptions } from "../types/middlewareTypes.js";
 import type { ChatMessage } from "./conversation.js";
 /**
@@ -108,19 +108,19 @@ export type StreamAnalyticsData = {
  * Future-ready for multi-modal capabilities while maintaining text focus
  */
 export type PCMEncoding = "PCM16LE";
-export interface AudioInputSpec {
+export type AudioInputSpec = {
     frames: AsyncIterable<Buffer>;
     sampleRateHz?: number;
     encoding?: PCMEncoding;
     channels?: 1;
-}
-export interface AudioChunk {
+};
+export type AudioChunk = {
     data: Buffer;
     sampleRateHz: number;
     channels: number;
     encoding: PCMEncoding;
-}
-export interface StreamOptions {
+};
+export type StreamOptions = {
     input: {
         text: string;
         audio?: AudioInputSpec;
@@ -179,7 +179,7 @@ export interface StreamOptions {
     };
     conversationMessages?: ChatMessage[];
     middleware?: MiddlewareFactoryOptions;
-}
+};
 /**
  * Stream function result type - Primary output format for streaming
  * Future-ready for multi-modal outputs while maintaining text focus

package/dist/types/tools.d.ts

@@ -3,7 +3,7 @@
  * argument patterns, execution metadata, context, and result types.
  */
 import { z } from "zod";
-import type { Result, JsonValue, ErrorInfo } from "./common.js";
+import type { ErrorInfo, JsonObject, JsonValue, Result, UnknownRecord } from "./common.js";
 import type { StandardRecord, ZodUnknownSchema } from "./typeAliases.js";
 /**
  * Commonly used Zod schema type aliases for cleaner type declarations
@@ -176,6 +176,63 @@ export type ToolMetadata = {
     documentation?: string;
     [key: string]: JsonValue | undefined;
 };
+/**
+ * Tool call object type for type-safe access to tool call properties
+ */
+export type ToolCallObject = UnknownRecord & {
+    toolName?: string;
+    name?: string;
+    toolCallId?: string;
+    id?: string;
+    args?: UnknownRecord;
+    arguments?: UnknownRecord;
+};
+/**
+ * Tool execution context for tracking
+ */
+export type ToolExecutionContext = {
+    executionId: string;
+    tool: string;
+    startTime: number;
+    endTime?: number;
+    result?: unknown;
+    error?: string;
+    metadata?: JsonObject;
+};
+/**
+ * NeuroLink Native Event System Types
+ */
+/**
+ * Tool execution event for real-time streaming
+ */
+export type ToolExecutionEvent = {
+    type: "tool:start" | "tool:end";
+    tool: string;
+    input?: unknown;
+    result?: unknown;
+    error?: string;
+    timestamp: number;
+    duration?: number;
+    executionId: string;
+};
+/**
+ * Tool execution summary for completed executions
+ */
+export type ToolExecutionSummary = {
+    tool: string;
+    startTime: number;
+    endTime: number;
+    duration: number;
+    success: boolean;
+    result?: unknown;
+    error?: string;
+    executionId: string;
+    metadata?: {
+        serverId?: string;
+        toolCategory?: "direct" | "custom" | "mcp";
+        isExternal?: boolean;
+    };
+};
 /**
  * Tool definition type
  */
@@ -215,6 +272,27 @@ export type ToolExecution = {
     executionTime: number;
     timestamp: number;
 };
+/**
+ * Pending tool execution type for Redis memory manager
+ * Temporary storage for tool execution data to avoid race conditions
+ */
+export type PendingToolExecution = {
+    toolCalls: Array<{
+        toolCallId?: string;
+        toolName?: string;
+        args?: Record<string, unknown>;
+        timestamp?: Date;
+        [key: string]: unknown;
+    }>;
+    toolResults: Array<{
+        toolCallId?: string;
+        result?: unknown;
+        error?: string;
+        timestamp?: Date;
+        [key: string]: unknown;
+    }>;
+    timestamp: number;
+};
 /**
  * Available tool information
  */

package/dist/types/utilities.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Utility module types - extracted from utils module files
+ */
+export type TimeoutConfig = {
+    operation: string;
+    timeout?: number | string;
+    gracefulShutdown?: boolean;
+    retryOnTimeout?: boolean;
+    maxRetries?: number;
+    abortSignal?: AbortSignal;
+};
+export type TimeoutResult<T> = {
+    success: boolean;
+    data?: T;
+    error?: Error;
+    timedOut: boolean;
+    executionTime: number;
+    retriesUsed: number;
+};
+/**
+ * Enhanced validation result with format checking
+ */
+export type APIValidationResult = {
+    isValid: boolean;
+    apiKey: string;
+    formatValid?: boolean;
+    errorType?: "missing" | "format" | "config";
+    error?: string;
+};

package/dist/types/utilities.js

@@ -0,0 +1,4 @@
+/**
+ * Utility module types - extracted from utils module files
+ */
+export {};

package/dist/utils/providerConfig.d.ts

@@ -4,17 +4,8 @@
  * Eliminates duplicate error messages and configuration logic
  * Enhanced with format validation and advanced error classification
  */
-/**
- * Configuration options for provider validation
- */
-export interface ProviderConfigOptions {
-    providerName: string;
-    envVarName: string;
-    setupUrl: string;
-    description: string;
-    instructions: string[];
-    fallbackEnvVars?: string[];
-}
+import type { APIValidationResult } from "../types/utilities.js";
+import type { ProviderConfigOptions } from "../types/providers.js";
 /**
  * API key format validation patterns (extracted from advanced validation system)
  * Exported for use across the codebase to replace scattered regex patterns
@@ -40,16 +31,6 @@ export declare const PROJECT_ID_FORMAT: {
     readonly MAX_LENGTH: 30;
     readonly PATTERN: RegExp;
 };
-/**
- * Enhanced validation result with format checking
- */
-export interface ValidationResult {
-    isValid: boolean;
-    apiKey: string;
-    formatValid?: boolean;
-    errorType?: "missing" | "format" | "config";
-    error?: string;
-}
 /**
  * Validates API key format for a specific provider
  * @param providerKey Provider identifier (e.g., 'openai', 'anthropic')
@@ -63,7 +44,7 @@ export declare function validateApiKeyFormat(providerKey: string, apiKey: string
  * @param enableFormatValidation Whether to validate API key format
  * @returns Validation result with detailed information
  */
-export declare function validateApiKeyEnhanced(config: ProviderConfigOptions, enableFormatValidation?: boolean): ValidationResult;
+export declare function validateApiKeyEnhanced(config: ProviderConfigOptions, enableFormatValidation?: boolean): APIValidationResult;
 /**
  * Validates an API key for a provider and returns it (BACKWARD COMPATIBLE)
  * Throws detailed error message if validation fails

package/dist/utils/timeout.d.ts

@@ -4,6 +4,7 @@
  * Provides flexible timeout parsing and error handling for AI operations.
  * Supports multiple time formats: milliseconds, seconds, minutes, hours.
  */
+import type { TimeoutConfig, TimeoutResult } from "../types/utilities.js";
 /**
  * Custom error class for timeout operations
  */
@@ -66,22 +67,6 @@ export declare function getDefaultTimeout(provider: string, operation?: "generat
  * @returns Promise that rejects with TimeoutError
  */
 export declare function createTimeoutPromise(timeout: number | string | undefined, provider: string, operation: "generate" | "stream"): Promise<never> | null;
-export interface TimeoutConfig {
-    operation: string;
-    timeout?: number | string;
-    gracefulShutdown?: boolean;
-    retryOnTimeout?: boolean;
-    maxRetries?: number;
-    abortSignal?: AbortSignal;
-}
-export interface TimeoutResult<T> {
-    success: boolean;
-    data?: T;
-    error?: Error;
-    timedOut: boolean;
-    executionTime: number;
-    retriesUsed: number;
-}
 /**
  * Enhanced timeout manager with proper cleanup and abort controller integration
  * Consolidated from timeout-manager.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "7.51.1",
+  "version": "7.51.2",
   "description": "Universal AI Development Platform with working MCP integration, multi-provider support, and professional CLI. Built-in tools operational, 58+ external MCP servers discoverable. Connect to filesystem, GitHub, database operations, and more. Build, test, and deploy AI applications with 9 major providers: OpenAI, Anthropic, Google AI, AWS Bedrock, Azure, Hugging Face, Ollama, and Mistral AI.",
   "author": {
     "name": "Juspay Technologies",