@juspay/neurolink 9.32.0 → 9.32.1

package/dist/client/server/routes/healthRoutes.js

@@ -1,187 +0,0 @@
-/**
- * Health Routes
- * Endpoints for health checks and system status
- */
-/**
- * Create health check routes
- */
-export function createHealthRoutes(basePath = "/api") {
-    return {
-        prefix: `${basePath}/health`,
-        routes: [
-            {
-                method: "GET",
-                path: `${basePath}/health`,
-                handler: async () => {
-                    return {
-                        status: "ok",
-                        timestamp: new Date().toISOString(),
-                        uptime: process.uptime() * 1000,
-                        version: process.env.npm_package_version || "unknown",
-                    };
-                },
-                description: "Basic health check",
-                tags: ["health"],
-            },
-            {
-                method: "GET",
-                path: `${basePath}/health/live`,
-                handler: async () => {
-                    // Liveness probe - just checks if the server is running
-                    return {
-                        status: "alive",
-                        timestamp: new Date().toISOString(),
-                    };
-                },
-                description: "Kubernetes liveness probe",
-                tags: ["health"],
-            },
-            {
-                method: "GET",
-                path: `${basePath}/health/ready`,
-                handler: async (ctx) => {
-                    // Readiness probe - checks if all dependencies are ready
-                    const tools = await ctx.toolRegistry.listTools();
-                    const hasTools = tools.length > 0;
-                    const hasExternalManager = !!ctx.externalServerManager;
-                    // Check external servers if available
-                    let externalServersReady = true;
-                    if (ctx.externalServerManager) {
-                        const statuses = ctx.externalServerManager.getServerStatuses();
-                        for (const status of statuses) {
-                            if (status.status !== "connected") {
-                                externalServersReady = false;
-                                break;
-                            }
-                        }
-                    }
-                    const isReady = hasTools || !hasExternalManager || externalServersReady;
-                    return {
-                        ready: isReady,
-                        timestamp: new Date().toISOString(),
-                        services: {
-                            neurolink: true,
-                            tools: hasTools,
-                            externalServers: externalServersReady,
-                        },
-                    };
-                },
-                description: "Kubernetes readiness probe",
-                tags: ["health"],
-            },
-            {
-                method: "GET",
-                path: `${basePath}/health/startup`,
-                handler: async (ctx) => {
-                    // Startup probe - checks if the application has started successfully
-                    const tools = await ctx.toolRegistry.listTools();
-                    return {
-                        started: true,
-                        timestamp: new Date().toISOString(),
-                        services: {
-                            neurolink: true,
-                            toolsLoaded: tools.length,
-                            externalServerManager: !!ctx.externalServerManager,
-                        },
-                    };
-                },
-                description: "Kubernetes startup probe",
-                tags: ["health"],
-            },
-            {
-                method: "GET",
-                path: `${basePath}/health/detailed`,
-                handler: async (ctx) => {
-                    const tools = await ctx.toolRegistry.listTools();
-                    // Group tools by source
-                    const toolsBySource = {};
-                    for (const tool of tools) {
-                        const source = typeof tool.source === "string"
-                            ? tool.source
-                            : tool.serverId || "built-in";
-                        toolsBySource[source] = (toolsBySource[source] || 0) + 1;
-                    }
-                    // Get external server statuses
-                    const externalServers = [];
-                    if (ctx.externalServerManager) {
-                        const statuses = ctx.externalServerManager.getServerStatuses();
-                        for (const status of statuses) {
-                            externalServers.push({
-                                name: status.serverId,
-                                status: status.status,
-                                toolCount: status.toolCount,
-                            });
-                        }
-                    }
-                    // Memory status
-                    const memory = ctx.neurolink.conversationMemory;
-                    const memoryStatus = {
-                        available: !!memory,
-                        type: memory?.constructor.name || "none",
-                    };
-                    // Build the base health response
-                    const healthResponse = {
-                        status: "ok",
-                        timestamp: new Date().toISOString(),
-                        uptime: process.uptime() * 1000,
-                        version: process.env.npm_package_version || "unknown",
-                        node: {
-                            version: process.version,
-                            platform: process.platform,
-                            arch: process.arch,
-                        },
-                        memory: {
-                            ...memoryStatus,
-                            process: {
-                                heapUsed: Math.round(process.memoryUsage().heapUsed / 1024 / 1024),
-                                heapTotal: Math.round(process.memoryUsage().heapTotal / 1024 / 1024),
-                                rss: Math.round(process.memoryUsage().rss / 1024 / 1024),
-                                external: Math.round(process.memoryUsage().external / 1024 / 1024),
-                            },
-                        },
-                        tools: {
-                            total: tools.length,
-                            bySource: toolsBySource,
-                        },
-                        externalServers: {
-                            count: externalServers.length,
-                            servers: externalServers,
-                        },
-                    };
-                    // Add proxy account pool status when proxy mode is active
-                    if (ctx.metadata?.accountPool) {
-                        const pool = ctx.metadata.accountPool;
-                        const allAccounts = pool.getAllAccounts();
-                        const statusCounts = {};
-                        for (const a of allAccounts) {
-                            statusCounts[a.status] = (statusCounts[a.status] || 0) + 1;
-                        }
-                        healthResponse.proxy = {
-                            totalAccounts: allAccounts.length,
-                            statusDistribution: statusCounts,
-                            healthyCount: pool.getHealthyCount(),
-                            strategy: pool.getStrategy(),
-                        };
-                    }
-                    return healthResponse;
-                },
-                description: "Detailed health information",
-                tags: ["health"],
-            },
-            {
-                method: "GET",
-                path: `${basePath}/version`,
-                handler: async () => {
-                    return {
-                        name: "@juspay/neurolink",
-                        version: process.env.npm_package_version || "unknown",
-                        node: process.version,
-                        timestamp: new Date().toISOString(),
-                    };
-                },
-                description: "Get version information",
-                tags: ["health", "version"],
-            },
-        ],
-    };
-}

