@selfagency/teamdynamix-mcp 0.1.0 → 0.2.0

package/index.js

@@ -10,17 +10,19 @@ 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;
 var SERVER_VERSION_OVERRIDE = process.env["MCP_SERVER_VERSION"]?.trim() || void 0;
-var LOG_LEVEL = process.env["MCP_LOG_LEVEL"] === "debug" || process.env["MCP_LOG_LEVEL"] === "warn" || process.env["MCP_LOG_LEVEL"] === "error" ? process.env["MCP_LOG_LEVEL"] : "info";
+var validLogLevels = ["debug", "info", "warn", "error"];
+var logLevelSchema = z.enum(validLogLevels);
+var parsedLogLevel = logLevelSchema.safeParse(process.env["MCP_LOG_LEVEL"]?.trim());
+var LOG_LEVEL = parsedLogLevel.success ? parsedLogLevel.data : "info";
 function normalizeOptionalString(value) {
   const normalized = value?.trim();
   return normalized ? normalized : void 0;
@@ -89,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()) {
@@ -115,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,
@@ -152,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";
@@ -199,10 +149,14 @@ var TextTransformModeSchema = z2.enum(["uppercase", "lowercase", "trim", "slug"]
 
 // src/schemas/teamdynamix/index.ts
 var TeamDynamixAppIdSchema = z3.number().int().positive().describe("TeamDynamix application ID.");
+var IsoDateSchema = z3.string().regex(
+  /^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}(:\d{2}(\.\d+)?)?(Z|[+-]\d{2}:?\d{2})?)?$/,
+  "Must be a valid ISO 8601 date string."
+);
 var TeamDynamixGuidSchema = z3.string().uuid().describe("TeamDynamix GUID identifier.");
 var TeamDynamixResponseFormatSchema = ResponseFormatSchema;
 var TicketSearchSchema = z3.object({
-  Keywords: z3.string().optional().describe("Full-text search term."),
+  Keywords: z3.string().max(500).optional().describe("Full-text search term."),
   MaxResults: z3.number().int().min(1).max(1e3).optional().default(50).describe("Maximum results to return (1\u20131000)."),
   StatusIDs: z3.array(z3.number().int()).optional().describe("Filter by ticket status IDs."),
   TypeIDs: z3.array(z3.number().int()).optional().describe("Filter by ticket type IDs."),
@@ -213,25 +167,25 @@ var TicketSearchSchema = z3.object({
   ResponsibleGroupIDs: z3.array(z3.number().int()).optional().describe("Filter by responsible group IDs."),
   ResponsibleUids: z3.array(z3.string().uuid()).optional().describe("Filter by responsible user GUIDs."),
   RequestorUids: z3.array(z3.string().uuid()).optional().describe("Filter by requestor user GUIDs."),
-  CreatedDateFrom: z3.string().optional().describe("ISO 8601 start date for creation date filter."),
-  CreatedDateTo: z3.string().optional().describe("ISO 8601 end date for creation date filter."),
-  ModifiedDateFrom: z3.string().optional().describe("ISO 8601 start date for last-modified filter."),
-  ModifiedDateTo: z3.string().optional().describe("ISO 8601 end date for last-modified filter."),
-  ClosedDateFrom: z3.string().optional().describe("ISO 8601 start date for closed date filter."),
-  ClosedDateTo: z3.string().optional().describe("ISO 8601 end date for closed date filter."),
-  SortBy: z3.string().optional().describe("Field name to sort results by."),
+  CreatedDateFrom: IsoDateSchema.optional().describe("ISO 8601 start date for creation date filter."),
+  CreatedDateTo: IsoDateSchema.optional().describe("ISO 8601 end date for creation date filter."),
+  ModifiedDateFrom: IsoDateSchema.optional().describe("ISO 8601 start date for last-modified filter."),
+  ModifiedDateTo: IsoDateSchema.optional().describe("ISO 8601 end date for last-modified filter."),
+  ClosedDateFrom: IsoDateSchema.optional().describe("ISO 8601 start date for closed date filter."),
+  ClosedDateTo: IsoDateSchema.optional().describe("ISO 8601 end date for closed date filter."),
+  SortBy: z3.string().max(100).optional().describe("Field name to sort results by."),
   SortOrder: z3.enum(["A", "D"]).optional().describe("Sort order: A = ascending, D = descending.")
 });
 var TicketCreateSchema = z3.object({
   TypeID: z3.number().int().positive().describe("Ticket type ID."),
-  Title: z3.string().min(1).describe("Ticket title/subject."),
+  Title: z3.string().min(1).max(500).describe("Ticket title/subject."),
   AccountID: z3.number().int().positive().optional().describe("Account/department ID."),
   StatusID: z3.number().int().nonnegative().optional().describe("Initial ticket status ID."),
   PriorityID: z3.number().int().nonnegative().optional().describe("Ticket priority ID."),
   UrgencyID: z3.number().int().nonnegative().optional().describe("Ticket urgency ID."),
   ImpactID: z3.number().int().nonnegative().optional().describe("Ticket impact ID."),
   SourceID: z3.number().int().nonnegative().optional().describe("Ticket source ID."),
-  Description: z3.string().optional().describe("Full description/body of the ticket (HTML supported)."),
+  Description: z3.string().max(65535).optional().describe("Full description/body of the ticket (HTML supported)."),
   RequestorUID: z3.string().uuid().optional().describe("GUID of the requestor."),
   ResponsibleUID: z3.string().uuid().optional().describe("GUID of the responsible technician."),
   ResponsibleGroupID: z3.number().int().positive().optional().describe("Responsible group ID."),
@@ -245,56 +199,56 @@ var TicketCreateSchema = z3.object({
 });
 var TicketPatchSchema = z3.object({
   TicketID: z3.number().int().positive().describe("Ticket ID to update."),
-  Attributes: z3.record(z3.string(), z3.string()).describe(
-    'Fields to update as key/value pairs. Keys must be valid ticket field names (e.g. "StatusID", "Title", "ResponsibleUID").'
+  Attributes: z3.record(z3.string().max(100), z3.string().max(65535)).refine((obj) => Object.keys(obj).length <= 50, { message: "Attributes may contain at most 50 fields per update." }).describe(
+    'Fields to update as key/value pairs. Keys must be valid ticket field names (e.g. "StatusID", "Title", "ResponsibleUID"). Maximum 50 fields per update.'
   ),
   NotifyRequestor: z3.boolean().optional().default(false).describe("Notify the requestor of the change."),
   NotifyResponsible: z3.boolean().optional().default(false).describe("Notify the responsible technician of the change."),
-  Comments: z3.string().optional().describe("Comment to attach to this update."),
+  Comments: z3.string().max(65535).optional().describe("Comment to attach to this update."),
   IsPrivate: z3.boolean().optional().default(false).describe("Whether the comment is private.")
 });
 var TicketCommentSchema = z3.object({
   TicketID: z3.number().int().positive().describe("Ticket ID to comment on."),
-  Body: z3.string().min(1).describe("Comment body (HTML supported)."),
+  Body: z3.string().min(1).max(65535).describe("Comment body (HTML supported)."),
   IsPrivate: z3.boolean().optional().default(false).describe("Whether this comment is private."),
   NotifyRequestor: z3.boolean().optional().default(false).describe("Notify the requestor."),
   NotifyResponsible: z3.boolean().optional().default(false).describe("Notify the responsible technician.")
 });
 var UserSearchSchema = z3.object({
-  SearchText: z3.string().optional().describe("Name, username, or email to search for."),
+  SearchText: z3.string().max(500).optional().describe("Name, username, or email to search for."),
   IsActive: z3.boolean().optional().describe("Filter by active (true) or inactive (false) users."),
   IsEmployee: z3.boolean().optional().describe("Filter to employees only."),
   AppID: z3.number().int().positive().optional().describe("Scope search to a specific application."),
   MaxResults: z3.number().int().min(1).max(1e3).optional().default(25).describe("Maximum results (1\u20131000).")
 });
 var GroupSearchSchema = z3.object({
-  NameLike: z3.string().optional().describe("Partial group name to search."),
+  NameLike: z3.string().max(500).optional().describe("Partial group name to search."),
   IsActive: z3.boolean().optional().describe("Filter by active (true) or inactive (false) groups."),
   AppID: z3.number().int().positive().optional().describe("Scope search to a specific application.")
 });
 var KbArticleSearchSchema = z3.object({
-  SearchText: z3.string().optional().describe("Full-text search within articles."),
+  SearchText: z3.string().max(500).optional().describe("Full-text search within articles."),
   CategoryID: z3.number().int().positive().optional().describe("Filter by KB category ID."),
   IsPublished: z3.boolean().optional().describe("Filter to published articles only."),
   MaxResults: z3.number().int().min(1).max(500).optional().default(25).describe("Maximum results (1\u2013500).")
 });
 var AssetSearchSchema = z3.object({
-  SerialLike: z3.string().optional().describe("Partial serial number to match."),
-  TagLike: z3.string().optional().describe("Partial asset tag to match."),
-  SearchText: z3.string().optional().describe("General text search across asset fields."),
+  SerialLike: z3.string().max(200).optional().describe("Partial serial number to match."),
+  TagLike: z3.string().max(200).optional().describe("Partial asset tag to match."),
+  SearchText: z3.string().max(500).optional().describe("General text search across asset fields."),
   StatusIDs: z3.array(z3.number().int()).optional().describe("Filter by asset status IDs."),
   OwnerUID: z3.string().uuid().optional().describe("Filter by asset owner GUID."),
   UsingDepartmentID: z3.number().int().positive().optional().describe("Filter by using department ID."),
   MaxResults: z3.number().int().min(1).max(1e3).optional().default(25).describe("Maximum results (1\u20131000).")
 });
 var ServiceSearchSchema = z3.object({
-  SearchText: z3.string().optional().describe("Full-text search across service fields."),
+  SearchText: z3.string().max(500).optional().describe("Full-text search across service fields."),
   IsActive: z3.boolean().optional().describe("Filter to active services only."),
   CategoryID: z3.number().int().positive().optional().describe("Filter by service category ID."),
   MaxResults: z3.number().int().min(1).max(500).optional().default(25).describe("Maximum results (1\u2013500).")
 });
 var ProjectSearchSchema = z3.object({
-  NameLike: z3.string().optional().describe("Partial project name to search."),
+  NameLike: z3.string().max(500).optional().describe("Partial project name to search."),
   TypeIDs: z3.array(z3.number().int()).optional().describe("Filter by project type IDs."),
   IsActive: z3.boolean().optional().describe("Filter to active projects."),
   ManagerUID: z3.string().uuid().optional().describe("Filter by project manager GUID."),
@@ -302,28 +256,28 @@ var ProjectSearchSchema = z3.object({
 });
 var TicketTaskCreateSchema = z3.object({
   TicketID: z3.number().int().positive().describe("Parent ticket ID."),
-  Title: z3.string().min(1).describe("Task title."),
-  Description: z3.string().optional().describe("Task description."),
+  Title: z3.string().min(1).max(500).describe("Task title."),
+  Description: z3.string().max(65535).optional().describe("Task description."),
   IsActive: z3.boolean().optional().default(true).describe("Whether the task is active."),
   AssignedUID: z3.string().uuid().optional().describe("GUID of the assigned user."),
   AssignedGroupID: z3.number().int().positive().optional().describe("Assigned group ID."),
   EstimatedMinutes: z3.number().int().nonnegative().optional().describe("Estimated minutes to complete."),
-  StartDate: z3.string().optional().describe("Task start date (ISO 8601)."),
-  EndDate: z3.string().optional().describe("Task due date (ISO 8601).")
+  StartDate: IsoDateSchema.optional().describe("Task start date (ISO 8601)."),
+  EndDate: IsoDateSchema.optional().describe("Task due date (ISO 8601).")
 });
 var KbArticleCreateSchema = z3.object({
-  Subject: z3.string().min(1).describe("Article title/subject."),
-  Body: z3.string().min(1).describe("Article body content (HTML supported)."),
-  Summary: z3.string().optional().describe("Short article summary."),
+  Subject: z3.string().min(1).max(500).describe("Article title/subject."),
+  Body: z3.string().min(1).max(5e5).describe("Article body content (HTML supported)."),
+  Summary: z3.string().max(2e3).optional().describe("Short article summary."),
   CategoryID: z3.number().int().positive().optional().describe("KB category ID."),
   IsPublished: z3.boolean().optional().default(false).describe("Whether to publish the article immediately."),
-  Tags: z3.string().optional().describe("Comma-separated tags for the article.")
+  Tags: z3.string().max(1e3).optional().describe("Comma-separated tags for the article.")
 });
 var KbArticleUpdateSchema = KbArticleCreateSchema.partial().extend({
   ArticleID: z3.number().int().positive().describe("KB article ID to update.")
 });
 var CiSearchSchema = z3.object({
-  SearchText: z3.string().optional().describe("Full-text search across CI fields."),
+  SearchText: z3.string().max(500).optional().describe("Full-text search across CI fields."),
   TypeIDs: z3.array(z3.number().int()).optional().describe("Filter by CI type IDs."),
   OwnerUID: z3.string().uuid().optional().describe("Filter by owner GUID."),
   MaxResults: z3.number().int().min(1).max(1e3).optional().default(25).describe("Maximum results (1\u20131000).")
@@ -332,25 +286,25 @@ var CustomAttributeComponentIdSchema = z3.number().int().positive().describe(
   "TeamDynamix component ID for the attribute context. Common values: 9 = Ticket, 27 = Asset, 63 = KB Article, 31 = Person."
 );
 var ProjectIssueCreateSchema = z3.object({
-  Title: z3.string().min(1).describe("Issue title."),
-  Description: z3.string().optional().describe("Issue description."),
+  Title: z3.string().min(1).max(500).describe("Issue title."),
+  Description: z3.string().max(65535).optional().describe("Issue description."),
   AssignedUID: z3.string().uuid().optional().describe("GUID of the assigned user."),
   StatusID: z3.number().int().nonnegative().optional().describe("Issue status ID."),
   PriorityID: z3.number().int().nonnegative().optional().describe("Issue priority ID."),
-  DueDate: z3.string().optional().describe("Issue due date (ISO 8601).")
+  DueDate: IsoDateSchema.optional().describe("Issue due date (ISO 8601).")
 });
 var ProjectRiskCreateSchema = z3.object({
-  Title: z3.string().min(1).describe("Risk title."),
-  Description: z3.string().optional().describe("Risk description."),
+  Title: z3.string().min(1).max(500).describe("Risk title."),
+  Description: z3.string().max(65535).optional().describe("Risk description."),
   AssignedUID: z3.string().uuid().optional().describe("GUID of the risk owner."),
   StatusID: z3.number().int().nonnegative().optional().describe("Risk status ID."),
   Probability: z3.number().int().min(1).max(100).optional().describe("Probability percentage (1\u2013100)."),
   Impact: z3.number().int().min(1).max(5).optional().describe("Impact level (1 = low, 5 = critical)."),
-  DueDate: z3.string().optional().describe("Risk resolution due date (ISO 8601).")
+  DueDate: IsoDateSchema.optional().describe("Risk resolution due date (ISO 8601).")
 });
 var TimeEntryQuerySchema = z3.object({
-  StartDate: z3.string().describe("Start date for time entries query (ISO 8601 date, e.g. 2026-01-01)."),
-  EndDate: z3.string().describe("End date for time entries query (ISO 8601 date, e.g. 2026-01-31).")
+  StartDate: IsoDateSchema.describe("Start date for time entries query (ISO 8601 date, e.g. 2026-01-01)."),
+  EndDate: IsoDateSchema.describe("End date for time entries query (ISO 8601 date, e.g. 2026-01-31).")
 });
 var TeamDynamixEntitySchema = z3.record(z3.string(), z3.unknown()).describe("Base TeamDynamix entity with flexible additional fields");
 var TeamDynamixNamedEntitySchema = z3.object({
@@ -390,396 +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 TeamDynamixClient = class {
+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
+    }
+  };
+}
+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;
   }
-  cachedToken = null;
-  async getCurrentUser() {
-    return await this.requestJson("/api/auth/getuser");
-  }
-  async listApplications() {
-    return await this.requestJson("/api/applications");
-  }
-  // -------------------------------------------------------------------------
-  // Discovery / Enumeration domains
-  // -------------------------------------------------------------------------
-  async listAccounts(appId) {
-    const path = appId ? `/api/${appId}/accounts` : "/api/accounts";
-    return await this.requestJson(path);
+  sdkPromise = null;
+  sdk() {
+    this.sdkPromise ??= createMcpSdkClient(this.config);
+    return this.sdkPromise;
   }
-  async getAccount(accountId) {
-    return await this.requestJson(`/api/accounts/${accountId}`);
+  //
+  // Discovery
+  //
+  getCurrentUser() {
+    return this.sdk().then((s) => s.discovery.authGetuser());
   }
-  async listLocations() {
-    return await this.requestJson("/api/locations");
+  listApplications() {
+    return this.sdk().then((s) => s.discovery.applications());
   }
-  async listFunctionalRoles() {
-    return await this.requestJson("/api/functionalroles");
+  //
+  // Tickets
+  //
+  getTicket(appId, ticketId) {
+    return this.sdk().then((s) => s.tickets.appIdTicketsId({ params: { path: { appId, id: ticketId } } }));
   }
-  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}`);
+  searchTickets(appId, _body) {
+    return this.sdk().then((s) => s.tickets.appIdTicketsFeed({ params: { path: { appId } } }));
   }
-  async listTicketStatuses(appId) {
-    return await this.requestJson(`/api/${appId}/tickets/statuses`);
+  listTicketTypes(appId) {
+    return this.sdk().then((s) => s.tickets.appIdTicketsTypes({ params: { path: { appId } } }));
   }
-  async listTicketTypes(appId) {
-    return await this.requestJson(`/api/${appId}/tickets/types`);
+  listTicketPriorities(appId) {
+    return this.sdk().then((s) => s.tickets.appIdTicketsPriorities({ params: { path: { appId } } }));
   }
-  async listTicketPriorities(appId) {
-    return await this.requestJson(`/api/${appId}/tickets/priorities`);
+  listTicketUrgencies(appId) {
+    return this.sdk().then((s) => s.tickets.appIdTicketsUrgencies({ params: { path: { appId } } }));
   }
-  async listTicketUrgencies(appId) {
-    return await this.requestJson(`/api/${appId}/tickets/urgencies`);
+  listTicketImpacts(appId) {
+    return this.sdk().then((s) => s.tickets.appIdTicketsImpacts({ params: { path: { appId } } }));
   }
-  async listTicketImpacts(appId) {
-    return await this.requestJson(`/api/${appId}/tickets/impacts`);
+  listTicketSources(appId) {
+    return this.sdk().then((s) => s.tickets.appIdTicketsSources({ params: { path: { appId } } }));
   }
-  async listTicketSources(appId) {
-    return await this.requestJson(`/api/${appId}/tickets/sources`);
+  getTicketFeed(appId, ticketId) {
+    return this.sdk().then((s) => s.tickets.appIdTicketsIdFeed({ params: { path: { appId, id: ticketId } } }));
   }
-  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) {
-    return await this.requestJson(
-      `/api/${appId}/tickets?NotifyRequestor=${notifyRequestor}&NotifyResponsible=${notifyResponsible}`,
-      {
-        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`);
-  }
-  async addTicketAsset(appId, ticketId, assetId) {
-    return await this.requestJson(`/api/${appId}/tickets/${ticketId}/assets/${assetId}`, {
-      method: "POST",
-      body: JSON.stringify({})
-    });
+  //
+  // People
+  //
+  getUser(uid) {
+    return this.sdk().then((s) => s.people.peopleUid({ params: { path: { uid } } }));
   }
-  async removeTicketAsset(appId, ticketId, assetId) {
-    await this.requestJson(`/api/${appId}/tickets/${ticketId}/assets/${assetId}`, { method: "DELETE" });
+  searchUsers(body) {
+    const searchText = typeof body["SearchText"] === "string" ? body["SearchText"] : "";
+    return this.sdk().then((s) => s.people.peopleLookup({ body: { SearchText: searchText } }));
   }
-  // -------------------------------------------------------------------------
-  // People & Groups
-  // -------------------------------------------------------------------------
-  async getUser(uid) {
-    return await this.requestJson(`/api/people/${encodeURIComponent(uid)}`);
+  getGroup(groupId) {
+    return this.sdk().then((s) => s.people.groupsId({ params: { path: { id: groupId } } }));
   }
-  async searchUsers(body) {
-    return await this.requestJson("/api/people/search", {
-      method: "POST",
-      body: JSON.stringify(body)
-    });
+  searchGroups(_body) {
+    return this.sdk().then((s) => s.people.searchGroups({ body: {} }));
   }
-  async getGroup(groupId) {
-    return await this.requestJson(`/api/groups/${groupId}`);
+  getGroupMembers(groupId) {
+    return this.sdk().then((s) => s.people.groupsIdMembers({ params: { path: { id: 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);
-    for (let attempt = 0; attempt <= cappedRetries; attempt += 1) {
-      const response = await fetch(endpoint, requestInit);
-      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.`
-      );
+}
+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 "";
     }
-    if (requireAdmin && this.config.authMode !== "admin") {
-      throw new Error(
-        "This TeamDynamix action requires admin authentication, but TEAMDYNAMIX_AUTH_MODE is not set to admin."
-      );
+    if (payload.every(isPlainObject)) {
+      return renderArrayAsMarkdownTable(payload);
     }
-    const expiresAtMs = this.cachedToken?.expiresAtMs;
-    if (this.cachedToken && (!expiresAtMs || expiresAtMs > Date.now() + 6e4)) {
-      return this.cachedToken.token;
+    return "```json\n" + JSON.stringify(payload, null, 2) + "\n```";
+  }
+  if (isPlainObject(payload)) {
+    const hasArrayOfObjects = Object.values(payload).some(isArrayOfPlainObjects);
+    if (hasArrayOfObjects) {
+      return renderObjectWithTables(payload);
     }
-    const token = await this.login();
-    return token;
+    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))}`);
   }
-  async login() {
-    if (!this.config.baseUrl) {
-      throw new Error("TeamDynamix base URL is not configured. Set TEAMDYNAMIX_BASE_URL.");
+  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]);
     }
-    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 response = await fetch(`${this.config.baseUrl}${loginPath}`, {
-      method: "POST",
-      headers: {
-        Accept: "application/json, text/plain;q=0.9",
-        "Content-Type": "application/json"
-      },
-      body
-    });
-    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
@@ -830,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",
@@ -864,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);
 }
@@ -1475,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);
@@ -1534,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);
@@ -1586,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);