yontrack-mcp 1.14.1 → 1.14.3

package/build/graphql-documents.test.js

@@ -0,0 +1,51 @@
+import { describe, it, expect } from "vitest";
+import { readFileSync, readdirSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { buildSchema, parse, validate } from "graphql";
+// Validates every GraphQL document sent by the server against the schema snapshots,
+// so that a field the Yontrack server does not expose fails here rather than at runtime.
+const root = (path) => fileURLToPath(new URL(`../${path}`, import.meta.url));
+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([]);
+const sourceFiles = [
+    "src/capabilities.ts",
+    "src/utils.ts",
+    ...readdirSync(root("src/tools"))
+        .filter((f) => f.endsWith(".ts") && !f.endsWith(".test.ts"))
+        .map((f) => `src/tools/${f}`),
+];
+/** `const NAME = \`...\`` constants holding a query or mutation, with `${OTHER}` constants inlined. */
+function documentsOf(file) {
+    const source = readFileSync(root(file), "utf-8");
+    const constants = new Map();
+    for (const [, name, text] of source.matchAll(/const (\w+) = `([^`]*)`;/g))
+        constants.set(name, text);
+    const inline = (text) => text.replace(/\$\{(\w+)\}/g, (match, name) => (constants.has(name) ? inline(constants.get(name)) : match));
+    return [...constants]
+        .map(([name, text]) => ({ name, text: inline(text) }))
+        .filter(({ text }) => /^\s*(query|mutation)\b/.test(text));
+}
+const cases = sourceFiles.flatMap((file) => documentsOf(file).flatMap(({ name, text }) => (V6_ONLY.has(file) ? ["v6"] : ["v5", "v6"]).map((version) => ({
+    file, name, text, version, known: KNOWN_INVALID.has(`${version} ${file} ${name}`),
+}))));
+describe("GraphQL documents", () => {
+    it("finds the documents to validate", () => {
+        const names = cases.map((c) => c.name);
+        expect(names).toContain("CREATE_VALIDATION_RUN");
+        expect(names).toContain("PROMOTE_BUILD");
+        expect(names).toContain("READINESS");
+    });
+    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);
+        expect(errors).toEqual([]);
+    });
+    it.each(cases.filter((c) => c.known))("$file $name is still a known issue against the $version schema", ({ text, version }) => {
+        expect(validate(schemas[version], parse(text))).not.toEqual([]);
+    });
+});

package/build/tools/branches.js

@@ -20,7 +20,7 @@ const CREATE_BRANCH = `
       description: $description
     }) {
       branch { id name displayName description disabled project { id name } }
-      userErrors { message }
+      errors { message }
     }
   }
 `;
@@ -41,11 +41,11 @@ export function registerBranchTools(server, allowMutations) {
             description: z.string().optional().describe("Branch description"),
         }, async ({ project, name, description }) => {
             const data = await gqlClient.request(CREATE_BRANCH, { projectName: project, name, description });
-            const { branch, userErrors } = data.createBranch;
-            if (userErrors?.length) {
+            const { branch, errors } = data.createBranch;
+            if (errors?.length) {
                 return {
                     isError: true,
-                    content: [{ type: "text", text: userErrors.map((e) => e.message).join(", ") }],
+                    content: [{ type: "text", text: errors.map((e) => e.message).join(", ") }],
                 };
             }
             return {

package/build/tools/branches.test.js

@@ -46,7 +46,7 @@ describe("list_branches", () => {
 describe("create_branch", () => {
     it("returns the created branch", async () => {
         const branch = { id: 10, name: "feature-x", displayName: "feature-x", description: "My feature", disabled: false };
-        mockRequest.mockResolvedValueOnce({ createBranch: { branch, userErrors: [] } });
+        mockRequest.mockResolvedValueOnce({ createBranch: { branch, errors: [] } });
         const client = await createTestClient(registerBranchTools);
         const result = await client.callTool({
             name: "create_branch",
@@ -56,9 +56,9 @@ describe("create_branch", () => {
         const text = result.content[0].text;
         expect(JSON.parse(text)).toEqual(branch);
     });
-    it("returns an error when userErrors is non-empty", async () => {
+    it("returns an error when errors is non-empty", async () => {
         mockRequest.mockResolvedValueOnce({
-            createBranch: { branch: null, userErrors: [{ message: "Branch already exists" }] },
+            createBranch: { branch: null, errors: [{ message: "Branch already exists" }] },
         });
         const client = await createTestClient(registerBranchTools);
         const result = await client.callTool({

package/build/tools/build-links.js

@@ -31,7 +31,7 @@ const SET_BUILD_LINKS = `
       fromBuild: $fromBuild
       links: $links
     }) {
-      userErrors { message }
+      errors { message }
     }
   }
 `;
@@ -59,11 +59,11 @@ export function registerBuildLinkTools(server, allowMutations) {
             links: z.array(BuildLinkInput).describe("Target builds to link to"),
         }, async ({ fromProject, fromBuild, links }) => {
             const data = await gqlClient.request(SET_BUILD_LINKS, { fromProject, fromBuild, links });
-            const { userErrors } = data.linksBuild;
-            if (userErrors?.length) {
+            const { errors } = data.linksBuild;
+            if (errors?.length) {
                 return {
                     isError: true,
-                    content: [{ type: "text", text: userErrors.map((e) => e.message).join(", ") }],
+                    content: [{ type: "text", text: errors.map((e) => e.message).join(", ") }],
                 };
             }
             return {

package/build/tools/build-links.test.js

@@ -40,7 +40,7 @@ describe("get_build_links", () => {
 });
 describe("set_build_links", () => {
     it("returns success message when links are set", async () => {
-        mockRequest.mockResolvedValueOnce({ linksBuild: { userErrors: [] } });
+        mockRequest.mockResolvedValueOnce({ linksBuild: { errors: [] } });
         const client = await createTestClient(registerBuildLinkTools);
         const result = await client.callTool({
             name: "set_build_links",
@@ -54,9 +54,9 @@ describe("set_build_links", () => {
         const text = result.content[0].text;
         expect(text).toContain("updated successfully");
     });
-    it("returns an error when userErrors is non-empty", async () => {
+    it("returns an error when errors is non-empty", async () => {
         mockRequest.mockResolvedValueOnce({
-            linksBuild: { userErrors: [{ message: "Build not found" }] },
+            linksBuild: { errors: [{ message: "Build not found" }] },
         });
         const client = await createTestClient(registerBuildLinkTools);
         const result = await client.callTool({

package/build/tools/builds.js

@@ -50,7 +50,7 @@ const CREATE_BUILD = `
       description: $description
     }) {
       build { id name displayName description branch { id name displayName project { id name } } }
-      userErrors { message }
+      errors { message }
     }
   }
 `;
@@ -85,11 +85,11 @@ export function registerBuildTools(server, allowMutations) {
             description: z.string().optional().describe("Build description"),
         }, async ({ project, branch, name, description }) => {
             const data = await gqlClient.request(CREATE_BUILD, { project, branch, name, description });
-            const { build, userErrors } = data.createBuild;
-            if (userErrors?.length) {
+            const { build, errors } = data.createBuild;
+            if (errors?.length) {
                 return {
                     isError: true,
-                    content: [{ type: "text", text: userErrors.map((e) => e.message).join(", ") }],
+                    content: [{ type: "text", text: errors.map((e) => e.message).join(", ") }],
                 };
             }
             return {

package/build/tools/builds.test.js

@@ -61,7 +61,7 @@ describe("find_build", () => {
 describe("create_build", () => {
     it("returns the created build", async () => {
         const build = { id: 10, name: "2.0.0", displayName: "2.0.0" };
-        mockRequest.mockResolvedValueOnce({ createBuild: { build, userErrors: [] } });
+        mockRequest.mockResolvedValueOnce({ createBuild: { build, errors: [] } });
         const client = await createTestClient(registerBuildTools);
         const result = await client.callTool({
             name: "create_build",
@@ -71,9 +71,9 @@ describe("create_build", () => {
         const text = result.content[0].text;
         expect(JSON.parse(text)).toEqual(build);
     });
-    it("returns an error when userErrors is non-empty", async () => {
+    it("returns an error when errors is non-empty", async () => {
         mockRequest.mockResolvedValueOnce({
-            createBuild: { build: null, userErrors: [{ message: "Branch not found" }] },
+            createBuild: { build: null, errors: [{ message: "Branch not found" }] },
         });
         const client = await createTestClient(registerBuildTools);
         const result = await client.callTool({

package/build/tools/projects.js

@@ -14,7 +14,7 @@ const CREATE_PROJECT = `
   mutation CreateProject($name: String!, $description: String) {
     createProject(input: { name: $name, description: $description }) {
       project { id name description disabled }
-      userErrors { message }
+      errors { message }
     }
   }
 `;
@@ -33,11 +33,11 @@ export function registerProjectTools(server, allowMutations) {
             description: z.string().optional().describe("Project description"),
         }, async ({ name, description }) => {
             const data = await gqlClient.request(CREATE_PROJECT, { name, description });
-            const { project, userErrors } = data.createProject;
-            if (userErrors?.length) {
+            const { project, errors } = data.createProject;
+            if (errors?.length) {
                 return {
                     isError: true,
-                    content: [{ type: "text", text: userErrors.map((e) => e.message).join(", ") }],
+                    content: [{ type: "text", text: errors.map((e) => e.message).join(", ") }],
                 };
             }
             return {

package/build/tools/projects.test.js

@@ -40,7 +40,7 @@ describe("list_projects", () => {
 describe("create_project", () => {
     it("returns the created project", async () => {
         const project = { id: 1, name: "newproject", description: "New", disabled: false };
-        mockRequest.mockResolvedValueOnce({ createProject: { project, userErrors: [] } });
+        mockRequest.mockResolvedValueOnce({ createProject: { project, errors: [] } });
         const client = await createTestClient(registerProjectTools);
         const result = await client.callTool({
             name: "create_project",
@@ -50,9 +50,9 @@ describe("create_project", () => {
         const text = result.content[0].text;
         expect(JSON.parse(text)).toEqual(project);
     });
-    it("returns an error when userErrors is non-empty", async () => {
+    it("returns an error when errors is non-empty", async () => {
         mockRequest.mockResolvedValueOnce({
-            createProject: { project: null, userErrors: [{ message: "Project already exists" }] },
+            createProject: { project: null, errors: [{ message: "Project already exists" }] },
         });
         const client = await createTestClient(registerProjectTools);
         const result = await client.callTool({

package/build/tools/promotion-levels.js

@@ -26,7 +26,7 @@ const CREATE_PROMOTION_LEVEL = `
       description: $description
     }) {
       promotionLevel { id name description branch { id name } }
-      userErrors { message }
+      errors { message }
     }
   }
 `;
@@ -69,11 +69,11 @@ export function registerPromotionLevelTools(server, allowMutations) {
         }, async ({ project, branch, name, description }) => {
             const branchId = await resolveBranchId(project, branch);
             const data = await gqlClient.request(CREATE_PROMOTION_LEVEL, { branchId, name, description });
-            const { promotionLevel, userErrors } = data.createPromotionLevelById;
-            if (userErrors?.length) {
+            const { promotionLevel, errors } = data.createPromotionLevelById;
+            if (errors?.length) {
                 return {
                     isError: true,
-                    content: [{ type: "text", text: userErrors.map((e) => e.message).join(", ") }],
+                    content: [{ type: "text", text: errors.map((e) => e.message).join(", ") }],
                 };
             }
             return {

package/build/tools/promotion-levels.test.js

@@ -83,7 +83,7 @@ describe("get_promotion_level_image", () => {
 describe("create_promotion_level", () => {
     it("returns the created promotion level", async () => {
         const level = { id: 3, name: "GOLD", description: "Gold level", branch: { id: 42, name: "main" } };
-        mockRequest.mockResolvedValueOnce({ createPromotionLevelById: { promotionLevel: level, userErrors: [] } });
+        mockRequest.mockResolvedValueOnce({ createPromotionLevelById: { promotionLevel: level, errors: [] } });
         const client = await createTestClient(registerPromotionLevelTools);
         const result = await client.callTool({
             name: "create_promotion_level",
@@ -93,9 +93,9 @@ describe("create_promotion_level", () => {
         const text = result.content[0].text;
         expect(JSON.parse(text)).toEqual(level);
     });
-    it("returns an error when userErrors is non-empty", async () => {
+    it("returns an error when errors is non-empty", async () => {
         mockRequest.mockResolvedValueOnce({
-            createPromotionLevelById: { promotionLevel: null, userErrors: [{ message: "Promotion level already exists" }] },
+            createPromotionLevelById: { promotionLevel: null, errors: [{ message: "Promotion level already exists" }] },
         });
         const client = await createTestClient(registerPromotionLevelTools);
         const result = await client.callTool({

package/build/tools/promotion-runs.js

@@ -38,7 +38,7 @@ const PROMOTE_BUILD = `
         creation { user time }
         promotionLevel { id name }
       }
