@juspay/neurolink 1.6.0 → 1.9.0

package/dist/lib/mcp/servers/utilities/utility-server.js

@@ -0,0 +1,326 @@
+/**
+ * NeuroLink Utility Server
+ * Provides general utility tools following Lighthouse patterns
+ */
+import { z } from "zod";
+import { createMCPServer } from "../../factory.js";
+import { logger } from "../../../utils/logger.js";
+/**
+ * Utility Server - General utility tools
+ */
+export const utilityServer = createMCPServer({
+    id: "neurolink-utility",
+    title: "NeuroLink Utility Server",
+    description: "Provides general utility tools for common operations",
+    category: "integrations",
+    version: "1.0.0",
+});
+/**
+ * Get Current Time Input Schema
+ */
+const GetCurrentTimeSchema = z.object({
+    format: z
+        .enum(["ISO", "UTC", "local"])
+        .default("local")
+        .optional()
+        .describe("Output format. If 'local', uses the specified timezone."),
+    timezone: z
+        .string()
+        .default("Asia/Kolkata")
+        .optional()
+        .describe("Timezone for 'local' format (e.g., Asia/Kolkata, UTC)."),
+});
+/**
+ * Register Get Current Time Tool
+ */
+utilityServer.registerTool({
+    name: "get-current-time",
+    description: "Get the current time in the specified timezone. Defaults to Indian Standard Time (IST/Asia/Kolkata).",
+    category: "time",
+    inputSchema: GetCurrentTimeSchema,
+    isImplemented: true,
+    execute: async (params, context) => {
+        const startTime = Date.now();
+        try {
+            const validatedInput = GetCurrentTimeSchema.parse(params);
+            const { format, timezone } = validatedInput;
+            logger.debug(`[Utility] Getting current time with format: ${format}, timezone: ${timezone}`);
+            const now = new Date();
+            const resultData = {
+                isoTime: now.toISOString(),
+                utcTime: now.toUTCString(),
+                timestamp: now.getTime(),
+                requestedFormat: format,
+                requestedTimezone: timezone,
+            };
+            let effectiveTimezone = timezone;
+            if (format === "local") {
+                try {
+                    resultData.localTime = now.toLocaleString("en-US", {
+                        timeZone: timezone,
+                    });
+                    resultData.actualTimezone = timezone;
+                }
+                catch (tzError) {
+                    const fallbackTimezone = "Asia/Kolkata";
+                    logger.warn(`[Utility] Invalid timezone '${timezone}', falling back to ${fallbackTimezone}`);
+                    resultData.localTime = now.toLocaleString("en-US", {
+                        timeZone: fallbackTimezone,
+                    });
+                    resultData.actualTimezone = fallbackTimezone;
+                    resultData.timezoneError = `Invalid timezone: ${timezone}. Fell back to ${fallbackTimezone}.`;
+                    effectiveTimezone = fallbackTimezone;
+                }
+            }
+            // Add human-readable display string
+            const displayDateString = now.toLocaleString("en-US", {
+                timeZone: effectiveTimezone,
+            });
+            resultData.displayString = `The current time is ${displayDateString} in ${effectiveTimezone}`;
+            const executionTime = Date.now() - startTime;
+            logger.debug(`[Utility] Time retrieved successfully in ${executionTime}ms`);
+            return {
+                success: true,
+                data: resultData,
+                usage: {
+                    executionTime,
+                },
+                metadata: {
+                    toolName: "get-current-time",
+                    serverId: "neurolink-utility",
+                    sessionId: context.sessionId,
+                    timestamp: Date.now(),
+                    executionTime,
+                },
+            };
+        }
+        catch (error) {
+            const executionTime = Date.now() - startTime;
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error(`[Utility] Get current time failed: ${errorMessage}`);
+            return {
+                success: false,
+                error: errorMessage,
+                metadata: {
+                    toolName: "get-current-time",
+                    serverId: "neurolink-utility",
+                    sessionId: context.sessionId,
+                    timestamp: Date.now(),
+                    executionTime,
+                },
+            };
+        }
+    },
+});
+/**
+ * Calculate Date Difference Schema
+ */
+const CalculateDateDifferenceSchema = z.object({
+    date1: z.string().describe("First date in ISO format or parseable string"),
+    date2: z.string().describe("Second date in ISO format or parseable string"),
+    unit: z
+        .enum(["seconds", "minutes", "hours", "days", "weeks", "months", "years"])
+        .default("days")
+        .optional()
+        .describe("Unit for the difference calculation"),
+});
+/**
+ * Register Calculate Date Difference Tool
+ */
+utilityServer.registerTool({
+    name: "calculate-date-difference",
+    description: "Calculate the difference between two dates in various units",
+    category: "time",
+    inputSchema: CalculateDateDifferenceSchema,
+    isImplemented: true,
+    execute: async (params, context) => {
+        const startTime = Date.now();
+        try {
+            const validatedInput = CalculateDateDifferenceSchema.parse(params);
+            const { date1, date2, unit } = validatedInput;
+            logger.debug(`[Utility] Calculating date difference between ${date1} and ${date2} in ${unit}`);
+            const d1 = new Date(date1);
+            const d2 = new Date(date2);
+            if (isNaN(d1.getTime())) {
+                throw new Error(`Invalid date format for date1: ${date1}`);
+            }
+            if (isNaN(d2.getTime())) {
+                throw new Error(`Invalid date format for date2: ${date2}`);
+            }
+            const diffMs = Math.abs(d2.getTime() - d1.getTime());
+            let difference;
+            switch (unit) {
+                case "seconds":
+                    difference = diffMs / 1000;
+                    break;
+                case "minutes":
+                    difference = diffMs / (1000 * 60);
+                    break;
+                case "hours":
+                    difference = diffMs / (1000 * 60 * 60);
+                    break;
+                case "days":
+                    difference = diffMs / (1000 * 60 * 60 * 24);
+                    break;
+                case "weeks":
+                    difference = diffMs / (1000 * 60 * 60 * 24 * 7);
+                    break;
+                case "months":
+                    difference = diffMs / (1000 * 60 * 60 * 24 * 30.44); // Average month
+                    break;
+                case "years":
+                    difference = diffMs / (1000 * 60 * 60 * 24 * 365.25); // Account for leap years
+                    break;
+                default:
+                    difference = diffMs / (1000 * 60 * 60 * 24); // Default to days
+            }
+            const resultData = {
+                date1: d1.toISOString(),
+                date2: d2.toISOString(),
+                difference: Math.round(difference * 100) / 100, // Round to 2 decimal places
+                unit,
+                milliseconds: diffMs,
+                displayString: `The difference between ${d1.toLocaleDateString()} and ${d2.toLocaleDateString()} is ${Math.round(difference * 100) / 100} ${unit}`,
+            };
+            const executionTime = Date.now() - startTime;
+            logger.debug(`[Utility] Date difference calculated successfully in ${executionTime}ms`);
+            return {
+                success: true,
+                data: resultData,
+                usage: {
+                    executionTime,
+                },
+                metadata: {
+                    toolName: "calculate-date-difference",
+                    serverId: "neurolink-utility",
+                    sessionId: context.sessionId,
+                    timestamp: Date.now(),
+                    executionTime,
+                },
+            };
+        }
+        catch (error) {
+            const executionTime = Date.now() - startTime;
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error(`[Utility] Calculate date difference failed: ${errorMessage}`);
+            return {
+                success: false,
+                error: errorMessage,
+                metadata: {
+                    toolName: "calculate-date-difference",
+                    serverId: "neurolink-utility",
+                    sessionId: context.sessionId,
+                    timestamp: Date.now(),
+                    executionTime,
+                },
+            };
+        }
+    },
+});
+/**
+ * Format Number Schema
+ */
+const FormatNumberSchema = z.object({
+    number: z.number().describe("Number to format"),
+    style: z
+        .enum(["decimal", "currency", "percent"])
+        .default("decimal")
+        .optional()
+        .describe("Formatting style"),
+    currency: z
+        .string()
+        .default("USD")
+        .optional()
+        .describe("Currency code when style is 'currency'"),
+    locale: z
+        .string()
+        .default("en-US")
+        .optional()
+        .describe("Locale for formatting"),
+    minimumFractionDigits: z
+        .number()
+        .min(0)
+        .max(20)
+        .optional()
+        .describe("Minimum number of decimal places"),
+    maximumFractionDigits: z
+        .number()
+        .min(0)
+        .max(20)
+        .optional()
+        .describe("Maximum number of decimal places"),
+});
+/**
+ * Register Format Number Tool
+ */
+utilityServer.registerTool({
+    name: "format-number",
+    description: "Format numbers in various styles (decimal, currency, percent, scientific)",
+    category: "formatting",
+    inputSchema: FormatNumberSchema,
+    isImplemented: true,
+    execute: async (params, context) => {
+        const startTime = Date.now();
+        try {
+            const validatedInput = FormatNumberSchema.parse(params);
+            const { number, style, currency, locale, minimumFractionDigits, maximumFractionDigits, } = validatedInput;
+            logger.debug(`[Utility] Formatting number ${number} with style: ${style}, locale: ${locale}`);
+            const options = {
+                style,
+            };
+            if (style === "currency") {
+                options.currency = currency;
+            }
+            if (minimumFractionDigits !== undefined) {
+                options.minimumFractionDigits = minimumFractionDigits;
+            }
+            if (maximumFractionDigits !== undefined) {
+                options.maximumFractionDigits = maximumFractionDigits;
+            }
+            const formatter = new Intl.NumberFormat(locale, options);
+            const formatted = formatter.format(number);
+            const resultData = {
+                original: number,
+                formatted,
+                style,
+                locale,
+                currency: style === "currency" ? currency : undefined,
+                displayString: `${number} formatted as ${formatted}`,
+            };
+            const executionTime = Date.now() - startTime;
+            logger.debug(`[Utility] Number formatted successfully in ${executionTime}ms`);
+            return {
+                success: true,
+                data: resultData,
+                usage: {
+                    executionTime,
+                },
+                metadata: {
+                    toolName: "format-number",
+                    serverId: "neurolink-utility",
+                    sessionId: context.sessionId,
+                    timestamp: Date.now(),
+                    executionTime,
+                },
+            };
+        }
+        catch (error) {
+            const executionTime = Date.now() - startTime;
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error(`[Utility] Format number failed: ${errorMessage}`);
+            return {
+                success: false,
+                error: errorMessage,
+                metadata: {
+                    toolName: "format-number",
+                    serverId: "neurolink-utility",
+                    sessionId: context.sessionId,
+                    timestamp: Date.now(),
+                    executionTime,
+                },
+            };
+        }
+    },
+});
+// Log successful server creation
+logger.debug("[Utility] NeuroLink Utility Server v1.0.0 created with 3 tools:", Object.keys(utilityServer.tools));

