@juspay/neurolink 7.51.1 → 7.51.2

package/dist/lib/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/lib/types/providers.js

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

package/dist/lib/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/lib/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/lib/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/lib/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/lib/types/utilities.js

@@ -0,0 +1,5 @@
+/**
+ * Utility module types - extracted from utils module files
+ */
+export {};
+//# sourceMappingURL=utilities.js.map

package/dist/lib/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/lib/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/dist/neurolink.d.ts

@@ -11,7 +11,8 @@ import type { GenerateOptions, GenerateResult } from "./types/generateTypes.js";
 import type { StreamOptions, StreamResult } from "./types/streamTypes.js";
 import type { MCPServerInfo, MCPExecutableTool } from "./types/mcpTypes.js";
 import type { ToolInfo } from "./types/tools.js";
-import type { NeuroLinkEvents, TypedEventEmitter, ToolExecutionContext, ToolExecutionSummary } from "./types/common.js";
+import type { NeuroLinkEvents, TypedEventEmitter } from "./types/common.js";
+import type { ToolExecutionContext, ToolExecutionSummary } from "./types/tools.js";
 import type { JsonObject } from "./types/common.js";
 import type { BatchOperationResult } from "./types/typeAliases.js";
 import type { ConversationMemoryConfig, ChatMessage } from "./types/conversation.js";

package/dist/types/common.d.ts

@@ -13,38 +13,41 @@ export type UnknownRecord = Record<string, unknown>;
  * Type-safe array of unknown items
  */
 export type UnknownArray = unknown[];
+/**
+ * Storage type for conversation memory factory
+ */
+export type StorageType = "memory" | "redis";
 /**
  * JSON-serializable value type
  */
 export type JsonValue = string | number | boolean | null | JsonObject | JsonArray;
-export interface JsonObject {
+export type JsonObject = {
     [key: string]: JsonValue;
-}
-export interface JsonArray extends Array<JsonValue> {
-}
+};
+export type JsonArray = JsonValue[];
 /**
  * Type-safe error handling
  */
-export interface ErrorInfo {
+export type ErrorInfo = {
     message: string;
     code?: string | number;
     stack?: string;
     cause?: unknown;
-}
+};
 /**
  * Generic success/error result type
  */
-export interface Result<T = unknown, E = ErrorInfo> {
+export type Result<T = unknown, E = ErrorInfo> = {
     success: boolean;
     data?: T;
     error?: E;
-}
+};
 /**
  * Function parameter type for dynamic functions
  */
-export interface FunctionParameters {
+export type FunctionParameters = {
     [key: string]: unknown;
-}
+};
 /**
  * Generic async function type
  */
@@ -73,54 +76,20 @@ export declare function getErrorMessage(error: unknown): string;
  * Safe error conversion
  */
 export declare function toErrorInfo(error: unknown): ErrorInfo;
-/**
- * NeuroLink Native Event System Types
- */
-/**
- * Tool execution event for real-time streaming
- */
-export interface 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 interface 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;
-    };
-}
 /**
  * Stream event types for real-time communication
  */
-export interface StreamEvent {
+export type StreamEvent = {
     type: "stream:chunk" | "stream:complete" | "stream:error";
     content?: string;
     metadata?: JsonObject;
     timestamp: number;
-}
+};
 /**
  * Enhanced NeuroLink event types
- * Flexible interface to support both typed and legacy event patterns
+ * Flexible type to support both typed and legacy event patterns
  */
-export interface NeuroLinkEvents {
+export type NeuroLinkEvents = {
     "tool:start": unknown;
     "tool:end": unknown;
     "stream:start": unknown;
@@ -146,7 +115,7 @@ export interface NeuroLinkEvents {
     error: unknown;
     log: unknown;
     [key: string]: unknown;
-}
+};
 /**
  * TypeScript utility for typed EventEmitter
  * Flexible interface to support both typed and legacy event patterns
@@ -159,15 +128,3 @@ export interface TypedEventEmitter<TEvents extends Record<string, unknown>> {
     listenerCount<K extends keyof TEvents>(event: K): number;
     listeners<K extends keyof TEvents>(event: K): Array<(...args: unknown[]) => void>;
 }
-/**
- * Tool execution context for tracking
- */
-export interface ToolExecutionContext {
-    executionId: string;
-    tool: string;
-    startTime: number;
-    endTime?: number;
-    result?: unknown;
-    error?: string;
-    metadata?: JsonObject;
-}

package/dist/types/content.d.ts

@@ -59,46 +59,57 @@ export type Content = TextContent | ImageContent | CSVContent | PDFContent;
 /**
  * Vision capability information for providers
  */
-export interface VisionCapability {
+export type VisionCapability = {
     provider: string;
     supportedModels: string[];
     maxImageSize?: number;
     supportedFormats: string[];
     maxImagesPerRequest?: number;
-}
+};
 /**
  * Provider-specific image format requirements
  */
-export interface ProviderImageFormat {
+export type ProviderImageFormat = {
     provider: string;
     format: "data_uri" | "base64" | "inline_data" | "source";
     requiresPrefix?: boolean;
     mimeTypeField?: string;
     dataField?: string;
-}
+};
 /**
  * Image processing result
  */
-export interface ProcessedImage {
+export type ProcessedImage = {
     data: string;
     mediaType: string;
     size: number;
     format: "data_uri" | "base64" | "inline_data" | "source";
-}
+};
 /**
  * Multimodal message structure for provider adapters
  */
-export interface MultimodalMessage {
+export type MultimodalMessage = {
     role: "user" | "assistant" | "system";
     content: Content[];
-}
+};
+/**
+ * Multimodal input type for options that may contain images or content arrays
+ */
+export type MultimodalInput = {
+    text: string;
+    images?: Array<Buffer | string>;
+    content?: Array<TextContent | ImageContent>;
+    csvFiles?: Array<Buffer | string>;
+    pdfFiles?: Array<Buffer | string>;
+    files?: Array<Buffer | string>;
+};
 /**
  * Provider-specific multimodal payload
  */
-export interface ProviderMultimodalPayload {
+export type ProviderMultimodalPayload = {
     provider: string;
     model: string;
     messages?: MultimodalMessage[];
     contents?: unknown[];
     [key: string]: unknown;
-}
+};