-      userErrors { message }
+      errors { message }
     }
   }
 `;
@@ -64,11 +64,11 @@ export function registerPromotionRunTools(server, allowMutations) {
             description: z.string().optional().describe("Optional description"),
         }, async ({ project, branch, build, promotion, description }) => {
             const data = await gqlClient.request(PROMOTE_BUILD, { project, branch, build, promotion, description });
-            const { promotionRun, userErrors } = data.createPromotionRun;
-            if (userErrors?.length) {
+            const { promotionRun, errors } = data.createPromotionRun;
+            if (errors?.length) {
                 return {
                     isError: true,
-                    content: [{ type: "text", text: userErrors.map((e) => e.message).join(", ") }],
+                    content: [{ type: "text", text: errors.map((e) => e.message).join(", ") }],
                 };
             }
             return {

package/build/tools/promotion-runs.test.js

@@ -46,7 +46,7 @@ describe("get_promotion_runs", () => {
 describe("promote_build", () => {
     it("returns the created promotion run", async () => {
         const run = { id: 5, description: null, creation: { user: "alice", time: "2024-01-01T00:00:00Z" }, promotionLevel: { id: 1, name: "BRONZE" } };
-        mockRequest.mockResolvedValueOnce({ createPromotionRun: { promotionRun: run, userErrors: [] } });
+        mockRequest.mockResolvedValueOnce({ createPromotionRun: { promotionRun: run, errors: [] } });
         const client = await createTestClient(registerPromotionRunTools);
         const result = await client.callTool({
             name: "promote_build",
@@ -56,9 +56,9 @@ describe("promote_build", () => {
         const text = result.content[0].text;
         expect(JSON.parse(text)).toEqual(run);
     });
-    it("returns an error when userErrors is non-empty", async () => {
+    it("returns an error when errors is non-empty", async () => {
         mockRequest.mockResolvedValueOnce({
-            createPromotionRun: { promotionRun: null, userErrors: [{ message: "Build not found" }] },
+            createPromotionRun: { promotionRun: null, errors: [{ message: "Build not found" }] },
         });
         const client = await createTestClient(registerPromotionRunTools);
         const result = await client.callTool({
@@ -69,6 +69,20 @@ describe("promote_build", () => {
         const text = result.content[0].text;
         expect(text).toContain("Build not found");
     });
+    it("returns the agent policy refusal as an error", async () => {
+        const refusal = "agent x[agent] may not promote to GOLD: GOLD is reserved to humans (agent policy)";
+        mockRequest.mockResolvedValueOnce({
+            createPromotionRun: { promotionRun: null, errors: [{ message: refusal }] },
+        });
+        const client = await createTestClient(registerPromotionRunTools);
+        const result = await client.callTool({
+            name: "promote_build",
+            arguments: { project: "myproject", branch: "main", build: "1.0.1", promotion: "GOLD" },
+        });
+        expect(result.isError).toBe(true);
+        const text = result.content[0].text;
+        expect(text).toBe(refusal);
+    });
     it("is not registered when mutations are disabled", async () => {
         const client = await createTestClient(registerPromotionRunTools, false);
         const { tools } = await client.listTools();

package/build/tools/search.js

@@ -1,67 +1,71 @@
 import { z } from "zod";
 import { gqlClient } from "../client.js";
+// `type` is required on v5 (and deprecated, but still accepted, on v6)
 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 }
   }
 `;
