@uarlouski/testrail-mcp-server 1.1.0 → 1.2.0

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [1.2.0] - 2026-02-14
+
+### Changed
+
+- Optimize MCP call responses by removing non-essential fields and nullish values
+- Migrated from `axios` to native `fetch` API for reduced dependency footprint
+
 ## [1.1.0] - 2026-02-09
 
 ### Added

package/README.md

@@ -1,8 +1,26 @@
 # TestRail MCP Server
 
-A Model Context Protocol (MCP) server for integrating LLMs with TestRail test case management.
+[![npm version](https://img.shields.io/npm/v/@uarlouski/testrail-mcp-server.svg)](https://www.npmjs.com/package/@uarlouski/testrail-mcp-server)
+[![License](https://img.shields.io/npm/l/@uarlouski/testrail-mcp-server.svg)](https://github.com/uarlouski/testrail-mcp-server/blob/main/LICENSE)
 
-## Usage
+A powerful **Model Context Protocol (MCP)** server for seamless integration between **Large Language Models (LLMs)** and **TestRail** test case management.
+
+This MCP server enables AI assistants like **Claude**, **Cursor**, **Windsurf**, and other MCP-compliant clients to interact directly with your TestRail instance. Streamline your QA workflows by allowing your AI to search, retrieve, create, and update test cases, plans, and runs.
+
+## 🚀 Features
+
+- **AI-Powered Test Management**: Bridge the gap between AI and your QA process.
+- **Smart Discovery**: List projects, suites, and sections to help LLMs understand your test organization.
+- **Comprehensive Case Operations**: Fetch, create, and update test cases with full support for custom fields.
+- **Context-Aware**: Designed to provide LLMs with the right context (templates, field options) for accurate test generation.
+
+## ⚙️ Usage
+
+Configure the server in your MCP client settings (e.g., `claude_desktop_config.json` or Cursor settings).
+
+### Claude Desktop / General MCP Clients
+
+Add the following to your configuration file:
 
 ```json
 {
@@ -10,6 +28,7 @@ A Model Context Protocol (MCP) server for integrating LLMs with TestRail test ca
     "testrail": {
       "command": "npx",
       "args": [
+        "-y",
         "@uarlouski/testrail-mcp-server@latest"
       ],
       "env": {
@@ -22,20 +41,37 @@ A Model Context Protocol (MCP) server for integrating LLMs with TestRail test ca
 }
 ```
 
-## Tools
+### Environment Variables
+
+| Variable | Description | Required |
+|----------|-------------|:--------:|
+| `TESTRAIL_INSTANCE_URL` | The URL of your TestRail instance (e.g., `https://example.testrail.io`) | Yes |
+| `TESTRAIL_USERNAME` | Your TestRail email address | Yes |
+| `TESTRAIL_API_KEY` | Your TestRail API key (generate in My Settings > API Keys) | Yes |
+
+## 🛠️ Available Tools
+
+This MCP server exposes the following tools to the LLM:
 
 | Tool | Description |
 |------|-------------|
-| `get_projects` | Discover available projects in your TestRail instance |
-| `get_case` | Fetch detailed test case info including custom fields |
-| `get_cases` | Query cases with filtering and pagination support |
-| `get_case_fields` | Explore available fields and dropdown options |
-| `get_templates` | List project templates to understand case structures |
-| `get_sections` | Navigate the test case hierarchy |
-| `create_case` | Create new test cases with full custom field support |
-| `update_case` | Modify a single test case |
-| `update_cases` | Bulk update multiple cases at once |
-
-## License
-
-Apache 2.0
+| `get_projects` | **Discovery**: List all available projects in the TestRail instance to establish context. |
+| `get_suites` | **Discovery**: Retrieve test suites for a given project (if not in single-suite mode). |
+| `get_sections` | **Structure**: navigate the folder/section hierarchy of a test suite. |
+| `get_cases` | **Search**: Query test cases with filtering (priority, template, type, etc.) and pagination. |
+| `get_case` | **Detail**: Fetch comprehensive details of a specific test case, including steps and custom fields. |
+| `create_case` | **Authoring**: Create new test cases. *Tip: The model should check templates and fields first to ensure validity.* |
+| `update_case` | **Maintenance**: Modify existing test case fields, title, or steps. |
+| `update_cases` | **Bulk Edit**: Update multiple cases simultaneously for efficient refactoring. |
+| `get_case_fields` | **Metadata**: Retrieve definitions of custom fields to understand available inputs. |
+| `get_templates` | **Metadata**: List available case templates to ensure correct case creation structure. |
+| `get_priorities` | **Metadata**: List available priority levels. |
+| `get_case_types` | **Metadata**: List available case types (e.g., Automated, Manual). |
+
+## 📜 License
+
+This project is licensed under the Apache 2.0 License - see the [LICENSE](LICENSE) file for details.
+
+---
+
+*Keywords: TestRail, MCP, Model Context Protocol, LLM, AI, Claude, Cursor, Windsurf, Test Management, QA, Automation, Testing, API*

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uarlouski/testrail-mcp-server",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Model Context Protocol (MCP) server for TestRail integration, enabling LLMs to fetch test cases and metadata.",
   "main": "index.js",
   "type": "module",
@@ -34,7 +34,6 @@
   "license": "Apache-2.0",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.25.3",
-    "axios": "^1.13.2",
     "dotenv": "^17.2.3",
     "zod": "^4.3.5"
   },

package/src/client/testrail.ts

@@ -1,4 +1,3 @@
-import axios, { AxiosInstance, AxiosError } from "axios";
 import { Case, Section, Priority, CaseType, CaseField, Template, Project } from "../types/testrail.js";
 
 interface PaginatedCasesResponse {
@@ -10,7 +9,8 @@ const API_INDEX = '/index.php?';
 const API_BASE_V2 = `${API_INDEX}/api/v2`;
 
 export class TestRailClient {
-    private client: AxiosInstance;
+    private baseUrl: string;
+    private headers: HeadersInit;
     private prioritiesPromise: Promise<Priority[]> | null = null;
     private caseTypesPromise: Promise<CaseType[]> | null = null;
     private caseFieldsPromise: Promise<CaseField[]> | null = null;
@@ -18,25 +18,16 @@ export class TestRailClient {
     private templatesPromiseMap: Map<string, Promise<Template[]>> = new Map();
 
     constructor(baseUrl: string, email: string, apiKey: string) {
-        const cleanedBaseUrl = baseUrl.replace(/\/$/, "");
-
-        this.client = axios.create({
-            baseURL: cleanedBaseUrl,
-            headers: {
-                "Content-Type": "application/json",
-            },
-            auth: {
-                username: email,
-                password: apiKey,
-            },
-            validateStatus: (status: number) => {
-                return status >= 200 && status < 300;
-            }
-        });
+        this.baseUrl = baseUrl.replace(/\/$/, "");
+        const auth = Buffer.from(`${email}:${apiKey}`).toString('base64');
+        this.headers = {
+            "Content-Type": "application/json",
+            "Authorization": `Basic ${auth}`,
+        };
     }
 
     async getCase(caseId: string): Promise<Case> {
-        return this.makeRequest<Case>(`${API_BASE_V2}/get_case/${caseId}`);
+        return this.get<Case>(`${API_BASE_V2}/get_case/${caseId}`);
     }
 
     async getCases(projectId: string, sectionId?: string, filter?: Record<string, string>): Promise<Case[]> {
@@ -56,7 +47,7 @@ export class TestRailClient {
         let nextUrl: string | null = url;
 
         while (nextUrl) {
-            const response: PaginatedCasesResponse = await this.makeRequest<PaginatedCasesResponse>(nextUrl);
+            const response: PaginatedCasesResponse = await this.get<PaginatedCasesResponse>(nextUrl);
 
             allCases.push(...response.cases);
 
@@ -70,26 +61,26 @@ export class TestRailClient {
     }
 
     async getSection(sectionId: string): Promise<Section> {
-        return this.makeRequest<Section>(`${API_BASE_V2}/get_section/${sectionId}`);
+        return this.get<Section>(`${API_BASE_V2}/get_section/${sectionId}`);
     }
 
     async getPriorities(): Promise<Priority[]> {
         if (!this.prioritiesPromise) {
-            this.prioritiesPromise = this.makeRequest<Priority[]>(`${API_BASE_V2}/get_priorities`);
+            this.prioritiesPromise = this.get<Priority[]>(`${API_BASE_V2}/get_priorities`);
         }
         return this.prioritiesPromise;
     }
 
     async getCaseTypes(): Promise<CaseType[]> {
         if (!this.caseTypesPromise) {
-            this.caseTypesPromise = this.makeRequest<CaseType[]>(`${API_BASE_V2}/get_case_types`);
+            this.caseTypesPromise = this.get<CaseType[]>(`${API_BASE_V2}/get_case_types`);
         }
         return this.caseTypesPromise;
     }
 
     async getCaseFields(): Promise<CaseField[]> {
         if (!this.caseFieldsPromise) {
-            this.caseFieldsPromise = this.makeRequest<CaseField[]>(`${API_BASE_V2}/get_case_fields`);
+            this.caseFieldsPromise = this.get<CaseField[]>(`${API_BASE_V2}/get_case_fields`);
         }
         return this.caseFieldsPromise;
     }
@@ -98,21 +89,21 @@ export class TestRailClient {
         if (!this.templatesPromiseMap.has(projectId)) {
             this.templatesPromiseMap.set(
                 projectId,
-                this.makeRequest<Template[]>(`${API_BASE_V2}/get_templates/${projectId}`)
+                this.get<Template[]>(`${API_BASE_V2}/get_templates/${projectId}`)
             );
         }
         return this.templatesPromiseMap.get(projectId)!;
     }
 
     async updateCase(caseId: string, fields: Record<string, any>): Promise<Case> {
-        return this.postRequest<Case>(`${API_BASE_V2}/update_case/${caseId}`, fields);
+        return this.post<Case>(`${API_BASE_V2}/update_case/${caseId}`, fields);
     }
 
     async updateCases(caseIds: number[], fields: Record<string, any>): Promise<Case[]> {
         // Assume the project is operating in single suite mode, get suite_id from the first case
         const caseData = await this.getCase(String(caseIds[0]));
 
-        const response = await this.postRequest<{ updated_cases: Case[] }>(`${API_BASE_V2}/update_cases/${caseData.suite_id}`, {
+        const response = await this.post<{ updated_cases: Case[] }>(`${API_BASE_V2}/update_cases/${caseData.suite_id}`, {
             case_ids: caseIds,
             ...fields,
         });
@@ -121,52 +112,50 @@ export class TestRailClient {
     }
 
     async createCase(sectionId: string, fields: Record<string, any>): Promise<Case> {
-        return this.postRequest<Case>(`${API_BASE_V2}/add_case/${sectionId}`, fields);
+        return this.post<Case>(`${API_BASE_V2}/add_case/${sectionId}`, fields);
     }
 
     async getSections(projectId: string): Promise<Section[]> {
-        const response = await this.makeRequest<{ sections: Section[] }>(`${API_BASE_V2}/get_sections/${projectId}`);
+        const response = await this.get<{ sections: Section[] }>(`${API_BASE_V2}/get_sections/${projectId}`);
         return response.sections;
     }
 
     async getProjects(): Promise<Project[]> {
         if (!this.projectsPromise) {
-            this.projectsPromise = this.makeRequest<{ projects: Project[] }>(`${API_BASE_V2}/get_projects`)
+            this.projectsPromise = this.get<{ projects: Project[] }>(`${API_BASE_V2}/get_projects`)
                 .then(response => response.projects);
         }
         return this.projectsPromise;
     }
 
-    private async makeRequest<T>(url: string): Promise<T> {
-        try {
-            const response = await this.client.get<T>(url);
-            return response.data;
-        } catch (error: any) {
-            throw this.handleError(error);
-        }
+    private async get<T>(endpoint: string): Promise<T> {
+        return this.executeRequest<T>('GET', endpoint);
     }
 
-    private async postRequest<T>(url: string, data: Record<string, any>): Promise<T> {
-        try {
-            const response = await this.client.post<T>(url, data);
-            return response.data;
-        } catch (error: any) {
-            throw this.handleError(error);
-        }
+    private async post<T>(endpoint: string, data: Record<string, any>): Promise<T> {
+        return this.executeRequest<T>('POST', endpoint, data);
     }
 
-    private handleError(error: any): Error {
-        let errorMessage = `TestRail API error: ${error.message}`;
+    private async executeRequest<T>(method: 'GET' | 'POST', endpoint: string, data?: Record<string, any>): Promise<T> {
+        const url = `${this.baseUrl}${endpoint}`;
+        const params: RequestInit = {
+            method,
+            headers: this.headers,
+        };
 
-        if (axios.isAxiosError(error)) {
-            const axiosError = error as AxiosError;
-            if (axiosError.response) {
-                errorMessage = `TestRail API error: ${axiosError.response.status} ${axiosError.response.statusText} - ${JSON.stringify(axiosError.response.data)}`;
-            } else if (axiosError.request) {
-                errorMessage = `TestRail API error: No response received. ${axiosError.message}`;
-            }
+        if (data) {
+            params.body = JSON.stringify(data);
+        }
+
+        const response = await fetch(url, params);
+
+        if (!response.ok) {
+            let errorMessage = `TestRail: ${response.status} ${response.statusText}`;
+            const errorText = await response.text();
+            errorMessage += ` - ${errorText}`;
+            throw new Error(errorMessage);
         }
 
-        return new Error(errorMessage);
+        return await response.json() as T;
     }
 }

package/src/index.ts

@@ -11,6 +11,7 @@ import { updateCasesTool } from "./tools/update_cases.js";
 import { createCaseTool } from "./tools/create_case.js";
 import { getSectionsTool } from "./tools/get_sections.js";
 import { getProjectsTool } from "./tools/get_projects.js";
+import { removeNullish } from "./utils/sanitizer.js";
 
 const TESTRAIL_INSTANCE_URL = process.env.TESTRAIL_INSTANCE_URL;
 const TESTRAIL_USERNAME = process.env.TESTRAIL_USERNAME;
@@ -23,7 +24,7 @@ if (!TESTRAIL_INSTANCE_URL || !TESTRAIL_USERNAME || !TESTRAIL_API_KEY) {
 
 const server = new McpServer({
     name: "TestRail MCP Server",
-    version: "1.1.0",
+    version: "1.2.0",
 });
 
 const client = new TestRailClient(TESTRAIL_INSTANCE_URL, TESTRAIL_USERNAME, TESTRAIL_API_KEY);
@@ -47,7 +48,26 @@ for (const tool of tools) {
             description: tool.description,
             inputSchema: tool.parameters,
         },
-        (args: any) => tool.handler(args, client)
+        async (args: any) => {
+            try {
+                const output: Record<string, any> = await tool.handler(args, client);
+                const sanitized = removeNullish(output);
+
+                return {
+                    content: [
+                        {
+                            type: "text" as const,
+                            text: JSON.stringify(sanitized, null, 2),
+                        },
+                    ],
+                } as any;
+            } catch (error: any) {
+                return {
+                    content: [{ type: "text", text: `Error: ${error.message}` }],
+                    isError: true,
+                };
+            }
+        }
     );
 }
 

package/src/tools/create_case.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { TestRailClient } from "../client/testrail.js";
-import { ToolDefinition, withErrorHandling } from "../types/custom.js";
+import { ToolDefinition } from "../types/custom.js";
 
 const parameters = {
     section_id: z.string().describe("The ID of the section where the case should be created"),
@@ -12,7 +12,7 @@ export const createCaseTool: ToolDefinition<typeof parameters, TestRailClient> =
     name: "create_case",
     description: "Create a new test case in TestRail. IMPORTANT: Before creating a case, first call get_templates to discover available templates for the project, then use get_case_fields to see which fields are available for the chosen template. Requires section_id and title.",
     parameters,
-    handler: withErrorHandling<typeof parameters, TestRailClient>(async ({ section_id, title, fields }, client) => {
+    handler: async ({ section_id, title, fields }, client) => {
         const caseData = {
             title,
             ...fields,
@@ -21,16 +21,9 @@ export const createCaseTool: ToolDefinition<typeof parameters, TestRailClient> =
         const createdCase = await client.createCase(section_id, caseData);
 
         return {
-            content: [
-                {
-                    type: "text" as const,
-                    text: JSON.stringify({
-                        success: true,
-                        case_id: createdCase.id,
-                        message: `Test case C${createdCase.id} created successfully`,
-                    }, null, 2),
-                },
-            ],
+            success: true,
+            case_id: createdCase.id,
+            message: `Test case C${createdCase.id} created successfully`,
         };
-    })
+    }
 };

package/src/tools/get_case.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { processCustomFields } from "../utils/mapper.js";
 import { TestRailClient } from "../client/testrail.js";
-import { TestCaseResponse, ToolDefinition, withErrorHandling } from "../types/custom.js";
+import { TestCaseResponse, ToolDefinition } from "../types/custom.js";
 
 const parameters = {
     case_id: z.string().describe("The ID of the test case (e.g. '123' or 'C123')"),
@@ -11,7 +11,7 @@ export const getCaseTool: ToolDefinition<typeof parameters, TestRailClient> = {
     name: "get_case",
     description: "Get a test case from TestRail by ID",
     parameters,
-    handler: withErrorHandling<typeof parameters, TestRailClient>(async ({ case_id }, client) => {
+    handler: async ({ case_id }, client) => {
         const id = case_id.toUpperCase().startsWith("C") ? case_id.substring(1) : case_id;
         const testCase = await client.getCase(id);
 
@@ -39,13 +39,6 @@ export const getCaseTool: ToolDefinition<typeof parameters, TestRailClient> = {
             ...customFields
         };
 
-        return {
-            content: [
-                {
-                    type: "text" as const,
-                    text: JSON.stringify(response, null, 2),
-                },
-            ],
-        };
-    })
+        return response;
+    }
 };

package/src/tools/get_case_fields.ts

@@ -1,5 +1,5 @@
 import { TestRailClient } from "../client/testrail.js";
-import { ToolDefinition, withErrorHandling } from "../types/custom.js";
+import { ToolDefinition } from "../types/custom.js";
 import { CaseField } from "../types/testrail.js";
 import { parseDropdownOptions } from "../utils/mapper.js";
 
@@ -76,7 +76,7 @@ export const getCaseFieldsTool: ToolDefinition<typeof parameters, TestRailClient
     name: "get_case_fields",
     description: "Get the field schema for test cases. Returns all available fields with their types, descriptions, and options (for dropdown fields). Use this to understand what fields can be set when creating or updating test cases.",
     parameters,
-    handler: withErrorHandling<typeof parameters, TestRailClient>(async (_args, client) => {
+    handler: async (_args, client) => {
         const caseFields = await client.getCaseFields();
 
         const customFieldSchemas = caseFields.filter(field => field.is_active).map(mapToFieldSchema);
@@ -85,13 +85,6 @@ export const getCaseFieldsTool: ToolDefinition<typeof parameters, TestRailClient
             fields: [...SYSTEM_FIELDS, ...customFieldSchemas],
         };
 
-        return {
-            content: [
-                {
-                    type: "text" as const,
-                    text: JSON.stringify(response, null, 2),
-                },
-            ],
-        };
-    })
+        return response;
+    }
 };

package/src/tools/get_cases.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { TestRailClient } from "../client/testrail.js";
-import { ToolDefinition, withErrorHandling } from "../types/custom.js";
+import { ToolDefinition } from "../types/custom.js";
 import { Case } from "../types/testrail.js";
 
 const parameters = {
@@ -19,7 +19,7 @@ export const getCasesTool: ToolDefinition<typeof parameters, TestRailClient> = {
     name: "get_cases",
     description: "Get all test cases for a project. Filter by section, API params (priority, type), or any field including custom fields via 'where'. Returns case IDs, titles, and any additional requested fields.",
     parameters,
-    handler: withErrorHandling<typeof parameters, TestRailClient>(async ({ project_id, section_id, filter, where, fields }, client) => {
+    handler: async ({ project_id, section_id, filter, where, fields }, client) => {
         let cases: Case[] = await client.getCases(project_id, section_id, filter);
 
         // Client-side filtering for custom fields and other unsupported API filters
@@ -55,13 +55,6 @@ export const getCasesTool: ToolDefinition<typeof parameters, TestRailClient> = {
             }),
         };
 
-        return {
-            content: [
-                {
-                    type: "text" as const,
-                    text: JSON.stringify(response, null, 2),
-                },
-            ],
-        };
-    })
+        return response;
+    }
 };

package/src/tools/get_projects.ts

@@ -1,40 +1,22 @@
 import { TestRailClient } from "../client/testrail.js";
-import { ToolDefinition, withErrorHandling } from "../types/custom.js";
+import { ToolDefinition } from "../types/custom.js";
+import { ProjectSchema } from "../types/testrail.js";
 
 const parameters = {};
 
-interface ProjectSchema {
-    id: number;
-    name: string;
-}
-
-interface ProjectsResponse {
-    projects: ProjectSchema[];
-}
-
 export const getProjectsTool: ToolDefinition<typeof parameters, TestRailClient> = {
     name: "get_projects",
     description: "Get all available projects in TestRail. Returns project IDs and names. Use this to find the project_id needed for get_sections and get_templates.",
     parameters,
-    handler: withErrorHandling<typeof parameters, TestRailClient>(async (_args, client) => {
+    handler: async (_args, client) => {
         const projects = await client.getProjects();
 
-        const response: ProjectsResponse = {
+        const response = {
             projects: projects
                 .filter(p => !p.is_completed)
-                .map(p => ({
-                    id: p.id,
-                    name: p.name,
-                })),
+                .map(p => ProjectSchema.parse(p)),
         };
 
-        return {
-            content: [
-                {
-                    type: "text" as const,
-                    text: JSON.stringify(response, null, 2),
-                },
-            ],
-        };
-    })
+        return response;
+    }
 };

package/src/tools/get_sections.ts

@@ -1,41 +1,23 @@
 import { z } from "zod";
 import { TestRailClient } from "../client/testrail.js";
-import { ToolDefinition, withErrorHandling } from "../types/custom.js";
+import { ToolDefinition } from "../types/custom.js";
+import { SectionSchema } from "../types/testrail.js";
 
 const parameters = {
     project_id: z.string().describe("The ID of the project"),
 };
 
-interface SectionSchema {
-    id: number;
-    name: string;
-}
-
-interface SectionsResponse {
-    sections: SectionSchema[];
-}
-
 export const getSectionsTool: ToolDefinition<typeof parameters, TestRailClient> = {
     name: "get_sections",
     description: "Get all sections for a project. Returns section IDs and names. Use this to find the section_id needed for create_case.",
     parameters,
-    handler: withErrorHandling<typeof parameters, TestRailClient>(async ({ project_id }, client) => {
+    handler: async ({ project_id }, client) => {
         const sections = await client.getSections(project_id);
 
-        const response: SectionsResponse = {
-            sections: sections.map(s => ({
-                id: s.id,
-                name: s.name,
-            })),
+        const response = {
+            sections: sections.map(s => SectionSchema.parse(s)),
         };
 
-        return {
-            content: [
-                {
-                    type: "text" as const,
-                    text: JSON.stringify(response, null, 2),
-                },
-            ],
-        };
-    })
+        return response;
+    }
 };

package/src/tools/get_templates.ts

@@ -1,41 +1,23 @@
 import { z } from "zod";
 import { TestRailClient } from "../client/testrail.js";
-import { ToolDefinition, withErrorHandling } from "../types/custom.js";
+import { ToolDefinition } from "../types/custom.js";
+import { TemplateSchema } from "../types/testrail.js";
 
 const parameters = {
     project_id: z.string().describe("The ID of the project"),
 };
 
-interface TemplateSchema {
-    id: number;
-    name: string;
-}
-
-interface TemplatesResponse {
-    templates: TemplateSchema[];
-}
-
 export const getTemplatesTool: ToolDefinition<typeof parameters, TestRailClient> = {
     name: "get_templates",
     description: "Get available test case templates for a project. Returns template IDs and names. Use template IDs with get_case_fields to understand which fields apply to each template.",
     parameters,
-    handler: withErrorHandling<typeof parameters, TestRailClient>(async ({ project_id }, client) => {
+    handler: async ({ project_id }, client) => {
         const templates = await client.getTemplates(project_id);
 
-        const response: TemplatesResponse = {
-            templates: templates.map(t => ({
-                id: t.id,
-                name: t.name,
-            })),
+        const response = {
+            templates: templates.map(t => TemplateSchema.parse(t)),
         };
 
-        return {
-            content: [
-                {
-                    type: "text" as const,
-                    text: JSON.stringify(response, null, 2),
-                },
-            ],
-        };
-    })
+        return response;
+    }
 };