package/dist/lib/mcp/tool-integration.d.ts

@@ -0,0 +1,67 @@
+/**
+ * MCP Tool Integration Layer
+ * Connects MCP tools to NeuroLink AI providers following Lighthouse patterns
+ */
+import type { NeuroLinkExecutionContext, ToolResult } from "./factory.js";
+/**
+ * Tool Integration System
+ * Provides natural language tool discovery and execution
+ */
+export declare class MCPToolIntegration {
+    private registry;
+    private context;
+    constructor(context?: Partial<NeuroLinkExecutionContext>);
+    /**
+     * Initialize tools from all active servers
+     */
+    private initializeTools;
+    /**
+     * Get all available tools
+     */
+    getAvailableTools(): {
+        name: string;
+        qualifiedName: string;
+        description: string;
+        server: string;
+        serverTitle: string;
+        category?: string;
+        serverCategory?: string;
+        permissions?: string[];
+        isImplemented?: boolean;
+    }[];
+    /**
+     * Find tools that match a query
+     */
+    findTools(query: string): Array<{
+        name: string;
+        description: string;
+        serverId: string;
+        relevance: number;
+    }>;
+    /**
+     * Execute a tool by name
+     */
+    executeTool(toolName: string, params: any, serverId?: string): Promise<ToolResult>;
+    /**
+     * Enhance AI prompt with tool context
+     */
+    createToolAwarePrompt(userPrompt: string): string;
+    /**
+     * Analyze AI response for tool usage requests
+     */
+    analyzeForToolUsage(aiResponse: string): Array<{
+        toolName: string;
+        params: any;
+        confidence: number;
+    }>;
+    /**
+     * Update context for tool execution
+     */
+    updateContext(updates: Partial<NeuroLinkExecutionContext>): void;
+}
+export declare function getToolIntegration(context?: Partial<NeuroLinkExecutionContext>): MCPToolIntegration;
+/**
+ * Initialize MCP tools for a session
+ * Following Lighthouse's initialization pattern
+ */
+export declare function initializeMCPTools(sessionId: string, context?: Partial<NeuroLinkExecutionContext>): Promise<MCPToolIntegration>;

