easy-mcp-nest 0.2.1 → 0.4.0

package/dist/core/documentation/openapi-generator.service.js

@@ -0,0 +1,116 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenApiGeneratorService = void 0;
+const common_1 = require("@nestjs/common");
+const tool_registry_service_1 = require("../../tooling/tool-registry/tool-registry.service");
+let OpenApiGeneratorService = class OpenApiGeneratorService {
+    toolRegistry;
+    constructor(toolRegistry) {
+        this.toolRegistry = toolRegistry;
+    }
+    generateOpenApiSpec(info) {
+        const tools = this.toolRegistry.getToolSchemasForLLM();
+        const spec = {
+            openapi: "3.0.0",
+            info: {
+                title: info.title,
+                version: info.version,
+                description: "MCP Server API - Auto-generated from tool definitions",
+            },
+            paths: {},
+            components: {
+                schemas: {},
+            },
+        };
+        for (const tool of tools) {
+            const path = `/tools/${encodeURIComponent(tool.function.name)}`;
+            spec.paths[path] = {
+                post: {
+                    summary: tool.function.description,
+                    operationId: tool.function.name,
+                    requestBody: {
+                        required: true,
+                        content: {
+                            "application/json": {
+                                schema: tool.function.parameters,
+                            },
+                        },
+                    },
+                    responses: {
+                        "200": {
+                            description: "Tool execution result",
+                            content: {
+                                "application/json": {
+                                    schema: {
+                                        type: "object",
+                                        properties: {
+                                            content: {
+                                                type: "array",
+                                                items: {
+                                                    type: "object",
+                                                    properties: {
+                                                        type: { type: "string" },
+                                                        text: { type: "string" },
+                                                    },
+                                                },
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                        "400": {
+                            description: "Invalid request",
+                        },
+                        "500": {
+                            description: "Tool execution error",
+                        },
+                    },
+                },
+            };
+        }
+        return spec;
+    }
+    generateMarkdownDocs(info) {
+        const tools = this.toolRegistry.getToolSchemasForLLM();
+        const escapeMarkdown = (text) => {
+            if (!text)
+                return "";
+            return text.replace(/([\\`*_{}[\]()#+-.!])/g, "\\$1");
+        };
+        let markdown = `# ${escapeMarkdown(info.title)} API Documentation\n\n`;
+        markdown += `Version: ${escapeMarkdown(info.version)}\n\n`;
+        markdown += `## Tools\n\n`;
+        for (const tool of tools) {
+            markdown += `### ${escapeMarkdown(tool.function.name)}\n\n`;
+            markdown += `${escapeMarkdown(tool.function.description)}\n\n`;
+            if (tool.function.parameters.properties) {
+                markdown += `#### Parameters\n\n`;
+                for (const [paramName, paramDef] of Object.entries(tool.function.parameters.properties)) {
+                    markdown += `- **${escapeMarkdown(paramName)}** (${escapeMarkdown(String(paramDef.type || "any"))})`;
+                    if (paramDef.description) {
+                        markdown += `: ${escapeMarkdown(paramDef.description)}`;
+                    }
+                    markdown += `\n`;
+                }
+                markdown += `\n`;
+            }
+        }
+        return markdown;
+    }
+};
+exports.OpenApiGeneratorService = OpenApiGeneratorService;
+exports.OpenApiGeneratorService = OpenApiGeneratorService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [tool_registry_service_1.ToolRegistryService])
+], OpenApiGeneratorService);
+//# sourceMappingURL=openapi-generator.service.js.map

package/dist/core/documentation/openapi-generator.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"openapi-generator.service.js","sourceRoot":"","sources":["../../../src/core/documentation/openapi-generator.service.ts"],"names":[],"mappings":"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"}

package/dist/core/errors/error-handler.interface.d.ts

@@ -0,0 +1,11 @@
+import { McpContext } from "../context/mcp-context.interface";
+import { JsonRpcError } from "../../interface/jsonrpc.interface";
+export type ErrorHandler = (error: Error, context: {
+    toolName?: string;
+    requestId?: string | number | null;
+    mcpContext?: McpContext;
+}) => JsonRpcError | Error | null;
+export interface ErrorHandlerConfig {
+    handler?: ErrorHandler;
+    logErrors?: boolean;
+}

package/dist/core/errors/error-handler.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=error-handler.interface.js.map

package/dist/core/errors/error-handler.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-handler.interface.js","sourceRoot":"","sources":["../../../src/core/errors/error-handler.interface.ts"],"names":[],"mappings":""}

package/dist/core/health/health-check.service.d.ts

@@ -0,0 +1,33 @@
+import { ToolRegistryService } from "../../tooling/tool-registry/tool-registry.service";
+import { MetricsService } from "../observability/metrics.service";
+export interface HealthCheckResult {
+    status: "healthy" | "unhealthy" | "degraded";
+    checks: {
+        server: {
+            status: string;
+            uptime: number;
+        };
+        tools: {
+            status: string;
+            count: number;
+        };
+        metrics?: {
+            status: string;
+            activeRequests: number;
+        };
+    };
+    timestamp: string;
+}
+export declare class HealthCheckService {
+    private readonly toolRegistry;
+    private readonly metricsService?;
+    constructor(toolRegistry: ToolRegistryService, metricsService?: MetricsService | undefined);
+    checkHealth(): Promise<HealthCheckResult>;
+    checkReadiness(): Promise<{
+        ready: boolean;
+        reason?: string;
+    }>;
+    checkLiveness(): Promise<{
+        alive: boolean;
+    }>;
+}

package/dist/core/health/health-check.service.js

@@ -0,0 +1,71 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HealthCheckService = void 0;
+const common_1 = require("@nestjs/common");
+const tool_registry_service_1 = require("../../tooling/tool-registry/tool-registry.service");
+const metrics_service_1 = require("../observability/metrics.service");
+let HealthCheckService = class HealthCheckService {
+    toolRegistry;
+    metricsService;
+    constructor(toolRegistry, metricsService) {
+        this.toolRegistry = toolRegistry;
+        this.metricsService = metricsService;
+    }
+    async checkHealth() {
+        const tools = this.toolRegistry.getToolSchemasForLLM();
+        const toolCount = tools.length;
+        const checks = {
+            server: {
+                status: "healthy",
+                uptime: process.uptime(),
+            },
+            tools: {
+                status: toolCount > 0 ? "healthy" : "unhealthy",
+                count: toolCount,
+            },
+        };
+        if (this.metricsService) {
+            const serverMetrics = this.metricsService.getServerMetrics();
+            checks.metrics = {
+                status: serverMetrics.activeRequests < 100 ? "healthy" : "degraded",
+                activeRequests: serverMetrics.activeRequests,
+            };
+        }
+        const allHealthy = Object.values(checks).every((check) => check.status === "healthy" || check.status === "degraded");
+        return {
+            status: allHealthy ? "healthy" : "unhealthy",
+            checks,
+            timestamp: new Date().toISOString(),
+        };
+    }
+    async checkReadiness() {
+        const tools = this.toolRegistry.getToolSchemasForLLM();
+        if (tools.length === 0) {
+            return { ready: false, reason: "No tools registered" };
+        }
+        return { ready: true };
+    }
+    async checkLiveness() {
+        return { alive: true };
+    }
+};
+exports.HealthCheckService = HealthCheckService;
+exports.HealthCheckService = HealthCheckService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(1, (0, common_1.Optional)()),
+    __metadata("design:paramtypes", [tool_registry_service_1.ToolRegistryService,
+        metrics_service_1.MetricsService])
+], HealthCheckService);
+//# sourceMappingURL=health-check.service.js.map

package/dist/core/health/health-check.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"health-check.service.js","sourceRoot":"","sources":["../../../src/core/health/health-check.service.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,2CAA8D;AAC9D,6FAAwF;AACxF,sEAAkE;AAmB3D,IAAM,kBAAkB,GAAxB,MAAM,kBAAkB;IAEV;IACY;IAF/B,YACmB,YAAiC,EACrB,cAA+B;QAD3C,iBAAY,GAAZ,YAAY,CAAqB;QACrB,mBAAc,GAAd,cAAc,CAAiB;IAC3D,CAAC;IAKJ,KAAK,CAAC,WAAW;QACf,MAAM,KAAK,GAAG,IAAI,CAAC,YAAY,CAAC,oBAAoB,EAAE,CAAC;QACvD,MAAM,SAAS,GAAG,KAAK,CAAC,MAAM,CAAC;QAE/B,MAAM,MAAM,GAAgC;YAC1C,MAAM,EAAE;gBACN,MAAM,EAAE,SAAS;gBACjB,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE;aACzB;YACD,KAAK,EAAE;gBACL,MAAM,EAAE,SAAS,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,WAAW;gBAC/C,KAAK,EAAE,SAAS;aACjB;SACF,CAAC;QAEF,IAAI,IAAI,CAAC,cAAc,EAAE,CAAC;YACxB,MAAM,aAAa,GAAG,IAAI,CAAC,cAAc,CAAC,gBAAgB,EAAE,CAAC;YAC7D,MAAM,CAAC,OAAO,GAAG;gBACf,MAAM,EAAE,aAAa,CAAC,cAAc,GAAG,GAAG,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,UAAU;gBACnE,cAAc,EAAE,aAAa,CAAC,cAAc;aAC7C,CAAC;QACJ,CAAC;QAED,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,KAAK,CAC5C,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,MAAM,KAAK,SAAS,IAAI,KAAK,CAAC,MAAM,KAAK,UAAU,CACrE,CAAC;QAEF,OAAO;YACL,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,WAAW;YAC5C,MAAM;YACN,SAAS,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;SACpC,CAAC;IACJ,CAAC;IAKD,KAAK,CAAC,cAAc;QAClB,MAAM,KAAK,GAAG,IAAI,CAAC,YAAY,CAAC,oBAAoB,EAAE,CAAC;QACvD,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACvB,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,qBAAqB,EAAE,CAAC;QACzD,CAAC;QACD,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;IACzB,CAAC;IAKD,KAAK,CAAC,aAAa;QACjB,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;IACzB,CAAC;CACF,CAAA;AA5DY,gDAAkB;6BAAlB,kBAAkB;IAD9B,IAAA,mBAAU,GAAE;IAIR,WAAA,IAAA,iBAAQ,GAAE,CAAA;qCADoB,2CAAmB;QACJ,gCAAc;GAHnD,kBAAkB,CA4D9B"}

package/dist/core/mcp-server/mcp-server.service.d.ts

@@ -6,6 +6,13 @@ import { JsonRpcRequest, JsonRpcResponse } from "../../interface/jsonrpc.interfa
 import { ResourceRegistryService } from "../../resources/resource-registry.service";
 import { PromptRegistryService } from "../../prompts/prompt-registry.service";
 import { ConfigHolderService } from "../../config/config-holder.service";
+import { ContextProviderService } from "../context/context-provider.service";
+import { ProgressNotifierService } from "../progress/progress-notifier.service";
+import { MetricsService } from "../observability/metrics.service";
+import { RateLimiterService } from "../rate-limiting/rate-limiter.service";
+import { RetryService } from "../resilience/retry.service";
+import { CircuitBreakerService } from "../resilience/circuit-breaker.service";
+import { BatchExecutorService } from "../batch/batch-executor.service";
 export declare class McpServerService implements OnModuleInit {
     private readonly toolRegistry;
     private readonly resourceRegistry;
@@ -13,9 +20,16 @@ export declare class McpServerService implements OnModuleInit {
     private readonly interfaceLayer;
     private readonly stdioGatewayService;
     private readonly configHolder;
+    private readonly contextProvider;
+    private readonly progressNotifier?;
+    private readonly metricsService?;
+    private readonly rateLimiter?;
+    private readonly retryService?;
+    private readonly circuitBreaker?;
+    private readonly batchExecutor?;
     private clientIdentifier;
     private readonly cancellationTokens;
-    constructor(toolRegistry: ToolRegistryService, resourceRegistry: ResourceRegistryService, promptRegistry: PromptRegistryService, interfaceLayer: IInterfaceLayer, stdioGatewayService: StdioGatewayService, configHolder: ConfigHolderService);
+    constructor(toolRegistry: ToolRegistryService, resourceRegistry: ResourceRegistryService, promptRegistry: PromptRegistryService, interfaceLayer: IInterfaceLayer, stdioGatewayService: StdioGatewayService, configHolder: ConfigHolderService, contextProvider: ContextProviderService, progressNotifier?: ProgressNotifierService | undefined, metricsService?: MetricsService | undefined, rateLimiter?: RateLimiterService | undefined, retryService?: RetryService | undefined, circuitBreaker?: CircuitBreakerService | undefined, batchExecutor?: BatchExecutorService | undefined);
     private getServerInfo;
     private getActorIdentifier;
     onModuleInit(): void;
@@ -24,6 +38,7 @@ export declare class McpServerService implements OnModuleInit {
     private handleInitialize;
     private handleListTools;
     private handleCallTool;
+    private handleBatchTools;
     private handleCancelRequest;
     private handleListResources;
     private handleReadResource;

package/dist/core/mcp-server/mcp-server.service.js

@@ -29,6 +29,14 @@ const schema_validator_1 = require("../utils/schema-validator");
 const logger_util_1 = require("../utils/logger.util");
 const sanitize_util_1 = require("../utils/sanitize.util");
 const constants_3 = require("../../config/constants");
+const context_provider_service_1 = require("../context/context-provider.service");
+const progress_notifier_service_1 = require("../progress/progress-notifier.service");
+const metrics_service_1 = require("../observability/metrics.service");
+const rate_limiter_service_1 = require("../rate-limiting/rate-limiter.service");
+const retry_service_1 = require("../resilience/retry.service");
+const circuit_breaker_service_1 = require("../resilience/circuit-breaker.service");
+const batch_executor_service_1 = require("../batch/batch-executor.service");
+const common_2 = require("@nestjs/common");
 let McpServerService = class McpServerService {
     toolRegistry;
     resourceRegistry;
@@ -36,15 +44,29 @@ let McpServerService = class McpServerService {
     interfaceLayer;
     stdioGatewayService;
     configHolder;
+    contextProvider;
+    progressNotifier;
+    metricsService;
+    rateLimiter;
+    retryService;
+    circuitBreaker;
+    batchExecutor;
     clientIdentifier = "stdio-client";
     cancellationTokens = new Map();
-    constructor(toolRegistry, resourceRegistry, promptRegistry, interfaceLayer, stdioGatewayService, configHolder) {
+    constructor(toolRegistry, resourceRegistry, promptRegistry, interfaceLayer, stdioGatewayService, configHolder, contextProvider, progressNotifier, metricsService, rateLimiter, retryService, circuitBreaker, batchExecutor) {
         this.toolRegistry = toolRegistry;
         this.resourceRegistry = resourceRegistry;
         this.promptRegistry = promptRegistry;
         this.interfaceLayer = interfaceLayer;
         this.stdioGatewayService = stdioGatewayService;
         this.configHolder = configHolder;
+        this.contextProvider = contextProvider;
+        this.progressNotifier = progressNotifier;
+        this.metricsService = metricsService;
+        this.rateLimiter = rateLimiter;
+        this.retryService = retryService;
+        this.circuitBreaker = circuitBreaker;
+        this.batchExecutor = batchExecutor;
     }
     getServerInfo() {
         const config = this.configHolder.getConfig();
@@ -117,6 +139,10 @@ let McpServerService = class McpServerService {
                 case "tools/call":
                     response = await this.handleCallTool(request);
                     return response;
+                case "tools/batch":
+                    response = await this.handleBatchTools(request);
+                    logger_util_1.logger.audit("McpServerService", "tools/batch", response.error ? "failure" : "success", { method: request.method }, request.id, this.getActorIdentifier(request));
+                    return response;
                 case "resources/list":
                     response = this.handleListResources(request);
                     logger_util_1.logger.audit("McpServerService", "resources/list", response.error ? "failure" : "success", { method: request.method }, request.id, this.getActorIdentifier(request));
@@ -315,8 +341,41 @@ let McpServerService = class McpServerService {
             }
             this.cancellationTokens.set(request.id, cancellationToken);
         }
+        const context = this.contextProvider.extractContext(request);
+        if (this.circuitBreaker?.isOpen(toolName)) {
+            logger_util_1.logger.audit("McpServerService", "tools/call", "failure", {
+                reason: "Circuit breaker open",
+                toolName: (0, sanitize_util_1.sanitizeName)(toolName),
+                method: request.method,
+            }, request.id, actorId);
+            return (0, jsonrpc_interface_1.createJsonRpcError)(request.id, mcp_protocol_interface_1.McpErrorCode.ToolExecutionError, "Service temporarily unavailable");
+        }
+        if (tool.rateLimit && this.rateLimiter) {
+            const rawIdentifier = context?.userId || context?.sessionId || context?.metadata?.ip || "anonymous";
+            const identifier = (0, sanitize_util_1.hashRateLimitIdentifier)(rawIdentifier);
+            const rateLimitResult = this.rateLimiter.checkRateLimit(toolName, identifier, tool.rateLimit);
+            if (!rateLimitResult.allowed) {
+                logger_util_1.logger.audit("McpServerService", "tools/call", "failure", {
+                    reason: "Rate limit exceeded",
+                    toolName: (0, sanitize_util_1.sanitizeName)(toolName),
+                    method: request.method,
+                }, request.id, actorId);
+                return (0, jsonrpc_interface_1.createJsonRpcError)(request.id, jsonrpc_interface_1.JsonRpcErrorCode.InvalidRequest, `Rate limit exceeded. Try again after ${new Date(rateLimitResult.resetTime).toISOString()}`);
+            }
+        }
+        const progressCallback = this.progressNotifier?.createProgressCallback(request.id);
+        const executeTool = async () => {
+            return await this.toolRegistry.executeTool(toolName, args, cancellationToken, context, progressCallback);
+        };
         try {
-            const toolResult = await this.toolRegistry.executeTool(toolName, args, cancellationToken);
+            let toolResult;
+            if (tool.retry && this.retryService) {
+                toolResult = await this.retryService.executeWithRetry(executeTool, tool.retry);
+            }
+            else {
+                toolResult = await executeTool();
+            }
+            this.circuitBreaker?.recordSuccess(toolName);
             if (cancellationToken.isCancelled) {
                 return (0, jsonrpc_interface_1.createJsonRpcError)(request.id, mcp_protocol_interface_1.McpErrorCode.RequestCancelled, "Request was cancelled");
             }
@@ -338,6 +397,7 @@ let McpServerService = class McpServerService {
             return (0, jsonrpc_interface_1.createJsonRpcSuccess)(request.id, result);
         }
         catch (error) {
+            this.circuitBreaker?.recordFailure(toolName);
             if (error instanceof easy_mcp_error_1.ToolNotFoundError) {
                 logger_util_1.logger.audit("McpServerService", "tools/call", "failure", {
                     reason: "ToolNotFoundError",
@@ -370,7 +430,132 @@ let McpServerService = class McpServerService {
         finally {
             if (request.id !== null && request.id !== undefined) {
                 this.cancellationTokens.delete(request.id);
+                this.progressNotifier?.cleanup(request.id);
+            }
+        }
+    }
+    async handleBatchTools(request) {
+        const params = request.params;
+        const actorId = this.getActorIdentifier(request);
+        if (!params || !Array.isArray(params.tools)) {
+            return (0, jsonrpc_interface_1.createJsonRpcError)(request.id, jsonrpc_interface_1.JsonRpcErrorCode.InvalidParams, "Missing or invalid tools array");
+        }
+        if (params.tools.length > 100) {
+            return (0, jsonrpc_interface_1.createJsonRpcError)(request.id, jsonrpc_interface_1.JsonRpcErrorCode.InvalidParams, "Batch size exceeds maximum limit of 100 tools");
+        }
+        if (!this.batchExecutor) {
+            return (0, jsonrpc_interface_1.createJsonRpcError)(request.id, jsonrpc_interface_1.JsonRpcErrorCode.MethodNotFound, "Batch execution not available");
+        }
+        const context = this.contextProvider.extractContext(request);
+        const cancellationToken = {
+            isCancelled: false,
+            onCancel: () => { },
+            cancel: () => {
+                cancellationToken.isCancelled = true;
+            },
+        };
+        if (request.id != null) {
+            this.cancellationTokens.set(request.id, cancellationToken);
+        }
+        const progressCallback = this.progressNotifier?.createProgressCallback(request.id);
+        try {
+            const batchRequests = [];
+            const validationErrors = [];
+            for (const toolRequest of params.tools) {
+                if (!toolRequest.name || typeof toolRequest.name !== "string") {
+                    validationErrors.push({
+                        tool: String(toolRequest.name || "[unknown]"),
+                        error: "Invalid tool name",
+                    });
+                    continue;
+                }
+                const toolName = toolRequest.name.trim();
+                if (toolName.length === 0) {
+                    validationErrors.push({
+                        tool: toolName,
+                        error: "Tool name cannot be empty",
+                    });
+                    continue;
+                }
+                let args = {};
+                if (toolRequest.arguments !== undefined && toolRequest.arguments !== null) {
+                    if (typeof toolRequest.arguments !== "object" || Array.isArray(toolRequest.arguments)) {
+                        validationErrors.push({
+                            tool: toolName,
+                            error: "Arguments must be a plain object",
+                        });
+                        continue;
+                    }
+                    args = toolRequest.arguments;
+                }
+                const tool = this.toolRegistry.getTool(toolName);
+                if (!tool) {
+                    validationErrors.push({
+                        tool: toolName,
+                        error: "Tool not found",
+                    });
+                    continue;
+                }
+                const validationError = (0, schema_validator_1.validateToolArguments)(args, tool.inputSchema);
+                if (validationError) {
+                    validationErrors.push({
+                        tool: toolName,
+                        error: validationError,
+                    });
+                    continue;
+                }
+                batchRequests.push({
+                    tool: toolName,
+                    args,
+                });
+            }
+            if (validationErrors.length > 0) {
+                logger_util_1.logger.audit("McpServerService", "tools/batch", "failure", {
+                    method: request.method,
+                    validationErrors: validationErrors.length,
+                }, request.id, actorId);
+                return (0, jsonrpc_interface_1.createJsonRpcError)(request.id, jsonrpc_interface_1.JsonRpcErrorCode.InvalidParams, `Batch validation failed: ${validationErrors.length} tool(s) have invalid parameters`);
+            }
+            const batchResults = await this.batchExecutor.executeBatch(batchRequests, cancellationToken, context, progressCallback);
+            for (const result of batchResults) {
+                logger_util_1.logger.audit("McpServerService", "tools/batch/tool", result.success ? "success" : "failure", {
+                    method: request.method,
+                    toolName: (0, sanitize_util_1.sanitizeName)(result.tool),
+                    batchRequestId: request.id,
+                }, request.id, actorId);
+            }
+            const result = {
+                results: batchResults.map((br) => ({
+                    tool: br.tool,
+                    success: br.success,
+                    result: br.success
+                        ? {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: (0, sanitize_util_1.sanitizeToolResult)(br.result),
+                                },
+                            ],
+                            isError: false,
+                        }
+                        : undefined,
+                    error: br.success ? undefined : br.error,
+                })),
+            };
+            return (0, jsonrpc_interface_1.createJsonRpcSuccess)(request.id, result);
+        }
+        catch (error) {
+            logger_util_1.logger.error("McpServerService", "Batch tool execution failed", {
+                component: "Layer 3",
+                error: (0, sanitize_util_1.sanitizeErrorMessage)(error),
+            });
+            return (0, jsonrpc_interface_1.createJsonRpcError)(request.id, mcp_protocol_interface_1.McpErrorCode.ToolExecutionError, "Batch execution failed");
+        }
+        finally {
+            if (request.id != null) {
+                this.cancellationTokens.delete(request.id);
             }
+            this.progressNotifier?.cleanup(request.id);
         }
     }
     handleCancelRequest(request) {
@@ -566,9 +751,22 @@ exports.McpServerService = McpServerService = __decorate([
     (0, common_1.Injectable)(),
     __param(3, (0, common_1.Inject)(constants_1.INTERFACE_LAYER_TOKEN)),
     __param(5, (0, common_1.Inject)(constants_2.CONFIG_TOKEN)),
+    __param(7, (0, common_2.Optional)()),
+    __param(8, (0, common_2.Optional)()),
+    __param(9, (0, common_2.Optional)()),
+    __param(10, (0, common_2.Optional)()),
+    __param(11, (0, common_2.Optional)()),
+    __param(12, (0, common_2.Optional)()),
     __metadata("design:paramtypes", [tool_registry_service_1.ToolRegistryService,
         resource_registry_service_1.ResourceRegistryService,
         prompt_registry_service_1.PromptRegistryService, Object, stdio_gateway_service_1.StdioGatewayService,
-        config_holder_service_1.ConfigHolderService])
+        config_holder_service_1.ConfigHolderService,
+        context_provider_service_1.ContextProviderService,
+        progress_notifier_service_1.ProgressNotifierService,
+        metrics_service_1.MetricsService,
+        rate_limiter_service_1.RateLimiterService,
+        retry_service_1.RetryService,
+        circuit_breaker_service_1.CircuitBreakerService,
+        batch_executor_service_1.BatchExecutorService])
 ], McpServerService);
 //# sourceMappingURL=mcp-server.service.js.map