@uarlouski/testrail-mcp-server 1.1.0 → 1.3.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## [1.3.0] - 2026-02-18
+
+### Added
+
+- **Test run and result management tools**
+    - `add_run` - Create a new test run in TestRail
+    - `get_tests` - Get tests for a test run, optionally filtered by status
+    - `add_results` - Add one or more test results to a test run
+    - `get_statuses` - Get all available test statuses (e.g. Passed, Failed, Blocked)
+- Add `add_attachment_to_run` tool to attach files to test runs
+
+## [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,31 @@
 # TestRail MCP Server
 
-A Model Context Protocol (MCP) server for integrating LLMs with TestRail test case management.
+[![npm version](https://badge.fury.io/js/@uarlouski%2Ftestrail-mcp-server.svg)](https://www.npmjs.com/package/@uarlouski/testrail-mcp-server)
+[![npm downloads](https://img.shields.io/npm/dm/@uarlouski/testrail-mcp-server.svg)](https://www.npmjs.com/package/@uarlouski/testrail-mcp-server)
+[![CI](https://github.com/uarlouski/testrail-mcp-server/actions/workflows/ci.yml/badge.svg)](https://github.com/uarlouski/testrail-mcp-server/actions/workflows/ci.yml)
+[![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.9.3-blue.svg)](https://www.typescriptlang.org/)
+[![GitHub stars](https://img.shields.io/github/stars/uarlouski/testrail-mcp-server.svg?style=social&label=Star)](https://github.com/uarlouski/testrail-mcp-server)
 
-## 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 +33,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 +46,42 @@ 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. |
+| `add_run` | **Test Execution**: Create a new test run in TestRail. |
+| `get_tests` | **Test Execution**: Get tests for a test run, optionally filtered by status. |
+| `add_results` | **Test Execution**: Add one or more test results to a test run. |
+| `add_attachment_to_run` | **Test Execution**: Add an attachment (file or zipped folder) to a test run. |
+| `get_statuses` | **Metadata**: Get all available test statuses (e.g. Passed, Failed, Blocked). |
+| `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.3.0",
   "description": "Model Context Protocol (MCP) server for TestRail integration, enabling LLMs to fetch test cases and metadata.",
   "main": "index.js",
   "type": "module",
@@ -34,11 +34,12 @@
   "license": "Apache-2.0",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.25.3",
-    "axios": "^1.13.2",
+    "archiver": "^7.0.1",
     "dotenv": "^17.2.3",
     "zod": "^4.3.5"
   },
   "devDependencies": {
+    "@types/archiver": "^7.0.0",
     "@types/jest": "^30.0.0",
     "@types/node": "^25.0.9",
     "jest": "^30.2.0",

package/src/client/testrail.ts

@@ -1,42 +1,43 @@
-import axios, { AxiosInstance, AxiosError } from "axios";
-import { Case, Section, Priority, CaseType, CaseField, Template, Project } from "../types/testrail.js";
+import { Case, Section, Priority, CaseType, CaseField, Template, Project, Run, Status, Test, Result, Attachment } from "../types/testrail.js";
+
+import * as fs from "fs";
 
 interface PaginatedCasesResponse {
     cases: Case[];
     _links: { next: string | null };
 }
 
+interface PaginatedTestsResponse {
+    tests: Test[];
+    _links: { next: string | null };
+}
+
 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 auth: string;
     private prioritiesPromise: Promise<Priority[]> | null = null;
     private caseTypesPromise: Promise<CaseType[]> | null = null;
     private caseFieldsPromise: Promise<CaseField[]> | null = null;
+    private statusesPromise: Promise<Status[]> | null = null;
     private projectsPromise: Promise<Project[]> | null = null;
     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.auth = `Basic ${auth}`;
+        this.headers = {
+            "Content-Type": "application/json",
+            "Authorization": this.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 +57,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,49 +71,53 @@ 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;
     }
 
+    async getStatuses(): Promise<Status[]> {
+        if (!this.statusesPromise) {
+            this.statusesPromise = this.get<Status[]>(`${API_BASE_V2}/get_statuses`);
+        }
+        return this.statusesPromise;
+    }
+
     async getTemplates(projectId: string): Promise<Template[]> {
         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}`, {
+    async updateCases(suiteId: number, caseIds: number[], fields: Record<string, any>): Promise<Case[]> {
+        const response = await this.post<{ updated_cases: Case[] }>(`${API_BASE_V2}/update_cases/${suiteId}`, {
             case_ids: caseIds,
             ...fields,
         });
@@ -121,52 +126,102 @@ 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 addRun(projectId: string, fields: Record<string, any>): Promise<Run> {
+        return this.post<Run>(`${API_BASE_V2}/add_run/${projectId}`, 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);
+
+    async getTests(runId: number, statusId?: number[]): Promise<Test[]> {
+        let url = `${API_BASE_V2}/get_tests/${runId}`;
+
+        if (statusId && statusId.length > 0) {
+            url += `&status_id=${statusId.join(',')}`;
         }
+
+        const allTests: Test[] = [];
+        let nextUrl: string | null = url;
+
+        while (nextUrl) {
+            const response: PaginatedTestsResponse = await this.get<PaginatedTestsResponse>(nextUrl);
+            allTests.push(...response.tests);
+
+            nextUrl = response._links?.next;
+            if (nextUrl) {
+                nextUrl = `${API_INDEX}${nextUrl}`;
+            }
+        }
+
+        return allTests;
     }
 
-    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);
+
+    async addResults(runId: number, results: Array<Record<string, any>>): Promise<Result[]> {
+        return this.post<Result[]>(`${API_BASE_V2}/add_results/${runId}`, { results });
+    }
+
+    async addAttachmentToRun(runId: number, filePath: string, filename: string): Promise<Attachment> {
+        const fileBuffer = await fs.promises.readFile(filePath);
+        const blob = new Blob([fileBuffer]);
+        const formData = new FormData();
+        formData.append('attachment', blob, filename);
+
+        const headers: HeadersInit = {
+            'Authorization': this.auth,
+        };
+
+        return this._executeRequest<Attachment>('POST', `${API_BASE_V2}/add_attachment_to_run/${runId}`, headers, formData);
+    }
+
+    private async get<T>(endpoint: string): Promise<T> {
+        return this.executeRequest<T>('GET', endpoint);
+    }
+
+    private async post<T>(endpoint: string, data: Record<string, any>): Promise<T> {
+        return this.executeRequest<T>('POST', endpoint, data);
+    }
+
+    private async executeRequest<T>(method: 'GET' | 'POST', endpoint: string, data?: Record<string, any>): Promise<T> {
+        let jsonData = undefined;
+        if (data) {
+            jsonData = JSON.stringify(data);
         }
+
+        return this._executeRequest<T>(method, endpoint, this.headers, jsonData);
     }
 
-    private handleError(error: any): Error {
-        let errorMessage = `TestRail API error: ${error.message}`;
+    private async _executeRequest<T>(method: 'GET' | 'POST', endpoint: string, headers: HeadersInit, body?: any): Promise<T> {
+        const url = `${this.baseUrl}${endpoint}`;
+        const params: RequestInit = {
+            method,
+            headers,
+            body,
+        };
 
-        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}`;
-            }
+        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,12 @@ 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 { addRunTool } from "./tools/add_run.js";
+import { getStatusesTool } from "./tools/get_statuses.js";
+import { getTestsTool } from "./tools/get_tests.js";
+import { addResultsTool } from "./tools/add_results.js";
+import { addAttachmentToRunTool } from "./tools/add_attachment_to_run.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 +29,7 @@ if (!TESTRAIL_INSTANCE_URL || !TESTRAIL_USERNAME || !TESTRAIL_API_KEY) {
 
 const server = new McpServer({
     name: "TestRail MCP Server",
-    version: "1.1.0",
+    version: "1.3.0",
 });
 
 const client = new TestRailClient(TESTRAIL_INSTANCE_URL, TESTRAIL_USERNAME, TESTRAIL_API_KEY);
@@ -38,6 +44,11 @@ const tools = [
     updateCaseTool,
     updateCasesTool,
     createCaseTool,
+    addRunTool,
+    getStatusesTool,
+    getTestsTool,
+    addResultsTool,
+    addAttachmentToRunTool,
 ]
 
 for (const tool of tools) {
@@ -47,7 +58,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),
+                        },
+                    ],
+                } as any;
+            } catch (error: any) {
+                return {
+                    content: [{ type: "text", text: `Error: ${error.message}` }],
+                    isError: true,
+                };
+            }
+        }
     );
 }
 

package/src/tools/add_attachment_to_run.ts

@@ -0,0 +1,62 @@
+import { TestRailClient } from "../client/testrail.js";
+import { z } from "zod";
+import { AttachmentSchema } from "../types/testrail.js";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import archiver from "archiver";
+import { ToolDefinition } from "../types/custom.js";
+
+const parameters = {
+    run_id: z.string().describe("The ID of the test run to attach the file to"),
+    file_path: z.string().describe("The path to the file or directory to attach. Directories will be automatically zipped."),
+}
+
+export const addAttachmentToRunTool: ToolDefinition<typeof parameters, TestRailClient> = {
+    name: "add_attachment_to_run",
+    description: "Add an attachment to a test run in TestRail. If the file_path points to a directory, it will be automatically zipped before uploading. Maximum upload size is 256MB.",
+    parameters,
+    handler: async ({ run_id, file_path }, client: TestRailClient) => {
+        if (!fs.existsSync(file_path)) {
+            throw new Error(`File or directory not found: ${file_path}`);
+        }
+
+        const stats = fs.statSync(file_path);
+        let uploadPath: string = file_path;
+        let filename: string = path.basename(file_path);
+        let isTemporary = false;
+
+        if (stats.isDirectory()) {
+            const basename = path.basename(file_path);
+            const tempDir = os.tmpdir();
+            const zipPath = path.join(tempDir, `${basename}-${Date.now()}.zip`);
+
+            await new Promise<void>((resolve, reject) => {
+                const output = fs.createWriteStream(zipPath);
+                const archive = archiver('zip', {
+                    zlib: { level: 9 }
+                });
+
+                output.on('close', () => resolve());
+                archive.on('error', (err) => reject(err));
+
+                archive.pipe(output);
+                archive.directory(file_path, basename);
+                archive.finalize();
+            });
+
+            uploadPath = zipPath;
+            filename = `${basename}.zip`;
+            isTemporary = true;
+        }
+
+        try {
+            const result = await client.addAttachmentToRun(Number(run_id), uploadPath, filename);
+            return AttachmentSchema.parse(result);
+        } finally {
+            if (isTemporary && fs.existsSync(uploadPath)) {
+                fs.unlinkSync(uploadPath);
+            }
+        }
+    },
+};

package/src/tools/add_results.ts

@@ -0,0 +1,28 @@
+import { TestRailClient } from "../client/testrail.js";
+import { z } from "zod";
+import { ResultSchema } from "../types/testrail.js";
+import { ToolDefinition } from "../types/custom.js";
+
+const parameters = {
+    run_id: z.number().describe("The ID of the test run"),
+    results: z.array(z.object({
+        test_id: z.number().describe("The ID of the test. Use get_tests with a run_id to retrieve available test IDs"),
+        status_id: z.number().describe("The ID of the test status (e.g. Passed, Failed). Use get_statuses to retrieve available status IDs"),
+        comment: z.string().optional().describe("Optional comment/description for the result"),
+        defects: z.string().optional().describe("Optional comma-separated list of defect IDs"),
+    })).describe("Array of results to add. Each result must have test_id and status_id"),
+}
+
+export const addResultsTool: ToolDefinition<typeof parameters, TestRailClient> = {
+    name: "add_results",
+    description: "Add one or more test results to a test run",
+    parameters,
+    handler: async ({ run_id, results }, client: TestRailClient) => {
+        const response = await client.addResults(run_id, results);
+        return {
+            success: true,
+            added_count: response.length,
+            results: response.map(r => ResultSchema.parse(r)),
+        };
+    },
+};

package/src/tools/add_run.ts

@@ -0,0 +1,24 @@
+import { TestRailClient } from "../client/testrail.js";
+import { z } from "zod";
+import { RunSchema } from "../types/testrail.js";
+import { ToolDefinition } from "../types/custom.js";
+
+const parameters = {
+    project_id: z.string().describe("The ID of the project. Use get_projects to find available projects"),
+    name: z.string().optional().describe("The name of the test run"),
+    description: z.string().optional().describe("The description of the test run"),
+    case_ids: z.array(z.number()).describe("Array of case IDs to include in the run. After creating the run, use get_tests with the returned run_id to retrieve test IDs for result submission")
+}
+
+export const addRunTool: ToolDefinition<typeof parameters, TestRailClient> = {
+    name: "add_run",
+    description: "Create a new test run in TestRail",
+    parameters,
+    handler: async ({ project_id, ...fields }, client: TestRailClient) => {
+        const caseData = await client.getCase(String(fields.case_ids[0]));
+        const params = { suite_id: caseData.suite_id, include_all: false, ...fields };
+        const run = await client.addRun(project_id, params);
+
+        return RunSchema.parse(run);
+    },
+};

package/src/tools/create_case.ts

@@ -1,18 +1,18 @@
 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"),
-    title: z.string().describe("The title of the test case (required)"),
-    fields: z.record(z.string(), z.any()).optional().describe("Optional object containing additional fields. Use get_case_fields to see available fields. Example: {\"priority_id\": 2, \"template_id\": 1, \"custom_automation_priority\": 1}"),
+    section_id: z.string().describe("The ID of the section where the case should be created. Use get_sections to find available sections"),
+    title: z.string().describe("The title of the test case"),
+    fields: z.record(z.string(), z.any()).optional().describe("Optional fields for the test case. First use get_templates to discover available templates, then get_case_fields to see available fields for your template. Example: {\"priority_id\": 2, \"template_id\": 1, \"custom_automation_priority\": 1}"),
 };
 
 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.",
+    description: "Create a new test case in TestRail",
     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`,
         };
-    })
+    }
 };