+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) },
+    };
+}
 export function registerSearchTools(server) {
     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 });
+        const search = type ? await searchType(token, type, size) : await searchAllTypes(token, size);
         return {
-            content: [{ type: "text", text: JSON.stringify(data.search, null, 2) }],
+            content: [{ type: "text", text: JSON.stringify(search, 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,
-        });
+        const search = await searchType(token, "scm-commit", size);
         return {
-            content: [{ type: "text", text: JSON.stringify(data.search, null, 2) }],
+            content: [{ type: "text", text: JSON.stringify(search, 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,
-        });
+        const search = await searchType(token, "scm-issue", size);
         return {
-            content: [{ type: "text", text: JSON.stringify(data.search, null, 2) }],
+            content: [{ type: "text", text: JSON.stringify(search, null, 2) }],
         };
     });
 }

package/build/tools/search.test.js

@@ -9,41 +9,47 @@ const mockRequest = gqlClient.request;
 beforeEach(() => {
     mockRequest.mockReset();
 });
+const result = (id, title, accuracy) => ({
+    type: { id, name: id, description: null },
+    title,
+    description: null,
+    accuracy,
+    data: null,
+});
+async function search(args) {
+    const client = await createTestClient(registerSearchTools);
+    const result = await client.callTool({ name: "search", arguments: args });
+    return JSON.parse(result.content[0].text);
+}
 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 text = result.content[0].text;
-        expect(JSON.parse(text)).toEqual(search);
+    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("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" },
+    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 } },
         });