package/dist/lib/mcp/tool-integration.js

@@ -0,0 +1,179 @@
+/**
+ * MCP Tool Integration Layer
+ * Connects MCP tools to NeuroLink AI providers following Lighthouse patterns
+ */
+import { mcpConfig } from "./config.js";
+import { logger } from "../utils/logger.js";
+import { MCPToolRegistry } from "./registry.js";
+/**
+ * Tool Integration System
+ * Provides natural language tool discovery and execution
+ */
+export class MCPToolIntegration {
+    registry;
+    context;
+    constructor(context) {
+        this.registry = new MCPToolRegistry();
+        this.context = {
+            sessionId: context?.sessionId || `session-${Date.now()}`,
+            userId: context?.userId,
+            aiProvider: context?.aiProvider,
+            ...context,
+        };
+        // Initialize with all active servers
+        this.initializeTools();
+    }
+    /**
+     * Initialize tools from all active servers
+     */
+    async initializeTools() {
+        const servers = await mcpConfig.getServers();
+        for (const server of servers) {
+            await this.registry.registerServer(server);
+        }
+        logger.debug("[Tool Integration] Initialized with servers:", {
+            serverCount: servers.length,
+            toolCount: this.registry.listTools().length,
+        });
+    }
+    /**
+     * Get all available tools
+     */
+    getAvailableTools() {
+        return this.registry.listTools();
+    }
+    /**
+     * Find tools that match a query
+     */
+    findTools(query) {
+        const allTools = this.registry.listTools();
+        const queryLower = query.toLowerCase();
+        const results = [];
+        for (const toolInfo of allTools) {
+            let relevance = 0;
+            // Check tool name
+            if (toolInfo.name.toLowerCase().includes(queryLower)) {
+                relevance += 10;
+            }
+            // Check tool description
+            if (toolInfo.description.toLowerCase().includes(queryLower)) {
+                relevance += 5;
+            }
+            // Check category if present
+            if (toolInfo.category?.toLowerCase().includes(queryLower)) {
+                relevance += 3;
+            }
+            if (relevance > 0) {
+                results.push({
+                    name: toolInfo.name,
+                    description: toolInfo.description,
+                    serverId: toolInfo.server,
+                    relevance,
+                });
+            }
+        }
+        // Sort by relevance
+        return results.sort((a, b) => b.relevance - a.relevance);
+    }
+    /**
+     * Execute a tool by name
+     */
+    async executeTool(toolName, params, serverId) {
+        try {
+            // If serverId is provided, use qualified name
+            const qualifiedName = serverId ? `${serverId}.${toolName}` : toolName;
+            const result = await this.registry.executeTool(qualifiedName, params, this.context, {
+                validateInput: true,
+                validatePermissions: true,
+                trackMetrics: true,
+            });
+            return result;
+        }
+        catch (error) {
+            logger.error("[Tool Integration] Tool execution failed:", error);
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+                metadata: {
+                    toolName,
+                    serverId,
+                    timestamp: Date.now(),
+                },
+            };
+        }
+    }
+    /**
+     * Enhance AI prompt with tool context
+     */
+    createToolAwarePrompt(userPrompt) {
+        const tools = this.getAvailableTools();
+        const toolDescriptions = tools
+            .map((t) => `- ${t.name}: ${t.description}`)
+            .join("\n");
+        return `${userPrompt}
+
+Available tools:
+${toolDescriptions}
+
+You can use these tools to provide more accurate and real-time information.`;
+    }
+    /**
+     * Analyze AI response for tool usage requests
+     */
+    analyzeForToolUsage(aiResponse) {
+        const toolRequests = [];
+        // Simple pattern matching for tool requests
+        // This can be enhanced with more sophisticated NLP
+        const toolPattern = /<tool[^>]*>([^<]+)<\/tool>/g;
+        let match;
+        while ((match = toolPattern.exec(aiResponse)) !== null) {
+            try {
+                const toolData = JSON.parse(match[1]);
+                toolRequests.push({
+                    toolName: toolData.name,
+                    params: toolData.params || {},
+                    confidence: 1.0,
+                });
+            }
+            catch (error) {
+                logger.warn("[Tool Integration] Failed to parse tool request:", match[1]);
+            }
+        }
+        return toolRequests;
+    }
+    /**
+     * Update context for tool execution
+     */
+    updateContext(updates) {
+        this.context = {
+            ...this.context,
+            ...updates,
+        };
+    }
+}
+/**
+ * Create a global tool integration instance
+ * This can be initialized once and reused
+ */
+let globalToolIntegration = null;
+export function getToolIntegration(context) {
+    if (!globalToolIntegration) {
+        globalToolIntegration = new MCPToolIntegration(context);
+    }
+    else if (context) {
+        globalToolIntegration.updateContext(context);
+    }
+    return globalToolIntegration;
+}
+/**
+ * Initialize MCP tools for a session
+ * Following Lighthouse's initialization pattern
+ */
+export async function initializeMCPTools(sessionId, context) {
+    const integration = getToolIntegration({
+        sessionId,
+        ...context,
+    });
+    logger.debug("[Tool Integration] MCP tools initialized for session:", sessionId);
+    return integration;
+}