@juspay/neurolink 5.0.0 → 5.2.0

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

@@ -60,12 +60,12 @@ export class WebSocketChatHandler extends SSEChatHandler {
                 latencyTarget: 200,
             });
             // Generate AI response
-            const result = await this.provider.generateText({
+            const result = await this.provider.generate({
                 prompt: request.prompt,
                 temperature: request.options?.temperature,
                 maxTokens: request.options?.maxTokens,
             });
-            if (!result || !result.text) {
+            if (!result || !result.content) {
                 throw new Error("Invalid AI response");
             }
             // Send response via WebSocket
@@ -75,7 +75,7 @@ export class WebSocketChatHandler extends SSEChatHandler {
                 connectionId,
                 timestamp: Date.now(),
                 data: {
-                    text: result.text,
+                    text: result.content,
                     sessionId: request.sessionId,
                     metadata: {
                         provider: this.provider.constructor.name,
@@ -98,12 +98,12 @@ export class WebSocketChatHandler extends SSEChatHandler {
     async handleGroupChat(roomId, request) {
         try {
             // Process AI request
-            const result = await this.provider.generateText({
+            const result = await this.provider.generate({
                 prompt: request.prompt,
                 temperature: request.options?.temperature,
                 maxTokens: request.options?.maxTokens,
             });
-            if (!result || !result.text) {
+            if (!result || !result.content) {
                 throw new Error("Invalid AI response");
             }
             // Broadcast to room
@@ -113,7 +113,7 @@ export class WebSocketChatHandler extends SSEChatHandler {
                 connectionId: "system",
                 timestamp: Date.now(),
                 data: {
-                    text: result.text,
+                    text: result.content,
                     sessionId: request.sessionId,
                     userId: request.userId,
                     isGroupMessage: true,
@@ -136,11 +136,11 @@ export class WebSocketChatHandler extends SSEChatHandler {
             const channelId = randomUUID();
             const channel = this.wsServer.createStreamingChannel(connectionId, channelId);
             // Generate response
-            const result = await this.provider.generateText({
+            const result = await this.provider.generate({
                 prompt: request.prompt,
                 ...request.options,
             });
-            if (!result || !result.text) {
+            if (!result || !result.content) {
                 throw new Error("Invalid AI response");
             }
             // Send complete response
@@ -150,7 +150,7 @@ export class WebSocketChatHandler extends SSEChatHandler {
                 connectionId,
                 timestamp: Date.now(),
                 data: {
-                    text: result.text,
+                    text: result.content,
                     isStreamingComplete: true,
                     channelId,
                 },

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

@@ -0,0 +1,423 @@
+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 { StreamOptions, StreamResult } from "../types/stream-types.js";
+/**
+ * Abstract base class for all AI providers
+ * Tools are integrated as first-class citizens - always available by default
+ */
+export declare abstract class BaseProvider implements AIProvider {
+    protected readonly modelName: string;
+    protected readonly providerName: AIProviderName;
+    protected readonly defaultTimeout: number;
+    protected readonly directTools: {
+        getCurrentTime: Tool<import("zod").ZodObject<{
+            timezone: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strip", import("zod").ZodTypeAny, {
+            timezone?: string | undefined;
+        }, {
+            timezone?: string | undefined;
+        }>, {
+            success: boolean;
+            time: string;
+            timezone: string;
+            iso: string;
+            timestamp?: undefined;
+            error?: undefined;
+        } | {
+            success: boolean;
+            time: string;
+            iso: string;
+            timestamp: number;
+            timezone?: undefined;
+            error?: undefined;
+        } | {
+            success: boolean;
+            error: string;
+            time?: undefined;
+            timezone?: undefined;
+            iso?: undefined;
+            timestamp?: undefined;
+        }> & {
+            execute: (args: {
+                timezone?: string | undefined;
+            }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
+                success: boolean;
+                time: string;
+                timezone: string;
+                iso: string;
+                timestamp?: undefined;
+                error?: undefined;
+            } | {
+                success: boolean;
+                time: string;
+                iso: string;
+                timestamp: number;
+                timezone?: undefined;
+                error?: undefined;
+            } | {
+                success: boolean;
+                error: string;
+                time?: undefined;
+                timezone?: undefined;
+                iso?: undefined;
+                timestamp?: undefined;
+            }>;
+        };
+        readFile: Tool<import("zod").ZodObject<{
+            path: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            path: string;
+        }, {
+            path: string;
+        }>, {
+            success: boolean;
+            error: string;
+            content?: undefined;
+            size?: undefined;
+            path?: undefined;
+            lastModified?: undefined;
+        } | {
+            success: boolean;
+            content: string;
+            size: number;
+            path: string;
+            lastModified: string;
+            error?: undefined;
+        } | {
+            success: boolean;
+            error: string;
+            path: string;
+            content?: undefined;
+            size?: undefined;
+            lastModified?: undefined;
+        }> & {
+            execute: (args: {
+                path: string;
+            }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
+                success: boolean;
+                error: string;
+                content?: undefined;
+                size?: undefined;
+                path?: undefined;
+                lastModified?: undefined;
+            } | {
+                success: boolean;
+                content: string;
+                size: number;
+                path: string;
+                lastModified: string;
+                error?: undefined;
+            } | {
+                success: boolean;
+                error: string;
+                path: string;
+                content?: undefined;
+                size?: undefined;
+                lastModified?: undefined;
+            }>;
+        };
+        listDirectory: Tool<import("zod").ZodObject<{
+            path: import("zod").ZodString;
+            includeHidden: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+        }, "strip", import("zod").ZodTypeAny, {
+            path: string;
+            includeHidden: boolean;
+        }, {
+            path: string;
+            includeHidden?: boolean | undefined;
+        }>, {
+            success: boolean;
+            path: string;
+            items: {
+                name: string;
+                type: string;
+                size: number | undefined;
+                lastModified: string;
+            }[];
+            count: number;
+            error?: undefined;
+        } | {
+            success: boolean;
+            error: string;
+            path: string;
+            items?: undefined;
+            count?: undefined;
+        }> & {
+            execute: (args: {
+                path: string;
+                includeHidden: boolean;
+            }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
+                success: boolean;
+                path: string;
+                items: {
+                    name: string;
+                    type: string;
+                    size: number | undefined;
+                    lastModified: string;
+                }[];
+                count: number;
+                error?: undefined;
+            } | {
+                success: boolean;
+                error: string;
+                path: string;
+                items?: undefined;
+                count?: undefined;
+            }>;
+        };
+        calculateMath: Tool<import("zod").ZodObject<{
+            expression: import("zod").ZodString;
+            precision: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+        }, "strip", import("zod").ZodTypeAny, {
+            expression: string;
+            precision: number;
+        }, {
+            expression: string;
+            precision?: number | undefined;
+        }>, {
+            success: boolean;
+            error: string;
+            expression?: undefined;
+            result?: undefined;
+            type?: undefined;
+        } | {
+            success: boolean;
+            expression: string;
+            result: any;
+            type: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+            error?: undefined;
+        } | {
+            success: boolean;
+            error: string;
+            expression: string;
+            result?: undefined;
+            type?: undefined;
+        }> & {
+            execute: (args: {
+                expression: string;
+                precision: number;
+            }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
+                success: boolean;
+                error: string;
+                expression?: undefined;
+                result?: undefined;
+                type?: undefined;
+            } | {
+                success: boolean;
+                expression: string;
+                result: any;
+                type: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+                error?: undefined;
+            } | {
+                success: boolean;
+                error: string;
+                expression: string;
+                result?: undefined;
+                type?: undefined;
+            }>;
+        };
+        writeFile: Tool<import("zod").ZodObject<{
+            path: import("zod").ZodString;
+            content: import("zod").ZodString;
+            mode: import("zod").ZodDefault<import("zod").ZodEnum<["create", "overwrite", "append"]>>;
+        }, "strip", import("zod").ZodTypeAny, {
+            path: string;
+            content: string;
+            mode: "create" | "overwrite" | "append";
+        }, {
+            path: string;
+            content: string;
+            mode?: "create" | "overwrite" | "append" | undefined;
+        }>, {
+            success: boolean;
+            error: string;
+            path?: undefined;
+            mode?: undefined;
+            size?: undefined;
+            written?: undefined;
+        } | {
+            success: boolean;
+            path: string;
+            mode: "create" | "overwrite" | "append";
+            size: number;
+            written: number;
+            error?: undefined;
+        } | {
+            success: boolean;
+            error: string;
+            path: string;
+            mode?: undefined;
+            size?: undefined;
+            written?: undefined;
+        }> & {
+            execute: (args: {
+                path: string;
+                content: string;
+                mode: "create" | "overwrite" | "append";
+            }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
+                success: boolean;
+                error: string;
+                path?: undefined;
+                mode?: undefined;
+                size?: undefined;
+                written?: undefined;
+            } | {
+                success: boolean;
+                path: string;
+                mode: "create" | "overwrite" | "append";
+                size: number;
+                written: number;
+                error?: undefined;
+            } | {
+                success: boolean;
+                error: string;
+                path: string;
+                mode?: undefined;
+                size?: undefined;
+                written?: undefined;
+            }>;
+        };
+        searchFiles: Tool<import("zod").ZodObject<{
+            directory: import("zod").ZodString;
+            pattern: import("zod").ZodString;
+            recursive: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+        }, "strip", import("zod").ZodTypeAny, {
+            directory: string;
+            pattern: string;
+            recursive: boolean;
+        }, {
+            directory: string;
+            pattern: string;
+            recursive?: boolean | undefined;
+        }>, {
+            success: boolean;
+            error: string;
+            directory?: undefined;
+            pattern?: undefined;
+            matches?: undefined;
+            count?: undefined;
+        } | {
+            success: boolean;
+            directory: string;
+            pattern: string;
+            matches: {
+                name: string;
+                path: string;
+                size: number;
+                lastModified: string;
+            }[];
+            count: number;
+            error?: undefined;
+        } | {
+            success: boolean;
+            error: string;
+            directory: string;
+            pattern: string;
+            matches?: undefined;
+            count?: undefined;
+        }> & {
+            execute: (args: {
+                directory: string;
+                pattern: string;
+                recursive: boolean;
+            }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
+                success: boolean;
+                error: string;
+                directory?: undefined;
+                pattern?: undefined;
+                matches?: undefined;
+                count?: undefined;
+            } | {
+                success: boolean;
+                directory: string;
+                pattern: string;
+                matches: {
+                    name: string;
+                    path: string;
+                    size: number;
+                    lastModified: string;
+                }[];
+                count: number;
+                error?: undefined;
+            } | {
+                success: boolean;
+                error: string;
+                directory: string;
+                pattern: string;
+                matches?: undefined;
+                count?: undefined;
+            }>;
+        };
+    };
+    protected mcpTools?: Record<string, Tool>;
+    protected sessionId?: string;
+    protected userId?: string;
+    protected sdk?: any;
+    constructor(modelName?: string, providerName?: AIProviderName, sdk?: any);
+    /**
+     * Check if this provider supports tool/function calling
+     * Override in subclasses to disable tools for specific providers or models
+     * @returns true by default, providers can override to return false
+     */
+    supportsTools(): boolean;
+    /**
+     * Primary streaming method - implements AIProvider interface
+     * When tools are involved, falls back to generate() with synthetic streaming
+     */
+    stream(optionsOrPrompt: StreamOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
+    /**
+     * Text generation method - implements AIProvider interface
+     * Tools are always available unless explicitly disabled
+     */
+    generate(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<EnhancedGenerateResult | null>;
+    /**
+     * Alias for generate method - implements AIProvider interface
+     */
+    gen(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<EnhancedGenerateResult | null>;
+    /**
+     * Provider-specific streaming implementation (only used when tools are disabled)
+     */
+    protected abstract executeStream(options: StreamOptions, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
+    /**
+     * Get the provider name
+     */
+    protected abstract getProviderName(): AIProviderName;
+    /**
+     * Get the default model for this provider
+     */
+    protected abstract getDefaultModel(): string;
+    /**
+     * REQUIRED: Every provider MUST implement this method
+     * Returns the Vercel AI SDK model instance for this provider
+     */
+    protected abstract getAISDKModel(): any | Promise<any>;
+    /**
+     * Get all available tools - direct tools are ALWAYS available
+     * MCP tools are added when available (without blocking)
+     */
+    protected getAllTools(): Promise<Record<string, Tool>>;
+    /**
+     * Set session context for MCP tools
+     */
+    setSessionContext(sessionId?: string, userId?: string): void;
+    /**
+     * Provider-specific error handling
+     */
+    protected abstract handleProviderError(error: any): 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 validateOptions(options: TextGenerationOptions): void;
+    protected getProviderInfo(): {
+        provider: string;
+        model: string;
+    };
+    /**
+     * Get timeout value in milliseconds
+     */
+    getTimeout(options: TextGenerationOptions | StreamOptions): number;
+}