@juspay/neurolink 5.2.0 → 6.0.0

package/dist/factories/compatibility-factory.d.ts

@@ -12,7 +12,22 @@ export declare class CompatibilityConversionFactory {
     /**
      * Convert GenerateResult to legacy TextGenerationResult format
      */
-    static convertGenerateToText(result: GenerateResult): any;
+    static convertGenerateToText(result: GenerateResult): {
+        content: string;
+        provider?: string;
+        model?: string;
+        usage?: {
+            inputTokens: number;
+            outputTokens: number;
+            totalTokens: number;
+        };
+        responseTime?: number;
+        toolsUsed?: number;
+        toolExecutions?: unknown[];
+        analytics?: unknown;
+        evaluation?: unknown;
+        [key: string]: unknown;
+    };
     /**
      * Convert GenerateOptions to TextGenerationOptions
      */

package/dist/factories/compatibility-factory.js

@@ -37,7 +37,9 @@ export class CompatibilityConversionFactory {
             model: result.model,
             usage: result.usage,
             responseTime: result.responseTime,
-            toolsUsed: result.toolsUsed,
+            toolsUsed: Array.isArray(result.toolsUsed)
+                ? result.toolsUsed.length
+                : result.toolsUsed,
             toolExecutions: result.toolExecutions,
             enhancedWithTools: result.enhancedWithTools,
             availableTools: result.availableTools,

package/dist/factories/provider-factory.d.ts

@@ -1,10 +1,11 @@
 import type { AIProvider, AIProviderName } from "../core/types.js";
+import type { UnknownRecord } from "../types/common.js";
 /**
  * Provider constructor interface - supports both sync constructors and async factory functions
  */
 type ProviderConstructor = {
-    new (modelName?: string, providerName?: any, sdk?: any): AIProvider;
-} | ((modelName?: string, providerName?: any, sdk?: any) => Promise<AIProvider>);
+    new (modelName?: string, providerName?: string, sdk?: UnknownRecord): AIProvider;
+} | ((modelName?: string, providerName?: string, sdk?: UnknownRecord) => Promise<AIProvider>);
 /**
  * Provider registration entry
  */
@@ -29,7 +30,7 @@ export declare class ProviderFactory {
     /**
      * Create a provider instance
      */
-    static createProvider(providerName: AIProviderName | string, modelName?: string, sdk?: any): Promise<AIProvider>;
+    static createProvider(providerName: AIProviderName | string, modelName?: string, sdk?: UnknownRecord): Promise<AIProvider>;
     /**
      * Check if a provider is registered
      */
@@ -63,7 +64,7 @@ export declare class ProviderFactory {
      * Create the best available provider for the given name
      * Used by NeuroLink SDK for streaming and generation
      */
-    static createBestProvider(providerName: AIProviderName | string, modelName?: string, enableMCP?: boolean, sdk?: any): Promise<AIProvider>;
+    static createBestProvider(providerName: AIProviderName | string, modelName?: string, enableMCP?: boolean, sdk?: UnknownRecord): Promise<AIProvider>;
 }
 /**
  * Helper function to create providers with backward compatibility

package/dist/factories/provider-factory.js

@@ -37,32 +37,23 @@ export class ProviderFactory {
         }
         const model = modelName || registration.defaultModel;
         try {
-            // Check if constructor is an async factory function or a class constructor
-            if (typeof registration.constructor === "function") {
-                // Check if it has a prototype (class constructor) or not (factory function)
-                if (registration.constructor.prototype &&
-                    registration.constructor.prototype.constructor ===
-                        registration.constructor) {
-                    // It's a class constructor
-                    return new registration.constructor(model, providerName, sdk);
-                }
-                else {
-                    // It's a factory function - call it and await if it returns a promise
-                    const result = registration.constructor(model, providerName, sdk);
-                    if (result && typeof result.then === "function") {
-                        // It's a Promise (async factory)
-                        return await result;
-                    }
-                    else {
-                        // It's a sync result, return it
-                        return result;
-                    }
-                }
+            // Try calling as factory function first, then fallback to constructor
+            let result;
+            try {
+                // Try as factory function
+                result = registration.constructor(model, providerName, sdk);
             }
-            else {
-                // Fallback - use as class constructor
-                return new registration.constructor(model, sdk);
+            catch (factoryError) {
+                // Fallback to constructor
+                result = new registration.constructor(model, providerName, sdk);
             }
+            // Only await if result is actually a Promise
+            if (result &&
+                typeof result === "object" &&
+                typeof result.then === "function") {
+                return await result;
+            }
+            return result;
         }
         catch (error) {
             logger.error(`Failed to create provider ${providerName}:`, error);

package/dist/factories/provider-generate-factory.js

@@ -37,35 +37,41 @@ export class ProviderGenerateFactory {
             try {
                 // Use existing generate method for identical performance
                 const textResult = await provider.generate(textOptions);
+                if (!textResult) {
+                    throw new Error("Generate method returned null result");
+                }
                 // Convert back to GenerateResult format with type safety
                 const generateResult = {
-                    content: textResult?.content || "",
-                    outputs: { text: textResult?.content || "" },
-                    provider: textResult?.provider,
-                    model: textResult?.model,
-                    usage: textResult?.usage
+                    content: textResult.content || "",
+                    outputs: { text: textResult.content || "" },
+                    provider: textResult.provider,
+                    model: textResult.model,
+                    usage: textResult.usage
                         ? {
-                            inputTokens: textResult.usage?.promptTokens || 0,
-                            outputTokens: textResult.usage?.completionTokens || 0,
-                            totalTokens: textResult.usage?.totalTokens || 0,
+                            inputTokens: textResult.usage.inputTokens || 0,
+                            outputTokens: textResult.usage.outputTokens || 0,
+                            totalTokens: textResult.usage.totalTokens || 0,
                         }
                         : undefined,
-                    responseTime: textResult?.responseTime,
-                    toolsUsed: textResult?.toolsUsed,
-                    toolExecutions: textResult?.toolExecutions?.map((te) => ({
-                        name: te.toolName || te.name || "",
-                        input: te.input || {},
-                        output: te.output || te.result,
-                        duration: te.executionTime || te.duration || 0,
-                    })),
-                    enhancedWithTools: textResult?.enhancedWithTools,
-                    availableTools: textResult?.availableTools?.map((at) => ({
+                    responseTime: textResult.responseTime,
+                    toolsUsed: textResult.toolsUsed,
+                    toolExecutions: textResult.toolExecutions?.map((te) => {
+                        const toolExecution = te;
+                        return {
+                            name: toolExecution.toolName || toolExecution.name || "",
+                            input: toolExecution.input || {},
+                            output: toolExecution.output || toolExecution.result,
+                            duration: toolExecution.executionTime || toolExecution.duration || 0,
+                        };
+                    }),
+                    enhancedWithTools: textResult.enhancedWithTools,
+                    availableTools: textResult.availableTools?.map((at) => ({
                         name: at.name || "",
                         description: at.description || "",
                         parameters: at.parameters || {},
                     })),
-                    analytics: textResult?.analytics,
-                    evaluation: textResult?.evaluation,
+                    analytics: textResult.analytics,
+                    evaluation: textResult.evaluation,
                 };
                 return generateResult;
             }

package/dist/lib/chat/client-utils.d.ts

@@ -63,6 +63,9 @@ export declare class ChatClient {
         reconnectCount: number;
     };
     private handleSSEEvent;
+    private isDataEventData;
+    private isErrorEventData;
+    private isCompleteEventData;
     private handleDataEvent;
     private handleErrorEvent;
     private handleCompleteEvent;

package/dist/lib/chat/client-utils.js

@@ -140,19 +140,36 @@ export class ChatClient {
     handleSSEEvent(event) {
         switch (event.type) {
             case "data":
-                this.handleDataEvent(event.data);
+                if (this.isDataEventData(event.data)) {
+                    this.handleDataEvent(event.data);
+                }
                 break;
             case "error":
-                this.handleErrorEvent(event.data);
+                if (this.isErrorEventData(event.data)) {
+                    this.handleErrorEvent(event.data);
+                }
                 break;
             case "complete":
-                this.handleCompleteEvent(event.data);
+                if (this.isCompleteEventData(event.data)) {
+                    this.handleCompleteEvent(event.data);
+                }
                 break;
             case "heartbeat":
                 // Heartbeat received, connection is alive
                 break;
         }
     }
+    isDataEventData(data) {
+        return (typeof data === "object" &&
+            data !== null &&
+            typeof data.type === "string");
+    }
+    isErrorEventData(data) {
+        return typeof data === "object" && data !== null;
+    }
+    isCompleteEventData(data) {
+        return typeof data === "object" && data !== null;
+    }
     handleDataEvent(data) {
         if (data.type === "chunk") {
             // Handle streaming response chunk
@@ -167,7 +184,7 @@ export class ChatClient {
                 const message = {
                     id: `msg_${Date.now()}_assistant`,
                     role: "assistant",
-                    content: data.content,
+                    content: data.content || "",
                     timestamp: Date.now(),
                 };
                 this.messages.push(message);
@@ -177,7 +194,7 @@ export class ChatClient {
         else if (data.type === "start") {
             // New conversation started
             const userMessage = {
-                id: data.messageId,
+                id: String(data.messageId || `msg_${Date.now()}_user`),
                 role: "user",
                 content: data.content || "", // Use data content if available
                 timestamp: Date.now(),

package/dist/lib/chat/index.d.ts

@@ -11,17 +11,14 @@ export type { ChatMessage, ChatRequest, SSEOptions, SessionOptions, SSEEvent, Ch
 /**
  * Quick setup helper for SSE chat
  */
-export declare function createSSEChat(provider: any, options?: any): Promise<SSEChatHandler>;
+export declare function createSSEChat(provider: unknown, options?: unknown): Promise<SSEChatHandler>;
 /**
  * Quick setup helper for chat session
  */
-export declare function createChatSession(sessionId: string, options?: any): Promise<import("./session.js").ChatSession>;
-/**
- * Enhanced factory function for real-time chat
- */
+export declare function createChatSession(sessionId: string, options?: unknown): Promise<import("./session.js").ChatSession>;
 export declare function createEnhancedChatService(options: {
-    provider: any;
+    provider: unknown;
     enableSSE?: boolean;
     enableWebSocket?: boolean;
-    streamingConfig?: any;
+    streamingConfig?: unknown;
 }): Promise<SSEChatHandler>;

package/dist/lib/chat/index.js

@@ -21,14 +21,6 @@ export async function createChatSession(sessionId, options) {
     const { ChatSession } = await import("./session.js");
     return new ChatSession(sessionId, options);
 }
-// Real-time Services (Phase 4) - Temporarily disabled for testing
-// export { WebSocketChatHandler } from './websocket-chat-handler.js';
-// export { NeuroLinkWebSocketServer } from '../services/websocket/websocket-server.js';
-// export { StreamingManager } from '../services/streaming/streaming-manager.js';
-// export * from '../services/types.js';
-/**
- * Enhanced factory function for real-time chat
- */
 export async function createEnhancedChatService(options) {
     if (options.enableWebSocket) {
         const { WebSocketChatHandler } = await import("./websocket-chat-handler.js");

package/dist/lib/chat/session-storage.d.ts

@@ -47,10 +47,10 @@ export declare class FileSessionStorage implements SessionStorage {
  */
 interface RedisClient {
     get(key: string): Promise<string | null>;
-    set(key: string, value: string, options?: any): Promise<any>;
+    set(key: string, value: string, options?: unknown): Promise<unknown>;
     del(key: string): Promise<number>;
     exists(key: string): Promise<number>;
-    expire?(key: string, ttl: number): Promise<any>;
+    expire?(key: string, ttl: number): Promise<unknown>;
     keys?(pattern: string): Promise<string[]>;
 }
 export declare class RedisSessionStorage implements SessionStorage {

package/dist/lib/chat/session.d.ts

@@ -3,6 +3,7 @@
  * Chat session management with persistence
  */
 import type { ChatMessage, SessionOptions, ChatSessionState } from "./types.js";
+import type { JsonValue } from "../types/common.js";
 export declare class ChatSession {
     private sessionId;
     private messages;
@@ -15,7 +16,7 @@ export declare class ChatSession {
     /**
      * Add message to session
      */
-    addMessage(role: "user" | "assistant" | "system", content: string, metadata?: any): ChatMessage;
+    addMessage(role: "user" | "assistant" | "system", content: string, metadata?: unknown): ChatMessage;
     /**
      * Get conversation history
      */
@@ -27,11 +28,11 @@ export declare class ChatSession {
     /**
      * Get session metadata
      */
-    getMetadata(): Record<string, any>;
+    getMetadata(): Record<string, JsonValue>;
     /**
      * Set session metadata
      */
-    setMetadata(key: string, value: any): void;
+    setMetadata(key: string, value: JsonValue): void;
     /**
      * Clear session history
      */

package/dist/lib/chat/session.js

@@ -36,7 +36,7 @@ export class ChatSession {
             role,
             content,
             timestamp: Date.now(),
-            metadata,
+            metadata: metadata,
         };
         this.messages.push(message);
         this.lastActivity = Date.now();

package/dist/lib/chat/sse-handler.js

@@ -49,29 +49,21 @@ export class SSEChatHandler {
                     systemPrompt: options.systemPrompt,
                 });
                 if (aiResponse?.stream) {
-                    // Convert async iterable to readable stream
+                    // Iterate over the async iterable stream
                     const reader = aiResponse.stream;
                     let fullResponse = "";
-                    try {
-                        while (true) {
-                            const { done, value } = await reader.read();
-                            if (done) {
-                                break;
-                            }
-                            fullResponse += value;
-                            // Send chunk to client
-                            await this.sendEvent(writer, {
-                                type: "data",
-                                data: {
-                                    type: "chunk",
-                                    content: value,
-                                    sessionId,
-                                },
-                            });
-                        }
-                    }
-                    finally {
-                        reader.releaseLock();
+                    for await (const chunk of reader) {
+                        const content = chunk.content;
+                        fullResponse += content;
+                        // Send chunk to client
+                        await this.sendEvent(writer, {
+                            type: "data",
+                            data: {
+                                type: "chunk",
+                                content: content,
+                                sessionId,
+                            },
+                        });
                     }
                     // Add AI response to session
                     const assistantMessage = {

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

@@ -2,6 +2,7 @@
  * Phase 3: SSE Chat Utilities
  * Type definitions for chat infrastructure
  */
+import type { JsonValue } from "../types/common.js";
 export interface ChatMessage {
     id: string;
     role: "user" | "assistant" | "system";
@@ -41,7 +42,7 @@ export interface SessionOptions {
 }
 export interface SSEEvent {
     type: "data" | "error" | "progress" | "complete" | "heartbeat";
-    data: any;
+    data: JsonValue;
     id?: string;
     retry?: number;
 }
@@ -50,7 +51,7 @@ export interface ChatSessionState {
     messages: ChatMessage[];
     createdAt: number;
     lastActivity: number;
-    metadata?: Record<string, any>;
+    metadata?: Record<string, JsonValue>;
 }
 export interface StreamingChatResponse {
     sessionId: string;

package/dist/lib/chat/websocket-chat-handler.d.ts

@@ -1,9 +1,10 @@
 import { SSEChatHandler } from "./sse-handler.js";
 import type { AIProvider } from "../core/types.js";
-import type { WebSocketOptions, ChatRequest, GroupChatRequest, StreamingChatRequest } from "../services/types.js";
-import type { SSEOptions } from "./types.js";
+import type { WebSocketOptions, GroupChatRequest, StreamingChatRequest } from "../services/types.js";
+import type { SSEOptions, ChatRequest } from "./types.js";
+import type { UnknownRecord } from "../types/common.js";
 export interface WebSocketChatOptions {
-    sseOptions?: any;
+    sseOptions?: UnknownRecord;
     wsOptions?: WebSocketOptions;
     enableTypingIndicators?: boolean;
     enablePresenceTracking?: boolean;

package/dist/lib/chat/websocket-chat-handler.js

@@ -61,7 +61,7 @@ export class WebSocketChatHandler extends SSEChatHandler {
             });
             // Generate AI response
             const result = await this.provider.generate({
-                prompt: request.prompt,
+                prompt: request.message,
                 temperature: request.options?.temperature,
                 maxTokens: request.options?.maxTokens,
             });
@@ -177,12 +177,8 @@ export class WebSocketChatHandler extends SSEChatHandler {
     }
     // Helper methods
     sendToConnection(connectionId, message) {
-        // Use the WebSocket server's send method
-        const ws = this.wsServer.connections?.get(connectionId);
-        if (ws && ws.readyState === 1) {
-            // WebSocket.OPEN
-            ws.send(JSON.stringify(message));
-        }
+        // Use the WebSocket server's public send method
+        this.wsServer.sendMessage(connectionId, message);
     }
     sendError(connectionId, errorMessage) {
         const errorMsg = {
@@ -227,18 +223,22 @@ export class WebSocketChatHandler extends SSEChatHandler {
         });
     }
     handleWebSocketChatMessage(connectionId, message) {
-        switch (message.data?.event) {
+        const data = message.data;
+        if (!data || typeof data !== "object") {
+            return;
+        }
+        switch (data.event) {
             case "chat_request":
-                this.handleWebSocketChatRequest(connectionId, message.data.request);
+                this.handleWebSocketChatRequest(connectionId, data.request);
                 break;
             case "join_room":
-                this.wsServer.joinRoom(connectionId, message.data.roomId);
+                this.wsServer.joinRoom(connectionId, data.roomId);
                 break;
             case "leave_room":
-                this.wsServer.leaveRoom(connectionId, message.data.roomId);
+                this.wsServer.leaveRoom(connectionId, data.roomId);
                 break;
             case "typing_start":
-                this.showTypingIndicator(connectionId, message.data.sender || "user");
+                this.showTypingIndicator(connectionId, data.sender || "user");
                 break;
             case "typing_stop":
                 this.clearTypingIndicator(connectionId);

package/dist/lib/core/analytics.d.ts

@@ -4,6 +4,7 @@
  * Provides lightweight analytics tracking for AI provider usage,
  * including tokens, costs, performance metrics, and custom context.
  */
+import type { JsonValue, UnknownRecord } from "../types/common.js";
 export interface AnalyticsData {
     provider: string;
     model: string;
@@ -14,10 +15,10 @@ export interface AnalyticsData {
     };
     cost?: number;
     responseTime: number;
-    context?: Record<string, any>;
+    context?: Record<string, JsonValue>;
     timestamp: string;
 }
 /**
  * Create analytics data structure from AI response
  */
-export declare function createAnalytics(provider: string, model: string, result: any, responseTime: number, context?: Record<string, any>): AnalyticsData;
+export declare function createAnalytics(provider: string, model: string, result: UnknownRecord, responseTime: number, context?: Record<string, JsonValue>): AnalyticsData;

package/dist/lib/core/analytics.js

@@ -51,23 +51,30 @@ export function createAnalytics(provider, model, result, responseTime, context)
  */
 function extractTokenUsage(result) {
     // Handle different response formats
-    if (result.usage) {
+    if (result.usage &&
+        typeof result.usage === "object" &&
+        result.usage !== null) {
         const usage = result.usage;
         // Standard format
-        if (usage.promptTokens !== undefined &&
-            usage.completionTokens !== undefined) {
+        if (typeof usage.promptTokens === "number" &&
+            typeof usage.completionTokens === "number") {
             return {
                 input: usage.promptTokens || 0,
                 output: usage.completionTokens || 0,
-                total: usage.totalTokens || usage.promptTokens + usage.completionTokens,
+                total: typeof usage.totalTokens === "number"
+                    ? usage.totalTokens
+                    : usage.promptTokens + usage.completionTokens,
             };
         }
         // Alternative formats
-        if (usage.input_tokens !== undefined && usage.output_tokens !== undefined) {
+        if (typeof usage.input_tokens === "number" &&
+            typeof usage.output_tokens === "number") {
             return {
                 input: usage.input_tokens || 0,
                 output: usage.output_tokens || 0,
-                total: usage.total_tokens || usage.input_tokens + usage.output_tokens,
+                total: typeof usage.total_tokens === "number"
+                    ? usage.total_tokens
+                    : usage.input_tokens + usage.output_tokens,
             };
         }
         // Generic tokens field
@@ -80,7 +87,9 @@ function extractTokenUsage(result) {
         }
     }
     // Fallback: estimate from text length
-    const textLength = result.text?.length || result.content?.length || 0;
+    const textLength = (typeof result.text === "string" ? result.text.length : 0) ||
+        (typeof result.content === "string" ? result.content.length : 0) ||
+        0;
     const estimatedTokens = Math.ceil(textLength / 4); // ~4 chars per token
     return {
         input: 0,

package/dist/lib/core/base-provider.d.ts

@@ -1,8 +1,35 @@
 import type { ZodType, ZodTypeDef } from "zod";
 import type { Schema } from "ai";
-import type { Tool } from "ai";
-import type { AIProvider, TextGenerationOptions, EnhancedGenerateResult, AnalyticsData, AIProviderName } from "../core/types.js";
+import type { Tool, LanguageModel } from "ai";
+import type { AIProvider, TextGenerationOptions, EnhancedGenerateResult, AnalyticsData, AIProviderName, EvaluationData } from "../core/types.js";
 import type { StreamOptions, StreamResult } from "../types/stream-types.js";
+import type { JsonValue, UnknownRecord } from "../types/common.js";
+import type { ToolResult } from "../types/tools.js";
+/**
+ * Interface for SDK with in-memory MCP servers
+ */
+export interface NeuroLinkSDK {
+    getInMemoryServers?: () => Map<string, {
+        server: {
+            title?: string;
+            description?: string;
+            tools?: Map<string, ToolInfo> | Record<string, ToolInfo>;
+        };
+        category?: string;
+        metadata?: UnknownRecord;
+    }>;
+}
+/**
+ * Interface for tool information in MCP servers
+ */
+interface ToolInfo {
+    description?: string;
+    inputSchema?: ZodType<JsonValue>;
+    parameters?: ZodType<JsonValue>;
+    execute: (args: JsonValue) => Promise<JsonValue | ToolResult> | JsonValue | ToolResult;
+    isImplemented?: boolean;
+    metadata?: UnknownRecord;
+}
 /**
  * Abstract base class for all AI providers
  * Tools are integrated as first-class citizens - always available by default
@@ -354,8 +381,8 @@ export declare abstract class BaseProvider implements AIProvider {
     protected mcpTools?: Record<string, Tool>;
     protected sessionId?: string;
     protected userId?: string;
-    protected sdk?: any;
-    constructor(modelName?: string, providerName?: AIProviderName, sdk?: any);
+    protected sdk?: NeuroLinkSDK;
+    constructor(modelName?: string, providerName?: AIProviderName, sdk?: NeuroLinkSDK);
     /**
      * Check if this provider supports tool/function calling
      * Override in subclasses to disable tools for specific providers or models
@@ -392,7 +419,7 @@ export declare abstract class BaseProvider implements AIProvider {
      * REQUIRED: Every provider MUST implement this method
      * Returns the Vercel AI SDK model instance for this provider
      */
-    protected abstract getAISDKModel(): any | Promise<any>;
+    protected abstract getAISDKModel(): LanguageModel | Promise<LanguageModel>;
     /**
      * Get all available tools - direct tools are ALWAYS available
      * MCP tools are added when available (without blocking)
@@ -405,12 +432,12 @@ export declare abstract class BaseProvider implements AIProvider {
     /**
      * Provider-specific error handling
      */
-    protected abstract handleProviderError(error: any): Error;
+    protected abstract handleProviderError(error: unknown): Error;
     protected normalizeTextOptions(optionsOrPrompt: TextGenerationOptions | string): TextGenerationOptions;
     protected normalizeStreamOptions(optionsOrPrompt: StreamOptions | string): StreamOptions;
     protected enhanceResult(result: EnhancedGenerateResult, options: TextGenerationOptions, startTime: number): Promise<EnhancedGenerateResult>;
     protected createAnalytics(result: EnhancedGenerateResult, responseTime: number, options: TextGenerationOptions): Promise<AnalyticsData>;
-    protected createEvaluation(result: EnhancedGenerateResult, options: TextGenerationOptions): Promise<any>;
+    protected createEvaluation(result: EnhancedGenerateResult, options: TextGenerationOptions): Promise<EvaluationData>;
     protected validateOptions(options: TextGenerationOptions): void;
     protected getProviderInfo(): {
         provider: string;
@@ -421,3 +448,4 @@ export declare abstract class BaseProvider implements AIProvider {
      */
     getTimeout(options: TextGenerationOptions | StreamOptions): number;
 }
+export {};