@juspay/neurolink 9.27.0 → 9.28.1

package/dist/mcp/toolAnnotations.js

@@ -0,0 +1,239 @@
+/**
+ * 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]";
+}

package/dist/mcp/toolConverter.d.ts

@@ -0,0 +1,178 @@
+/**
+ * Tool Converter Utilities
+ *
+ * Converts between NeuroLink tool format and MCP tool format.
+ * Enables seamless interoperability between NeuroLink's internal
+ * tool representation and the MCP protocol specification.
+ *
+ * @module mcp/toolConverter
+ * @since 8.39.0
+ */
+import type { JsonObject, JsonValue } from "../types/common.js";
+import type { NeuroLinkExecutionContext, ToolResult } from "../types/mcpTypes.js";
+import type { MCPServerTool, MCPToolAnnotations } from "./toolAnnotations.js";
+/**
+ * NeuroLink internal tool format
+ */
+export type NeuroLinkTool = {
+    /**
+     * Tool name
+     */
+    name: string;
+    /**
+     * Tool description
+     */
+    description: string;
+    /**
+     * Input parameters schema
+     */
+    parameters?: JsonObject;
+    /**
+     * Tool execution function
+     */
+    execute: (params: unknown, context?: NeuroLinkExecutionContext) => Promise<ToolResult | unknown>;
+    /**
+     * Category for organization
+     */
+    category?: string;
+    /**
+     * Tags for filtering
+     */
+    tags?: string[];
+    /**
+     * Whether the tool is async
+     */
+    isAsync?: boolean;
+    /**
+     * Custom metadata
+     */
+    metadata?: Record<string, JsonValue>;
+};
+/**
+ * MCP protocol tool format (from @modelcontextprotocol/sdk)
+ */
+export type MCPProtocolTool = {
+    /**
+     * Tool name
+     */
+    name: string;
+    /**
+     * Tool description
+     */
+    description?: string;
+    /**
+     * JSON Schema for input
+     */
+    inputSchema: {
+        type: "object";
+        properties?: Record<string, JsonObject>;
+        required?: string[];
+    };
+    /**
+     * Optional annotations (MCP 2024-11-05+)
+     */
+    annotations?: {
+        title?: string;
+        readOnlyHint?: boolean;
+        destructiveHint?: boolean;
+        idempotentHint?: boolean;
+        openWorldHint?: boolean;
+    };
+};
+/**
+ * Tool converter options
+ */
+export type ToolConverterOptions = {
+    /**
+     * Automatically infer annotations from tool definition
+     */
+    inferAnnotations?: boolean;
+    /**
+     * Default annotations to apply
+     */
+    defaultAnnotations?: MCPToolAnnotations;
+    /**
+     * Whether to preserve original metadata
+     */
+    preserveMetadata?: boolean;
+    /**
+     * Namespace prefix for tool names
+     */
+    namespacePrefix?: string;
+};
+/**
+ * Convert NeuroLink tool to MCP server tool format
+ */
+export declare function neuroLinkToolToMCP(tool: NeuroLinkTool, options?: ToolConverterOptions): MCPServerTool;
+/**
+ * Convert MCP server tool to NeuroLink tool format
+ */
+export declare function mcpToolToNeuroLink(tool: MCPServerTool, options?: {
+    removeNamespacePrefix?: string;
+}): NeuroLinkTool;
+/**
+ * Convert MCP protocol tool to MCPServerTool
+ * (For tools received from external MCP servers)
+ */
+export declare function mcpProtocolToolToServerTool(protocolTool: MCPProtocolTool, executor: (params: unknown, context?: NeuroLinkExecutionContext) => Promise<ToolResult | unknown>, options?: ToolConverterOptions): MCPServerTool;
+/**
+ * Convert MCPServerTool to MCP protocol tool format
+ * (For exposing tools to external MCP clients)
+ */
+export declare function serverToolToMCPProtocol(tool: MCPServerTool): MCPProtocolTool;
+/**
+ * Batch convert NeuroLink tools to MCP format
+ */
+export declare function batchConvertToMCP(tools: NeuroLinkTool[], options?: ToolConverterOptions): MCPServerTool[];
+/**
+ * Batch convert MCP tools to NeuroLink format
+ */
+export declare function batchConvertToNeuroLink(tools: MCPServerTool[], options?: {
+    removeNamespacePrefix?: string;
+}): NeuroLinkTool[];
+/**
+ * Create a tool from a function with automatic schema inference
+ */
+export declare function createToolFromFunction<TParams extends Record<string, unknown>>(name: string, description: string, fn: (params: TParams, context?: NeuroLinkExecutionContext) => Promise<unknown>, options?: {
+    parameters?: JsonObject;
+    annotations?: MCPToolAnnotations;
+    metadata?: Record<string, unknown>;
+}): MCPServerTool;
+/**
+ * Validate tool name according to MCP specification
+ */
+export declare function validateToolName(name: string): {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Sanitize tool name for MCP compatibility
+ */
+export declare function sanitizeToolName(name: string): string;
+/**
+ * Tool compatibility matrix
+ */
+export declare const TOOL_COMPATIBILITY: {
+    /**
+     * Features supported by MCP 2024-11-05 specification
+     */
+    readonly MCP_2024_11_05: {
+        readonly annotations: true;
+        readonly inputSchema: true;
+        readonly outputSchema: false;
+        readonly streamingResults: false;
+        readonly batchExecution: false;
+    };
+    /**
+     * Features supported by NeuroLink
+     */
+    readonly NEUROLINK: {
+        readonly annotations: true;
+        readonly inputSchema: true;
+        readonly outputSchema: true;
+        readonly streamingResults: true;
+        readonly batchExecution: true;
+        readonly categories: true;
+        readonly tags: true;
+    };
+};

package/dist/mcp/toolConverter.js

@@ -0,0 +1,258 @@
+/**
+ * Tool Converter Utilities
+ *
+ * Converts between NeuroLink tool format and MCP tool format.
+ * Enables seamless interoperability between NeuroLink's internal
+ * tool representation and the MCP protocol specification.
+ *
+ * @module mcp/toolConverter
+ * @since 8.39.0
+ */
+import { inferAnnotations } from "./toolAnnotations.js";
+import { withTimeout } from "../utils/async/withTimeout.js";
+/**
+ * Convert NeuroLink tool to MCP server tool format
+ */
+export function neuroLinkToolToMCP(tool, options = {}) {
+    const { inferAnnotations: shouldInfer = true, defaultAnnotations = {}, preserveMetadata = true, namespacePrefix, } = options;
+    // Apply namespace prefix if provided
+    const toolName = namespacePrefix
+        ? `${namespacePrefix}_${tool.name}`
+        : tool.name;
+    // Infer annotations from tool definition
+    const inferredAnnotations = shouldInfer
+        ? inferAnnotations({ name: tool.name, description: tool.description })
+        : {};
+    // Build annotations
+    const annotations = {
+        ...defaultAnnotations,
+        ...inferredAnnotations,
+    };
+    // Add tags if present
+    if (tool.tags?.length) {
+        annotations.tags = [
+            ...new Set([...(annotations.tags ?? []), ...tool.tags]),
+        ];
+    }
+    // Build input schema
+    const inputSchema = tool.parameters ?? {
+        type: "object",
+        properties: {},
+    };
+    // Build metadata
+    const metadata = preserveMetadata
+        ? { ...tool.metadata }
+        : {};
+    if (tool.category) {
+        metadata.category = tool.category;
+    }
+    if (tool.isAsync !== undefined) {
+        metadata.isAsync = tool.isAsync;
+    }
+    return {
+        name: toolName,
+        description: tool.description,
+        inputSchema,
+        annotations,
+        execute: tool.execute,
+        metadata,
+    };
+}
+/**
+ * Convert MCP server tool to NeuroLink tool format
+ */
+export function mcpToolToNeuroLink(tool, options = {}) {
+    const { removeNamespacePrefix } = options;
+    // Remove namespace prefix if provided
+    let toolName = tool.name;
+    if (removeNamespacePrefix &&
+        tool.name.startsWith(`${removeNamespacePrefix}_`)) {
+        toolName = tool.name.slice(removeNamespacePrefix.length + 1);
+    }
+    return {
+        name: toolName,
+        description: tool.description,
+        parameters: tool.inputSchema,
+        execute: tool.execute,
+        category: tool.metadata?.category,
+        tags: tool.annotations?.tags,
+        metadata: tool.metadata,
+    };
+}
+/**
+ * Convert MCP protocol tool to MCPServerTool
+ * (For tools received from external MCP servers)
+ */
+export function mcpProtocolToolToServerTool(protocolTool, executor, options = {}) {
+    const { inferAnnotations: shouldInfer = true, defaultAnnotations = {} } = options;
+    // Convert protocol annotations to our format
+    const protocolAnnotations = protocolTool.annotations ?? {};
+    // Infer additional annotations
+    const inferredAnnotations = shouldInfer
+        ? inferAnnotations({
+            name: protocolTool.name,
+            description: protocolTool.description ?? "",
+        })
+        : {};
+    // Merge annotations with precedence: protocol > inferred > defaults
+    const annotations = {
+        ...defaultAnnotations,
+        ...inferredAnnotations,
+        title: protocolAnnotations.title ??
+            inferredAnnotations.title ??
+            defaultAnnotations.title,
+        readOnlyHint: protocolAnnotations.readOnlyHint ??
+            inferredAnnotations.readOnlyHint ??
+            defaultAnnotations.readOnlyHint,
+        destructiveHint: protocolAnnotations.destructiveHint ??
+            inferredAnnotations.destructiveHint ??
+            defaultAnnotations.destructiveHint,
+        idempotentHint: protocolAnnotations.idempotentHint ??
+            inferredAnnotations.idempotentHint ??
+            defaultAnnotations.idempotentHint,
+        openWorldHint: protocolAnnotations.openWorldHint ??
+            inferredAnnotations.openWorldHint ??
+            defaultAnnotations.openWorldHint,
+    };
+    return {
+        name: protocolTool.name,
+        description: protocolTool.description ?? "No description provided",
+        inputSchema: protocolTool.inputSchema,
+        annotations,
+        execute: executor,
+    };
+}
+/**
+ * Convert MCPServerTool to MCP protocol tool format
+ * (For exposing tools to external MCP clients)
+ */
+export function serverToolToMCPProtocol(tool) {
+    // Build protocol annotations
+    const annotations = {};
+    if (tool.annotations?.title) {
+        annotations.title = tool.annotations.title;
+    }
+    if (tool.annotations?.readOnlyHint !== undefined) {
+        annotations.readOnlyHint = tool.annotations.readOnlyHint;
+    }
+    if (tool.annotations?.destructiveHint !== undefined) {
+        annotations.destructiveHint = tool.annotations.destructiveHint;
+    }
+    if (tool.annotations?.idempotentHint !== undefined) {
+        annotations.idempotentHint = tool.annotations.idempotentHint;
+    }
+    if (tool.annotations?.openWorldHint !== undefined) {
+        annotations.openWorldHint = tool.annotations.openWorldHint;
+    }
+    // Build input schema
+    const inputSchema = tool.inputSchema ?? {
+        type: "object",
+        properties: {},
+    };
+    return {
+        name: tool.name,
+        description: tool.description,
+        inputSchema: {
+            type: "object",
+            properties: (inputSchema.properties ?? {}),
+            required: ("required" in inputSchema
+                ? inputSchema.required
+                : undefined),
+        },
+        annotations: Object.keys(annotations).length > 0 ? annotations : undefined,
+    };
+}
+/**
+ * Batch convert NeuroLink tools to MCP format
+ */
+export function batchConvertToMCP(tools, options = {}) {
+    return tools.map((tool) => neuroLinkToolToMCP(tool, options));
+}
+/**
+ * Batch convert MCP tools to NeuroLink format
+ */
+export function batchConvertToNeuroLink(tools, options = {}) {
+    return tools.map((tool) => mcpToolToNeuroLink(tool, options));
+}
+/**
+ * Create a tool from a function with automatic schema inference
+ */
+export function createToolFromFunction(name, description, fn, options) {
+    const inferredAnnotations = inferAnnotations({ name, description });
+    return {
+        name,
+        description,
+        inputSchema: options?.parameters ?? { type: "object", properties: {} },
+        annotations: {
+            ...inferredAnnotations,
+            ...options?.annotations,
+        },
+        execute: async (params, context) => {
+            const toolTimeoutMs = 30_000;
+            const result = await withTimeout(fn(params, context), toolTimeoutMs, `Tool '${name}' execution timed out after ${toolTimeoutMs}ms`);
+            return result;
+        },
+        metadata: options?.metadata,
+    };
+}
+/**
+ * Validate tool name according to MCP specification
+ */
+export function validateToolName(name) {
+    const errors = [];
+    if (!name || typeof name !== "string") {
+        errors.push("Tool name is required and must be a string");
+    }
+    else {
+        if (name.length > 64) {
+            errors.push("Tool name must be 64 characters or less");
+        }
+        if (!/^[a-zA-Z_][a-zA-Z0-9_-]*$/.test(name)) {
+            errors.push("Tool name must start with a letter or underscore and contain only alphanumeric characters, underscores, and hyphens");
+        }
+    }
+    return { valid: errors.length === 0, errors };
+}
+/**
+ * Sanitize tool name for MCP compatibility
+ */
+export function sanitizeToolName(name) {
+    // Replace invalid characters with underscores
+    let sanitized = name.replace(/[^a-zA-Z0-9_-]/g, "_");
+    // Ensure starts with letter or underscore
+    if (!/^[a-zA-Z_]/.test(sanitized)) {
+        sanitized = `_${sanitized}`;
+    }
+    // Truncate to 64 characters
+    if (sanitized.length > 64) {
+        sanitized = sanitized.slice(0, 64);
+    }
+    return sanitized;
+}
+/**
+ * Tool compatibility matrix
+ */
+export const TOOL_COMPATIBILITY = {
+    /**
+     * Features supported by MCP 2024-11-05 specification
+     */
+    MCP_2024_11_05: {
+        annotations: true,
+        inputSchema: true,
+        outputSchema: false,
+        streamingResults: false,
+        batchExecution: false,
+    },
+    /**
+     * Features supported by NeuroLink
+     */
+    NEUROLINK: {
+        annotations: true,
+        inputSchema: true,
+        outputSchema: true,
+        streamingResults: true,
+        batchExecution: true,
+        categories: true,
+        tags: true,
+    },
+};