agent-enderun 0.8.8 → 0.9.0

package/framework-mcp/src/tools/codebase.ts

@@ -1,284 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { Project } from "ts-morph";
-import { 
-    collectFilesRecursively, 
-    resolveSafePath 
-} from "../utils.js";
-import { 
-    SEARCH_CODEBASE_ARGS_SCHEMA, 
-    ANALYZE_DEPENDENCIES_ARGS_SCHEMA,
-    ANALYZE_CODEBASE_INTELLIGENCE_ARGS_SCHEMA,
-    ANALYZE_PROCEDURAL_CONTINUITY_ARGS_SCHEMA,
-    GENERATE_DEPENDENCY_GRAPH_ARGS_SCHEMA
-} from "../schemas.js";
-
-export const codebaseTools = [
-    {
-        name: "search_codebase",
-        description: "Semantic search across the codebase using grep for exact matches and context. Ideal for finding logic and patterns.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                query: {
-                    type: "string",
-                    description: "Search query or regex pattern",
-                },
-                extension: {
-                    type: "string",
-                    description: "File extension filter (e.g., ts, md)",
-                    default: "ts",
-                },
-            },
-            required: ["query"],
-        },
-    },
-    {
-        name: "codebase_search",
-        description: "Compatibility alias for search_codebase. Use when older agent prompts still reference codebase_search.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                query: {
-                    type: "string",
-                    description: "Search query or regex pattern",
-                },
-                extension: {
-                    type: "string",
-                    description: "File extension filter (e.g., ts, md)",
-                    default: "ts",
-                },
-            },
-            required: ["query"],
-        },
-    },
-    {
-        name: "analyze_dependencies",
-        description: "Analyze code dependencies for a specific file or folder using import tracking.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                path: {
-                    type: "string",
-                    description: "Path to analyze (relative to project root)",
-                },
-            },
-            required: ["path"],
-        },
-    },
-    {
-        name: "codebase_graph_query",
-        description: "Compatibility alias for analyze_dependencies. Returns import-level dependency information for a file or folder.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                path: {
-                    type: "string",
-                    description: "Path to analyze (relative to project root)",
-                },
-            },
-            required: ["path"],
-        },
-    },
-    {
-        name: "analyze_codebase_intelligence",
-        description: "Scans the codebase for complexity spikes and potential dead code (exported but unused symbols).",
-        inputSchema: {
-            type: "object",
-            properties: {
-                path: {
-                    type: "string",
-                    description: "Path to scan (relative to project root)",
-                    default: ".",
-                },
-            },
-        },
-    },
-    {
-        name: "analyze_procedural_continuity",
-        description: "Compares a target file with a reference file to identify stylistic or structural deviations. Ensures agents follow existing patterns.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                targetPath: {
-                    type: "string",
-                    description: "Path to the newly created/modified file",
-                },
-                referencePath: {
-                    type: "string",
-                    description: "Path to an existing 'gold standard' file for comparison",
-                },
-            },
-            required: ["targetPath", "referencePath"],
-        },
-    },
-    {
-        name: "generate_dependency_graph",
-        description: "Generates a Mermaid-compatible dependency graph of the codebase or a specific directory.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                path: {
-                    type: "string",
-                    description: "Path to scan (relative to project root)",
-                    default: "src",
-                },
-                format: {
-                    type: "string",
-                    enum: ["mermaid", "json"],
-                    default: "mermaid",
-                },
-            },
-        },
-    },
-];
-
-export const codebaseHandlers = {
-    search_codebase: async (args: unknown, projectRoot: string) => {
-        const parsed = SEARCH_CODEBASE_ARGS_SCHEMA.safeParse(args);
-        if (!parsed.success) {
-            return { content: [{ type: "text", text: "Invalid query/extension argument." }] };
-        }
-        const { query, extension } = parsed.data;
-        try {
-            const files = collectFilesRecursively(projectRoot, new Set([extension]));
-            let queryRegex: RegExp;
-            try {
-                queryRegex = new RegExp(query, "i");
-            } catch {
-                return { content: [{ type: "text", text: "Invalid regex pattern in query." }] };
-            }
-            const matches: string[] = [];
-            const MAX_RESULTS = 30;
-            for (const filePath of files) {
-                if (matches.length >= MAX_RESULTS) break;
-                const content = fs.readFileSync(filePath, "utf-8");
-                const lines = content.split("\n");
-                for (let i = 0; i < lines.length; i++) {
-                    if (matches.length >= MAX_RESULTS) break;
-                    const line = lines[i];
-                    if (queryRegex.test(line)) {
-                        const relativePath = path.relative(projectRoot, filePath);
-                        matches.push(`- ${relativePath}:${i + 1}: ${line.trim()}`);
-                    }
-                }
-            }
-            return { content: [{ type: "text", text: matches.join("\n") || "No matches found." }] };
-        } catch {
-            return { content: [{ type: "text", text: "Search failed." }] };
-        }
-    },
-    analyze_dependencies: async (args: unknown, projectRoot: string) => {
-        const parsed = ANALYZE_DEPENDENCIES_ARGS_SCHEMA.safeParse(args);
-        if (!parsed.success) {
-            return { content: [{ type: "text", text: "Invalid path argument." }] };
-        }
-        const targetPath = parsed.data.path;
-        try {
-            const fullPath = resolveSafePath(projectRoot, targetPath);
-            if (!fs.existsSync(fullPath)) return { content: [{ type: "text", text: `Path not found: ${targetPath}` }] };
-            const stats = fs.statSync(fullPath);
-            const tsProject = new Project({ compilerOptions: { allowJs: true } });
-            if (stats.isDirectory()) {
-                tsProject.addSourceFilesAtPaths(path.join(fullPath, "**/*.{ts,tsx,js,jsx}"));
-                const sourceFiles = tsProject.getSourceFiles();
-                return { content: [{ type: "text", text: `Directory contains ${sourceFiles.length} source files. Use a specific file path for deep dependency analysis.` }] };
-            } else {
-                const sourceFile = tsProject.addSourceFileAtPath(fullPath);
-                const imports = sourceFile.getImportDeclarations();
-                const importDetails = imports.map((imp) => {
-                    const moduleSpecifier = imp.getModuleSpecifierValue();
-                    const source = imp.getModuleSpecifierSourceFile();
-                    const resolvedPath = source ? path.relative(projectRoot, source.getFilePath()) : "unresolved/external";
-                    return `- ${moduleSpecifier} (${resolvedPath})`;
-                });
-                return { content: [{ type: "text", text: `Dependencies for ${targetPath}:\n${importDetails.length > 0 ? importDetails.join("\n") : "No imports found."}` }] };
-            }
-        } catch (error) {
-            return { content: [{ type: "text", text: "Analysis failed: " + (error instanceof Error ? error.message : String(error)) }] };
-        }
-    },
-    analyze_codebase_intelligence: async (args: unknown, projectRoot: string) => {
-        const parsed = ANALYZE_CODEBASE_INTELLIGENCE_ARGS_SCHEMA.safeParse(args);
-        const targetPath = parsed.success ? parsed.data.path : ".";
-        try {
-            const safeTargetPath = resolveSafePath(projectRoot, targetPath);
-            if (!fs.existsSync(safeTargetPath)) return { content: [{ type: "text", text: "Target path not found." }] };
-            const tsProject = new Project({ compilerOptions: { allowJs: true } });
-            tsProject.addSourceFilesAtPaths(path.join(safeTargetPath, "**/*.{ts,tsx}"));
-            const complexitySpikes: string[] = [];
-            const potentialDeadCode: string[] = [];
-            for (const sourceFile of tsProject.getSourceFiles()) {
-                const relativePath = path.relative(projectRoot, sourceFile.getFilePath());
-                const lineCount = sourceFile.getEndLineNumber();
-                if (lineCount > 300) complexitySpikes.push(`${relativePath} (${lineCount} lines)`);
-                sourceFile.getExportedDeclarations().forEach((declarations, name) => {
-                    const isUsed = tsProject.getSourceFiles().some(sf => {
-                        if (sf === sourceFile) return false;
-                        return sf.getImportDeclarations().some(i => i.getModuleSpecifierValue().includes(sourceFile.getBaseNameWithoutExtension()) && i.getNamedImports().some(ni => ni.getName() === name));
-                    });
-                    if (!isUsed && !sourceFile.getFilePath().includes("index.ts") && !sourceFile.getFilePath().includes("shared-types")) {
-                        potentialDeadCode.push(`${relativePath} -> ${name}`);
-                    }
-                });
-            }
-            return { content: [{ type: "text", text: `### CODEBASE INTELLIGENCE REPORT\n\n**Complexity Spikes (>300 lines):**\n${complexitySpikes.length > 0 ? complexitySpikes.map(s => `- ${s}`).join("\n") : "- None detected"}\n\n**Potential Dead Code (Unused Exports):**\n${potentialDeadCode.length > 0 ? potentialDeadCode.map(d => `- ${d}`).join("\n") : "- None detected (within scanned scope)"}` }] };
-        } catch {
-            return { content: [{ type: "text", text: "Intelligence scan failed." }] };
-        }
-    },
-    analyze_procedural_continuity: async (args: unknown, projectRoot: string) => {
-        const parsed = ANALYZE_PROCEDURAL_CONTINUITY_ARGS_SCHEMA.safeParse(args);
-        if (!parsed.success) return { content: [{ type: "text", text: "Invalid targetPath or referencePath." }] };
-        try {
-            const targetFull = resolveSafePath(projectRoot, parsed.data.targetPath);
-            const referenceFull = resolveSafePath(projectRoot, parsed.data.referencePath);
-            if (!fs.existsSync(targetFull) || !fs.existsSync(referenceFull)) return { content: [{ type: "text", text: "One or both files not found." }] };
-            const tsProject = new Project({ compilerOptions: { allowJs: true } });
-            const targetFile = tsProject.addSourceFileAtPath(targetFull);
-            const referenceFile = tsProject.addSourceFileAtPath(referenceFull);
-            const deviations: string[] = [];
-            const targetImports = targetFile.getImportDeclarations().map(i => i.getModuleSpecifierValue());
-            const referenceImports = referenceFile.getImportDeclarations().map(i => i.getModuleSpecifierValue());
-            const missingImports = referenceImports.filter(i => !targetImports.includes(i) && !i.startsWith("."));
-            if (missingImports.length > 0) deviations.push(`Missing standard imports found in reference: ${missingImports.join(", ")}`);
-            if (referenceFile.getClasses().length > 0 && targetFile.getClasses().length === 0) deviations.push("Reference uses classes, but target does not.");
-            const targetFunctions = targetFile.getFunctions().map(f => f.getName());
-            const referenceFunctions = referenceFile.getFunctions().map(f => f.getName());
-            if (referenceFunctions.some(f => f?.startsWith("get")) && !targetFunctions.some(f => f?.startsWith("get"))) deviations.push("Reference uses 'get' prefix for functions, target does not.");
-            return { content: [{ type: "text", text: deviations.length > 0 ? `### PROCEDURAL CONTINUITY DEVIATIONS\n\n${deviations.map(d => `- ${d}`).join("\n")}` : "No major structural or stylistic deviations detected based on reference." }] };
-        } catch {
-            return { content: [{ type: "text", text: "Dependency analysis failed." }] };
-        }
-    },
-    generate_dependency_graph: async (args: unknown, projectRoot: string) => {
-        const parsed = GENERATE_DEPENDENCY_GRAPH_ARGS_SCHEMA.safeParse(args);
-        const targetPath = parsed.success ? parsed.data.path : "src";
-        const format = parsed.success ? parsed.data.format : "mermaid";
-        try {
-            const safeTargetPath = resolveSafePath(projectRoot, targetPath);
-            if (!fs.existsSync(safeTargetPath)) return { content: [{ type: "text", text: "Target path not found." }] };
-            const tsProject = new Project({ compilerOptions: { allowJs: true } });
-            tsProject.addSourceFilesAtPaths(path.join(safeTargetPath, "**/*.{ts,tsx}"));
-            const edges: { from: string; to: string }[] = [];
-            for (const sourceFile of tsProject.getSourceFiles()) {
-                const from = sourceFile.getBaseNameWithoutExtension();
-                sourceFile.getImportDeclarations().forEach(imp => {
-                    const moduleSpecifier = imp.getModuleSpecifierValue();
-                    if (moduleSpecifier.startsWith(".")) {
-                        const to = path.basename(moduleSpecifier, path.extname(moduleSpecifier));
-                        edges.push({ from, to });
-                    }
-                });
-            }
-            if (format === "json") return { content: [{ type: "text", text: JSON.stringify(edges, null, 2) }] };
-            let mermaid = "graph TD\n";
-            const uniqueEdges = Array.from(new Set(edges.map(e => `${e.from} --> ${e.to}`)));
-            if (uniqueEdges.length === 0) return { content: [{ type: "text", text: "No internal dependencies found in the scanned path." }] };
-            mermaid += uniqueEdges.join("\n");
-            return { content: [{ type: "text", text: `### VISUAL ARCHITECTURE MAP: ${targetPath}\n\n\`\`\`mermaid\n${mermaid}\n\`\`\`\n\n**Total Nodes:** ${new Set(edges.flatMap(e => [e.from, e.to])).size} | **Total Edges:** ${uniqueEdges.length}` }] };
-        } catch {
-            return { content: [{ type: "text", text: "Dependency graph generation failed." }] };
-        }
-    },
-};