package/dist/client/server/routes/index.js

@@ -1,57 +0,0 @@
-/**
- * Route Builders
- * Pre-built route definitions for common NeuroLink endpoints
- */
-import { createAgentRoutes } from "./agentRoutes.js";
-import { createClaudeProxyRoutes } from "./claudeProxyRoutes.js";
-// ClaudeProxyDeps removed
-import { createHealthRoutes } from "./healthRoutes.js";
-import { createMCPRoutes } from "./mcpRoutes.js";
-import { createMemoryRoutes } from "./memoryRoutes.js";
-import { createOpenApiRoutes } from "./openApiRoutes.js";
-import { createToolRoutes } from "./toolRoutes.js";
-// Re-export route builders from individual files
-export { createAgentRoutes } from "./agentRoutes.js";
-export { createClaudeProxyRoutes } from "./claudeProxyRoutes.js";
-// ClaudeProxyDeps removed
-export { createHealthRoutes } from "./healthRoutes.js";
-export { createMCPRoutes } from "./mcpRoutes.js";
-export { createMemoryRoutes } from "./memoryRoutes.js";
-export { createOpenApiRoutes } from "./openApiRoutes.js";
-export { createToolRoutes } from "./toolRoutes.js";
-/**
- * Create all standard routes
- * Convenience method that combines all route groups
- */
-export function createAllRoutes(basePath = "/api", options) {
-    const routes = [
-        createAgentRoutes(basePath),
-        createToolRoutes(basePath),
-        createMCPRoutes(basePath),
-        createMemoryRoutes(basePath),
-        createHealthRoutes(basePath),
-    ];
-    // Conditionally add OpenAPI/Swagger routes
-    if (options?.enableSwagger) {
-        routes.push(createOpenApiRoutes(basePath, options.getRoutes));
-    }
-    // Conditionally add Claude-compatible proxy routes
-    if (options?.claudeProxy) {
-        routes.push(createClaudeProxyRoutes(undefined, basePath));
-    }
-    return routes;
-}
-/**
- * Register all routes with a server adapter
- */
-export function registerAllRoutes(adapter, basePath = "/api", options) {
-    // If adapter has listRoutes and getRoutes not provided, use adapter's listRoutes
-    const routeOptions = {
-        ...options,
-        getRoutes: options?.getRoutes ?? adapter.listRoutes?.bind(adapter),
-    };
-    const routeGroups = createAllRoutes(basePath, routeOptions);
-    for (const group of routeGroups) {
-        adapter.registerRouteGroup(group);
-    }
-}

