@testomatio/mcp 2.1.1 → 2.2.0-beta

package/src/mcp/definitions/testruns.js

@@ -149,7 +149,13 @@ export const TESTRUNS_TOOLS = [
           "type": "string"
         },
         "status": {
-          "type": "string"
+          "type": "string",
+          "enum": [
+            "passed",
+            "failed",
+            "skipped",
+            "pending"
+          ]
         },
         "message": {
           "type": "string"
@@ -189,7 +195,13 @@ export const TESTRUNS_TOOLS = [
           "type": "string"
         },
         "status": {
-          "type": "string"
+          "type": "string",
+          "enum": [
+            "passed",
+            "failed",
+            "skipped",
+            "pending"
+          ]
         },
         "message": {
           "type": "string"
@@ -229,127 +241,6 @@ export const TESTRUNS_TOOLS = [
       "additionalProperties": false
     }
   },
-  {
-    "name": "testruns_search",
-    "description": "Search testruns (delegates to testruns list; docs has no dedicated search parameter)",
-    "inputSchema": {
-      "type": "object",
-      "properties": {
-        "run_id": {
-          "type": "string"
-        },
-        "test_ids": {
-          "type": [
-            "array",
-            "string"
-          ],
-          "items": {
-            "type": "string"
-          }
-        },
-        "filter_status": {
-          "type": "string",
-          "enum": [
-            "passed",
-            "failed",
-            "skipped",
-            "pending"
-          ]
-        },
-        "filter_kind": {
-          "type": "string",
-          "enum": [
-            "manual",
-            "automated"
-          ]
-        },
-        "filter_user": {
-          "type": [
-            "integer",
-            "string"
-          ]
-        },
-        "filter_priority": {
-          "type": "string",
-          "enum": [
-            "low",
-            "normal",
-            "important",
-            "high",
-            "critical"
-          ]
-        },
-        "filter_substatus": {
-          "type": "string"
-        },
-        "filter_search": {
-          "type": "string"
-        },
-        "page": {
-          "type": "integer",
-          "minimum": 1
-        },
-        "per_page": {
-          "type": "integer",
-          "minimum": 1,
-          "maximum": 100
-        },
-        "filter_message": {
-          "type": "boolean"
-        },
-        "filter_link": {
-          "type": "boolean"
-        },
-        "filter_finished_at_date_range": {
-          "type": "string"
-        },
-        "tags": {
-          "type": [
-            "array",
-            "string"
-          ],
-          "items": {
-            "type": "string"
-          }
-        },
-        "labels": {
-          "type": [
-            "array",
-            "string"
-          ],
-          "items": {
-            "type": "string"
-          }
-        },
-        "envs": {
-          "type": [
-            "array",
-            "string"
-          ],
-          "items": {
-            "type": "string"
-          }
-        },
-        "rungroups": {
-          "type": [
-            "array",
-            "string"
-          ],
-          "items": {
-            "type": "string"
-          }
-        },
-        "defects": {
-          "type": "string",
-          "enum": [
-            "has_defects",
-            "without_defects"
-          ]
-        }
-      },
-      "additionalProperties": false
-    }
-  },
   {
     "name": "testruns_issues_list",
     "description": "List linked issues for a testrun (/api/v2/{project_id}/issues?testrun_id=...)",

package/src/mcp/definitions/tests.js

@@ -59,7 +59,14 @@ export const TESTS_TOOLS = [
           "type": "string"
         },
         "priority": {
-          "type": "string"
+          "type": "string",
+          "enum": [
+            "low",
+            "normal",
+            "important",
+            "high",
+            "critical"
+          ]
         },
         "assigned_to": {
           "type": "string"
@@ -68,7 +75,12 @@ export const TESTS_TOOLS = [
           "type": "string"
         },
         "state": {
-          "type": "string"
+          "type": "string",
+          "enum": [
+            "manual",
+            "detached",
+            "automated"
+          ]
         },
         "link": {
           "type": "array",
@@ -135,7 +147,14 @@ export const TESTS_TOOLS = [
           "type": "string"
         },
         "priority": {
-          "type": "string"
+          "type": "string",
+          "enum": [
+            "low",
+            "normal",
+            "important",
+            "high",
+            "critical"
+          ]
         },
         "assigned_to": {
           "type": "string"
@@ -144,7 +163,12 @@ export const TESTS_TOOLS = [
           "type": "string"
         },
         "state": {
-          "type": "string"
+          "type": "string",
+          "enum": [
+            "manual",
+            "detached",
+            "automated"
+          ]
         },
         "sync": {
           "type": "boolean"
@@ -207,29 +231,6 @@ export const TESTS_TOOLS = [
       "additionalProperties": false
     }
   },
-  {
-    "name": "tests_search",
-    "description": `Search tests using TQL (delegates to tests_list). ${TESTS_TQL_REFERENCE}`,
-    "inputSchema": {
-      "type": "object",
-      "properties": {
-        "page": {
-          "type": "integer",
-          "minimum": 1
-        },
-        "per_page": {
-          "type": "integer",
-          "minimum": 1,
-          "maximum": 100
-        },
-        "tql": {
-          "type": "string",
-          "description": TESTS_TQL_INPUT_DESCRIPTION
-        }
-      },
-      "additionalProperties": false
-    }
-  },
   {
     "name": "tests_issues_list",
     "description": "List linked issues for a test (/api/v2/{project_id}/issues?test_id=...)",

package/src/mcp/definitions/tql-reference.js

@@ -89,62 +89,42 @@ const RUNS_TQL_EXAMPLES = [
 const COMMON_TQL_SYNTAX =
   "Supported syntax includes logical operators `and`, `or`, `not`, equality operators `==` and `!=`, list membership `in [...]`, `%` for partial text match on supported text fields, and parentheses for grouping. Ordered comparisons `>`, `<`, `>=`, `<=` are for ordered fields such as `priority`, dates, and numeric counters/durations. Use quotes for string values, for example `state == 'automated'`.";
 
-export const TESTS_TQL_REFERENCE =
-  `TQL (Testomat.io Query Language) is a string expression passed in \`tql\` to filter tests. ${COMMON_TQL_SYNTAX} ` +
-  `Documented test variables: ${TESTS_TQL_VARIABLES.map((item) => `\`${item}\``).join(', ')}. ` +
-  `Documented examples: ${TESTS_TQL_EXAMPLES.map((item) => `\`${item}\``).join(', ')}. ` +
-  'Do not invent undocumented fields or syntax. If a query fails, simplify it to one documented predicate.';
+const TESTS_TQL_FIELDS = TESTS_TQL_VARIABLES.join(', ');
+const RUNS_TQL_FIELDS = RUNS_TQL_VARIABLES.join(', ');
 
-export const TESTS_TQL_INPUT_DESCRIPTION =
-  `TQL filter for tests. Documented variables: ${TESTS_TQL_VARIABLES.map((item) => `\`${item}\``).join(', ')}. ` +
-  `Examples: ${TESTS_TQL_EXAMPLES.map((item) => `\`${item}\``).join(', ')}.`;
+export const TQL_FULL_REFERENCE = [
+  'TQL (Testomat.io Query Language) is a string expression used to filter tests and runs.',
+  COMMON_TQL_SYNTAX,
+  '',
+  `Tests filter variables: ${TESTS_TQL_VARIABLES.map((v) => `\`${v}\``).join(', ')}.`,
+  `Tests examples: ${TESTS_TQL_EXAMPLES.map((e) => `\`${e}\``).join(', ')}.`,
+  '',
+  `Runs filter variables: ${RUNS_TQL_VARIABLES.map((v) => `\`${v}\``).join(', ')}.`,
+  'Runs also support boolean flags used without comparison, e.g. `failed`, `finished`, `automated`, `with_defect`.',
+  `Runs examples: ${RUNS_TQL_EXAMPLES.map((e) => `\`${e}\``).join(', ')}.`,
+  '',
+  'Parameter name: tests/runs/plans use `tql`; analytics tools use `q`.',
+  'Do not invent undocumented fields or syntax. If a query fails, simplify it to one documented predicate.',
+].join('\n');
 
+export const TESTS_TQL_REFERENCE =
+  'Filter tests with `tql` (TQL); call `tql_help` for the syntax and full field list.';
 export const RUNS_TQL_REFERENCE =
-  `TQL (Testomat.io Query Language) is a string expression passed in \`tql\` to filter runs. ${COMMON_TQL_SYNTAX} ` +
-  'Runs also support boolean flags without comparison such as `failed`, `finished`, `automated`, or `with_defect`. ' +
-  `Documented run variables: ${RUNS_TQL_VARIABLES.map((item) => `\`${item}\``).join(', ')}. ` +
-  `Documented examples: ${RUNS_TQL_EXAMPLES.map((item) => `\`${item}\``).join(', ')}. ` +
-  'Do not invent undocumented fields or syntax. If a query fails, simplify it to one documented predicate.';
-
-export const RUNS_TQL_INPUT_DESCRIPTION =
-  `TQL filter for runs. Documented variables: ${RUNS_TQL_VARIABLES.map((item) => `\`${item}\``).join(', ')}. ` +
-  `Examples: ${RUNS_TQL_EXAMPLES.map((item) => `\`${item}\``).join(', ')}.`;
-
+  'Filter runs with `tql` (TQL); runs also accept boolean flags. Call `tql_help` for the syntax and full field list.';
 export const PLANS_TQL_REFERENCE =
-  `TQL (Testomat.io Query Language) is a string expression passed in \`tql\` to select tests included in a plan. ${COMMON_TQL_SYNTAX} ` +
-  `Plan TQL uses documented test variables: ${TESTS_TQL_VARIABLES.map((item) => `\`${item}\``).join(', ')}. ` +
-  `Documented examples: ${TESTS_TQL_EXAMPLES.map((item) => `\`${item}\``).join(', ')}. ` +
-  'Use `tql` when you want the API to resolve matching tests automatically instead of sending explicit `test_ids`. Do not invent undocumented fields or syntax. If a query fails, simplify it to one documented predicate.';
-
-export const PLANS_TQL_INPUT_DESCRIPTION =
-  'TQL filter for selecting tests included in the plan. ' +
-  `Documented test variables: ${TESTS_TQL_VARIABLES.map((item) => `\`${item}\``).join(', ')}. ` +
-  `Examples: ${TESTS_TQL_EXAMPLES.map((item) => `\`${item}\``).join(', ')}.`;
-
+  'Select tests for the plan with `tql` (TQL); the API resolves matching tests. Call `tql_help` for the syntax and full field list.';
 export const ANALYTICS_TESTS_TQL_REFERENCE =
-  `TQL (Testomat.io Query Language) is a string expression passed in \`q\` to filter enterprise analytics test reports. ${COMMON_TQL_SYNTAX} ` +
-  'For analytics tools, the API parameter name is `q`, not `tql`. ' +
-  `Documented analytics test variables: ${TESTS_TQL_VARIABLES.map((item) => `\`${item}\``).join(', ')}. ` +
-  `Documented examples: ${TESTS_TQL_EXAMPLES.map((item) => `\`${item}\``).join(', ')}. ` +
-  'Do not invent undocumented fields or syntax. If a query fails, simplify it to one documented predicate.';
-
-export const ANALYTICS_TESTS_TQL_INPUT_DESCRIPTION =
-  'TQL filter for analytics test reports. The API parameter name is `q`, not `tql`. ' +
-  `Documented variables: ${TESTS_TQL_VARIABLES.map((item) => `\`${item}\``).join(', ')}. ` +
-  `Examples: ${TESTS_TQL_EXAMPLES.map((item) => `\`${item}\``).join(', ')}.`;
-
+  'Filter analytics test reports with `q` (TQL). Call `tql_help` for the syntax and full field list.';
 export const ANALYTICS_STATS_TQL_REFERENCE =
-  `TQL (Testomat.io Query Language) is a string expression passed in \`q\` to filter enterprise analytics aggregated reports. ${COMMON_TQL_SYNTAX} ` +
-  'For analytics tools, the API parameter name is `q`, not `tql`. ' +
-  'According to the official Analytics docs, analytics queries are configured using supported query variables for two data sources: `Tests Variables` and `Runs Variables`. ' +
-  `Documented Tests Variables: ${TESTS_TQL_VARIABLES.map((item) => `\`${item}\``).join(', ')}. ` +
-  `Documented Runs Variables: ${RUNS_TQL_VARIABLES.map((item) => `\`${item}\``).join(', ')}. ` +
-  `Documented Tests examples: ${TESTS_TQL_EXAMPLES.map((item) => `\`${item}\``).join(', ')}. ` +
-  `Documented Runs examples: ${RUNS_TQL_EXAMPLES.map((item) => `\`${item}\``).join(', ')}. ` +
-  'Use Tests Variables for test-centric filters and Runs Variables for run-centric filters such as `plan`, `rungroup`, `env`, `finished_at`, or `has_test_tag`. Do not invent undocumented fields or syntax. If a query fails, simplify it to one documented predicate.';
+  'Filter analytics aggregated reports with `q` (TQL; tests or runs variables). Call `tql_help` for the syntax and full field list.';
 
+export const TESTS_TQL_INPUT_DESCRIPTION =
+  `TQL filter for tests. Fields: ${TESTS_TQL_FIELDS}. Call \`tql_help\` for syntax. Examples: \`priority == 'high'\`, \`state == 'automated'\`, \`suite % 'Checkout'\`.`;
+export const RUNS_TQL_INPUT_DESCRIPTION =
+  `TQL filter for runs. Fields: ${RUNS_TQL_FIELDS}. Call \`tql_help\` for syntax. Examples: \`finished and with_defect\`, \`env in ['Windows', 'Linux']\`, \`has_retries > 2\`.`;
+export const PLANS_TQL_INPUT_DESCRIPTION =
+  `TQL to select tests for the plan. Fields: ${TESTS_TQL_FIELDS}. Call \`tql_help\` for syntax. Examples: \`priority == 'high'\`, \`tag in ['smoke', 'stage1']\`.`;
+export const ANALYTICS_TESTS_TQL_INPUT_DESCRIPTION =
+  `TQL filter (param \`q\`) for analytics test reports. Fields: ${TESTS_TQL_FIELDS}. Call \`tql_help\` for syntax. Examples: \`priority == 'high'\`, \`state == 'automated'\`.`;
 export const ANALYTICS_STATS_TQL_INPUT_DESCRIPTION =
