@daghis/teamcity-mcp 1.9.6 → 1.10.1

package/dist/index.js

@@ -261,17 +261,11 @@ var init_build_status_manager = __esm({
             buildData = response.data;
           } else {
             const locator = this.buildLocator(options);
-            const response = await this.client.builds.getMultipleBuilds(
+            const response = await this.client.builds.getBuild(
               locator,
               this.getFieldSelection(options)
             );
-            const data = response.data;
-            if (!Array.isArray(data.build) || data.build.length === 0) {
-              throw new BuildNotFoundError(
-                `No build found for number ${options.buildNumber} in ${options.buildTypeId}`
-              );
-            }
-            buildData = data.build[0];
+            buildData = response.data;
           }
           if (buildData == null) {
             throw new BuildNotFoundError("Build data is undefined");
@@ -936,6 +930,137 @@ var ResolutionTypeEnum = {
   AtTime: "atTime"
 };
 
+// src/teamcity/agent-requirements-manager.ts
+var JSON_HEADERS = {
+  headers: {
+    "Content-Type": "application/json",
+    Accept: "application/json"
+  }
+};
+var JSON_GET_HEADERS = {
+  headers: {
+    Accept: "application/json"
+  }
+};
+var toStringRecord = (input) => {
+  if (!input) {
+    return {};
+  }
+  return Object.fromEntries(
+    Object.entries(input).map(([name, value]) => {
+      if (value === void 0 || value === null) {
+        return [name, ""];
+      }
+      if (typeof value === "boolean") {
+        return [name, value ? "true" : "false"];
+      }
+      return [name, String(value)];
+    })
+  );
+};
+var propertiesToRecord = (properties) => {
+  if (properties == null) {
+    return {};
+  }
+  const propertyEntries = properties.property;
+  const items = Array.isArray(propertyEntries) ? propertyEntries : propertyEntries != null ? [propertyEntries] : [];
+  const record = {};
+  for (const item of items) {
+    if (!item?.name) {
+      continue;
+    }
+    record[item.name] = item.value != null ? String(item.value) : "";
+  }
+  return record;
+};
+var recordToProperties = (record) => {
+  const entries = Object.entries(record);
+  if (entries.length === 0) {
+    return void 0;
+  }
+  return {
+    property: entries.map(([name, value]) => ({ name, value }))
+  };
+};
+var mergeRecords = (base, override) => ({
+  ...base,
+  ...override
+});
+var AgentRequirementsManager = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async addRequirement(input) {
+    const { buildTypeId } = input;
+    const payload = this.buildPayload(void 0, input);
+    const response = await this.client.modules.buildTypes.addAgentRequirementToBuildType(
+      buildTypeId,
+      void 0,
+      payload,
+      JSON_HEADERS
+    );
+    const id = response.data?.id;
+    if (!id) {
+      throw new Error("TeamCity did not return an agent requirement identifier.");
+    }
+    return { id };
+  }
+  async updateRequirement(requirementId, input) {
+    const { buildTypeId } = input;
+    const existing = await this.fetchRequirement(buildTypeId, requirementId);
+    if (!existing) {
+      throw new Error(
+        `Agent requirement ${requirementId} was not found on ${buildTypeId}; verify the ID or update via the TeamCity UI.`
+      );
+    }
+    const payload = this.buildPayload(existing, input);
+    await this.client.modules.buildTypes.replaceAgentRequirement(
+      buildTypeId,
+      requirementId,
+      void 0,
+      payload,
+      JSON_HEADERS
+    );
+    return { id: requirementId };
+  }
+  async deleteRequirement(buildTypeId, requirementId) {
+    await this.client.modules.buildTypes.deleteAgentRequirement(
+      buildTypeId,
+      requirementId,
+      JSON_HEADERS
+    );
+  }
+  async fetchRequirement(buildTypeId, requirementId) {
+    try {
+      const response = await this.client.modules.buildTypes.getAgentRequirement(
+        buildTypeId,
+        requirementId,
+        "id,type,disabled,properties(property(name,value))",
+        JSON_GET_HEADERS
+      );
+      return response.data;
+    } catch (error2) {
+      if (typeof error2 === "object" && error2 !== null && "response" in error2 && error2.response?.status === 404) {
+        return null;
+      }
+      throw error2;
+    }
+  }
+  buildPayload(existing, input) {
+    const baseProps = propertiesToRecord(existing?.properties);
+    const mergedProps = mergeRecords(baseProps, toStringRecord(input.properties));
+    const payload = {
+      ...existing ?? {},
+      disabled: input.disabled ?? existing?.disabled
+    };
+    const properties = recordToProperties(mergedProps);
+    if (properties) {
+      payload.properties = properties;
+    }
+    return payload;
+  }
+};
+
 // src/teamcity/artifact-manager.ts
 var import_axios = require("axios");
 init_errors();
@@ -1817,6 +1942,356 @@ var BuildConfigurationUpdateManager = class {
   }
 };
 
+// src/teamcity/build-dependency-manager.ts
+var JSON_HEADERS2 = {
+  headers: {
+    "Content-Type": "application/json",
+    Accept: "application/json"
+  }
+};
+var JSON_GET_HEADERS2 = {
+  headers: {
+    Accept: "application/json"
+  }
+};
+var defaultTypeFor = (dependencyType) => {
+  switch (dependencyType) {
+    case "artifact":
+      return void 0;
+    case "snapshot":
+      return void 0;
+    default:
+      return void 0;
+  }
+};
+var toStringRecord2 = (input) => {
+  if (!input) {
+    return {};
+  }
+  const entries = Object.entries(input).map(([name, value]) => {
+    if (value === void 0 || value === null) {
+      return [name, ""];
+    }
+    if (typeof value === "boolean") {
+      return [name, value ? "true" : "false"];
+    }
+    return [name, String(value)];
+  });
+  return Object.fromEntries(entries);
+};
+var propertiesToRecord2 = (properties) => {
+  if (properties == null) {
+    return {};
+  }
+  const propertyEntries = properties.property;
+  const collection = Array.isArray(propertyEntries) ? propertyEntries : propertyEntries != null ? [propertyEntries] : [];
+  const map = {};
+  for (const item of collection) {
+    if (!item?.name) {
+      continue;
+    }
+    map[item.name] = item.value != null ? String(item.value) : "";
+  }
+  return map;
+};
+var recordToProperties2 = (record) => {
+  const entries = Object.entries(record);
+  if (entries.length === 0) {
+    return void 0;
+  }
+  return {
+    property: entries.map(([name, value]) => ({ name, value }))
+  };
+};
+var mergeRecords2 = (base, override) => {
+  const merged = { ...base };
+  for (const [key, value] of Object.entries(override)) {
+    merged[key] = value;
+  }
+  return merged;
+};
+var BuildDependencyManager = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async addDependency(input) {
+    const { buildTypeId, dependencyType, dependsOn } = input;
+    if (!dependsOn || dependsOn.trim() === "") {
+      throw new Error(
+        "dependsOn is required when adding a dependency; specify the upstream build configuration ID or use the TeamCity UI."
+      );
+    }
+    const payload = this.buildPayload(dependencyType, void 0, {
+      ...input,
+      dependsOn
+    });
+    const response = await this.createDependency(dependencyType, buildTypeId, payload);
+    const id = response.data?.id;
+    if (!id) {
+      throw new Error("TeamCity did not return a dependency identifier. Verify server response.");
+    }
+    return { id };
+  }
+  async updateDependency(dependencyId, input) {
+    const { buildTypeId, dependencyType } = input;
+    const existing = await this.fetchDependency(dependencyType, buildTypeId, dependencyId);
+    if (!existing) {
+      throw new Error(
+        `Dependency ${dependencyId} was not found on ${buildTypeId}; verify the identifier or update via the TeamCity UI.`
+      );
+    }
+    const payload = this.buildPayload(dependencyType, existing, input);
+    await this.replaceDependency(dependencyType, buildTypeId, dependencyId, payload);
+    return { id: dependencyId };
+  }
+  async deleteDependency(dependencyType, buildTypeId, dependencyId) {
+    if (!dependencyId) {
+      throw new Error("dependencyId is required to delete a dependency.");
+    }
+    if (dependencyType === "artifact") {
+      await this.client.modules.buildTypes.deleteArtifactDependency(
+        buildTypeId,
+        dependencyId,
+        JSON_HEADERS2
+      );
+      return;
+    }
+    await this.client.modules.buildTypes.deleteSnapshotDependency(
+      buildTypeId,
+      dependencyId,
+      JSON_HEADERS2
+    );
+  }
+  async createDependency(dependencyType, buildTypeId, payload) {
+    if (dependencyType === "artifact") {
+      return this.client.modules.buildTypes.addArtifactDependencyToBuildType(
+        buildTypeId,
+        void 0,
+        payload,
+        JSON_HEADERS2
+      );
+    }
+    return this.client.modules.buildTypes.addSnapshotDependencyToBuildType(
+      buildTypeId,
+      void 0,
+      payload,
+      JSON_HEADERS2
+    );
+  }
+  async replaceDependency(dependencyType, buildTypeId, dependencyId, payload) {
+    if (dependencyType === "artifact") {
+      return this.client.modules.buildTypes.replaceArtifactDependency(
+        buildTypeId,
+        dependencyId,
+        void 0,
+        payload,
+        JSON_HEADERS2
+      );
+    }
+    return this.client.modules.buildTypes.replaceSnapshotDependency(
+      buildTypeId,
+      dependencyId,
+      void 0,
+      payload,
+      JSON_HEADERS2
+    );
+  }
+  async fetchDependency(dependencyType, buildTypeId, dependencyId) {
+    try {
+      if (dependencyType === "artifact") {
+        const response2 = await this.client.modules.buildTypes.getArtifactDependency(
+          buildTypeId,
+          dependencyId,
+          "id,type,disabled,properties(property(name,value)),'source-buildType'(id)",
+          JSON_GET_HEADERS2
+        );
+        return response2.data;
+      }
+      const response = await this.client.modules.buildTypes.getSnapshotDependency(
+        buildTypeId,
+        dependencyId,
+        "id,type,disabled,properties(property(name,value)),'source-buildType'(id)",
+        JSON_GET_HEADERS2
+      );
+      return response.data;
+    } catch (error2) {
+      if (this.isNotFound(error2)) {
+        return null;
+      }
+      throw error2;
+    }
+  }
+  buildPayload(dependencyType, existing, input) {
+    const baseProps = propertiesToRecord2(existing?.properties);
+    const mergedProps = mergeRecords2(baseProps, toStringRecord2(input.properties));
+    const properties = recordToProperties2(mergedProps);
+    const resolvedType = input.type ?? existing?.type ?? defaultTypeFor(dependencyType);
+    const payload = {
+      ...existing ?? {},
+      disabled: input.disabled ?? existing?.disabled
+    };
+    if (resolvedType) {
+      payload.type = resolvedType;
+    }
+    if (properties) {
+      payload.properties = properties;
+    }
+    const dependsOn = input.dependsOn ?? existing?.["source-buildType"]?.id;
+    if (dependsOn) {
+      payload["source-buildType"] = { id: dependsOn };
+    } else {
+      delete payload["source-buildType"];
+    }
+    return payload;
+  }
+  isNotFound(error2) {
+    return Boolean(
+      typeof error2 === "object" && error2 !== null && "response" in error2 && error2.response?.status === 404
+    );
+  }
+};
+
+// src/teamcity/build-feature-manager.ts
+var JSON_HEADERS3 = {
+  headers: {
+    "Content-Type": "application/json",
+    Accept: "application/json"
+  }
+};
+var JSON_GET_HEADERS3 = {
+  headers: {
+    Accept: "application/json"
+  }
+};
+var toStringRecord3 = (input) => {
+  if (!input) {
+    return {};
+  }
+  return Object.fromEntries(
+    Object.entries(input).map(([name, value]) => {
+      if (value === void 0 || value === null) {
+        return [name, ""];
+      }
+      if (typeof value === "boolean") {
+        return [name, value ? "true" : "false"];
+      }
+      return [name, String(value)];
+    })
+  );
+};
+var propertiesToRecord3 = (properties) => {
+  if (properties == null) {
+    return {};
+  }
+  const propertyEntries = properties.property;
+  const items = Array.isArray(propertyEntries) ? propertyEntries : propertyEntries != null ? [propertyEntries] : [];
+  const record = {};
+  for (const item of items) {
+    if (!item?.name) {
+      continue;
+    }
+    record[item.name] = item.value != null ? String(item.value) : "";
+  }
+  return record;
+};
+var recordToProperties3 = (record) => {
+  const entries = Object.entries(record);
+  if (entries.length === 0) {
+    return void 0;
+  }
+  return {
+    property: entries.map(([name, value]) => ({ name, value }))
+  };
+};
+var mergeRecords3 = (base, override) => ({
+  ...base,
+  ...override
+});
+var BuildFeatureManager = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async addFeature(input) {
+    const { buildTypeId, type } = input;
+    if (!type || type.trim() === "") {
+      throw new Error("type is required when adding a build feature.");
+    }
+    const payload = this.buildPayload(void 0, input);
+    payload.type = type;
+    const response = await this.client.modules.buildTypes.addBuildFeatureToBuildType(
+      buildTypeId,
+      void 0,
+      payload,
+      JSON_HEADERS3
+    );
+    const id = response.data?.id;
+    if (!id) {
+      throw new Error("TeamCity did not return a feature identifier.");
+    }
+    return { id };
+  }
+  async updateFeature(featureId, input) {
+    const { buildTypeId } = input;
+    const existing = await this.fetchFeature(buildTypeId, featureId);
+    if (!existing) {
+      throw new Error(
+        `Feature ${featureId} was not found on ${buildTypeId}; verify the feature ID or update via the TeamCity UI.`
+      );
+    }
+    const payload = this.buildPayload(existing, input);
+    await this.client.modules.buildTypes.replaceBuildFeature(
+      buildTypeId,
+      featureId,
+      void 0,
+      payload,
+      JSON_HEADERS3
+    );
+    return { id: featureId };
+  }
+  async deleteFeature(buildTypeId, featureId) {
+    await this.client.modules.buildTypes.deleteFeatureOfBuildType(
+      buildTypeId,
+      featureId,
+      JSON_HEADERS3
+    );
+  }
+  async fetchFeature(buildTypeId, featureId) {
+    try {
+      const response = await this.client.modules.buildTypes.getBuildFeature(
+        buildTypeId,
+        featureId,
+        "id,type,disabled,properties(property(name,value))",
+        JSON_GET_HEADERS3
+      );
+      return response.data;
+    } catch (error2) {
+      if (typeof error2 === "object" && error2 !== null && "response" in error2 && error2.response?.status === 404) {
+        return null;
+      }
+      throw error2;
+    }
+  }
+  buildPayload(existing, input) {
+    const baseProps = propertiesToRecord3(existing?.properties);
+    const mergedProps = mergeRecords3(baseProps, toStringRecord3(input.properties));
+    const payload = {
+      ...existing ?? {},
+      disabled: input.disabled ?? existing?.disabled
+    };
+    if (existing?.type && !input.type) {
+      payload.type = existing.type;
+    }
+    if (input.type) {
+      payload.type = input.type;
+    }
+    const properties = recordToProperties3(mergedProps);
+    if (properties) {
+      payload.properties = properties;
+    }
+    return payload;
+  }
+};
+
 // src/teamcity/build-results-manager.ts
 init_errors();
 var isRecord2 = (value) => {
@@ -37781,6 +38256,14 @@ var DEV_TOOLS = [
       type: "object",
       properties: {
         buildId: { type: "string", description: "Build ID" },
+        buildNumber: {
+          type: "string",
+          description: "Human build number (requires buildTypeId when provided)"
+        },
+        buildTypeId: {
+          type: "string",
+          description: "Build configuration identifier (required when using buildNumber)"
+        },
         includeTests: { type: "boolean", description: "Include test summary" },
         includeProblems: { type: "boolean", description: "Include build problems" },
         includeQueueTotals: {
@@ -37791,16 +38274,32 @@ var DEV_TOOLS = [
           type: "boolean",
           description: "Include waitReason for the queued item (extra API call when queued)"
         }
-      },
-      required: ["buildId"]
+      }
     },
     handler: async (args) => {
       const schema = import_zod4.z.object({
-        buildId: import_zod4.z.string().min(1),
+        buildId: import_zod4.z.string().min(1).optional(),
+        buildNumber: import_zod4.z.string().min(1).optional(),
+        buildTypeId: import_zod4.z.string().min(1).optional(),
         includeTests: import_zod4.z.boolean().optional(),
         includeProblems: import_zod4.z.boolean().optional(),
         includeQueueTotals: import_zod4.z.boolean().optional(),
         includeQueueReason: import_zod4.z.boolean().optional()
+      }).superRefine((value, ctx) => {
+        if (!value.buildId && !value.buildNumber) {
+          ctx.addIssue({
+            code: import_zod4.z.ZodIssueCode.custom,
+            path: ["buildId"],
+            message: "Either buildId or buildNumber must be provided"
+          });
+        }
+        if (value.buildNumber && !value.buildTypeId) {
+          ctx.addIssue({
+            code: import_zod4.z.ZodIssueCode.custom,
+            path: ["buildTypeId"],
+            message: "buildTypeId is required when querying by buildNumber"
+          });
+        }
       });
       return runTool(
         "get_build_status",
@@ -37810,6 +38309,8 @@ var DEV_TOOLS = [
           const statusManager = new (await Promise.resolve().then(() => (init_build_status_manager(), build_status_manager_exports))).BuildStatusManager(adapter);
           const result = await statusManager.getBuildStatus({
             buildId: typed.buildId,
+            buildNumber: typed.buildNumber,
+            buildTypeId: typed.buildTypeId,
             includeTests: typed.includeTests,
             includeProblems: typed.includeProblems
           });
@@ -37830,8 +38331,11 @@ var DEV_TOOLS = [
             }
             if (typed.includeQueueReason) {
               try {
-                const qb = await adapter.modules.buildQueue.getQueuedBuild(typed.buildId);
-                enrich.waitReason = qb.data.waitReason;
+                const targetBuildId = typed.buildId ?? result.buildId;
+                if (targetBuildId) {
+                  const qb = await adapter.modules.buildQueue.getQueuedBuild(targetBuildId);
+                  enrich.waitReason = qb.data.waitReason;
+                }
               } catch {
               }
             }
@@ -40314,6 +40818,392 @@ var FULL_MODE_TOOLS = [
     },
     mode: "full"
   },
+  // === Dependency, Feature, and Requirement Management ===
+  {
+    name: "manage_build_dependencies",
+    description: "Add, update, or delete artifact and snapshot dependencies for a build configuration",
+    inputSchema: {
+      type: "object",
+      properties: {
+        buildTypeId: { type: "string", description: "Build configuration ID" },
+        dependencyType: {
+          type: "string",
+          enum: ["artifact", "snapshot"],
+          description: "Dependency type to manage"
+        },
+        action: {
+          type: "string",
+          enum: ["add", "update", "delete"],
+          description: "Operation to perform"
+        },
+        dependencyId: {
+          type: "string",
+          description: "Dependency ID (required for update/delete)"
+        },
+        dependsOn: {
+          type: "string",
+          description: "Upstream build configuration ID for the dependency"
+        },
+        properties: {
+          type: "object",
+          description: "Dependency properties (e.g. cleanDestinationDirectory, pathRules)"
+        },
+        type: {
+          type: "string",
+          description: "Override dependency type value sent to TeamCity"
+        },
+        disabled: { type: "boolean", description: "Disable or enable the dependency" }
+      },
+      required: ["buildTypeId", "dependencyType", "action"]
+    },
+    handler: async (args) => {
+      const propertyValue = import_zod4.z.union([import_zod4.z.string(), import_zod4.z.number(), import_zod4.z.boolean()]);
+      const schema = import_zod4.z.object({
+        buildTypeId: import_zod4.z.string().min(1),
+        dependencyType: import_zod4.z.enum(["artifact", "snapshot"]),
+        action: import_zod4.z.enum(["add", "update", "delete"]),
+        dependencyId: import_zod4.z.string().min(1).optional(),
+        dependsOn: import_zod4.z.string().min(1).optional(),
+        properties: import_zod4.z.record(import_zod4.z.string(), propertyValue).optional(),
+        type: import_zod4.z.string().min(1).optional(),
+        disabled: import_zod4.z.boolean().optional()
+      }).superRefine((value, ctx) => {
+        if ((value.action === "update" || value.action === "delete") && !value.dependencyId) {
+          ctx.addIssue({
+            code: import_zod4.z.ZodIssueCode.custom,
+            message: "dependencyId is required for update/delete actions. Provide the TeamCity dependency ID or fall back to the UI.",
+            path: ["dependencyId"]
+          });
+        }
+        if (value.action === "add" && !value.dependsOn) {
+          ctx.addIssue({
+            code: import_zod4.z.ZodIssueCode.custom,
+            message: "dependsOn is required when adding a dependency.",
+            path: ["dependsOn"]
+          });
+        }
+      });
+      return runTool(
+        "manage_build_dependencies",
+        schema,
+        async (typed) => {
+          const adapter = createAdapterFromTeamCityAPI(TeamCityAPI.getInstance());
+          const manager = new BuildDependencyManager(adapter);
+          switch (typed.action) {
+            case "add": {
+              const result = await manager.addDependency({
+                buildTypeId: typed.buildTypeId,
+                dependencyType: typed.dependencyType,
+                dependsOn: typed.dependsOn,
+                properties: typed.properties,
+                type: typed.type,
+                disabled: typed.disabled
+              });
+              return json({
+                success: true,
+                action: "manage_build_dependencies",
+                operation: "add",
+                buildTypeId: typed.buildTypeId,
+                dependencyType: typed.dependencyType,
+                dependencyId: result.id
+              });
+            }
+            case "update": {
+              const result = await manager.updateDependency(typed.dependencyId, {
+                buildTypeId: typed.buildTypeId,
+                dependencyType: typed.dependencyType,
+                dependsOn: typed.dependsOn,
+                properties: typed.properties,
+                type: typed.type,
+                disabled: typed.disabled
+              });
+              return json({
+                success: true,
+                action: "manage_build_dependencies",
+                operation: "update",
+                buildTypeId: typed.buildTypeId,
+                dependencyType: typed.dependencyType,
+                dependencyId: result.id
+              });
+            }
+            case "delete": {
+              await manager.deleteDependency(
+                typed.dependencyType,
+                typed.buildTypeId,
+                typed.dependencyId
+              );
+              return json({
+                success: true,
+                action: "manage_build_dependencies",
+                operation: "delete",
+                buildTypeId: typed.buildTypeId,
+                dependencyType: typed.dependencyType,
+                dependencyId: typed.dependencyId
+              });
+            }
+            default:
+              return json({
+                success: false,
+                action: "manage_build_dependencies",
+                error: `Unsupported action: ${typed.action}`
+              });
+          }
+        },
+        args
+      );
+    },
+    mode: "full"
+  },
+  {
+    name: "manage_build_features",
+    description: "Add, update, or delete build features such as ssh-agent or requirements enforcement",
+    inputSchema: {
+      type: "object",
+      properties: {
+        buildTypeId: { type: "string", description: "Build configuration ID" },
+        action: {
+          type: "string",
+          enum: ["add", "update", "delete"],
+          description: "Operation to perform"
+        },
+        featureId: {
+          type: "string",
+          description: "Feature ID (required for update/delete)"
+        },
+        type: { type: "string", description: "Feature type (required for add)" },
+        properties: { type: "object", description: "Feature properties" },
+        disabled: { type: "boolean", description: "Disable or enable the feature" }
+      },
+      required: ["buildTypeId", "action"]
+    },
+    handler: async (args) => {
+      const propertyValue = import_zod4.z.union([import_zod4.z.string(), import_zod4.z.number(), import_zod4.z.boolean()]);
+      const schema = import_zod4.z.object({
+        buildTypeId: import_zod4.z.string().min(1),
+        action: import_zod4.z.enum(["add", "update", "delete"]),
+        featureId: import_zod4.z.string().min(1).optional(),
+        type: import_zod4.z.string().min(1).optional(),
+        properties: import_zod4.z.record(import_zod4.z.string(), propertyValue).optional(),
+        disabled: import_zod4.z.boolean().optional()
+      }).superRefine((value, ctx) => {
+        if ((value.action === "update" || value.action === "delete") && !value.featureId) {
+          ctx.addIssue({
+            code: import_zod4.z.ZodIssueCode.custom,
+            message: "featureId is required for update/delete actions. Capture the feature ID from TeamCity or use the UI.",
+            path: ["featureId"]
+          });
+        }
+        if (value.action === "add" && !value.type) {
+          ctx.addIssue({
+            code: import_zod4.z.ZodIssueCode.custom,
+            message: "type is required when adding a build feature.",
+            path: ["type"]
+          });
+        }
+      });
+      return runTool(
+        "manage_build_features",
+        schema,
+        async (typed) => {
+          const adapter = createAdapterFromTeamCityAPI(TeamCityAPI.getInstance());
+          const manager = new BuildFeatureManager(adapter);
+          switch (typed.action) {
+            case "add": {
+              const result = await manager.addFeature({
+                buildTypeId: typed.buildTypeId,
+                type: typed.type,
+                properties: typed.properties,
+                disabled: typed.disabled
+              });
+              return json({
+                success: true,
+                action: "manage_build_features",
+                operation: "add",
+                buildTypeId: typed.buildTypeId,
+                featureId: result.id
+              });
+            }
+            case "update": {
+              const result = await manager.updateFeature(typed.featureId, {
+                buildTypeId: typed.buildTypeId,
+                type: typed.type,
+                properties: typed.properties,
+                disabled: typed.disabled
+              });
+              return json({
+                success: true,
+                action: "manage_build_features",
+                operation: "update",
+                buildTypeId: typed.buildTypeId,
+                featureId: result.id
+              });
+            }
+            case "delete": {
+              await manager.deleteFeature(typed.buildTypeId, typed.featureId);
+              return json({
+                success: true,
+                action: "manage_build_features",
+                operation: "delete",
+                buildTypeId: typed.buildTypeId,
+                featureId: typed.featureId
+              });
+            }
+            default:
+              return json({
+                success: false,
+                action: "manage_build_features",
+                error: `Unsupported action: ${typed.action}`
+              });
+          }
+        },
+        args
+      );
+    },
+    mode: "full"
+  },
+  {
+    name: "manage_agent_requirements",
+    description: "Add, update, or delete build agent requirements for a configuration",
+    inputSchema: {
+      type: "object",
+      properties: {
+        buildTypeId: { type: "string", description: "Build configuration ID" },
+        action: {
+          type: "string",
+          enum: ["add", "update", "delete"],
+          description: "Operation to perform"
+        },
+        requirementId: {
+          type: "string",
+          description: "Requirement ID (required for update/delete)"
+        },
+        properties: {
+          type: "object",
+          description: "Requirement properties (e.g. property-name, condition, value)"
+        },
+        disabled: { type: "boolean", description: "Disable or enable the requirement" }
+      },
+      required: ["buildTypeId", "action"]
+    },
+    handler: async (args) => {
+      const propertyValue = import_zod4.z.union([import_zod4.z.string(), import_zod4.z.number(), import_zod4.z.boolean()]);
+      const schema = import_zod4.z.object({
+        buildTypeId: import_zod4.z.string().min(1),
+        action: import_zod4.z.enum(["add", "update", "delete"]),
+        requirementId: import_zod4.z.string().min(1).optional(),
+        properties: import_zod4.z.record(import_zod4.z.string(), propertyValue).optional(),
+        disabled: import_zod4.z.boolean().optional()
+      }).superRefine((value, ctx) => {
+        if ((value.action === "update" || value.action === "delete") && !value.requirementId) {
+          ctx.addIssue({
+            code: import_zod4.z.ZodIssueCode.custom,
+            message: "requirementId is required for update/delete actions. Capture the requirement ID via the API or TeamCity UI.",
+            path: ["requirementId"]
+          });
+        }
+      });
+      return runTool(
+        "manage_agent_requirements",
+        schema,
+        async (typed) => {
+          const adapter = createAdapterFromTeamCityAPI(TeamCityAPI.getInstance());
+          const manager = new AgentRequirementsManager(adapter);
+          switch (typed.action) {
+            case "add": {
+              const result = await manager.addRequirement({
+                buildTypeId: typed.buildTypeId,
+                properties: typed.properties,
+                disabled: typed.disabled
+              });
+              return json({
+                success: true,
+                action: "manage_agent_requirements",
+                operation: "add",
+                buildTypeId: typed.buildTypeId,
+                requirementId: result.id
+              });
+            }
+            case "update": {
+              const result = await manager.updateRequirement(typed.requirementId, {
+                buildTypeId: typed.buildTypeId,
+                properties: typed.properties,
+                disabled: typed.disabled
+              });
+              return json({
+                success: true,
+                action: "manage_agent_requirements",
+                operation: "update",
+                buildTypeId: typed.buildTypeId,
+                requirementId: result.id
+              });
+            }
+            case "delete": {
+              await manager.deleteRequirement(typed.buildTypeId, typed.requirementId);
+              return json({
+                success: true,
+                action: "manage_agent_requirements",
+                operation: "delete",
+                buildTypeId: typed.buildTypeId,
+                requirementId: typed.requirementId
+              });
+            }
+            default:
+              return json({
+                success: false,
+                action: "manage_agent_requirements",
+                error: `Unsupported action: ${typed.action}`
+              });
+          }
+        },
+        args
+      );
+    },
+    mode: "full"
+  },
+  {
+    name: "set_build_config_state",
+    description: "Enable or disable a build configuration by toggling its paused flag",
+    inputSchema: {
+      type: "object",
+      properties: {
+        buildTypeId: { type: "string", description: "Build configuration ID" },
+        paused: { type: "boolean", description: "True to pause/disable, false to enable" }
+      },
+      required: ["buildTypeId", "paused"]
+    },
+    handler: async (args) => {
+      const schema = import_zod4.z.object({
+        buildTypeId: import_zod4.z.string().min(1),
+        paused: import_zod4.z.boolean()
+      });
+      return runTool(
+        "set_build_config_state",
+        schema,
+        async (typed) => {
+          const adapter = createAdapterFromTeamCityAPI(TeamCityAPI.getInstance());
+          await adapter.modules.buildTypes.setBuildTypeField(
+            typed.buildTypeId,
+            "paused",
+            String(typed.paused),
+            {
+              headers: {
+                "Content-Type": "text/plain",
+                Accept: "application/json"
+              }
+            }
+          );
+          return json({
+            success: true,
+            action: "set_build_config_state",
+            buildTypeId: typed.buildTypeId,
+            paused: typed.paused
+          });
+        },
+        args
+      );
+    },
+    mode: "full"
+  },
   // === VCS attachment ===
   {
     name: "add_vcs_root_to_build",