@daghis/teamcity-mcp 1.9.5 → 1.10.0

package/dist/index.js

@@ -936,6 +936,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 +1948,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) => {
@@ -1891,11 +2372,37 @@ var BuildResultsManager = class _BuildResultsManager {
       }
       return result;
     } catch (error2) {
-      const errorMessage = error2 instanceof Error ? error2.message : String(error2);
-      if (errorMessage.includes("not found")) {
-        throw new Error(`Build not found: ${buildId}`);
+      if (error2 instanceof TeamCityAPIError) {
+        if (error2.statusCode === 404) {
+          throw new TeamCityNotFoundError("Build", buildId, error2.requestId, error2);
+        }
+        throw error2;
+      }
+      if (this.isAxiosNotFound(error2)) {
+        const axiosError = error2;
+        const apiError = TeamCityAPIError.fromAxiosError(axiosError);
+        if (apiError.statusCode === 404) {
+          throw new TeamCityNotFoundError("Build", buildId, apiError.requestId, apiError);
+        }
+        throw apiError;
       }
-      throw new Error(`Failed to fetch build results: ${errorMessage}`);
+      const message = error2 instanceof Error ? error2.message : String(error2);
+      if (/not found/i.test(message)) {
+        throw new TeamCityNotFoundError(
+          "Build",
+          buildId,
+          void 0,
+          error2 instanceof Error ? error2 : void 0
+        );
+      }
+      throw new TeamCityAPIError(
+        `Failed to fetch build results: ${message}`,
+        "GET_BUILD_RESULTS_FAILED",
+        void 0,
+        void 0,
+        void 0,
+        error2 instanceof Error ? error2 : void 0
+      );
     }
   }
   /**
@@ -2407,6 +2914,10 @@ var BuildResultsManager = class _BuildResultsManager {
   getCacheKey(buildId, options) {
     return `${buildId}:${JSON.stringify(options)}`;
   }
+  isAxiosNotFound(error2) {
+    const axiosError = error2;
+    return Boolean(axiosError?.response && axiosError.response.status === 404);
+  }
   /**
    * Get from cache if valid
    */
@@ -38988,6 +39499,17 @@ var DEV_TOOLS = [
       type: "object",
       properties: {
         buildId: { type: "string", description: "Build ID" },
+        buildTypeId: {
+          type: "string",
+          description: "Build configuration ID when resolving by number"
+        },
+        buildNumber: {
+          oneOf: [
+            { type: "string", description: "Build number as TeamCity displays it" },
+            { type: "number", description: "Numeric build number" }
+          ],
+          description: "Build number when buildId is not available"
+        },
         includeArtifacts: {
           type: "boolean",
           description: "Include artifacts listing and metadata"
@@ -39006,12 +39528,13 @@ var DEV_TOOLS = [
           enum: ["base64", "stream"],
           default: "base64"
         }
-      },
-      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(),
+        buildTypeId: import_zod4.z.string().min(1).optional(),
+        buildNumber: import_zod4.z.union([import_zod4.z.string().min(1), import_zod4.z.number().int()]).optional(),
         includeArtifacts: import_zod4.z.boolean().optional(),
         includeStatistics: import_zod4.z.boolean().optional(),
         includeChanges: import_zod4.z.boolean().optional(),
@@ -39019,6 +39542,24 @@ var DEV_TOOLS = [
         artifactFilter: import_zod4.z.string().min(1).optional(),
         maxArtifactSize: import_zod4.z.number().int().min(1).optional(),
         artifactEncoding: import_zod4.z.enum(["base64", "stream"]).default("base64")
+      }).superRefine((value, ctx) => {
+        const hasBuildId = typeof value.buildId === "string" && value.buildId.trim().length > 0;
+        const hasBuildType = typeof value.buildTypeId === "string" && value.buildTypeId.trim().length > 0;
+        const hasBuildNumber = value.buildNumber !== void 0 && String(value.buildNumber).trim().length > 0;
+        if (hasBuildType !== hasBuildNumber) {
+          ctx.addIssue({
+            code: import_zod4.z.ZodIssueCode.custom,
+            message: "buildTypeId and buildNumber must be provided together",
+            path: hasBuildType ? ["buildNumber"] : ["buildTypeId"]
+          });
+        }
+        if (!hasBuildId && !(hasBuildType && hasBuildNumber)) {
+          ctx.addIssue({
+            code: import_zod4.z.ZodIssueCode.custom,
+            message: "Provide either buildId or buildTypeId with buildNumber",
+            path: ["buildId"]
+          });
+        }
       });
       return runTool(
         "get_build_results",
@@ -39026,16 +39567,42 @@ var DEV_TOOLS = [
         async (typed) => {
           const adapter = createAdapterFromTeamCityAPI(TeamCityAPI.getInstance());
           const manager = new BuildResultsManager(adapter);
-          const result = await manager.getBuildResults(typed.buildId, {
-            includeArtifacts: typed.includeArtifacts,
-            includeStatistics: typed.includeStatistics,
-            includeChanges: typed.includeChanges,
-            includeDependencies: typed.includeDependencies,
-            artifactFilter: typed.artifactFilter,
-            maxArtifactSize: typed.maxArtifactSize,
-            artifactEncoding: typed.artifactEncoding
-          });
-          return json(result);
+          const trimmedBuildId = typeof typed.buildId === "string" ? typed.buildId.trim() : void 0;
+          const hasBuildId = typeof trimmedBuildId === "string" && trimmedBuildId.length > 0;
+          const buildTypeId = typed.buildTypeId?.trim();
+          const buildNumberRaw = typed.buildNumber;
+          const buildNumber = typeof buildNumberRaw === "number" ? buildNumberRaw.toString() : buildNumberRaw?.toString().trim();
+          let buildLocator;
+          let friendlyIdentifier;
+          if (hasBuildId && trimmedBuildId) {
+            buildLocator = trimmedBuildId;
+            friendlyIdentifier = `ID '${trimmedBuildId}'`;
+          } else if (buildTypeId && buildNumber) {
+            buildLocator = `buildType:(id:${buildTypeId}),number:${buildNumber}`;
+            friendlyIdentifier = `build type '${buildTypeId}' and number ${buildNumber}`;
+          } else {
+            throw new TeamCityAPIError(
+              "Unable to resolve build identifier",
+              "INVALID_BUILD_IDENTIFIER"
+            );
+          }
+          try {
+            const result = await manager.getBuildResults(buildLocator, {
+              includeArtifacts: typed.includeArtifacts,
+              includeStatistics: typed.includeStatistics,
+              includeChanges: typed.includeChanges,
+              includeDependencies: typed.includeDependencies,
+              artifactFilter: typed.artifactFilter,
+              maxArtifactSize: typed.maxArtifactSize,
+              artifactEncoding: typed.artifactEncoding ?? "base64"
+            });
+            return json(result);
+          } catch (error2) {
+            if (error2 instanceof TeamCityNotFoundError) {
+              throw new TeamCityNotFoundError("Build", friendlyIdentifier, error2.requestId, error2);
+            }
+            throw error2;
+          }
         },
         args
       );
@@ -40228,6 +40795,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",