package/framework-mcp/src/tools/contract.ts

@@ -1,221 +0,0 @@
-import fs from "fs";
-import path from "path";
-import crypto from "crypto";
-import { Project } from "ts-morph";
-import { 
-    getFrameworkDir, 
-    collectFilesRecursively 
-} from "../utils.js";
-import { VERIFY_CONTRACT_INTEGRITY_ARGS_SCHEMA } from "../schemas.js";
-
-function calculateContractHash(sharedTypesDir: string, projectRoot: string): string {
-    const files = collectFilesRecursively(sharedTypesDir, new Set(["ts"])).sort();
-    const hash = crypto.createHash("sha256");
-    files.forEach((filePath) => {
-        hash.update(path.relative(projectRoot, filePath));
-        hash.update("\0");
-        hash.update(fs.readFileSync(filePath));
-        hash.update("\0");
-    });
-    return hash.digest("hex");
-}
-
-export const contractTools = [
-    {
-        name: "verify_api_contract",
-        description: "Verify if the shared-types match the stored contract hash in contract.version.json.",
-        inputSchema: { type: "object", properties: {} },
-    },
-    {
-        name: "update_contract_hash",
-        description: "Generate a new hash for shared-types and update contract.version.json.",
-        inputSchema: { type: "object", properties: {} },
-    },
-    {
-        name: "verify_contract_integrity",
-        description: "Deeply analyzes API documentation and shared types to ensure they are perfectly synchronized.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                domain: {
-                    type: "string",
-                    description: "The API domain to verify (e.g. 'auth', 'user')",
-                },
-            },
-            required: ["domain"],
-        },
-    },
-    {
-        name: "validate_frontend_api_contract",
-        description: "Scans frontend hooks for API calls and compares them against backend API documentation and contracts. Returns mismatches (missing endpoints, type issues, etc.).",
-        inputSchema: {
-            type: "object",
-            properties: {
-                frontendHooksPath: {
-                    type: "string",
-                    description: "Relative path to frontend hooks directory (default: apps/web/src/pages)",
-                },
-                backendApiDocsPath: {
-                    type: "string",
-                    description: "Relative path to backend API documentation (default: docs/api)",
-                },
-            },
-        },
-    },
-];
-
-export const contractHandlers = {
-    verify_api_contract: async (args: unknown, projectRoot: string) => {
-        try {
-            const sharedTypesDir = path.join(projectRoot, "apps/backend/src/types");
-            const contractJsonPath = path.join(projectRoot, "apps/backend/contract.version.json");
-            if (!fs.existsSync(sharedTypesDir) || !fs.existsSync(contractJsonPath)) return { content: [{ type: "text", text: "Missing shared-types directory or contract.version.json" }] };
-            const currentHash = calculateContractHash(sharedTypesDir, projectRoot);
-            const storedHash = JSON.parse(fs.readFileSync(contractJsonPath, "utf-8")).contract_hash;
-            return { content: [{ type: "text", text: currentHash === storedHash ? "✅ MATCH: Contract is valid and synchronized." : `❌ MISMATCH: Current hash (${currentHash.slice(0, 8)}...) does not match stored hash (${storedHash.slice(0, 8)}...).` }] };
-        } catch {
-            return { content: [{ type: "text", text: "Contract integrity check failed." }] };
-        }
-    },
-    update_contract_hash: async (args: unknown, projectRoot: string) => {
-        try {
-            const sharedTypesDir = path.join(projectRoot, "apps/backend/src/types");
-            const contractJsonPath = path.join(projectRoot, "apps/backend/contract.version.json");
-            if (!fs.existsSync(sharedTypesDir)) return { content: [{ type: "text", text: "Missing shared-types directory" }] };
-            const files = collectFilesRecursively(sharedTypesDir, new Set(["ts"])).sort();
-            if (files.length === 0) return { content: [{ type: "text", text: "⚠️ WARNING: No TypeScript files found in shared-types/src. Hash not updated." }] };
-            const currentHash = calculateContractHash(sharedTypesDir, projectRoot);
-            const contractJson = fs.existsSync(contractJsonPath) ? JSON.parse(fs.readFileSync(contractJsonPath, "utf-8")) : {};
-            contractJson.contract_hash = currentHash;
-            contractJson.last_updated = new Date().toISOString();
-            fs.writeFileSync(contractJsonPath, JSON.stringify(contractJson, null, 2));
-            return { content: [{ type: "text", text: `SUCCESS: Contract hash updated to ${currentHash}` }] };
-        } catch {
-            return { content: [{ type: "text", text: "Failed to update contract hash." }] };
-        }
-    },
-    verify_contract_integrity: async (args: unknown, projectRoot: string) => {
-        const parsed = VERIFY_CONTRACT_INTEGRITY_ARGS_SCHEMA.safeParse(args ?? {});
-        if (!parsed.success) return { content: [{ type: "text", text: "Invalid domain argument." }] };
-        try {
-            const frameworkDir = getFrameworkDir(projectRoot);
-            const apiDocPath = path.join(projectRoot, frameworkDir, "docs/api", `${parsed.data.domain}.md`);
-            const sharedTypesDir = path.join(projectRoot, "apps/backend/src/types");
-
-            if (!fs.existsSync(apiDocPath)) return { content: [{ type: "text", text: `API documentation not found for domain: ${parsed.data.domain}` }] };
-            if (!fs.existsSync(sharedTypesDir)) return { content: [{ type: "text", text: "Shared types directory not found." }] };
-
-            const project = new Project();
-            project.addSourceFilesAtPaths(path.join(sharedTypesDir, "**/*.ts"));
-
-            const mentionedTypes = Array.from(fs.readFileSync(apiDocPath, "utf-8").matchAll(/`([^`]+)`/g))
-                .map(m => m[1])
-                .filter(t => /^[A-Z][a-zA-Z0-9]+(DTO|Response|Request|Status|Type)?$/.test(t));
-
-            const uniqueTypes = Array.from(new Set(mentionedTypes));
-            const missingTypes = uniqueTypes.filter(t => {
-                const found = project.getSourceFiles().some(sf => 
-                    sf.getInterface(t) || sf.getTypeAlias(t) || sf.getEnum(t) || sf.getClass(t)
-                );
-                return !found;
-            });
-
-            return { content: [{ type: "text", text: `### CONTRACT INTEGRITY SHIELD: ${parsed.data.domain.toUpperCase()}\n\n` + `- **Missing/Undefined Types:** ${missingTypes.length > 0 ? `⚠️ ${missingTypes.join(", ")}` : "✅ All types synchronized"}\n\n` + `**Result:** ${missingTypes.length === 0 ? "PASSED" : "FAILED"}` }] };
-        } catch {
-            return { content: [{ type: "text", text: "Contract verification failed." }] };
-        }
-    },
-
-    validate_frontend_api_contract: async (args: unknown, projectRoot: string) => {
-        const a = args as Record<string, string> | undefined;
-        const frontendPath = a?.frontendHooksPath || "apps/web/src/pages";
-        const backendDocsPath = a?.backendApiDocsPath || "docs/api";
-
-        try {
-            const fullFrontendPath = path.join(projectRoot, frontendPath);
-            const fullBackendDocsPath = path.join(projectRoot, backendDocsPath);
-
-            if (!fs.existsSync(fullFrontendPath)) {
-                return { content: [{ type: "text", text: `Frontend hooks path not found: ${frontendPath}` }] };
-            }
-
-            const hookFiles = collectFilesRecursively(fullFrontendPath, new Set(["ts", "tsx"]));
-            const apiCalls: { endpoint: string; responseType?: string }[] = [];
-
-            // Hook dosyalarındaki fetch çağrılarını ve response tiplerini çıkar
-            for (const file of hookFiles) {
-                const content = fs.readFileSync(file, "utf-8");
-
-                // Basit regex ile endpoint + response tipi yakala
-                const matches = content.matchAll(
-                    /(?:const\s+\w+\s*[:=]\s*await\s+)?fetch\(['"`](\/api\/[^'"`]+)['"`][^)]*\)\s*(?:\.then[^;]+)?(?:\s*as\s+([A-Z][a-zA-Z0-9]+)|:\s*([A-Z][a-zA-Z0-9]+))?/g
-                );
-
-                for (const match of matches) {
-                    const endpoint = match[1];
-                    const responseType = match[2] || match[3];
-                    apiCalls.push({ endpoint, responseType });
-                }
-            }
-
-            const uniqueEndpoints = Array.from(new Set(apiCalls.map(c => c.endpoint)));
-
-            if (!fs.existsSync(fullBackendDocsPath)) {
-                return { content: [{ type: "text", text: `Backend API docs path not found: ${backendDocsPath}` }] };
-            }
-
-            const backendDocFiles = collectFilesRecursively(fullBackendDocsPath, new Set(["md"]));
-            const documentedEndpoints: string[] = [];
-
-            for (const file of backendDocFiles) {
-                const content = fs.readFileSync(file, "utf-8");
-                const matches = content.matchAll(/`?(\/api\/[a-zA-Z0-9/_-]+)`?/g);
-                for (const match of matches) {
-                    documentedEndpoints.push(match[1]);
-                }
-            }
-
-            const missingInDocs = uniqueEndpoints.filter(ep => !documentedEndpoints.some(d => ep.startsWith(d)));
-            const missingInHooks = documentedEndpoints.filter(d => !uniqueEndpoints.some(e => e.startsWith(d)));
-
-            let report = `### FRONTEND ↔ BACKEND CONTRACT VALIDATION REPORT\n\n`;
-            report += `**Scanned Frontend Hooks:** ${uniqueEndpoints.length} unique endpoints found\n`;
-            report += `**Scanned Backend API Docs:** ${documentedEndpoints.length} endpoints documented\n\n`;
-
-            if (missingInDocs.length > 0) {
-                report += `⚠️ **Endpoints called from frontend but NOT documented in backend:**\n${missingInDocs.map(e => `- ${e}`).join("\n")}\n\n`;
-            } else {
-                report += `✅ All frontend-called endpoints are documented in backend.\n\n`;
-            }
-
-            if (missingInHooks.length > 0) {
-                report += `ℹ️ **Endpoints documented in backend but NOT used in scanned frontend hooks:**\n${missingInHooks.map(e => `- ${e}`).join("\n")}\n\n`;
-            }
-
-            // Basit tip karşılaştırması (eğer responseType varsa)
-            const typeMismatches: string[] = [];
-            for (const call of apiCalls) {
-                if (call.responseType) {
-                    const docContent = backendDocFiles
-                        .map(f => fs.readFileSync(f, "utf-8"))
-                        .join("\n");
-
-                    if (!docContent.includes(call.responseType)) {
-                        typeMismatches.push(`${call.endpoint} → expected type "${call.responseType}" not found in docs`);
-                    }
-                }
-            }
-
-            if (typeMismatches.length > 0) {
-                report += `⚠️ **Potential Type Mismatches:**\n${typeMismatches.map(m => `- ${m}`).join("\n")}\n\n`;
-            }
-
-            report += `**Result:** ${missingInDocs.length === 0 && typeMismatches.length === 0 ? "PASSED" : "FAILED (see mismatches above)"}`;
-
-            return { content: [{ type: "text", text: report }] };
-        } catch (err: unknown) {
-            const message = err instanceof Error ? err.message : String(err);
-            return { content: [{ type: "text", text: `Validation failed: ${message}` }] };
-        }
-    },
-};