@juspay/neurolink 6.1.0 → 6.2.1

package/dist/lib/providers/mcp-provider.d.ts

@@ -1,75 +0,0 @@
-/**
- * NeuroLink MCP-Aware AI Provider
- * Integrates MCP tools with AI providers following Lighthouse's pattern
- */
-import type { AIProvider, TextGenerationOptions } from "../core/types.js";
-import type { Schema } from "ai";
-import type { GenerateResult } from "../types/generate-types.js";
-import type { ZodType, ZodTypeDef } from "zod";
-import type { StreamOptions, StreamResult } from "../types/stream-types.js";
-/**
- * MCP-Aware Provider Configuration
- */
-export interface MCPProviderConfig {
-    baseProvider: AIProvider;
-    providerName?: string;
-    modelName?: string;
-    enableMCP?: boolean;
-    sessionId?: string;
-    userId?: string;
-    organizationId?: string;
-}
-/**
- * MCP-Aware AI Provider
- * Wraps any AI provider with MCP tool capabilities
- */
-export declare class MCPAwareProvider implements AIProvider {
-    private baseProvider;
-    private config;
-    private sessionId;
-    private mcpInitialized;
-    constructor(config: MCPProviderConfig);
-    /**
-     * Initialize MCP tools for this session
-     */
-    private initializeMCP;
-    /**
-     * PRIMARY METHOD: Stream content using AI (recommended for new code)
-     * Future-ready for multi-modal capabilities with current text focus
-     */
-    stream(optionsOrPrompt: StreamOptions | string, analysisSchema?: unknown): Promise<StreamResult>;
-    generate(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<GenerateResult>;
-    /**
-     * Detect if the prompt is requesting tool usage
-     */
-    private detectToolRequest;
-    /**
-     * Get session statistics
-     */
-    getSessionStats(): {
-        sessionId: string;
-        toolCount: number;
-        executionCount: number;
-        isConnected: boolean;
-        uptime: number;
-    } | null;
-    /**
-     * Clean up session
-     */
-    cleanup(): Promise<void>;
-    /**
-     * Alias for generate() - CLI-SDK consistency
-     */
-    /**
-     * Short alias for generate() - CLI-SDK consistency
-     */
-    gen(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<GenerateResult>;
-}
-/**
- * Create an MCP-aware provider
- */
-export declare function createMCPAwareProvider(baseProvider: AIProvider, config?: Partial<MCPProviderConfig>): MCPAwareProvider;
-/**
- * Check if a provider is MCP-aware
- */
-export declare function isMCPAwareProvider(provider: AIProvider): provider is MCPAwareProvider;

package/dist/lib/providers/mcp-provider.js

@@ -1,283 +0,0 @@
-/**
- * NeuroLink MCP-Aware AI Provider
- * Integrates MCP tools with AI providers following Lighthouse's pattern
- */
-import { getMCPManager } from "../mcp/manager.js";
-import { initializeMCPTools } from "../mcp/initialize-tools.js";
-import { logger } from "../utils/logger.js";
-import { v4 as uuidv4 } from "uuid";
-/**
- * MCP-Aware AI Provider
- * Wraps any AI provider with MCP tool capabilities
- */
-export class MCPAwareProvider {
-    baseProvider;
-    config;
-    sessionId;
-    mcpInitialized = false;
-    constructor(config) {
-        this.baseProvider = config.baseProvider;
-        this.config = config;
-        this.sessionId = config.sessionId || uuidv4();
-    }
-    /**
-     * Initialize MCP tools for this session
-     */
-    async initializeMCP() {
-        if (this.mcpInitialized || this.config.enableMCP === false) {
-            return;
-        }
-        try {
-            // Get or create MCP client for this session
-            const mcpClient = getMCPManager(this.sessionId, {
-                userId: this.config.userId || "anonymous",
-                aiProvider: this.config.providerName || "unknown",
-                modelId: this.config.modelName,
-            });
-            // Create execution context
-            const context = {
-                sessionId: this.sessionId,
-                userId: this.config.userId || "anonymous",
-                organizationId: this.config.organizationId || "default",
-                aiProvider: this.config.providerName || "unknown",
-                modelId: this.config.modelName,
-                timestamp: Date.now(),
-                // Required properties
-                secureFS: {
-                    readFile: async () => {
-                        throw new Error("secureFS not configured");
-                    },
-                    writeFile: async () => {
-                        throw new Error("secureFS not configured");
-                    },
-                    readdir: async () => {
-                        throw new Error("secureFS not configured");
-                    },
-                    stat: async () => {
-                        throw new Error("secureFS not configured");
-                    },
-                    mkdir: async () => {
-                        throw new Error("secureFS not configured");
-                    },
-                    exists: async () => false,
-                },
-                path: {
-                    join: (...paths) => {
-                        const pathModule = require("path");
-                        return pathModule.join(...paths);
-                    },
-                    resolve: (...paths) => {
-                        const pathModule = require("path");
-                        return pathModule.resolve(...paths);
-                    },
-                    relative: (from, to) => {
-                        const pathModule = require("path");
-                        return pathModule.relative(from, to);
-                    },
-                    dirname: (pathArg) => {
-                        const pathModule = require("path");
-                        return pathModule.dirname(pathArg);
-                    },
-                    basename: (pathArg, ext) => {
-                        const pathModule = require("path");
-                        return pathModule.basename(pathArg, ext);
-                    },
-                },
-                grantedPermissions: [],
-                log: console.log,
-            };
-            // Initialize all MCP tools
-            initializeMCPTools(this.sessionId, mcpClient, context);
-            this.mcpInitialized = true;
-            const tools = mcpClient.getTools();
-            const toolCount = Object.keys(tools).length;
-            logger.info(`[MCP Provider] Initialized ${toolCount} tools for session ${this.sessionId}`);
-        }
-        catch (error) {
-            logger.error(`[MCP Provider] Failed to initialize MCP for session ${this.sessionId}`, error);
-            // Continue without MCP tools if initialization fails
-        }
-    }
-    /**
-     * PRIMARY METHOD: Stream content using AI (recommended for new code)
-     * Future-ready for multi-modal capabilities with current text focus
-     */
-    async stream(optionsOrPrompt, analysisSchema) {
-        const functionTag = "MCPAwareProvider.stream";
-        const startTime = Date.now();
-        // Parse parameters - support both string and options object
-        const options = typeof optionsOrPrompt === "string"
-            ? { input: { text: optionsOrPrompt } }
-            : optionsOrPrompt;
-        // Validate input
-        if (!options?.input?.text ||
-            typeof options.input.text !== "string" ||
-            options.input.text.trim() === "") {
-            throw new Error("Stream options must include input.text as a non-empty string");
-        }
-        // Use base provider's stream implementation
-        const baseResult = await this.baseProvider.stream(options);
-        if (!baseResult) {
-            throw new Error("No stream response received from provider");
-        }
-        // Return the result with MCP metadata
-        return {
-            ...baseResult,
-            provider: "mcp",
-            model: options.model || "unknown",
-            metadata: {
-                streamId: `mcp-${Date.now()}`,
-                startTime,
-            },
-        };
-    }
-    async generate(optionsOrPrompt, analysisSchema) {
-        // Ensure MCP is initialized
-        await this.initializeMCP();
-        // Parse options
-        const options = typeof optionsOrPrompt === "string"
-            ? { prompt: optionsOrPrompt }
-            : optionsOrPrompt;
-        // Validate prompt is provided
-        if (!options.prompt || options.prompt.trim() === "") {
-            throw new Error("MCP Provider requires a valid prompt. Please provide a non-empty prompt string.");
-        }
-        // Check if prompt requests tool usage
-        const needsTools = this.detectToolRequest(options.prompt);
-        if (needsTools && this.mcpInitialized) {
-            // Get MCP client
-            const mcpClient = getMCPManager(this.sessionId);
-            // Create enhanced prompt with available tools
-            const tools = mcpClient.getTools();
-            const toolList = Object.keys(tools)
-                .map((name) => {
-                const tool = tools[name];
-                return `- ${name}: ${tool.description || "No description"}`;
-            })
-                .join("\n");
-            const enhancedPrompt = `${options.prompt}
-
-Available tools:
-${toolList}
-
-To use a tool, respond with:
-TOOL: <tool_name>
-PARAMS: <json_params>
-
-Otherwise, provide a direct response.`;
-            // Generate response with enhanced prompt
-            const response = await this.baseProvider.generate({
-                ...options,
-                prompt: enhancedPrompt,
-            }, analysisSchema);
-            if (!response) {
-                return {
-                    content: "No response generated",
-                    provider: "mcp",
-                    model: "unknown",
-                };
-            }
-            // Check if response includes tool invocation
-            const toolMatch = response.content.match(/TOOL:\s*(\S+)\s*\nPARAMS:\s*({.*})/s);
-            if (toolMatch) {
-                const toolName = toolMatch[1];
-                const toolParams = JSON.parse(toolMatch[2]);
-                // Execute tool
-                const toolResult = await mcpClient.executeTool(toolName, toolParams);
-                // Generate final response with tool result
-                const finalPrompt = `${options.prompt}
-
-Tool ${toolName} was executed with result:
-${JSON.stringify(toolResult, null, 2)}
-
-Please provide a response based on this information.`;
-                const finalResponse = await this.baseProvider.generate({
-                    ...options,
-                    prompt: finalPrompt,
-                }, analysisSchema);
-                if (!finalResponse) {
-                    return {
-                        content: "Tool execution failed",
-                        provider: "mcp",
-                        model: "unknown",
-                    };
-                }
-                // Return response (tool usage is tracked internally)
-                return finalResponse;
-            }
-            return response;
-        }
-        // Regular generation without tools
-        const result = await this.baseProvider.generate(options);
-        if (!result) {
-            return {
-                content: "Base provider returned no result",
-                provider: "mcp",
-                model: "unknown",
-            };
-        }
-        return result;
-    }
-    /**
-     * Detect if the prompt is requesting tool usage
-     */
-    detectToolRequest(prompt) {
-        const toolKeywords = [
-            "use tool",
-            "call tool",
-            "execute tool",
-            "run tool",
-            "invoke tool",
-            "what tools",
-            "available tools",
-            "list tools",
-        ];
-        const lowerPrompt = prompt.toLowerCase();
-        return toolKeywords.some((keyword) => lowerPrompt.includes(keyword));
-    }
-    /**
-     * Get session statistics
-     */
-    getSessionStats() {
-        if (!this.mcpInitialized) {
-            return null;
-        }
-        const mcpClient = getMCPManager(this.sessionId);
-        return mcpClient.getStats();
-    }
-    /**
-     * Clean up session
-     */
-    async cleanup() {
-        if (this.mcpInitialized) {
-            const { removeMCPManager } = await import("../mcp/manager.js");
-            await removeMCPManager(this.sessionId);
-            this.mcpInitialized = false;
-        }
-    }
-    /**
-     * Alias for generate() - CLI-SDK consistency
-     */
-    /**
-     * Short alias for generate() - CLI-SDK consistency
-     */
-    async gen(optionsOrPrompt, analysisSchema) {
-        return this.generate(optionsOrPrompt, analysisSchema);
-    }
-}
-/**
- * Create an MCP-aware provider
- */
-export function createMCPAwareProvider(baseProvider, config) {
-    return new MCPAwareProvider({
-        baseProvider,
-        enableMCP: true,
-        ...config,
-    });
-}
-/**
- * Check if a provider is MCP-aware
- */
-export function isMCPAwareProvider(provider) {
-    return provider instanceof MCPAwareProvider;
-}

package/dist/lib/providers/timeout-wrapper.d.ts

@@ -1,40 +0,0 @@
-/**
- * Timeout wrapper for AI provider operations
- *
- * Provides a consistent way to add timeout functionality to any async operation.
- */
-/**
- * Wrap an async operation with a timeout
- * @param promise - The promise to wrap
- * @param timeout - Timeout duration (number in ms or string with unit)
- * @param provider - Provider name for error messages
- * @param operation - Operation type (generate or stream)
- * @returns The result of the promise or throws TimeoutError
- */
-export declare function withTimeout<T>(promise: Promise<T>, timeout: number | string | undefined, provider: string, operation: "generate" | "stream"): Promise<T>;
-/**
- * Wrap a streaming async generator with timeout
- * @param generator - The async generator to wrap
- * @param timeout - Timeout duration for the entire stream
- * @param provider - Provider name for error messages
- * @returns Wrapped async generator that respects timeout
- */
-export declare function withStreamingTimeout<T>(generator: AsyncGenerator<T>, timeout: number | string | undefined, provider: string): AsyncGenerator<T>;
-/**
- * Create an abort controller with timeout
- * @param timeout - Timeout duration
- * @param provider - Provider name for error messages
- * @param operation - Operation type
- * @returns AbortController and cleanup function
- */
-export declare function createTimeoutController(timeout: number | string | undefined, provider: string, operation: "generate" | "stream"): {
-    controller: AbortController;
-    cleanup: () => void;
-    timeoutMs: number;
-} | null;
-/**
- * Merge abort signals (for combining user abort with timeout)
- * @param signals - Array of abort signals to merge
- * @returns Combined abort controller
- */
-export declare function mergeAbortSignals(signals: (AbortSignal | undefined)[]): AbortController;

package/dist/lib/providers/timeout-wrapper.js

@@ -1,100 +0,0 @@
-/**
- * Timeout wrapper for AI provider operations
- *
- * Provides a consistent way to add timeout functionality to any async operation.
- */
-import { parseTimeout, TimeoutError, createTimeoutPromise, } from "../utils/timeout.js";
-/**
- * Wrap an async operation with a timeout
- * @param promise - The promise to wrap
- * @param timeout - Timeout duration (number in ms or string with unit)
- * @param provider - Provider name for error messages
- * @param operation - Operation type (generate or stream)
- * @returns The result of the promise or throws TimeoutError
- */
-export async function withTimeout(promise, timeout, provider, operation) {
-    const timeoutPromise = createTimeoutPromise(timeout, provider, operation);
-    if (!timeoutPromise) {
-        // No timeout specified, return original promise
-        return promise;
-    }
-    // Race between the actual operation and timeout
-    return Promise.race([promise, timeoutPromise]);
-}
-/**
- * Wrap a streaming async generator with timeout
- * @param generator - The async generator to wrap
- * @param timeout - Timeout duration for the entire stream
- * @param provider - Provider name for error messages
- * @returns Wrapped async generator that respects timeout
- */
-export async function* withStreamingTimeout(generator, timeout, provider) {
-    const timeoutMs = parseTimeout(timeout);
-    if (!timeoutMs) {
-        // No timeout, pass through original generator
-        yield* generator;
-        return;
-    }
-    const startTime = Date.now();
-    try {
-        for await (const chunk of generator) {
-            // Check if we've exceeded the timeout
-            if (Date.now() - startTime > timeoutMs) {
-                throw new TimeoutError(`${provider} streaming operation timed out after ${timeout}`, timeoutMs, provider, "stream");
-            }
-            yield chunk;
-        }
-    }
-    finally {
-        // Ensure generator is properly closed
-        if (generator.return) {
-            await generator.return(undefined);
-        }
-    }
-}
-/**
- * Create an abort controller with timeout
- * @param timeout - Timeout duration
- * @param provider - Provider name for error messages
- * @param operation - Operation type
- * @returns AbortController and cleanup function
- */
-export function createTimeoutController(timeout, provider, operation) {
-    const timeoutMs = parseTimeout(timeout);
-    if (!timeoutMs) {
-        return null;
-    }
-    const controller = new AbortController();
-    const timer = setTimeout(() => {
-        controller.abort(new TimeoutError(`${provider} ${operation} operation timed out after ${timeout}`, timeoutMs, provider, operation));
-    }, timeoutMs);
-    // Cleanup function to clear the timer
-    const cleanup = () => {
-        clearTimeout(timer);
-    };
-    return { controller, cleanup, timeoutMs };
-}
-/**
- * Merge abort signals (for combining user abort with timeout)
- * @param signals - Array of abort signals to merge
- * @returns Combined abort controller
- */
-export function mergeAbortSignals(signals) {
-    const controller = new AbortController();
-    // Listen to all signals and abort when any fires
-    for (const signal of signals) {
-        if (signal && !signal.aborted) {
-            signal.addEventListener("abort", () => {
-                if (!controller.signal.aborted) {
-                    controller.abort(signal.reason);
-                }
-            });
-        }
-        // If any signal is already aborted, abort immediately
-        if (signal?.aborted) {
-            controller.abort(signal.reason);
-            break;
-        }
-    }
-    return controller;
-}

package/dist/lib/sdk/tool-extension.d.ts

@@ -1,181 +0,0 @@
-/**
- * NeuroLink SDK Tool Extension System
- * Allows developers to register custom tools that integrate with AI providers
- */
-import { z } from "zod";
-import type { Tool } from "ai";
-import { logger } from "../utils/logger.js";
-/**
- * Custom tool interface for SDK users
- */
-export interface CustomTool {
-    /**
-     * Tool description that helps AI understand when to use it
-     */
-    description: string;
-    /**
-     * Parameters schema using Zod or JSON Schema
-     */
-    parameters?: z.ZodSchema | Record<string, unknown>;
-    /**
-     * Tool execution function
-     */
-    execute: (args: unknown, context?: ToolContext) => Promise<unknown> | unknown;
-    /**
-     * Optional metadata
-     */
-    category?: string;
-    version?: string;
-    author?: string;
-    /**
-     * Optional configuration
-     */
-    config?: {
-        timeout?: number;
-        retries?: number;
-        rateLimit?: {
-            requests: number;
-            window: number;
-        };
-    };
-}
-/**
- * Context provided to tools during execution
- */
-export interface ToolContext {
-    /**
-     * Call another tool
-     */
-    callTool: (name: string, args: unknown) => Promise<unknown>;
-    /**
-     * Current session information
-     */
-    session: {
-        id: string;
-        userId?: string;
-        provider?: string;
-        model?: string;
-    };
-    /**
-     * Logger instance
-     */
-    logger: typeof logger;
-}
-/**
- * Tool middleware function
- */
-export type ToolMiddleware = (toolName: string, args: unknown, next: () => Promise<unknown>, context: ToolContext) => Promise<unknown>;
-/**
- * Tool permission configuration
- */
-export interface ToolPermissions {
-    allowlist?: string[];
-    denylist?: string[];
-    requireApproval?: string[];
-    customValidator?: (toolName: string, args: unknown) => boolean | Promise<boolean>;
-}
-/**
- * Converts a custom tool to Vercel AI SDK format
- */
-export declare function convertToAISDKTool(name: string, customTool: CustomTool): Tool;
-/**
- * Tool registry for managing custom tools
- */
-export declare class ToolRegistry {
-    private tools;
-    private middleware;
-    private permissions;
-    private rateLimits;
-    /**
-     * Simple rate limiting check with automatic cleanup
-     */
-    private checkRateLimit;
-    /**
-     * Register a custom tool
-     */
-    register(name: string, tool: CustomTool): void;
-    /**
-     * Register multiple tools at once
-     */
-    registerMany(tools: Record<string, CustomTool>): void;
-    /**
-     * Unregister a tool
-     */
-    unregister(name: string): boolean;
-    /**
-     * Get a tool by name
-     */
-    get(name: string): CustomTool | undefined;
-    /**
-     * Get all registered tools
-     */
-    getAll(): Map<string, CustomTool>;
-    /**
-     * Convert all tools to AI SDK format
-     */
-    toAISDKTools(): Record<string, Tool>;
-    /**
-     * Add middleware
-     */
-    use(middleware: ToolMiddleware): void;
-    /**
-     * Set permissions
-     */
-    setPermissions(permissions: ToolPermissions): void;
-    /**
-     * Check if a tool is allowed
-     */
-    private isToolAllowed;
-    /**
-     * Execute a tool with middleware
-     */
-    execute(name: string, args: unknown, context: ToolContext): Promise<unknown>;
-}
-/**
- * Create a simple tool helper
- */
-export declare function createTool(config: CustomTool): CustomTool;
-/**
- * Create an async tool helper
- */
-export declare function createAsyncTool(config: Omit<CustomTool, "execute"> & {
-    execute: (args: unknown, context?: ToolContext) => Promise<unknown>;
-}): CustomTool;
-/**
- * Create a batch tool that processes multiple items
- */
-export declare function createBatchTool<T, R>(config: Omit<CustomTool, "execute" | "parameters"> & {
-    parameters: z.ZodSchema<{
-        items: T[];
-    }>;
-    processItem: (item: T, context?: ToolContext) => Promise<R> | R;
-    batchSize?: number;
-}): CustomTool;
-/**
- * Tool testing utilities
- */
-export declare const TestUtils: {
-    /**
-     * Create a mock tool context
-     */
-    mockContext(overrides?: Partial<ToolContext>): ToolContext;
-    /**
-     * Test a tool with mock data
-     */
-    testTool(tool: CustomTool, testCases: Array<{
-        input: unknown;
-        expected?: unknown;
-    }>): Promise<({
-        input: unknown;
-        output: unknown;
-        success: boolean;
-        matches: boolean | undefined;
-        error?: undefined;
-    } | {
-        input: unknown;
-        error: string;
-        success: boolean;
-        output?: undefined;
-        matches?: undefined;
-    })[]>;
-};