package/dist/client/server/routes/mcpRoutes.js

@@ -1,342 +0,0 @@
-/**
- * MCP Routes
- * Endpoints for MCP server management
- */
-import { z } from "zod";
-import { createErrorResponse, ServerNameParamSchema, ToolArgumentsSchema, validateParams, validateRequest, } from "../utils/validation.js";
-/**
- * MCP tool execution params schema
- */
-const MCPToolExecuteParamsSchema = z.object({
-    name: z.string().min(1, "Server name is required"),
-    toolName: z.string().min(1, "Tool name is required"),
-});
-/**
- * Handler: List all MCP servers
- */
-async function handleListServers(ctx) {
-    const manager = ctx.externalServerManager;
-    if (!manager) {
-        return {
-            servers: [],
-            total: 0,
-            message: "External server manager not available",
-            metadata: {
-                timestamp: new Date().toISOString(),
-                requestId: ctx.requestId,
-            },
-        };
-    }
-    const serverInfos = manager.listServers();
-    const statuses = manager.getServerStatuses();
-    // Create a map of statuses by serverId for quick lookup
-    const statusMap = new Map(statuses.map((s) => [s.serverId, s]));
-    const servers = serverInfos.map((info) => {
-        const status = statusMap.get(info.name);
-        return {
-            serverId: info.name,
-            name: info.name,
-            status: status?.status || "disconnected",
-            toolCount: status?.toolCount || 0,
-            lastHealthCheck: status?.checkedAt?.toISOString(),
-            error: status?.issues?.[0],
-        };
-    });
-    return {
-        servers,
-        total: servers.length,
-        metadata: {
-            timestamp: new Date().toISOString(),
-            requestId: ctx.requestId,
-        },
-    };
-}
-/**
- * Handler: Get MCP server status
- */
-async function handleGetServer(ctx) {
-    // Validate params
-    const paramValidation = validateParams(ServerNameParamSchema, ctx.params, ctx.requestId);
-    if (!paramValidation.success) {
-        return paramValidation.error;
-    }
-    const { name } = paramValidation.data;
-    const manager = ctx.externalServerManager;
-    if (!manager) {
-        return createErrorResponse("MCP_UNAVAILABLE", "External server manager not available", undefined, ctx.requestId);
-    }
-    const serverInfos = manager.listServers();
-    const serverInfo = serverInfos.find((s) => s.name === name);
-    if (!serverInfo) {
-        return createErrorResponse("SERVER_NOT_FOUND", `MCP server '${name}' not found`, undefined, ctx.requestId);
-    }
-    const statuses = manager.getServerStatuses();
-    const status = statuses.find((s) => s.serverId === name);
-    // Get tools for this server
-    const tools = await ctx.toolRegistry.listTools();
-    const serverTools = tools.filter((t) => t.source === name);
-    return {
-        serverId: name,
-        name,
-        status: status?.status || "disconnected",
-        toolCount: status?.toolCount || 0,
-        tools: serverTools.map((t) => ({
-            name: t.name,
-            description: t.description,
-        })),
-        lastHealthCheck: status?.checkedAt?.toISOString(),
-        error: status?.issues?.[0],
-        metadata: {
-            timestamp: new Date().toISOString(),
-            requestId: ctx.requestId,
-        },
-    };
-}
-/**
- * Handler: Reconnect to an MCP server
- */
-async function handleReconnectServer(ctx) {
-    // Validate params
-    const paramValidation = validateParams(ServerNameParamSchema, ctx.params, ctx.requestId);
-    if (!paramValidation.success) {
-        return paramValidation.error;
-    }
-    const { name } = paramValidation.data;
-    const manager = ctx.externalServerManager;
-    if (!manager) {
-        return createErrorResponse("MCP_UNAVAILABLE", "External server manager not available", undefined, ctx.requestId);
-    }
-    try {
-        // To reconnect, we need to get the existing config and re-add
-        const serverInfos = manager.listServers();
-        const serverInfo = serverInfos.find((s) => s.name === name);
-        if (!serverInfo) {
-            return createErrorResponse("SERVER_NOT_FOUND", `Server '${name}' not found`, undefined, ctx.requestId);
-        }
-        // Note: Full reconnect would require storing config
-        // For now, return the current status
-        const statuses = manager.getServerStatuses();
-        const status = statuses.find((s) => s.serverId === name);
-        return {
-            success: true,
-            server: {
-                serverId: name,
-                name,
-                status: status?.status || "disconnected",
-                toolCount: status?.toolCount || 0,
-            },
-            message: "Server status retrieved (full reconnect requires server restart)",
-            metadata: {
-                timestamp: new Date().toISOString(),
-                requestId: ctx.requestId,
-            },
-        };
-    }
-    catch (error) {
-        return createErrorResponse("RECONNECT_FAILED", error instanceof Error ? error.message : String(error), undefined, ctx.requestId);
-    }
-}
-/**
- * Handler: Remove an MCP server
- */
-async function handleRemoveServer(ctx) {
-    // Validate params
-    const paramValidation = validateParams(ServerNameParamSchema, ctx.params, ctx.requestId);
-    if (!paramValidation.success) {
-        return paramValidation.error;
-    }
-    const { name } = paramValidation.data;
-    const manager = ctx.externalServerManager;
-    if (!manager) {
-        return createErrorResponse("MCP_UNAVAILABLE", "External server manager not available", undefined, ctx.requestId);
-    }
-    try {
-        const result = await manager.removeServer(name);
-        if (!result.success) {
-            return createErrorResponse("REMOVE_FAILED", result.error || "Failed to remove server", undefined, ctx.requestId);
-        }
-        return {
-            success: true,
-            message: `Server '${name}' removed`,
-            metadata: {
-                timestamp: new Date().toISOString(),
-                requestId: ctx.requestId,
-            },
-        };
-    }
-    catch (error) {
-        return createErrorResponse("REMOVE_FAILED", error instanceof Error ? error.message : String(error), undefined, ctx.requestId);
-    }
-}
-/**
- * Handler: List tools from a specific MCP server
- */
-async function handleListServerTools(ctx) {
-    // Validate params
-    const paramValidation = validateParams(ServerNameParamSchema, ctx.params, ctx.requestId);
-    if (!paramValidation.success) {
-        return paramValidation.error;
-    }
-    const { name } = paramValidation.data;
-    // Get tools from this specific server
-    const tools = await ctx.toolRegistry.listTools();
-    const serverTools = tools.filter((t) => t.source === name);
-    if (serverTools.length === 0) {
-        // Check if server exists
-        const manager = ctx.externalServerManager;
-        if (manager) {
-            const serverInfos = manager.listServers();
-            const serverInfo = serverInfos.find((s) => s.name === name);
-            if (!serverInfo) {
-                return createErrorResponse("SERVER_NOT_FOUND", `MCP server '${name}' not found`, undefined, ctx.requestId);
-            }
-        }
-    }
-    return {
-        serverId: name,
-        tools: serverTools.map((tool) => ({
-            name: tool.name,
-            description: tool.description,
-            inputSchema: tool.inputSchema,
-        })),
-        total: serverTools.length,
-        metadata: {
-            timestamp: new Date().toISOString(),
-            requestId: ctx.requestId,
-        },
-    };
-}
-/**
- * Handler: Execute a tool from a specific MCP server
- */
-async function handleExecuteTool(ctx) {
-    // Validate params
-    const paramValidation = validateParams(MCPToolExecuteParamsSchema, ctx.params, ctx.requestId);
-    if (!paramValidation.success) {
-        return paramValidation.error;
-    }
-    const { name, toolName } = paramValidation.data;
-    // Validate body (tool arguments)
-    const bodyValidation = validateRequest(ToolArgumentsSchema, ctx.body || {}, ctx.requestId);
-    if (!bodyValidation.success) {
-        return bodyValidation.error;
-    }
-    const args = bodyValidation.data;
-    const startTime = Date.now();
-    try {
-        // Verify tool exists for this server
-        const tools = await ctx.toolRegistry.listTools();
-        const tool = tools.find((t) => t.name === toolName && t.source === name);
-        if (!tool) {
-            return createErrorResponse("TOOL_NOT_FOUND", `Tool '${toolName}' not found on server '${name}'`, undefined, ctx.requestId);
-        }
-        // Execute the tool
-        const result = await ctx.toolRegistry.executeTool(toolName, args);
-        return {
-            success: true,
-            data: result,
-            duration: Date.now() - startTime,
-            metadata: {
-                server: name,
-                toolName,
-                timestamp: new Date().toISOString(),
-                requestId: ctx.requestId,
-            },
-        };
-    }
-    catch (error) {
-        return createErrorResponse("EXECUTION_FAILED", error instanceof Error ? error.message : String(error), { duration: Date.now() - startTime }, ctx.requestId);
-    }
-}
-/**
- * Handler: Health check for all MCP servers
- */
-async function handleMCPHealth(ctx) {
-    const manager = ctx.externalServerManager;
-    if (!manager) {
-        return {
-            healthy: false,
-            message: "External server manager not available",
-            servers: [],
-        };
-    }
-    const statuses = manager.getServerStatuses();
-    const serverStatuses = statuses.map((s) => ({
-        name: s.serverId,
-        healthy: s.isHealthy,
-        error: s.issues?.[0],
-    }));
-    const allHealthy = serverStatuses.every((s) => s.healthy);
-    const someHealthy = serverStatuses.some((s) => s.healthy);
-    return {
-        healthy: serverStatuses.length === 0 || allHealthy,
-        status: serverStatuses.length === 0
-            ? "no_servers"
-            : allHealthy
-                ? "all_healthy"
-                : someHealthy
-                    ? "degraded"
-                    : "unhealthy",
-        servers: serverStatuses,
-        timestamp: new Date().toISOString(),
-    };
-}
-/**
- * Create MCP server management routes
- */
-export function createMCPRoutes(basePath = "/api") {
-    return {
-        prefix: `${basePath}/mcp`,
-        routes: [
-            {
-                method: "GET",
-                path: `${basePath}/mcp/servers`,
-                handler: handleListServers,
-                description: "List all MCP servers",
-                tags: ["mcp"],
-            },
-            {
-                method: "GET",
-                path: `${basePath}/mcp/servers/:name`,
-                handler: handleGetServer,
-                description: "Get MCP server status",
-                tags: ["mcp"],
-            },
-            {
-                method: "POST",
-                path: `${basePath}/mcp/servers/:name/reconnect`,
-                handler: handleReconnectServer,
-                description: "Reconnect to an MCP server",
-                tags: ["mcp"],
-            },
-            {
-                method: "DELETE",
-                path: `${basePath}/mcp/servers/:name`,
-                handler: handleRemoveServer,
-                description: "Remove an MCP server",
-                tags: ["mcp"],
-            },
-            {
-                method: "GET",
-                path: `${basePath}/mcp/servers/:name/tools`,
-                handler: handleListServerTools,
-                description: "List tools from a specific MCP server",
-                tags: ["mcp", "tools"],
-            },
-            {
-                method: "POST",
-                path: `${basePath}/mcp/servers/:name/tools/:toolName/execute`,
-                handler: handleExecuteTool,
-                description: "Execute a tool from a specific MCP server",
-                tags: ["mcp", "tools"],
-            },
-            {
-                method: "GET",
-                path: `${basePath}/mcp/health`,
-                handler: handleMCPHealth,
-                description: "Health check for all MCP servers",
-                tags: ["mcp", "health"],
-            },
-        ],
-    };
-}