@selfagency/teamdynamix-mcp 0.1.1 → 0.2.0

package/index.js

@@ -10,12 +10,11 @@ import { z } from "zod";
 // src/constants.ts
 var SERVER_NAME = "teamdynamix-mcp";
 var SERVER_VERSION = "0.2.0";
+var CHARACTER_LIMIT = 25e3;
 var TEAMDYNAMIX_TOOL_PREFIX = "teamdynamix";
 var TEAMDYNAMIX_DEFAULT_TIMEOUT_MS = 3e4;
 var TEAMDYNAMIX_DEFAULT_MAX_RETRIES = 2;
 var TEAMDYNAMIX_MAX_RETRY_ATTEMPTS = 5;
-var TEAMDYNAMIX_MIN_RATE_LIMIT_WAIT_MS = 5e3;
-var TEAMDYNAMIX_MAX_RATE_LIMIT_WAIT_MS = 3e4;
 
 // src/config.ts
 var SERVER_NAME_OVERRIDE = process.env["MCP_SERVER_NAME"]?.trim() || void 0;
@@ -92,7 +91,8 @@ function getTeamDynamixConfig() {
     timeoutMs: normalizeNumberWithDefault(process.env["TEAMDYNAMIX_TIMEOUT_MS"], TEAMDYNAMIX_DEFAULT_TIMEOUT_MS, 1e3),
     maxRetries,
     enableWriteTools: normalizeBoolean(process.env["TEAMDYNAMIX_ENABLE_WRITE_TOOLS"], false),
-    enableAdminTools: normalizeBoolean(process.env["TEAMDYNAMIX_ENABLE_ADMIN_TOOLS"], false)
+    enableAdminTools: normalizeBoolean(process.env["TEAMDYNAMIX_ENABLE_ADMIN_TOOLS"], false),
+    enableDeleteTools: normalizeBoolean(process.env["TEAMDYNAMIX_ENABLE_DELETE_TOOLS"], false)
   };
 }
 function getTeamDynamixConfigStatus(config = getTeamDynamixConfig()) {
@@ -118,26 +118,6 @@ function getTeamDynamixConfigStatus(config = getTeamDynamixConfig()) {
 import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 
 // src/services/teamdynamix/core.service.ts
-function parseRateLimit(headers, nowMs = Date.now()) {
-  const limitRaw = headers.get("X-RateLimit-Limit");
-  const remainingRaw = headers.get("X-RateLimit-Remaining");
-  const resetRaw = headers.get("X-RateLimit-Reset");
-  const resetTime = resetRaw ? Date.parse(resetRaw) : Number.NaN;
-  const computedWaitMs = Number.isFinite(resetTime) ? resetTime - nowMs : TEAMDYNAMIX_MIN_RATE_LIMIT_WAIT_MS;
-  const waitMs = Math.min(
-    Math.max(
-      Number.isFinite(computedWaitMs) ? computedWaitMs : TEAMDYNAMIX_MIN_RATE_LIMIT_WAIT_MS,
-      TEAMDYNAMIX_MIN_RATE_LIMIT_WAIT_MS
-    ),
-    TEAMDYNAMIX_MAX_RATE_LIMIT_WAIT_MS
-  );
-  return {
-    limit: limitRaw ? Number.parseInt(limitRaw, 10) : null,
-    remaining: remainingRaw ? Number.parseInt(remainingRaw, 10) : null,
-    resetAt: Number.isFinite(resetTime) ? new Date(resetTime).toISOString() : null,
-    waitMs
-  };
-}
 function redactTeamDynamixConfig(config) {
   return {
     baseUrl: config.baseUrl ?? null,
@@ -155,39 +135,6 @@ function redactTeamDynamixConfig(config) {
     enableAdminTools: config.enableAdminTools
   };
 }
-function decodeJwtExpiryEpochSeconds(token) {
-  const segments = token.split(".");
-  const payload = segments[1];
-  if (!payload) {
-    return null;
-  }
-  try {
-    const normalized = payload.replace(/-/g, "+").replace(/_/g, "/");
-    const padding = normalized.length % 4 === 0 ? "" : "=".repeat(4 - normalized.length % 4);
-    const decoded = Buffer.from(`${normalized}${padding}`, "base64").toString("utf8");
-    const parsed = JSON.parse(decoded);
-    return typeof parsed.exp === "number" ? parsed.exp : null;
-  } catch {
-    return null;
-  }
-}
-function extractAuthToken(payload) {
-  if (typeof payload === "string" && payload.trim()) {
-    return payload.trim();
-  }
-  if (!payload || typeof payload !== "object") {
-    throw new Error("Unable to extract bearer token from TeamDynamix authentication response.");
-  }
-  const record = payload;
-  const candidateKeys = ["token", "Token", "accessToken", "AccessToken", "bearerToken", "TokenText", "value"];
-  for (const key of candidateKeys) {
-    const candidate = record[key];
-    if (typeof candidate === "string" && candidate.trim()) {
-      return candidate.trim();
-    }
-  }
-  throw new Error("Unable to extract bearer token from TeamDynamix authentication response.");
-}
 
 // src/tools/teamdynamix.domain-gateways.tools.ts
 import { z as z4 } from "zod";
@@ -397,441 +344,457 @@ var TeamDynamixUserSchema = z3.object({
 var TeamDynamixListResponseSchema = z3.array(z3.record(z3.string(), z3.unknown())).describe("Array of TeamDynamix entities");
 var TeamDynamixSingleResponseSchema = z3.record(z3.string(), z3.unknown()).describe("Single TeamDynamix entity response");
 
-// src/services/teamdynamix/client.service.ts
-function assertWriteToolsEnabled(config) {
-  if (!config.enableWriteTools) {
-    throw new Error(
-      "Write tools are disabled. Set TEAMDYNAMIX_ENABLE_WRITE_TOOLS=true in your environment to enable ticket creation, updates, comments, and other write operations."
-    );
+// src/client/sdk-client.factory.ts
+import { createTeamDynamixClient, loginWithPassword, loginWithServiceAccount } from "@selfagency/teamdynamix-ts";
+function createTokenProvider(config, tenant) {
+  if (config.authMode === "admin") {
+    if (!config.beid || !config.webServicesKey) {
+      throw new Error("BEID and WebServicesKey are required for admin authentication");
+    }
+    return loginWithServiceAccount({
+      tenant,
+      beid: config.beid,
+      webServicesKey: config.webServicesKey
+    });
   }
-}
-function sleep(ms) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
+  if (!config.username || !config.password) {
+    throw new Error("Username and password are required for standard authentication");
+  }
+  return loginWithPassword({
+    tenant,
+    username: config.username,
+    password: config.password
   });
 }
-function normalizePath(path) {
-  return path.startsWith("/") ? path : `/${path}`;
+function extractTenant(baseUrl) {
+  const normalized = baseUrl.replace(/\/+$/, "").replace(/\/TDWebApi$/, "");
+  const withoutProtocol = normalized.replace(/^https?:\/\//, "");
+  const parts = withoutProtocol.split("/");
+  return parts[0] ?? "";
 }
-var TokenBucket = class {
-  constructor(capacity, refillRatePerMs) {
-    this.capacity = capacity;
-    this.refillRatePerMs = refillRatePerMs;
-    this.tokens = capacity;
-    this.lastRefillMs = Date.now();
-  }
-  tokens;
-  lastRefillMs;
-  refill() {
-    const now = Date.now();
-    const elapsed = now - this.lastRefillMs;
-    this.tokens = Math.min(this.capacity, this.tokens + elapsed * this.refillRatePerMs);
-    this.lastRefillMs = now;
-  }
-  async acquire() {
-    this.refill();
-    if (this.tokens >= 1) {
-      this.tokens -= 1;
-      return;
+function buildSdkConfig(config, tenant, tokenProvider) {
+  return {
+    tenant,
+    tokenProvider,
+    environment: config.baseUrl?.includes("sandbox") ? "sandbox" : "production",
+    baseUrl: config.baseUrl,
+    timeoutMs: config.timeoutMs,
+    runtimeValidationMode: config.enableAdminTools ? "fail-closed" : "fail-open",
+    retryPolicy: {
+      maxRetries: config.maxRetries
     }
-    const waitMs = Math.ceil((1 - this.tokens) / this.refillRatePerMs);
-    await sleep(waitMs);
-    return this.acquire();
-  }
-};
-var sharedRateLimiter = new TokenBucket(20, 2 / 1e3);
-var TeamDynamixClient = class {
-  constructor(config, rateLimiter = sharedRateLimiter) {
+  };
+}
+async function createMcpSdkClient(config) {
+  const tenant = extractTenant(config.baseUrl ?? "");
+  const tokenProvider = createTokenProvider(config, tenant);
+  const sdkConfig = buildSdkConfig(config, tenant, tokenProvider);
+  const { client } = await createTeamDynamixClient(sdkConfig);
+  return client;
+}
+
+// src/services/teamdynamix/client.factory.ts
+var UnifiedTeamDynamixClient = class {
+  constructor(config) {
     this.config = config;
-    this.rateLimiter = rateLimiter;
-  }
-  cachedToken = null;
-  async getCurrentUser() {
-    return await this.requestJson("/api/auth/getuser");
   }
-  async listApplications() {
-    return await this.requestJson("/api/applications");
+  sdkPromise = null;
+  sdk() {
+    this.sdkPromise ??= createMcpSdkClient(this.config);
+    return this.sdkPromise;
   }
-  // -------------------------------------------------------------------------
-  // Discovery / Enumeration domains
-  // -------------------------------------------------------------------------
-  async listAccounts(appId) {
-    const path = appId ? `/api/${appId}/accounts` : "/api/accounts";
-    return await this.requestJson(path);
+  //
+  // Discovery
+  //
+  getCurrentUser() {
+    return this.sdk().then((s) => s.discovery.authGetuser());
   }
-  async getAccount(accountId) {
-    return await this.requestJson(`/api/accounts/${accountId}`);
+  listApplications() {
+    return this.sdk().then((s) => s.discovery.applications());
   }
-  async listLocations() {
-    return await this.requestJson("/api/locations");
+  //
+  // Tickets
+  //
+  getTicket(appId, ticketId) {
+    return this.sdk().then((s) => s.tickets.appIdTicketsId({ params: { path: { appId, id: ticketId } } }));
   }
-  async listFunctionalRoles() {
-    return await this.requestJson("/api/functionalroles");
+  searchTickets(appId, _body) {
+    return this.sdk().then((s) => s.tickets.appIdTicketsFeed({ params: { path: { appId } } }));
   }
-  async listCustomAttributes(componentId, appId, associatedTypeId) {
-    const qs = new URLSearchParams({ componentId: String(componentId) });
-    if (appId !== void 0) qs.set("appId", String(appId));
-    if (associatedTypeId !== void 0) qs.set("associatedTypeId", String(associatedTypeId));
-    return await this.requestJson(`/api/attributes/custom?${qs}`);
+  listTicketTypes(appId) {
+    return this.sdk().then((s) => s.tickets.appIdTicketsTypes({ params: { path: { appId } } }));
   }
-  async listTicketStatuses(appId) {
-    return await this.requestJson(`/api/${appId}/tickets/statuses`);
+  listTicketPriorities(appId) {
+    return this.sdk().then((s) => s.tickets.appIdTicketsPriorities({ params: { path: { appId } } }));
   }
-  async listTicketTypes(appId) {
-    return await this.requestJson(`/api/${appId}/tickets/types`);
+  listTicketUrgencies(appId) {
+    return this.sdk().then((s) => s.tickets.appIdTicketsUrgencies({ params: { path: { appId } } }));
   }
-  async listTicketPriorities(appId) {
-    return await this.requestJson(`/api/${appId}/tickets/priorities`);
+  listTicketImpacts(appId) {
+    return this.sdk().then((s) => s.tickets.appIdTicketsImpacts({ params: { path: { appId } } }));
   }
-  async listTicketUrgencies(appId) {
-    return await this.requestJson(`/api/${appId}/tickets/urgencies`);
+  listTicketSources(appId) {
+    return this.sdk().then((s) => s.tickets.appIdTicketsSources({ params: { path: { appId } } }));
   }
-  async listTicketImpacts(appId) {
-    return await this.requestJson(`/api/${appId}/tickets/impacts`);
+  getTicketFeed(appId, ticketId) {
+    return this.sdk().then((s) => s.tickets.appIdTicketsIdFeed({ params: { path: { appId, id: ticketId } } }));
   }
-  async listTicketSources(appId) {
-    return await this.requestJson(`/api/${appId}/tickets/sources`);
-  }
-  async getTicket(appId, ticketId) {
-    return await this.requestJson(`/api/${appId}/tickets/${ticketId}`);
+  //
+  // Ticket Relationships
+  //
+  getTicketTasks(appId, ticketId) {
+    return this.sdk().then(
+      (s) => s.ticketRelationships.appIdTicketsTicketIdTasks({ params: { path: { appId, ticketId } } })
+    );
   }
-  async searchTickets(appId, body) {
-    return await this.requestJson(`/api/${appId}/tickets/search`, {
-      method: "POST",
-      body: JSON.stringify(body)
-    });
+  createTicketTask(appId, ticketId, body) {
+    return this.sdk().then((s) => s.ticketRelationships.createTicketTask({ appId, ticketId, body }));
   }
-  async createTicket(appId, body, notifyRequestor = false, notifyResponsible = false) {
-    const qs = new URLSearchParams({
-      NotifyRequestor: String(notifyRequestor),
-      NotifyResponsible: String(notifyResponsible)
-    });
-    return await this.requestJson(`/api/${appId}/tickets?${qs}`, {
-      method: "POST",
-      body: JSON.stringify(body)
-    });
+  listTicketAssets(appId, ticketId) {
+    return this.sdk().then(
+      (s) => s.ticketRelationships.appIdTicketsIdAssets({ params: { path: { appId, id: ticketId } } })
+    );
   }
-  async updateTicket(appId, ticketId, body, notifyRequestor = false, notifyResponsible = false, comments = "", isPrivate = false) {
-    const qs = new URLSearchParams({
-      NotifyRequestor: String(notifyRequestor),
-      NotifyResponsible: String(notifyResponsible),
-      ...comments ? { Comments: comments } : {},
-      IsPrivate: String(isPrivate)
-    });
-    return await this.requestJson(`/api/${appId}/tickets/${ticketId}?${qs}`, {
-      method: "PATCH",
-      body: JSON.stringify(body)
-    });
+  addTicketAsset(appId, ticketId, assetId) {
+    return this.sdk().then((s) => s.ticketRelationships.addTicketAsset({ appId, ticketId, assetId }));
   }
-  async addTicketComment(appId, ticketId, body, isPrivate = false, notifyRequestor = false, notifyResponsible = false) {
-    return await this.requestJson(`/api/${appId}/tickets/${ticketId}/feed`, {
-      method: "POST",
-      body: JSON.stringify({
-        Body: body,
-        IsPrivate: isPrivate,
-        NotifyRequestor: notifyRequestor,
-        NotifyResponsible: notifyResponsible
-      })
+  removeTicketAsset(appId, ticketId, assetId) {
+    return this.sdk().then((s) => {
+      s.ticketRelationships.removeTicketAsset({ appId, ticketId, assetId, confirm: true });
     });
   }
-  async getTicketFeed(appId, ticketId) {
-    return await this.requestJson(`/api/${appId}/tickets/${ticketId}/feed`);
+  getTicketContacts(appId, ticketId) {
+    return this.sdk().then(
+      (s) => s.ticketRelationships.appIdTicketsIdContacts({ params: { path: { appId, id: ticketId } } })
+    );
   }
-  async getTicketTasks(appId, ticketId) {
-    return await this.requestJson(`/api/${appId}/tickets/${ticketId}/tasks`);
+  addTicketContact(appId, ticketId, contactUid) {
+    return this.sdk().then((s) => s.ticketRelationships.addTicketContact({ appId, ticketId, contactUid }));
   }
-  async createTicketTask(appId, ticketId, body) {
-    return await this.requestJson(`/api/${appId}/tickets/${ticketId}/tasks`, {
-      method: "POST",
-      body: JSON.stringify(body)
+  removeTicketContact(appId, ticketId, contactUid) {
+    return this.sdk().then((s) => {
+      s.ticketRelationships.removeTicketContact({ appId, ticketId, contactUid, confirm: true });
     });
   }
-  async listTicketAssets(appId, ticketId) {
-    return await this.requestJson(`/api/${appId}/tickets/${ticketId}/assets`);
+  //
+  // People
+  //
+  getUser(uid) {
+    return this.sdk().then((s) => s.people.peopleUid({ params: { path: { uid } } }));
   }
-  async addTicketAsset(appId, ticketId, assetId) {
-    return await this.requestJson(`/api/${appId}/tickets/${ticketId}/assets/${assetId}`, {
-      method: "POST",
-      body: JSON.stringify({})
-    });
+  searchUsers(body) {
+    const searchText = typeof body["SearchText"] === "string" ? body["SearchText"] : "";
+    return this.sdk().then((s) => s.people.peopleLookup({ body: { SearchText: searchText } }));
   }
-  async removeTicketAsset(appId, ticketId, assetId) {
-    await this.requestJson(`/api/${appId}/tickets/${ticketId}/assets/${assetId}`, { method: "DELETE" });
+  getGroup(groupId) {
+    return this.sdk().then((s) => s.people.groupsId({ params: { path: { id: groupId } } }));
   }
-  // -------------------------------------------------------------------------
-  // People & Groups
-  // -------------------------------------------------------------------------
-  async getUser(uid) {
-    return await this.requestJson(`/api/people/${encodeURIComponent(uid)}`);
+  searchGroups(_body) {
+    return this.sdk().then((s) => s.people.searchGroups({ body: {} }));
   }
-  async searchUsers(body) {
-    return await this.requestJson("/api/people/search", {
-      method: "POST",
-      body: JSON.stringify(body)
-    });
+  getGroupMembers(groupId) {
+    return this.sdk().then((s) => s.people.groupsIdMembers({ params: { path: { id: groupId } } }));
   }
-  async getGroup(groupId) {
-    return await this.requestJson(`/api/groups/${groupId}`);
-  }
-  async searchGroups(body) {
-    return await this.requestJson("/api/groups/search", {
-      method: "POST",
-      body: JSON.stringify(body)
-    });
+  //
+  // Knowledge Base
+  //
+  getKbArticle(appId, articleId) {
+    return this.sdk().then((s) => s.knowledgeBase.appIdKnowledgebaseId({ params: { path: { appId, id: articleId } } }));
+  }
+  searchKbArticles(appId, body) {
+    const keyword = typeof body["SearchText"] === "string" ? body["SearchText"] : "";
+    return this.sdk().then((s) => s.knowledgeBase.appIdKnowledgebaseId({ params: { path: { appId, id: 0 } } })).then(
+      (r) => Array.isArray(r) ? r.filter((item) => {
+        const s = typeof item === "object" && item !== null ? JSON.stringify(item).toLowerCase() : "";
+        return keyword ? s.includes(keyword.toLowerCase()) : true;
+      }) : []
+    );
   }
-  async getGroupMembers(groupId) {
-    return await this.requestJson(`/api/groups/${groupId}/members`);
+  listKbCategories(appId) {
+    return this.sdk().then(
+      (s) => s.knowledgeBase.appIdKnowledgebaseCategories({ params: { path: { appId } } })
+    );
   }
-  // -------------------------------------------------------------------------
-  // Knowledge Base
-  // -------------------------------------------------------------------------
-  async getKbArticle(appId, articleId) {
-    return await this.requestJson(`/api/${appId}/knowledgebase/${articleId}`);
-  }
-  async searchKbArticles(appId, body) {
-    return await this.requestJson(`/api/${appId}/knowledgebase/search`, {
-      method: "POST",
-      body: JSON.stringify(body)
+  //
+  // Assets
+  //
+  getAsset(appId, assetId) {
+    return this.sdk().then((s) => s.assets.appIdAssetsId({ params: { path: { appId, id: assetId } } }));
+  }
+  searchAssets(appId, _body) {
+    return this.sdk().then((s) => s.assets.appIdAssetsFeed({ params: { path: { appId } } }));
+  }
+  listAssetStatuses(appId) {
+    return this.sdk().then((s) => s.assets.appIdAssetsStatuses({ params: { path: { appId } } }));
+  }
+  listProductModels(appId) {
+    return this.sdk().then((s) => s.assets.appIdAssetsModels({ params: { path: { appId } } }));
+  }
+  listVendors(appId) {
+    return this.sdk().then((s) => s.cmdb.appIdAssetsVendors({ params: { path: { appId } } }));
+  }
+  //
+  // CMDB
+  //
+  getConfigurationItem(appId, ciId) {
+    return this.sdk().then((s) => s.cmdb.appIdCmdbId({ params: { path: { appId, id: ciId } } }));
+  }
+  searchConfigurationItems(appId, _body) {
+    return this.sdk().then((s) => s.cmdb.appIdCmdbSearches({ params: { path: { appId } } }));
+  }
+  listCiTypes(appId) {
+    return this.sdk().then((s) => s.cmdb.appIdCmdbTypes({ params: { path: { appId } } }));
+  }
+  listCiRelationshipTypes() {
+    return this.sdk().then((s) => s.cmdb.appIdCmdbRelationshiptypes());
+  }
+  //
+  // Services
+  //
+  listServiceCatalog(appId) {
+    return this.sdk().then((s) => s.services.appIdServices({ params: { path: { appId } } }));
+  }
+  getService(appId, serviceId) {
+    return this.sdk().then((s) => s.services.appIdServicesId({ params: { path: { appId, id: serviceId } } }));
+  }
+  searchServices(appId, body) {
+    const keyword = typeof body["Keyword"] === "string" ? body["Keyword"] : "";
+    return this.sdk().then((s) => s.services.appIdServices({ params: { path: { appId } } })).then((r) => {
+      if (!Array.isArray(r)) return [];
+      if (!keyword) return r;
+      const lower = keyword.toLowerCase();
+      return r.filter((item) => {
+        const text = typeof item === "object" && item !== null ? JSON.stringify(item).toLowerCase() : "";
+        return text.includes(lower);
+      });
     });
   }
-  async listKbCategories(appId) {
-    return await this.requestJson(`/api/${appId}/knowledgebase/categories`);
+  listServiceCategories(appId) {
+    return this.sdk().then((s) => s.services.appIdServicesCategories({ params: { path: { appId } } }));
   }
-  async createKbArticle(appId, body) {
-    return await this.requestJson(`/api/${appId}/knowledgebase`, {
-      method: "POST",
-      body: JSON.stringify(body)
-    });
+  //
+  // Projects
+  //
+  getProject(projectId) {
+    return this.sdk().then((s) => s.projects.projectsId({ params: { path: { id: projectId } } }));
   }
-  async updateKbArticle(appId, articleId, body) {
-    return await this.requestJson(`/api/${appId}/knowledgebase/${articleId}`, {
-      method: "PUT",
-      body: JSON.stringify(body)
-    });
+  searchProjects(_body) {
+    return this.sdk().then((s) => s.projects.projectsFeed());
   }
-  // -------------------------------------------------------------------------
-  // Assets / CMDB
-  // -------------------------------------------------------------------------
-  async getAsset(appId, assetId) {
-    return await this.requestJson(`/api/${appId}/assets/${assetId}`);
+  listProjectTypes() {
+    return this.sdk().then((s) => s.projects.projectsTypes());
   }
-  async searchAssets(appId, body) {
-    return await this.requestJson(`/api/${appId}/assets/search`, {
-      method: "POST",
-      body: JSON.stringify(body)
-    });
+  getProjectPlans(projectId) {
+    return this.sdk().then(
+      (s) => s.projects.projectsProjectIDPlansPlanID({ params: { path: { id: projectId } } })
+    );
   }
-  async listAssetStatuses(appId) {
-    return await this.requestJson(`/api/${appId}/assets/statuses`);
+  getProjectIssues(projectId) {
+    return this.sdk().then(
+      (s) => s.projects.projectsProjectIdIssuesCategories({ params: { path: { id: projectId } } })
+    );
   }
-  async listProductModels(appId) {
-    return await this.requestJson(`/api/${appId}/assets/models`);
+  getProjectRisks(projectId) {
+    return this.sdk().then(
+      (s) => s.projects.projectsProjectIdRisksCategories({ params: { path: { id: projectId } } })
+    );
   }
-  async listVendors(appId) {
-    return await this.requestJson(`/api/${appId}/assets/vendors`);
+  //
+  // Time
+  //
+  listTimeTypes() {
+    return this.sdk().then((s) => s.time.timeTypes());
   }
-  async getConfigurationItem(appId, ciId) {
-    return await this.requestJson(`/api/${appId}/cmdb/${ciId}`);
+  getMyTimeEntries(_startDate, _endDate) {
+    return this.sdk().then((s) => s.time.timeId({ params: { path: { id: 0 } } }));
   }
-  async searchConfigurationItems(appId, body) {
-    return await this.requestJson(`/api/${appId}/cmdb/search`, {
-      method: "POST",
-      body: JSON.stringify(body)
-    });
+  //
+  // Reference Data
+  //
+  listAccounts(_appId) {
+    return this.sdk().then((s) => s.referenceData.accounts());
   }
-  async listCiTypes(appId) {
-    return await this.requestJson(`/api/${appId}/cmdb/types`);
+  getAccount(accountId) {
+    return this.sdk().then((s) => s.referenceData.accountsId({ params: { path: { id: accountId } } }));
   }
-  async listCiRelationshipTypes() {
-    return await this.requestJson("/api/cmdb/relationshiptypes");
+  listLocations() {
+    return this.sdk().then((s) => s.referenceData.locations());
   }
-  // -------------------------------------------------------------------------
-  // Service Catalog
-  // -------------------------------------------------------------------------
-  async listServiceCatalog(appId) {
-    return await this.requestJson(`/api/${appId}/services`);
+  listFunctionalRoles() {
+    return this.sdk().then((s) => s.referenceData.securityrolesPermissions());
   }
-  async getService(appId, serviceId) {
-    return await this.requestJson(`/api/${appId}/services/${serviceId}`);
+  listCustomAttributes(_componentId, _appId, _associatedTypeId) {
+    return this.sdk().then((s) => s.referenceData.attributesCustom());
   }
-  async searchServices(appId, body) {
-    return await this.requestJson(`/api/${appId}/services/search`, {
-      method: "POST",
-      body: JSON.stringify(body)
-    });
+  listTicketStatuses(appId) {
+    return this.sdk().then((s) => s.referenceData.appIdTicketsStatuses({ params: { path: { appId } } }));
   }
-  // -------------------------------------------------------------------------
-  // Projects
-  // -------------------------------------------------------------------------
-  async getProject(projectId) {
-    return await this.requestJson(`/api/projects/${projectId}`);
-  }
-  async searchProjects(body) {
-    return await this.requestJson("/api/projects/search", {
-      method: "POST",
-      body: JSON.stringify(body)
-    });
+  //
+  // Mutations
+  //
+  createTicket(appId, body, _notifyRequestor, _notifyResponsible) {
+    return this.sdk().then((s) => s.tickets.createTicket({ appId, body }));
   }
-  async listProjectTypes() {
-    return await this.requestJson("/api/projects/types");
+  updateTicket(appId, ticketId, body, _notifyRequestor, _notifyResponsible, _comments, _isPrivate) {
+    return this.sdk().then((s) => s.tickets.updateTicket({ appId, ticketId, body }));
   }
-  async getProjectPlans(projectId) {
-    return await this.requestJson(`/api/projects/${projectId}/plans`);
+  addTicketComment(appId, ticketId, body, _isPrivate, _notifyRequestor, _notifyResponsible) {
+    return this.sdk().then((s) => s.tickets.addTicketComment({ appId, ticketId, body: { Body: body } }));
   }
-  async getProjectIssues(projectId) {
-    return await this.requestJson(`/api/projects/${projectId}/issues`);
+  createKbArticle(appId, body) {
+    return this.sdk().then((s) => s.knowledgeBase.createArticle({ appId, body }));
   }
-  async getProjectRisks(projectId) {
-    return await this.requestJson(`/api/projects/${projectId}/risks`);
+  updateKbArticle(appId, articleId, body) {
+    return this.sdk().then((s) => s.knowledgeBase.updateArticle({ appId, articleId, body }));
   }
-  async createProjectIssue(projectId, body) {
-    return await this.requestJson(`/api/projects/${projectId}/issues`, {
-      method: "POST",
-      body: JSON.stringify(body)
-    });
+  createProjectIssue(_projectId, body) {
+    return this.sdk().then((s) => s.projects.createIssue({ body }));
   }
-  async createProjectRisk(projectId, body) {
-    return await this.requestJson(`/api/projects/${projectId}/risks`, {
-      method: "POST",
-      body: JSON.stringify(body)
-    });
+  createProjectRisk(_projectId, body) {
+    return this.sdk().then((s) => s.projects.createRisk({ body }));
   }
-  async listTimeTypes() {
-    return await this.requestJson("/api/time/types");
+  //
+  // Delete mutations (confirm:true required for all)
+  //
+  deleteAsset(appId, assetId) {
+    return this.sdk().then((s) => s.assets.deleteAsset({ appId, assetId, confirm: true }));
   }
-  async getMyTimeEntries(startDate, endDate) {
-    const qs = new URLSearchParams({ startDate, endDate });
-    return await this.requestJson(`/api/time/entries?${qs}`);
+  deleteConfigurationItem(appId, ciId) {
+    return this.sdk().then((s) => s.cmdb.deleteConfigurationItem({ appId, configurationItemId: ciId, confirm: true }));
   }
-  async getTicketContacts(appId, ticketId) {
-    return await this.requestJson(`/api/${appId}/tickets/${ticketId}/contacts`);
+  deleteService(appId, serviceId) {
+    return this.sdk().then((s) => s.services.deleteService({ appId, serviceId, confirm: true }));
   }
-  async addTicketContact(appId, ticketId, contactUid) {
-    return await this.requestJson(`/api/${appId}/tickets/${ticketId}/contacts/${contactUid}`, {
-      method: "PUT"
-    });
+  deleteServiceCategory(appId, categoryId) {
+    return this.sdk().then((s) => s.services.deleteServiceCategory({ appId, categoryId, confirm: true }));
   }
-  async removeTicketContact(appId, ticketId, contactUid) {
-    await this.requestJson(`/api/${appId}/tickets/${ticketId}/contacts/${contactUid}`, {
-      method: "DELETE"
-    });
+  deleteTimeEntry(timeEntryId) {
+    return this.sdk().then((s) => s.time.deleteTimeEntry({ timeEntryId, confirm: true }));
   }
-  async listServiceCategories(appId) {
-    return await this.requestJson(`/api/${appId}/services/categories`);
+};
+function createConfiguredTeamDynamixClient() {
+  return new UnifiedTeamDynamixClient(getTeamDynamixConfig());
+}
+function assertWriteToolsEnabled(config) {
+  if (!config.enableWriteTools) {
+    throw new Error("Write tools are disabled. Set TEAMDYNAMIX_ENABLE_WRITE_TOOLS=true in your environment.");
   }
-  async requestJson(path, options = {}) {
-    const headers = new Headers(options.headers);
-    headers.set("Accept", "application/json");
-    if (options.body && !headers.has("Content-Type") && !(options.body instanceof FormData)) {
-      headers.set("Content-Type", "application/json");
-    }
-    const token = await this.getBearerToken(options.requireAdmin ?? false);
-    headers.set("Authorization", `Bearer ${token}`);
-    const requestInit = {
-      method: options.method ?? "GET",
-      headers,
-      body: options.body
-    };
-    const endpoint = `${this.config.baseUrl}${normalizePath(path)}`;
-    const cappedRetries = Math.min(this.config.maxRetries, TEAMDYNAMIX_MAX_RETRY_ATTEMPTS);
-    await this.rateLimiter.acquire();
-    for (let attempt = 0; attempt <= cappedRetries; attempt += 1) {
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), this.config.timeoutMs);
-      let response;
-      try {
-        response = await fetch(endpoint, { ...requestInit, signal: controller.signal });
-      } finally {
-        clearTimeout(timeoutId);
-      }
-      if (response.status === 429 && attempt < cappedRetries) {
-        const rateLimit = parseRateLimit(response.headers);
-        if (LOG_LEVEL === "debug") {
-          console.error(
-            `[teamdynamix-mcp] rate limited on ${normalizePath(path)}; retry ${attempt + 1}/${cappedRetries} in ${rateLimit.waitMs}ms`
-          );
-        }
-        await sleep(rateLimit.waitMs);
-        continue;
-      }
-      if (!response.ok) {
-        await response.text();
-        throw new Error(`TeamDynamix request failed (${response.status}) for ${normalizePath(path)}.`);
-      }
-      const contentType = response.headers.get("content-type") ?? "";
-      if (contentType.includes("application/json")) {
-        const data = await response.json();
-        if (Array.isArray(data)) {
-          TeamDynamixListResponseSchema.parse(data);
-        } else if (typeof data === "object" && data !== null) {
-          TeamDynamixSingleResponseSchema.parse(data);
-        }
-        return data;
-      }
-      const text = await response.text();
-      return text;
-    }
-    throw new Error(`TeamDynamix request exceeded retry budget for ${normalizePath(path)}.`);
-  }
-  async getBearerToken(requireAdmin) {
-    const configStatus = getTeamDynamixConfigStatus(this.config);
-    if (!configStatus.configured) {
-      throw new Error(
-        `TeamDynamix is not configured. Missing: ${configStatus.missing.join(", ")}. Populate the required environment variables in .env before using TeamDynamix tools.`
-      );
-    }
-    if (requireAdmin && this.config.authMode !== "admin") {
-      throw new Error(
-        "This TeamDynamix action requires admin authentication, but TEAMDYNAMIX_AUTH_MODE is not set to admin."
-      );
+}
+function assertDeleteToolsEnabled(config) {
+  if (!config.enableDeleteTools) {
+    throw new Error("Delete tools are disabled. Set TEAMDYNAMIX_ENABLE_DELETE_TOOLS=true in your environment.");
+  }
+}
+
+// src/services/teamdynamix/render.service.ts
+import { tablemark } from "tablemark";
+function render(payload, responseFormat, characterLimit = CHARACTER_LIMIT) {
+  if (responseFormat === "json") {
+    if (typeof payload === "undefined") return "undefined";
+    return JSON.stringify(payload, null, 2);
+  }
+  const markdown = renderMarkdown(payload);
+  return truncateMarkdown(markdown, characterLimit);
+}
+function renderMarkdown(payload) {
+  if (payload == null) return "";
+  if (typeof payload !== "object") {
+    return String(payload);
+  }
+  if (Array.isArray(payload)) {
+    if (payload.length === 0) {
+      return "";
     }
-    const expiresAtMs = this.cachedToken?.expiresAtMs;
-    if (this.cachedToken && (!expiresAtMs || expiresAtMs > Date.now() + 6e4)) {
-      return this.cachedToken.token;
+    if (payload.every(isPlainObject)) {
+      return renderArrayAsMarkdownTable(payload);
     }
-    const token = await this.login();
-    return token;
+    return "```json\n" + JSON.stringify(payload, null, 2) + "\n```";
   }
-  async login() {
-    if (!this.config.baseUrl) {
-      throw new Error("TeamDynamix base URL is not configured. Set TEAMDYNAMIX_BASE_URL.");
+  if (isPlainObject(payload)) {
+    const hasArrayOfObjects = Object.values(payload).some(isArrayOfPlainObjects);
+    if (hasArrayOfObjects) {
+      return renderObjectWithTables(payload);
     }
-    const isAdmin = this.config.authMode === "admin";
-    const loginPath = isAdmin ? "/api/auth/loginadmin" : "/api/auth/login";
-    const body = isAdmin ? JSON.stringify({ BEID: this.config.beid, WebServicesKey: this.config.webServicesKey }) : JSON.stringify({ username: this.config.username, password: this.config.password });
-    const loginController = new AbortController();
-    const loginTimeoutId = setTimeout(() => loginController.abort(), this.config.timeoutMs);
-    let response;
-    try {
-      response = await fetch(`${this.config.baseUrl}${loginPath}`, {
-        method: "POST",
-        headers: {
-          Accept: "application/json, text/plain;q=0.9",
-          "Content-Type": "application/json"
-        },
-        body,
-        signal: loginController.signal
-      });
-    } finally {
-      clearTimeout(loginTimeoutId);
+    return renderObjectAsMarkdownList(payload);
+  }
+  return "";
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isArrayOfPlainObjects(value) {
+  return Array.isArray(value) && value.length > 0 && value.every(isPlainObject);
+}
+function serializeValue(value) {
+  if (typeof value !== "object" || value === null) return String(value);
+  if (Array.isArray(value)) return value.map(serializeValue).join(", ");
+  return "{ " + Object.entries(value).map(([k, v]) => `${k}: ${typeof v === "object" && v !== null ? "[Object]" : String(v)}`).join(", ") + " }";
+}
+function renderObjectAsMarkdownList(obj) {
+  const lines = [];
+  for (const [key, val] of Object.entries(obj)) {
+    lines.push(`- **${key}**: ${truncateCell(serializeValue(val))}`);
+  }
+  return lines.join("\n");
+}
+function renderObjectWithTables(obj) {
+  const lines = [];
+  const scalarEntries = [];
+  const arrayEntries = [];
+  for (const [key, val] of Object.entries(obj)) {
+    if (isArrayOfPlainObjects(val)) {
+      arrayEntries.push([key, val]);
+    } else {
+      scalarEntries.push([key, val]);
     }
-    if (!response.ok) {
-      await response.text();
-      throw new Error(`TeamDynamix authentication failed (${response.status}).`);
+  }
+  if (scalarEntries.length > 0) {
+    lines.push("**Metadata:**");
+    for (const [key, val] of scalarEntries) {
+      lines.push(`- **${key}**: ${truncateCell(serializeValue(val))}`);
     }
-    const contentType = response.headers.get("content-type") ?? "";
-    const payload = contentType.includes("application/json") ? await response.json() : await response.text();
-    const token = extractAuthToken(payload);
-    const expiryEpochSeconds = decodeJwtExpiryEpochSeconds(token);
-    this.cachedToken = {
-      token,
-      expiresAtMs: expiryEpochSeconds ? expiryEpochSeconds * 1e3 : null
-    };
-    return token;
+    lines.push("");
   }
-};
-function createConfiguredTeamDynamixClient() {
-  return new TeamDynamixClient(getTeamDynamixConfig());
+  for (const [key, arr] of arrayEntries) {
+    lines.push(`**${key}:**`);
+    const table = renderArrayAsMarkdownTable(arr);
+    lines.push(table);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function renderArrayAsMarkdownTable(arr) {
+  const toCellText = ({ value }) => serializeValue(value);
+  let table = tablemark(arr, {
+    toCellText,
+    headerCase: "preserve"
+  });
+  table = table.replace(/\| +/g, "| ").replace(/ +\|/g, " |");
+  table = table.replace(
+    /^(\| +:)(-+)( +\|)/gm,
+    (_match, _pre, _dashes, _post, offset, str) => {
+      if (str.slice(0, offset).includes(":---")) return _match;
+      const headerLine = str.slice(0, offset).split("\n").reverse().find((l) => l.startsWith("|"));
+      if (!headerLine) return _match;
+      const colCount = headerLine.split("|").length - 2;
+      const dashCounts = Array.from({ length: colCount }, (_, i) => 3 + i);
+      const newRow = [""].concat(dashCounts.map((n) => ` :${"-".repeat(n)} `)).concat([""]).join("|");
+      return newRow;
+    }
+  );
+  return table;
+}
+function truncateCell(str) {
+  const MAX = 120;
+  if (str.length <= MAX) return str;
+  return str.slice(0, MAX) + "\u2026";
+}
+function truncateMarkdown(markdown, limit) {
+  if (markdown.length <= limit) return markdown;
+  const ellipsis = "...";
+  if (limit <= ellipsis.length) return markdown.slice(0, limit);
+  const truncated = markdown.slice(0, limit - ellipsis.length).replace(/\n+$/, "");
+  return truncated + ellipsis;
 }
 
 // src/tools/teamdynamix.domain-gateways.tools.ts
@@ -882,20 +845,24 @@ var teamdynamixAssetsActionSchema = z4.enum([
   "get_asset",
   "search_assets",
   "list_asset_statuses",
-  "list_product_models"
+  "list_product_models",
+  "delete_asset"
 ]);
 var teamdynamixCmdbActionSchema = z4.enum([
   "get_ci",
   "search_cis",
   "list_ci_types",
   "list_ci_relationship_types",
-  "list_vendors"
+  "list_vendors",
+  "delete_ci"
 ]);
 var teamdynamixServicesActionSchema = z4.enum([
   "list_services",
   "get_service",
   "search_services",
-  "list_service_categories"
+  "list_service_categories",
+  "delete_service",
+  "delete_service_category"
 ]);
 var teamdynamixProjectsActionSchema = z4.enum([
   "get_project",
@@ -916,11 +883,6 @@ var teamdynamixReferenceDataActionSchema = z4.enum([
   "list_custom_attributes"
 ]);
 var gatewayPayloadSchema = z4.record(z4.string(), z4.unknown()).default({});
-function render(data, responseFormat) {
-  if (responseFormat === "json") return JSON.stringify(data, null, 2);
-  if (typeof data === "string") return data;
-  return JSON.stringify(data, null, 2);
-}
 function messageFromError(error) {
   return error instanceof Error ? error.message : String(error);
 }
@@ -1527,6 +1489,23 @@ function registerTeamDynamixAssetsGateway(server2) {
             const models = await client.listProductModels(parsed.app_id);
             return toSuccessResponse({ appId: parsed.app_id, count: models.length, models }, response_format);
           }
+          case "delete_asset": {
+            const parsed = parsePayload(
+              z4.object({
+                app_id: TeamDynamixAppIdSchema,
+                asset_id: z4.number().int().positive(),
+                confirm: z4.literal(true)
+              }),
+              payload,
+              action
+            );
+            assertDeleteToolsEnabled(getTeamDynamixConfig());
+            await client.deleteAsset(parsed.app_id, parsed.asset_id);
+            return toSuccessResponse(
+              { appId: parsed.app_id, assetId: parsed.asset_id, deleted: true },
+              response_format
+            );
+          }
         }
       } catch (error) {
         return toErrorResponse(error);
@@ -1586,6 +1565,20 @@ function registerTeamDynamixCmdbGateway(server2) {
             const vendors = await client.listVendors(parsed.app_id);
             return toSuccessResponse({ appId: parsed.app_id, count: vendors.length, vendors }, response_format);
           }
+          case "delete_ci": {
+            const parsed = parsePayload(
+              z4.object({
+                app_id: TeamDynamixAppIdSchema,
+                ci_id: z4.number().int().positive(),
+                confirm: z4.literal(true)
+              }),
+              payload,
+              action
+            );
+            assertDeleteToolsEnabled(getTeamDynamixConfig());
+            await client.deleteConfigurationItem(parsed.app_id, parsed.ci_id);
+            return toSuccessResponse({ appId: parsed.app_id, ciId: parsed.ci_id, deleted: true }, response_format);
+          }
         }
       } catch (error) {
         return toErrorResponse(error);
@@ -1638,6 +1631,40 @@ function registerTeamDynamixServicesGateway(server2) {
             const categories = await client.listServiceCategories(parsed.app_id);
             return toSuccessResponse({ appId: parsed.app_id, count: categories.length, categories }, response_format);
           }
+          case "delete_service": {
+            const parsed = parsePayload(
+              z4.object({
+                app_id: TeamDynamixAppIdSchema,
+                service_id: z4.number().int().positive(),
+                confirm: z4.literal(true)
+              }),
+              payload,
+              action
+            );
+            assertDeleteToolsEnabled(getTeamDynamixConfig());
+            await client.deleteService(parsed.app_id, parsed.service_id);
+            return toSuccessResponse(
+              { appId: parsed.app_id, serviceId: parsed.service_id, deleted: true },
+              response_format
+            );
+          }
+          case "delete_service_category": {
+            const parsed = parsePayload(
+              z4.object({
+                app_id: TeamDynamixAppIdSchema,
+                category_id: z4.number().int().positive(),
+                confirm: z4.literal(true)
+              }),
+              payload,
+              action
+            );
+            assertDeleteToolsEnabled(getTeamDynamixConfig());
+            await client.deleteServiceCategory(parsed.app_id, parsed.category_id);
+            return toSuccessResponse(
+              { appId: parsed.app_id, categoryId: parsed.category_id, deleted: true },
+              response_format
+            );
+          }
         }
       } catch (error) {
         return toErrorResponse(error);