@juspay/neurolink 11.13.0 → 11.13.2

package/dist/lib/mcp/servers/utilities/utilityServer.js

@@ -1,327 +0,0 @@
-/**
- * NeuroLink Utility Server
- * Provides general utility tools following standard 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 {
-                    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));
-//# sourceMappingURL=utilityServer.js.map

package/dist/lib/mcp/toolAnnotations.d.ts

@@ -1,57 +0,0 @@
-/**
- * MCP Tool Annotations System
- *
- * Enhanced tool annotations for MCP tools providing hints to AI models
- * about tool behavior, safety, and execution characteristics.
- *
- * Implements MCP 2024-11-05 specification tool annotations including:
- * - readOnlyHint: Tool only reads data
- * - destructiveHint: Tool performs destructive operations
- * - idempotentHint: Tool can be safely retried
- * - requiresConfirmation: Tool needs user confirmation
- *
- * @module mcp/toolAnnotations
- * @since 8.39.0
- */
-import type { MCPServerTool, MCPToolAnnotations } from "../types/index.js";
-/**
- * Infer annotations from tool definition
- * Uses heuristics based on tool description and name
- */
-export declare function inferAnnotations(tool: Pick<MCPServerTool, "name" | "description">): MCPToolAnnotations;
-/**
- * Merge multiple annotation objects with precedence
- * Later annotations override earlier ones
- */
-export declare function mergeAnnotations(...annotationSets: (MCPToolAnnotations | undefined)[]): MCPToolAnnotations;
-/**
- * Validate tool annotations
- * Returns list of validation errors (empty if valid)
- */
-export declare function validateAnnotations(annotations: MCPToolAnnotations): string[];
-/**
- * Create a tool with default annotations inferred
- */
-export declare function createAnnotatedTool(tool: Omit<MCPServerTool, "annotations"> & {
-    annotations?: MCPToolAnnotations;
-}): MCPServerTool;
-/**
- * Check if a tool requires confirmation based on annotations
- */
-export declare function requiresConfirmation(tool: MCPServerTool): boolean;
-/**
- * Check if a tool is safe for automatic retry
- */
-export declare function isSafeToRetry(tool: MCPServerTool): boolean;
-/**
- * Get tool safety level based on annotations
- */
-export declare function getToolSafetyLevel(tool: MCPServerTool): "safe" | "moderate" | "dangerous";
-/**
- * Filter tools by annotation predicates
- */
-export declare function filterToolsByAnnotations(tools: MCPServerTool[], predicate: (annotations: MCPToolAnnotations) => boolean): MCPServerTool[];
-/**
- * Get human-readable summary of tool annotations
- */
-export declare function getAnnotationSummary(annotations: MCPToolAnnotations): string;

package/dist/lib/mcp/toolAnnotations.js

