yontrack-mcp 1.14.2 → 1.15.0

package/README.md

@@ -46,10 +46,14 @@ Read-only tools answering the questions an agent asks before promoting or deploy
 | `dependency_builds_at_level` | Which builds of a dependency project are at a given promotion level? |
 | `agent_policy` | What may the agent behind the token do on a project? (`{ "agent": false }` for a human token) |
 
-These tools are **only available with Yontrack 6**. The server detects them by probing the Yontrack schema (for the `Readiness` and `AgentPolicy` types), not by reading its version: on Yontrack 5 they are not listed at all. The probe runs once per process; when Yontrack cannot be reached, the tools are hidden and the next request probes again (in `stdio` mode the server is built once, so restart it). Set `YONTRACK_AGENT_TOOLS` to `true` or `false` to skip the probe.
+These tools are **only available with Yontrack 6**. The server detects them by probing the Yontrack schema (for the `Readiness` and `AgentPolicy` types), not by reading its version: on Yontrack 5 they are not listed at all. The probe runs once per process; when Yontrack cannot be reached, the tools are hidden and the next request probes again (in `stdio` mode the server is built once, so restart it). Set `YONTRACK_AGENT_TOOLS` to `true` or `false` to force them on or off (the probe still runs, for the [search](#search)).
 
 On Yontrack 6, the `yontrack://schema` resource also serves the Yontrack 6 schema instead of the Yontrack 5 one.
 
+### Search
+
+`search`, `search_commits` and `search_issues` return `{ pageItems, pageInfo: { totalSize } }` on both Yontrack 5 and 6. On Yontrack 5, a search without `type` runs one search per result type and keeps the best results. On Yontrack 6 (detected by probing the schema for the `SearchResults` type, whatever `YONTRACK_AGENT_TOOLS` says), they send a single request and also return `capped` (`true` when `totalSize` is a lower bound) and `message` (e.g. when the search index is being built). Yontrack 6 requires at least 2 characters to search for.
+
 ### Agent sessions
 
 When an agent uses this server with the token of an **agent account** (Yontrack 6), Yontrack can attribute what it records (builds, validations, promotions…) to the agent's session. The server sends the `X-Yontrack-Agent-Session` and `X-Yontrack-Agent-Session-Link` headers on every request to Yontrack, taken from:
@@ -324,7 +328,7 @@ An API token is required to authenticate against Yontrack. To generate one, log
 | `YONTRACK_URL`               | Yes      | —                             | URL of the Yontrack instance (e.g. `https://yontrack.example.com`)                                                                                                                   |
 | `YONTRACK_TOKEN`             | Yes      | —                             | API token for authenticating against Yontrack                                                                                                                                        |
 | `YONTRACK_MUTATIONS_ENABLED` | No       | `false`                       | Set to `true` to enable mutation tools (create/promote/link operations). When unset or `false`, only read-only query tools are registered.                                           |
-| `YONTRACK_AGENT_TOOLS`       | No       | `auto`                        | Agent-context tools: `auto` registers them when Yontrack 6 is detected, `true` always, `false` never. See [Agent-context tools](#agent-context-tools-yontrack-6).                       |
+| `YONTRACK_AGENT_TOOLS`       | No       | `auto`                        | Agent-context tools: `auto` registers them when Yontrack 6 is detected, `true` always, `false` never. Does not affect the [search](#search). See [Agent-context tools](#agent-context-tools-yontrack-6). |
 | `YONTRACK_UI_URL`            | No       | —                             | URL of the Yontrack UI (e.g. `https://yontrack.example.com`), used for the links returned by the agent-context tools. Links are left out when unset.                                |
 | `YONTRACK_AGENT_SESSION`     | No       | —                             | Agent session ID sent to Yontrack when the incoming MCP request carries no session headers. See [Agent sessions](#agent-sessions).                                                |
 | `YONTRACK_AGENT_SESSION_LINK`| No       | —                             | Link to the agent session (absolute `https` URL), sent together with `YONTRACK_AGENT_SESSION`.                                                                                      |

package/build/capabilities.js

@@ -4,21 +4,24 @@ const PROBE = `
   query ProbeCapabilities {
     readiness: __type(name: "Readiness") { name }
     agentPolicy: __type(name: "AgentPolicy") { name }
+    searchResults: __type(name: "SearchResults") { name }
   }
 `;
-const NONE = { agentTools: false, agentPolicy: false };
-const ALL = { agentTools: true, agentPolicy: true };
+const OVERRIDES = {
+    auto: undefined,
+    true: { agentTools: true, agentPolicy: true },
+    false: { agentTools: false, agentPolicy: false },
+};
 /**
  * A definite answer is cached for the life of the probe. A probe error is not
- * cached: the tools are hidden for that call and the next call probes again.
+ * cached: the tools are hidden, the search falls back to the Yontrack 5 API
+ * (still accepted by Yontrack 6) for that call, and the next call probes again.
+ * `YONTRACK_AGENT_TOOLS` overrides the agent-context tools only.
  */
 export function createCapabilityProbe(mode) {
+    const override = OVERRIDES[mode];
     let cached;
     async function get() {
-        if (mode === "true")
-            return ALL;
-        if (mode === "false")
-            return NONE;
         if (cached)
             return cached;
         try {
@@ -26,12 +29,14 @@ export function createCapabilityProbe(mode) {
             cached = {
                 agentTools: data.readiness != null,
                 agentPolicy: data.agentPolicy != null,
+                ...override,
+                searchResults: data.searchResults != null,
             };
             return cached;
         }
         catch (err) {
-            process.stderr.write(`Could not probe Yontrack capabilities, hiding agent-context tools for now: ${err instanceof Error ? err.message : String(err)}\n`);
-            return NONE;
+            process.stderr.write(`Could not probe Yontrack capabilities${override ? "" : ", hiding agent-context tools for now"}: ${err instanceof Error ? err.message : String(err)}\n`);
+            return { agentTools: false, agentPolicy: false, ...override, searchResults: false };
         }
     }
     return { get };

package/build/capabilities.test.js

@@ -13,46 +13,64 @@ describe("capability probe (auto)", () => {
         mockRequest.mockResolvedValueOnce({
             readiness: { name: "Readiness" },
             agentPolicy: { name: "AgentPolicy" },
+            searchResults: { name: "SearchResults" },
         });
         const probe = createCapabilityProbe("auto");
-        expect(await probe.get()).toEqual({ agentTools: true, agentPolicy: true });
+        expect(await probe.get()).toEqual({ agentTools: true, agentPolicy: true, searchResults: true });
     });
     it("detects Yontrack 5 when neither type exists", async () => {
-        mockRequest.mockResolvedValueOnce({ readiness: null, agentPolicy: null });
+        mockRequest.mockResolvedValueOnce({ readiness: null, agentPolicy: null, searchResults: null });
         const probe = createCapabilityProbe("auto");
-        expect(await probe.get()).toEqual({ agentTools: false, agentPolicy: false });
+        expect(await probe.get()).toEqual({ agentTools: false, agentPolicy: false, searchResults: false });
     });
     it("enables agent tools without agent_policy when only Readiness exists", async () => {
-        mockRequest.mockResolvedValueOnce({ readiness: { name: "Readiness" }, agentPolicy: null });
+        mockRequest.mockResolvedValueOnce({
+            readiness: { name: "Readiness" },
+            agentPolicy: null,
+            searchResults: { name: "SearchResults" },
+        });
         const probe = createCapabilityProbe("auto");
-        expect(await probe.get()).toEqual({ agentTools: true, agentPolicy: false });
+        expect(await probe.get()).toEqual({ agentTools: true, agentPolicy: false, searchResults: true });
     });
     it("caches a definite answer for the life of the probe", async () => {
-        mockRequest.mockResolvedValueOnce({ readiness: null, agentPolicy: null });
+        mockRequest.mockResolvedValueOnce({ readiness: null, agentPolicy: null, searchResults: null });
         const probe = createCapabilityProbe("auto");
         await probe.get();
         await probe.get();
         expect(mockRequest).toHaveBeenCalledTimes(1);
     });
-    it("hides the tools on a probe error and probes again next time", async () => {
+    it("hides the tools and falls back to the v5 search on a probe error, and probes again next time", async () => {
         mockRequest
             .mockRejectedValueOnce(new Error("connection refused"))
-            .mockResolvedValueOnce({ readiness: { name: "Readiness" }, agentPolicy: { name: "AgentPolicy" } });
+            .mockResolvedValueOnce({
+            readiness: { name: "Readiness" },
+            agentPolicy: { name: "AgentPolicy" },
+            searchResults: { name: "SearchResults" },
+        });
         const probe = createCapabilityProbe("auto");
-        expect(await probe.get()).toEqual({ agentTools: false, agentPolicy: false });
-        expect(await probe.get()).toEqual({ agentTools: true, agentPolicy: true });
+        expect(await probe.get()).toEqual({ agentTools: false, agentPolicy: false, searchResults: false });
+        expect(await probe.get()).toEqual({ agentTools: true, agentPolicy: true, searchResults: true });
         expect(mockRequest).toHaveBeenCalledTimes(2);
     });
 });
 describe("capability probe (override)", () => {
-    it("forces the tools on without probing when set to true", async () => {
+    it("forces the tools on when set to true, still probing the search API", async () => {
+        mockRequest.mockResolvedValueOnce({ readiness: null, agentPolicy: null, searchResults: null });
         const probe = createCapabilityProbe("true");
-        expect(await probe.get()).toEqual({ agentTools: true, agentPolicy: true });
-        expect(mockRequest).not.toHaveBeenCalled();
+        expect(await probe.get()).toEqual({ agentTools: true, agentPolicy: true, searchResults: false });
     });
-    it("forces the tools off without probing when set to false", async () => {
+    it("forces the tools off when set to false, still probing the search API", async () => {
+        mockRequest.mockResolvedValueOnce({
+            readiness: { name: "Readiness" },
+            agentPolicy: { name: "AgentPolicy" },
+            searchResults: { name: "SearchResults" },
+        });
         const probe = createCapabilityProbe("false");
-        expect(await probe.get()).toEqual({ agentTools: false, agentPolicy: false });
-        expect(mockRequest).not.toHaveBeenCalled();
+        expect(await probe.get()).toEqual({ agentTools: false, agentPolicy: false, searchResults: true });
+    });
+    it("keeps the override on a probe error, with the v5 search", async () => {
+        mockRequest.mockRejectedValueOnce(new Error("connection refused"));
+        const probe = createCapabilityProbe("true");
+        expect(await probe.get()).toEqual({ agentTools: true, agentPolicy: true, searchResults: false });
     });
 });

package/build/graphql-documents.test.js

@@ -9,13 +9,14 @@ const schemas = {
     v5: buildSchema(readFileSync(root("yontrack-v5.graphql"), "utf-8")),
     v6: buildSchema(readFileSync(root("yontrack-v6.graphql"), "utf-8")),
 };
-// Yontrack 6 only: never sent to a v5 server (see docs/adr/0001-agent-context-tools-v6-only.md)
-const V6_ONLY = new Set(["src/tools/agent-context.ts", "src/tools/agent-context-support.ts"]);
-// Known invalid documents, as "version file NAME": these must be fixed, then removed from here
-const KNOWN_INVALID = new Set([
-    // search(type:) is required on v5, but the `search` tool sends it only when given
-    "v5 src/tools/search.ts SEARCH",
+// Yontrack 6 only: never sent to a v5 server (see docs/adr/0001 and 0002)
+const V6_ONLY = new Set([
+    "src/tools/agent-context.ts",
+    "src/tools/agent-context-support.ts",
+    "src/tools/search-results.ts",
 ]);
+// Known invalid documents, as "version file NAME": these must be fixed, then removed from here
+const KNOWN_INVALID = new Set([]);
 const sourceFiles = [
     "src/capabilities.ts",
     "src/utils.ts",
@@ -43,6 +44,7 @@ describe("GraphQL documents", () => {
         expect(names).toContain("CREATE_VALIDATION_RUN");
         expect(names).toContain("PROMOTE_BUILD");
         expect(names).toContain("READINESS");
+        expect(names).toContain("SEARCH_RESULTS");
     });
     it.each(cases.filter((c) => !c.known))("$file $name is valid against the $version schema", ({ text, version }) => {
         const errors = validate(schemas[version], parse(text)).map((e) => e.message);

package/build/server.test.js

@@ -12,14 +12,14 @@ async function connect(capabilities) {
 }
 describe("createServer", () => {
     it("exposes the agent-context tools and mentions them on Yontrack 6", async () => {
-        const client = await connect({ agentTools: true, agentPolicy: true });
+        const client = await connect({ agentTools: true, agentPolicy: true, searchResults: true });
         const names = (await client.listTools()).tools.map((t) => t.name);
         expect(names).toEqual(expect.arrayContaining(["list_projects", "build_readiness", "agent_policy"]));
         expect(client.getInstructions()).toContain("build_readiness");
         expect(client.getInstructions()).toContain("agent_policy");
     });
     it("hides the agent-context tools and does not mention them on Yontrack 5", async () => {
-        const client = await connect({ agentTools: false, agentPolicy: false });
+        const client = await connect({ agentTools: false, agentPolicy: false, searchResults: false });
         const names = (await client.listTools()).tools.map((t) => t.name);
         expect(names).toContain("list_projects");
         expect(names).not.toContain("build_readiness");

package/build/tools/agent-context.test.js

@@ -16,7 +16,7 @@ vi.mock("../config.js", () => ({
 const { gqlClient } = await import("../client.js");
 const { config } = await import("../config.js");
 const mockRequest = gqlClient.request;
-const V6 = { agentTools: true, agentPolicy: true };
+const V6 = { agentTools: true, agentPolicy: true, searchResults: true };
 function connect(capabilities = V6) {
     return createTestClient((server) => registerAgentContextTools(server, capabilities));
 }
@@ -460,13 +460,13 @@ describe("registration", () => {
         expect(await toolNames(V6)).toEqual(expect.arrayContaining([...AGENT_TOOLS, "agent_policy"]));
     });
     it("registers no agent-context tool on Yontrack 5", async () => {
-        expect(await toolNames({ agentTools: false, agentPolicy: false })).toEqual([]);
+        expect(await toolNames({ agentTools: false, agentPolicy: false, searchResults: true })).toEqual([]);
     });
     it("registers agent_policy on its own probe, independently of readiness", async () => {
-        expect(await toolNames({ agentTools: false, agentPolicy: true })).toEqual(["agent_policy"]);
+        expect(await toolNames({ agentTools: false, agentPolicy: true, searchResults: true })).toEqual(["agent_policy"]);
     });
     it("leaves out agent_policy when the instance has readiness but no agent policy", async () => {
-        const names = await toolNames({ agentTools: true, agentPolicy: false });
+        const names = await toolNames({ agentTools: true, agentPolicy: false, searchResults: true });
         expect(names).toEqual(expect.arrayContaining(AGENT_TOOLS));
         expect(names).not.toContain("agent_policy");
     });

package/build/tools/index.js

@@ -19,7 +19,7 @@ export function registerAllTools(server, capabilities) {
     registerPromotionLevelTools(server, mutationsEnabled);
     registerPromotionRunTools(server, mutationsEnabled);
     registerBuildLinkTools(server, mutationsEnabled);
-    registerSearchTools(server);
+    registerSearchTools(server, capabilities.searchResults);
     registerGraphQLTools(server, mutationsEnabled, capabilities.agentTools);
     registerAgentContextTools(server, capabilities);
 }

package/build/tools/search-results.js

@@ -0,0 +1,33 @@
+import { gqlClient } from "../client.js";
+// Yontrack 6 only: `query` and `types` replace the deprecated `token` and `type`,
+// and one request covers every type, best results first (see docs/adr/0002-search-api-by-capability.md)
+const SEARCH_RESULTS = `
+  query SearchResults($query: String!, $types: [String!], $size: Int) {
+    search(query: $query, types: $types, size: $size) {
+      items {
+        type { id name description }
+        title
+        description
+        accuracy
+        data
+      }
+      total
+      capped
+      message
+    }
+  }
+`;
+/** Searches the given type, or all of them, mapped to the Yontrack 5 page shape. */
+export async function searchResults(query, type, size) {
+    const { search } = await gqlClient.request(SEARCH_RESULTS, {
+        query,
+        size,
+        ...(type && { types: [type] }),
+    });
+    return {
+        pageItems: search.items,
+        pageInfo: { totalSize: search.total },
+        capped: search.capped,
+        message: search.message,
+    };
+}

package/build/tools/search.js

@@ -1,67 +1,76 @@
 import { z } from "zod";
 import { gqlClient } from "../client.js";
+import { searchResults } from "./search-results.js";
+// Yontrack 5 API: `type` is required on v5 (and deprecated, but still accepted, on v6).
+// On Yontrack 6, `searchResults` is used instead.
 const SEARCH = `
-  query Search($token: String!, $type: String, $size: Int) {
+  query Search($token: String!, $type: String!, $size: Int) {
     search(token: $token, type: $type, size: $size) {
       pageItems {
         type { id name description }
         title
         description
         accuracy
+        data
       }
       pageInfo { totalSize }
     }
   }
 `;
-const SEARCH_TYPED = `
-  query SearchTyped($token: String!, $type: String!, $size: Int) {
-    search(token: $token, type: $type, size: $size) {
-      pageItems {
-        type { id name description }
-        title
-        description
-        accuracy
-        data
-      }
-      pageInfo { totalSize }
-    }
+const SEARCH_RESULT_TYPES = `
+  query SearchResultTypes {
+    searchResultTypes { id }
   }
 `;
-export function registerSearchTools(server) {
+async function searchType(token, type, size) {
+    const data = await gqlClient.request(SEARCH, { token, type, size });
+    return data.search ?? { pageItems: [], pageInfo: { totalSize: 0 } };
+}
+/** Searches each type of result, keeping the best `size` results overall. */
+async function searchAllTypes(token, size) {
+    const { searchResultTypes } = await gqlClient.request(SEARCH_RESULT_TYPES);
+    const pages = await Promise.all(searchResultTypes.flatMap(({ id }) => (id ? [searchType(token, id, size)] : [])));
+    return {
+        pageItems: pages
+            .flatMap((page) => page.pageItems)
+            .sort((a, b) => (b.accuracy ?? 0) - (a.accuracy ?? 0))
+            .slice(0, size),
+        pageInfo: { totalSize: pages.reduce((total, page) => total + (page.pageInfo?.totalSize ?? 0), 0) },
+    };
+}
+/** `searchResultsAvailable`: the Yontrack 6 search API is available (`Capabilities.searchResults`). */
+export function registerSearchTools(server, searchResultsAvailable) {
+    const search = (token, type, size) => searchResultsAvailable
+        ? searchResults(token, type, size)
+        : type
+            ? searchType(token, type, size)
+            : searchAllTypes(token, size);
     server.tool("search", "Full-text search across all Yontrack entities (projects, branches, builds, etc.)", {
         token: z.string().describe("Search query"),
-        type: z.string().optional().describe("Entity type filter (e.g. 'project', 'build')"),
+        type: z
+            .string()
+            .optional()
+            .describe("Type of result to search for (e.g. 'project', 'build'); all types when omitted"),
         size: z.number().int().optional().default(10).describe("Max number of results"),
     }, async ({ token, type, size }) => {
-        const data = await gqlClient.request(SEARCH, { token, type, size });
         return {
-            content: [{ type: "text", text: JSON.stringify(data.search, null, 2) }],
+            content: [{ type: "text", text: JSON.stringify(await search(token, type, size), null, 2) }],
         };
     });
     server.tool("search_commits", "Search for SCM commits by keyword or commit message", {
         token: z.string().describe("Search query (keyword or commit message fragment)"),
         size: z.number().int().optional().default(10).describe("Max number of results"),
     }, async ({ token, size }) => {
-        const data = await gqlClient.request(SEARCH_TYPED, {
-            token,
-            type: "scm-commit",
-            size,
-        });
         return {
-            content: [{ type: "text", text: JSON.stringify(data.search, null, 2) }],
+            content: [{ type: "text", text: JSON.stringify(await search(token, "scm-commit", size), null, 2) }],
         };
     });
     server.tool("search_issues", "Search for SCM issues by keyword or issue key", {
         token: z.string().describe("Search query (keyword or issue key)"),
         size: z.number().int().optional().default(10).describe("Max number of results"),
     }, async ({ token, size }) => {
-        const data = await gqlClient.request(SEARCH_TYPED, {
-            token,
-            type: "scm-issue",
-            size,
-        });
         return {
-            content: [{ type: "text", text: JSON.stringify(data.search, null, 2) }],
+            content: [{ type: "text", text: JSON.stringify(await search(token, "scm-issue", size), null, 2) }],
         };
     });
 }

package/build/tools/search.test.js

@@ -9,41 +9,103 @@ const mockRequest = gqlClient.request;
 beforeEach(() => {
     mockRequest.mockReset();
 });
-describe("search", () => {
-    it("returns search results", async () => {
-        const search = {
-            pageItems: [
-                { type: { id: "project", name: "Project", description: null }, title: "myproject", description: null, accuracy: 1.0 },
-            ],
-            pageInfo: { totalSize: 1 },
-        };
-        mockRequest.mockResolvedValueOnce({ search });
-        const client = await createTestClient(registerSearchTools);
-        const result = await client.callTool({
-            name: "search",
-            arguments: { token: "myproject" },
+const result = (id, title, accuracy) => ({
+    type: { id, name: id, description: null },
+    title,
+    description: null,
+    accuracy,
+    data: null,
+});
+async function call(name, args, searchResults) {
+    const client = await createTestClient((server) => registerSearchTools(server, searchResults));
+    const result = await client.callTool({ name, arguments: args });
+    return JSON.parse(result.content[0].text);
+}
+const search = (args) => call("search", args, false);
+const searchV6 = (args) => call("search", args, true);
+describe("search (Yontrack 5 API)", () => {
+    it("searches the given type only", async () => {
+        const page = { pageItems: [result("build", "1.0.0", 1.0)], pageInfo: { totalSize: 1 } };
+        mockRequest.mockResolvedValueOnce({ search: page });
+        expect(await search({ token: "foo", type: "build", size: 5 })).toEqual(page);
+        expect(mockRequest).toHaveBeenCalledTimes(1);
+        expect(mockRequest).toHaveBeenCalledWith(expect.any(String), { token: "foo", type: "build", size: 5 });
+    });
+    it("searches every type when none is given, best results first", async () => {
+        mockRequest
+            .mockResolvedValueOnce({ searchResultTypes: [{ id: "project" }, { id: "build" }] })
+            .mockResolvedValueOnce({
+            search: { pageItems: [result("project", "p1", 0.5), result("project", "p2", 0.1)], pageInfo: { totalSize: 2 } },
+        })
+            .mockResolvedValueOnce({
+            search: { pageItems: [result("build", "b1", 0.9)], pageInfo: { totalSize: 7 } },
+        });
+        expect(await search({ token: "foo", size: 2 })).toEqual({
+            pageItems: [result("build", "b1", 0.9), result("project", "p1", 0.5)],
+            pageInfo: { totalSize: 9 },
         });
-        const text = result.content[0].text;
-        expect(JSON.parse(text)).toEqual(search);
+        expect(mockRequest).toHaveBeenCalledWith(expect.stringContaining("searchResultTypes"));
+        expect(mockRequest).toHaveBeenCalledWith(expect.any(String), { token: "foo", type: "project", size: 2 });
+        expect(mockRequest).toHaveBeenCalledWith(expect.any(String), { token: "foo", type: "build", size: 2 });
     });
     it("returns empty results when nothing matches", async () => {
-        const search = { pageItems: [], pageInfo: { totalSize: 0 } };
-        mockRequest.mockResolvedValueOnce({ search });
-        const client = await createTestClient(registerSearchTools);
-        const result = await client.callTool({
-            name: "search",
-            arguments: { token: "zzznomatch" },
+        mockRequest
+            .mockResolvedValueOnce({ searchResultTypes: [{ id: "project" }] })
+            .mockResolvedValueOnce({ search: { pageItems: [], pageInfo: { totalSize: 0 } } });
+        expect(await search({ token: "zzznomatch" })).toEqual({ pageItems: [], pageInfo: { totalSize: 0 } });
+    });
+    it("searches commits through their type", async () => {
+        const page = { pageItems: [result("scm-commit", "abc123", 1.0)], pageInfo: { totalSize: 1 } };
+        mockRequest.mockResolvedValueOnce({ search: page });
+        expect(await call("search_commits", { token: "fix" }, false)).toEqual(page);
+        expect(mockRequest).toHaveBeenCalledWith(expect.stringContaining("token: $token"), {
+            token: "fix",
+            type: "scm-commit",
+            size: 10,
         });
-        const text = result.content[0].text;
-        expect(JSON.parse(text)).toEqual(search);
-    });
-    it("passes type and size filters to the GraphQL client", async () => {
-        mockRequest.mockResolvedValueOnce({ search: { pageItems: [], pageInfo: { totalSize: 0 } } });
-        const client = await createTestClient(registerSearchTools);
-        await client.callTool({
-            name: "search",
-            arguments: { token: "foo", type: "build", size: 5 },
+    });
+});
+describe("search (Yontrack 6 API)", () => {
+    const results = (items, total, message = null) => ({
+        search: { items, total, capped: false, message },
+    });
+    it("searches all types in a single request, keeping the output shape", async () => {
+        mockRequest.mockResolvedValueOnce(results([result("build", "b1", 0.9), result("project", "p1", 0.5)], 9));
+        expect(await searchV6({ token: "foo", size: 2 })).toEqual({
+            pageItems: [result("build", "b1", 0.9), result("project", "p1", 0.5)],
+            pageInfo: { totalSize: 9 },
+            capped: false,
+            message: null,
+        });
+        expect(mockRequest).toHaveBeenCalledTimes(1);
+        expect(mockRequest.mock.calls[0][0]).toContain("search(query: $query, types: $types, size: $size)");
+        expect(mockRequest.mock.calls[0][1]).toStrictEqual({ query: "foo", size: 2 });
+    });
+    it("restricts the search to the given type", async () => {
+        mockRequest.mockResolvedValueOnce(results([result("build", "1.0.0", 1.0)], 1));
+        await searchV6({ token: "foo", type: "build", size: 5 });
+        expect(mockRequest).toHaveBeenCalledWith(expect.any(String), { query: "foo", types: ["build"], size: 5 });
+    });
+    it("passes on the capped flag and the message of the search", async () => {
+        mockRequest.mockResolvedValueOnce({
+            search: { items: [], total: 1000, capped: true, message: "The search index is being built" },
+        });
+        expect(await searchV6({ token: "foo" })).toMatchObject({
+            pageInfo: { totalSize: 1000 },
+            capped: true,
+            message: "The search index is being built",
+        });
+    });
+    it.each([
+        ["search_commits", "scm-commit"],
+        ["search_issues", "scm-issue"],
+    ])("%s searches the %s type", async (tool, type) => {
+        mockRequest.mockResolvedValueOnce(results([], 0));
+        await call(tool, { token: "fix" }, true);
+        expect(mockRequest).toHaveBeenCalledWith(expect.stringContaining("query: $query"), {
+            query: "fix",
+            types: [type],
+            size: 10,
         });
-        expect(mockRequest).toHaveBeenCalledWith(expect.any(String), { token: "foo", type: "build", size: 5 });
     });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yontrack-mcp",
-  "version": "1.14.2",
+  "version": "1.15.0",
   "description": "MCP server for Yontrack (Ontrack CI/CD monitoring platform)",
   "repository": {
     "type": "git",