-  'TQL filter for analytics aggregated reports. The API parameter name is `q`, not `tql`. ' +
-  `Documented Tests Variables: ${TESTS_TQL_VARIABLES.map((item) => `\`${item}\``).join(', ')}. ` +
-  `Documented Runs Variables: ${RUNS_TQL_VARIABLES.map((item) => `\`${item}\``).join(', ')}. ` +
-  `Examples: ${TESTS_TQL_EXAMPLES.map((item) => `\`${item}\``).join(', ')}, ${RUNS_TQL_EXAMPLES.map((item) => `\`${item}\``).join(', ')}.`;
+  `TQL filter (param \`q\`) for analytics reports. Test fields: ${TESTS_TQL_FIELDS}. Run fields: ${RUNS_TQL_FIELDS}. Call \`tql_help\` for syntax. Examples: \`priority == 'high'\`, \`finished_at >= '2025-07-01' and failed\`.`;

package/src/mcp/list-projection.js

@@ -0,0 +1,140 @@
+/**
+ * Slim projection for list-tool responses.
+ *
+ * List tools return only what an index view needs: entity-specific heavy fields
+ * and null values are dropped.
+ * `verbose:true` returns the full body; `fields:[...]` selects a custom field set.
+ * Every shaped response carries a `_view` marker so the caller knows it is partial.
+ */
+
+const HEAVY_FIELDS_BY_ENTITY = {
+  tests: new Set(['description', 'code', 'cleanTitle', 'publicTitle']),
+  suites: new Set(['description', 'code', 'cleanTitle', 'publicTitle']),
+  runs: new Set(['description']),
+  testruns: new Set(['description', 'code']),
+  rungroups: new Set(['description']),
+  steps: new Set(['description']),
+  snippets: new Set(['description']),
+  plans: new Set(['description']),
+  requirements: new Set(['description']),
+  analytics_tests: new Set(['description', 'code', 'cleanTitle', 'publicTitle']),
+};
+
+function isNullish(value) {
+  return value === null || value === undefined;
+}
+
+function pickFields(item, fields) {
+  const result = {};
+  for (const key of fields) {
+    if (!(key in item)) continue;
+    const value = item[key];
+    if (isNullish(value)) continue;
+    result[key] = value;
+  }
+  return result;
+}
+
+function stripHeavy(item, heavyFields) {
+  const result = {};
+  for (const [key, value] of Object.entries(item)) {
+    if (heavyFields.has(key)) continue;
+    if (isNullish(value)) continue;
+    result[key] = value;
+  }
+  return result;
+}
+
+function mapItems(items, fn) {
+  return items.map((item) =>
+    item && typeof item === 'object' && !Array.isArray(item) ? fn(item) : item
+  );
+}
+
+function applyToEnvelope(payload, fn) {
+  if (!payload || typeof payload !== 'object') return payload;
+  if (Array.isArray(payload)) return mapItems(payload, fn);
+  if (Array.isArray(payload.data)) {
+    return { ...payload, data: mapItems(payload.data, fn) };
+  }
+  return payload;
+}
+
+const VIEW_NOTE =
+  'Entity-specific heavy fields and null values removed. Pass verbose:true for full bodies or fields:[...] to select fields.';
+
+function withViewMarker(result, note = VIEW_NOTE) {
+  if (
+    result &&
+    typeof result === 'object' &&
+    !Array.isArray(result) &&
+    Array.isArray(result.data)
+  ) {
+    return { ...result, _view: note };
+  }
+  return result;
+}
+
+/**
+ * Shape a list payload: drop entity-specific heavy and null fields by default, full body on `verbose`,
+ * custom field set on `fields`. A `_view` marker is added to shaped envelopes.
+ *
+ * @param {*} payload              raw API response ({ data, meta } or a bare array)
+ * @param {{ verbose?: boolean, fields?: string[], entity?: string }} [opts]
+ */
+export function slimList(payload, { verbose = false, fields, entity } = {}) {
+  if (verbose) {
+    return payload;
+  }
+  if (Array.isArray(fields) && fields.length) {
+    return withViewMarker(
+      applyToEnvelope(payload, (item) => pickFields(item, fields)),
+      `Custom fields [${fields.join(', ')}]. Pass verbose:true for the full object.`
+    );
+  }
+  const heavyFields = HEAVY_FIELDS_BY_ENTITY[entity] ?? new Set();
+  return withViewMarker(applyToEnvelope(payload, (item) => stripHeavy(item, heavyFields)));
+}
+
+const LIST_OPTION_PROPERTIES = {
+  verbose: {
+    type: 'boolean',
+    default: false,
+    description:
+      'Return full response bodies. Default strips entity-specific heavy fields and null values; set true when you need those.',
+  },
+  fields: {
+    type: 'array',
+    items: { type: 'string' },
+    description:
+      'Fields to keep per item (e.g. ["id","title","status","message"]). Ignored when verbose is true.',
+  },
+};
+
+/**
+ * Inject `verbose`/`fields` input params into every list-style tool definition so the
+ * model can opt into full bodies or a custom projection. Returns shallow copies; the
+ * source definitions are not mutated.
+ *
+ * @param {Array} tools
+ * @param {{ extraNames?: string[] }} [options]  additional tool names to augment
+ */
+export function withListOptions(tools, { extraNames = [] } = {}) {
+  return tools.map((tool) => {
+    if (!tool || !tool.name) return tool;
+    const isListStyle = tool.name.endsWith('_list') || extraNames.includes(tool.name);
+    if (!isListStyle) return tool;
+
+    const inputSchema = tool.inputSchema || { type: 'object', properties: {} };
+    const properties = { ...(inputSchema.properties || {}), ...LIST_OPTION_PROPERTIES };
+
+    return {
+      ...tool,
+      description: `${tool.description ?? ''} Entity-specific heavy fields are stripped by default; verbose:true for full bodies.`.trim(),
+      inputSchema: {
+        ...inputSchema,
+        properties,
+      },
+    };
+  });
+}

package/src/mcp/registry/attachments.js

@@ -0,0 +1,40 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import { ATTACHMENT_RESOURCE_KEYS } from '../configs/attachments-config.js';
+
+export const attachmentMethods = {
+  listAttachmentsForKey({ resourceKey, resourceId }) {
+    this.assertSupportedAttachmentResourceKey(resourceKey);
+    return this.apiClient.list('attachments', { [resourceKey]: resourceId });
+  },
+
+  async uploadAttachmentForKey({ resourceKey, resourceId, filePath }) {
+    this.assertSupportedAttachmentResourceKey(resourceKey);
+    const formData = await this.buildAttachmentFormData(filePath);
+
+    return this.apiClient.createMultipart('attachments', formData, {
+      [resourceKey]: resourceId,
+    });
+  },
+
+  deleteAttachmentForKey({ resourceKey, resourceId, attachmentId }) {
+    this.assertSupportedAttachmentResourceKey(resourceKey);
+    return this.apiClient.delete('attachments', attachmentId, { [resourceKey]: resourceId });
+  },
+
+  async buildAttachmentFormData(filePath) {
+    const resolvedPath = path.resolve(String(filePath));
+    const data = await fs.readFile(resolvedPath);
+    const formData = new FormData();
+
+    formData.append('file', new Blob([data]), path.basename(resolvedPath));
+    return formData;
+  },
+
+  assertSupportedAttachmentResourceKey(resourceKey) {
+    if (!ATTACHMENT_RESOURCE_KEYS.includes(resourceKey)) {
+      throw new Error(`Unsupported attachment resource key: ${resourceKey}`);
+    }
+  },
+};

package/src/mcp/registry/handlers.js

@@ -1,17 +1,23 @@
 import { ENTITY_CRUD_CONFIGS } from '../configs/entity-crud-config.js';
+import { ATTACHMENT_SCOPED_TOOL_CONFIGS } from '../configs/attachments-config.js';
 import { ISSUE_SCOPED_TOOL_CONFIGS } from '../configs/issues-config.js';
+import { slimList } from '../list-projection.js';
 
 export const handlerMethods = {
   registerEntityCrudHandlers(handlers) {
     for (const spec of ENTITY_CRUD_CONFIGS) {
-      const { toolPrefix, resource, idArg, listMethod, searchMethod } = spec;
-
-      handlers[`${toolPrefix}_list`] = async (args = {}) =>
-        this.asText(await this[listMethod](args));
-      if (searchMethod) {
-        handlers[`${toolPrefix}_search`] = async (args = {}) =>
-          this.asText(await this[searchMethod](args));
-      }
+      const { toolPrefix, resource, idArg, listMethod } = spec;
+
+      handlers[`${toolPrefix}_list`] = async (args = {}) => {
+        const { verbose, fields, ...listArgs } = args;
+        return this.asText(
+          slimList(await this[listMethod](listArgs), {
+            verbose,
+            fields,
+            entity: toolPrefix,
+          })
+        );
+      };
       handlers[`${toolPrefix}_get`] = async (args = {}) =>
         this.asText(await this.apiClient.get(resource, this.pickRequiredArg(args, idArg)));
       handlers[`${toolPrefix}_create`] = async (args = {}) =>
@@ -30,13 +36,16 @@ export const handlerMethods = {
     for (const { toolPrefix, resourceKey } of ISSUE_SCOPED_TOOL_CONFIGS) {
       handlers[`${toolPrefix}_issues_list`] = async (args = {}) =>
         this.asText(
-          await this.listIssuesForKey({
-            resourceKey,
-            resourceId: this.pickRequiredArg(args, resourceKey),
-            page: args.page,
-            per_page: args.per_page,
-            source: args.source,
-          })
+          slimList(
+            await this.listIssuesForKey({
+              resourceKey,
+              resourceId: this.pickRequiredArg(args, resourceKey),
+              page: args.page,
+              per_page: args.per_page,
+              source: args.source,
+            }),
+            { verbose: args.verbose, fields: args.fields, entity: 'issues' }
+          )
         );
 
       handlers[`${toolPrefix}_issues_link`] = async (args = {}) =>
@@ -54,17 +63,61 @@ export const handlerMethods = {
     }
   },
 
+  registerScopedAttachmentHandlers(handlers) {
+    for (const { toolPrefix, resourceKey } of ATTACHMENT_SCOPED_TOOL_CONFIGS) {
+      handlers[`${toolPrefix}_attachments_list`] = async (args = {}) =>
+        this.asText(
+          slimList(
+            await this.listAttachmentsForKey({
+              resourceKey,
+              resourceId: this.pickRequiredArg(args, resourceKey),
+            }),
+            { verbose: args.verbose, fields: args.fields, entity: 'attachments' }
+          )
+        );
+
+      handlers[`${toolPrefix}_attachments_upload`] = async (args = {}) =>
+        this.asText(
+          await this.uploadAttachmentForKey({
+            resourceKey,
+            resourceId: this.pickRequiredArg(args, resourceKey),
+            filePath: this.pickRequiredArg(args, 'file_path'),
+          })
+        );
+
+      handlers[`${toolPrefix}_attachments_delete`] = async (args = {}) =>
+        this.asText(
+          await this.deleteAttachmentForKey({
+            resourceKey,
+            resourceId: this.pickRequiredArg(args, resourceKey),
+            attachmentId: this.pickRequiredArg(args, 'attachment_id'),
+          })
+        );
+    }
+  },
+
   registerGlobalHandlers(handlers) {
-    handlers.tags_list = async () => this.asText(await this.listTags());
+    handlers.project_info = async () => this.asText(await this.apiClient.get('info'));
+
+    handlers.tags_list = async (args = {}) =>
+      this.asText(slimList(await this.listTags(), { ...args, entity: 'tags' }));
     handlers.tags_get = async ({ tag_id: tagId }) => this.asText(await this.getTagByTitle(tagId));
-    handlers.tags_search = async (args = {}) => this.asText(await this.searchTags(args));
 
-    handlers.milestones_list = async (args = {}) => this.asText(await this.listMilestones(args));
+    handlers.milestones_list = async (args = {}) => {
+      const { verbose, fields, ...listArgs } = args;
+      return this.asText(
+        slimList(await this.listMilestones(listArgs), { verbose, fields, entity: 'milestones' })
+      );
+    };
     handlers.milestones_get = async ({ milestone_id: milestoneId }) =>
       this.asText(await this.apiClient.get('milestones', milestoneId));
 
-    handlers.issues_list = async (args = {}) => this.asText(await this.listIssues(args));
-    handlers.issues_search = async (args = {}) => this.asText(await this.searchIssues(args));
+    handlers.issues_list = async (args = {}) => {
+      const { verbose, fields, ...listArgs } = args;
+      return this.asText(
+        slimList(await this.listIssues(listArgs), { verbose, fields, entity: 'issues' })
+      );
+    };
     handlers.issues_create = async (args = {}) => this.asText(await this.createIssue(args));
     handlers.issues_delete = async ({ issue_id: issueId, type }) =>
       this.asText(await this.apiClient.delete('issues', issueId, { type }));

package/src/mcp/registry/issues.js

@@ -11,10 +11,6 @@ export const issueMethods = {
     });
   },
 
-  searchIssues(args = {}) {
-    return this.listIssues(args);
-  },
-
   createIssue({ url, jira_id: jiraId, ...resourceQuery } = {}) {
     this.validateIssueResourceQuery(resourceQuery, { allowEmpty: false, allowMany: false });
     return this.linkIssueToResource({