@@ -1,240 +0,0 @@
-/**
- * MCP Tool Annotations System
- *
- * Enhanced tool annotations for MCP tools providing hints to AI models
- * about tool behavior, safety, and execution characteristics.
- *
- * Implements MCP 2024-11-05 specification tool annotations including:
- * - readOnlyHint: Tool only reads data
- * - destructiveHint: Tool performs destructive operations
- * - idempotentHint: Tool can be safely retried
- * - requiresConfirmation: Tool needs user confirmation
- *
- * @module mcp/toolAnnotations
- * @since 8.39.0
- */
-/**
- * Infer annotations from tool definition
- * Uses heuristics based on tool description and name
- */
-export function inferAnnotations(tool) {
-    const name = tool.name;
-    const description = tool.description.toLowerCase();
-    const annotations = {};
-    // Helper: match keyword with word boundaries to avoid false positives
-    // (e.g., "get" should not match "forget", "together", "target")
-    // Also handles underscore/hyphen/camelCase-separated names (e.g., "delete_record", "readFile")
-    const matchesKeyword = (text, keyword) => {
-        // Standard word boundary match (works for space-separated text like descriptions)
-        if (new RegExp(`\\b${keyword}\\b`, "i").test(text)) {
-            return true;
-        }
-        // Also check underscore/hyphen/camelCase segments (common in tool names)
-        const normalized = text
-            .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
-            .toLowerCase();
-        return normalized
-            .split(/[_-]/)
-            .some((segment) => segment === keyword.toLowerCase());
-    };
-    // Infer read-only from description keywords
-    const readOnlyKeywords = [
-        "get",
-        "list",
-        "read",
-        "fetch",
-        "query",
-        "search",
-        "find",
-        "show",
-        "display",
-        "view",
-        "retrieve",
-        "check",
-        "inspect",
-        "look",
-    ];
-    if (readOnlyKeywords.some((keyword) => matchesKeyword(description, keyword) || matchesKeyword(name, keyword))) {
-        annotations.readOnlyHint = true;
-    }
-    // Infer destructive from description keywords
-    const destructiveKeywords = [
-        "delete",
-        "remove",
-        "drop",
-        "destroy",
-        "clear",
-        "purge",
-        "erase",
-        "wipe",
-        "truncate",
-        "reset",
-    ];
-    if (destructiveKeywords.some((keyword) => matchesKeyword(description, keyword) || matchesKeyword(name, keyword))) {
-        annotations.destructiveHint = true;
-        annotations.requiresConfirmation = true;
-    }
-    // Infer idempotent from description keywords
-    const idempotentKeywords = ["set", "update", "put", "upsert", "replace"];
-    if (idempotentKeywords.some((keyword) => matchesKeyword(description, keyword) || matchesKeyword(name, keyword)) &&
-        !annotations.destructiveHint) {
-        annotations.idempotentHint = true;
-    }
-    // Infer complexity from description length and keywords
-    const complexKeywords = [
-        "complex",
-        "analyze",
-        "process",
-        "generate",
-        "transform",
-        "compute",
-        "calculate",
-    ];
-    if (complexKeywords.some((keyword) => matchesKeyword(description, keyword) || matchesKeyword(name, keyword))) {
-        annotations.complexity = "complex";
-    }
-    else if (description.length > 100) {
-        annotations.complexity = "medium";
-    }
-    else {
-        annotations.complexity = "simple";
-    }
-    return annotations;
-}
-/**
- * Merge multiple annotation objects with precedence
- * Later annotations override earlier ones
- */
-export function mergeAnnotations(...annotationSets) {
-    const result = {};
-    for (const annotations of annotationSets) {
-        if (annotations) {
-            const existingTags = result.tags ? [...result.tags] : [];
-            Object.assign(result, annotations);
-            // Special handling for arrays (merge instead of replace)
-            if (existingTags.length > 0 || annotations.tags) {
-                const newTags = annotations.tags ?? [];
-                result.tags = [...new Set([...existingTags, ...newTags])];
-            }
-        }
-    }
-    return result;
-}
-/**
- * Validate tool annotations
- * Returns list of validation errors (empty if valid)
- */
-export function validateAnnotations(annotations) {
-    const errors = [];
-    // Check for conflicting annotations
-    if (annotations.readOnlyHint && annotations.destructiveHint) {
-        errors.push("Tool cannot be both readOnly and destructive - these are conflicting hints");
-    }
-    // Validate rate limit hint
-    if (annotations.rateLimitHint !== undefined &&
-        (annotations.rateLimitHint < 0 ||
-            !Number.isFinite(annotations.rateLimitHint))) {
-        errors.push("rateLimitHint must be a non-negative number");
-    }
-    // Validate estimated duration
-    if (annotations.estimatedDuration !== undefined &&
-        (annotations.estimatedDuration < 0 ||
-            !Number.isFinite(annotations.estimatedDuration))) {
-        errors.push("estimatedDuration must be a non-negative number");
-    }
-    // Validate cost hint
-    if (annotations.costHint !== undefined &&
-        (annotations.costHint < 0 || !Number.isFinite(annotations.costHint))) {
-        errors.push("costHint must be a non-negative number");
-    }
-    // Validate tags are strings
-    if (annotations.tags) {
-        for (const tag of annotations.tags) {
-            if (typeof tag !== "string" || tag.length === 0) {
-                errors.push("All tags must be non-empty strings");
-                break;
-            }
-        }
-    }
-    return errors;
-}
-/**
- * Create a tool with default annotations inferred
- */
-export function createAnnotatedTool(tool) {
-    const inferredAnnotations = inferAnnotations(tool);
-    const mergedAnnotations = mergeAnnotations(inferredAnnotations, tool.annotations);
-    return {
-        ...tool,
-        annotations: mergedAnnotations,
-    };
-}
-/**
- * Check if a tool requires confirmation based on annotations
- */
-export function requiresConfirmation(tool) {
-    return !!(tool.annotations?.requiresConfirmation || tool.annotations?.destructiveHint);
-}
-/**
- * Check if a tool is safe for automatic retry
- */
-export function isSafeToRetry(tool) {
-    return !!(tool.annotations?.idempotentHint || tool.annotations?.readOnlyHint);
-}
-/**
- * Get tool safety level based on annotations
- */
-export function getToolSafetyLevel(tool) {
-    if (tool.annotations?.destructiveHint) {
-        return "dangerous";
-    }
-    if (tool.annotations?.readOnlyHint) {
-        return "safe";
-    }
-    if (tool.annotations?.idempotentHint) {
-        return "moderate";
-    }
-    // Default to moderate for unknown tools
-    return "moderate";
-}
-/**
- * Filter tools by annotation predicates
- */
-export function filterToolsByAnnotations(tools, predicate) {
-    return tools.filter((tool) => {
-        const annotations = tool.annotations ?? {};
-        return predicate(annotations);
-    });
-}
-/**
- * Get human-readable summary of tool annotations
- */
-export function getAnnotationSummary(annotations) {
-    const parts = [];
-    if (annotations.title) {
-        parts.push(annotations.title);
-    }
-    if (annotations.readOnlyHint) {
-        parts.push("read-only");
-    }
-    if (annotations.destructiveHint) {
-        parts.push("DESTRUCTIVE");
-    }
-    if (annotations.idempotentHint) {
-        parts.push("idempotent");
-    }
-    if (annotations.requiresConfirmation) {
-        parts.push("requires confirmation");
-    }
-    if (annotations.complexity) {
-        parts.push(`${annotations.complexity} complexity`);
-    }
-    if (annotations.estimatedDuration !== undefined) {
-        parts.push(`~${annotations.estimatedDuration}ms`);
-    }
-    if (annotations.tags?.length) {
-        parts.push(`tags: ${annotations.tags.join(", ")}`);
-    }
-    return parts.length > 0 ? `[${parts.join(" | ")}]` : "[no annotations]";
-}
-//# sourceMappingURL=toolAnnotations.js.map