-        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 },
+        expect(await search({ token: "foo", size: 2 })).toEqual({
+            pageItems: [result("build", "b1", 0.9), result("project", "p1", 0.5)],
+            pageInfo: { totalSize: 9 },
         });
-        expect(mockRequest).toHaveBeenCalledWith(expect.any(String), { token: "foo", type: "build", size: 5 });
+        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 () => {
+        mockRequest
+            .mockResolvedValueOnce({ searchResultTypes: [{ id: "project" }] })
+            .mockResolvedValueOnce({ search: { pageItems: [], pageInfo: { totalSize: 0 } } });
+        expect(await search({ token: "zzznomatch" })).toEqual({ pageItems: [], pageInfo: { totalSize: 0 } });
     });
 });

package/build/tools/validation-runs.js

@@ -42,7 +42,7 @@ const CREATE_VALIDATION_RUN = `
         runOrder
         lastStatus { statusID { id name } }
       }
-      userErrors { message }
+      errors { message }
     }
   }
 `;
@@ -79,11 +79,11 @@ export function registerValidationRunTools(server, allowMutations) {
                 status,
                 description,
             });
-            const { validationRun, userErrors } = data.createValidationRun;
-            if (userErrors?.length) {
+            const { validationRun, errors } = data.createValidationRun;
+            if (errors?.length) {
                 return {
                     isError: true,
-                    content: [{ type: "text", text: userErrors.map((e) => e.message).join(", ") }],
+                    content: [{ type: "text", text: errors.map((e) => e.message).join(", ") }],
                 };
             }
             return {

package/build/tools/validation-runs.test.js

@@ -46,7 +46,7 @@ describe("get_validation_runs", () => {
 describe("create_validation_run", () => {
     it("returns the created validation run", async () => {
         const run = { id: 10, runOrder: 1, lastStatus: { statusID: { id: "PASSED", name: "Passed" } } };
-        mockRequest.mockResolvedValueOnce({ createValidationRun: { validationRun: run, userErrors: [] } });
+        mockRequest.mockResolvedValueOnce({ createValidationRun: { validationRun: run, errors: [] } });
         const client = await createTestClient(registerValidationRunTools);
         const result = await client.callTool({
             name: "create_validation_run",
@@ -56,9 +56,9 @@ describe("create_validation_run", () => {
         const text = result.content[0].text;
         expect(JSON.parse(text)).toEqual(run);
     });
-    it("returns an error when userErrors is non-empty", async () => {
+    it("returns an error when errors is non-empty", async () => {
         mockRequest.mockResolvedValueOnce({
-            createValidationRun: { validationRun: null, userErrors: [{ message: "Validation stamp not found" }] },
+            createValidationRun: { validationRun: null, errors: [{ message: "Validation stamp not found" }] },
         });
         const client = await createTestClient(registerValidationRunTools);
         const result = await client.callTool({

package/build/tools/validation-stamps.js

@@ -24,7 +24,7 @@ const CREATE_VALIDATION_STAMP = `
       description: $description
     }) {
       validationStamp { id name description }
-      userErrors { message }
+      errors { message }
     }
   }
 `;
@@ -49,11 +49,11 @@ export function registerValidationStampTools(server, allowMutations) {
         }, async ({ project, branch, name, description }) => {
             const branchId = await resolveBranchId(project, branch);
             const data = await gqlClient.request(CREATE_VALIDATION_STAMP, { branchId, name, description });
-            const { validationStamp, userErrors } = data.createValidationStampById;
-            if (userErrors?.length) {
+            const { validationStamp, errors } = data.createValidationStampById;
+            if (errors?.length) {
                 return {
                     isError: true,
-                    content: [{ type: "text", text: userErrors.map((e) => e.message).join(", ") }],
+                    content: [{ type: "text", text: errors.map((e) => e.message).join(", ") }],
                 };
             }
             return {

package/build/tools/validation-stamps.test.js

@@ -40,7 +40,7 @@ describe("list_validation_stamps", () => {
 describe("create_validation_stamp", () => {
     it("returns the created validation stamp", async () => {
         const stamp = { id: 5, name: "SECURITY", description: "Security scan" };
-        mockRequest.mockResolvedValueOnce({ createValidationStampById: { validationStamp: stamp, userErrors: [] } });
+        mockRequest.mockResolvedValueOnce({ createValidationStampById: { validationStamp: stamp, errors: [] } });
         const client = await createTestClient(registerValidationStampTools);
         const result = await client.callTool({
             name: "create_validation_stamp",
@@ -50,9 +50,9 @@ describe("create_validation_stamp", () => {
         const text = result.content[0].text;
         expect(JSON.parse(text)).toEqual(stamp);
     });
-    it("returns an error when userErrors is non-empty", async () => {
+    it("returns an error when errors is non-empty", async () => {
         mockRequest.mockResolvedValueOnce({
-            createValidationStampById: { validationStamp: null, userErrors: [{ message: "Stamp already exists" }] },
+            createValidationStampById: { validationStamp: null, errors: [{ message: "Stamp already exists" }] },
         });
         const client = await createTestClient(registerValidationStampTools);
         const result = await client.callTool({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yontrack-mcp",
-  "version": "1.14.1",
+  "version": "1.14.3",
   "description": "MCP server for Yontrack (Ontrack CI/CD monitoring platform)",
   "repository": {
     "type": "git",
@@ -34,6 +34,7 @@
     "@semantic-release/git": "^10.0.1",
     "@types/express": "^5.0.6",
     "@types/node": "^22.0.0",
+    "graphql": "^16.14.2",
     "semantic-release": "^24.2.9",
     "tsx": "^4.19.0",
     "typescript": "^5.7.0",