@selfagency/teamdynamix-mcp 0.1.0

package/index.js

@@ -0,0 +1,1868 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { McpServer as McpServer2 } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/config.ts
+import { z } from "zod";
+
+// src/constants.ts
+var SERVER_NAME = "teamdynamix-mcp";
+var SERVER_VERSION = "0.2.0";
+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";
+function normalizeOptionalString(value) {
+  const normalized = value?.trim();
+  return normalized ? normalized : void 0;
+}
+function normalizeOptionalNumber(value) {
+  if (!value?.trim()) {
+    return void 0;
+  }
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
+}
+function normalizeBoolean(value, defaultValue) {
+  if (!value) {
+    return defaultValue;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "true") return true;
+  if (normalized === "false") return false;
+  return defaultValue;
+}
+function normalizeNumberWithDefault(value, defaultValue, minimum) {
+  if (!value?.trim()) {
+    return defaultValue;
+  }
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed >= minimum ? parsed : defaultValue;
+}
+function normalizeTeamDynamixBaseUrl(value) {
+  const normalized = normalizeOptionalString(value);
+  return normalized ? normalized.replace(/\/+$/, "") : void 0;
+}
+function validateHttpsBaseUrl(value) {
+  if (!value) return void 0;
+  const schema = z.string().url().refine((url) => url.startsWith("https://"), {
+    message: "TEAMDYNAMIX_BASE_URL must be an https URL."
+  });
+  const parsed = schema.safeParse(value);
+  if (!parsed.success) {
+    throw new Error(parsed.error.issues[0]?.message ?? "Invalid TEAMDYNAMIX_BASE_URL.");
+  }
+  return value;
+}
+function normalizeTeamDynamixAuthMode(value) {
+  return value?.trim().toLowerCase() === "admin" ? "admin" : "standard";
+}
+function getTeamDynamixConfig() {
+  const baseUrl = validateHttpsBaseUrl(normalizeTeamDynamixBaseUrl(process.env["TEAMDYNAMIX_BASE_URL"]));
+  const maxRetries = normalizeNumberWithDefault(
+    process.env["TEAMDYNAMIX_MAX_RETRIES"],
+    TEAMDYNAMIX_DEFAULT_MAX_RETRIES,
+    0
+  );
+  if (maxRetries > 5) {
+    throw new Error(`TEAMDYNAMIX_MAX_RETRIES must be between 0 and ${TEAMDYNAMIX_MAX_RETRY_ATTEMPTS}.`);
+  }
+  return {
+    baseUrl,
+    authMode: normalizeTeamDynamixAuthMode(process.env["TEAMDYNAMIX_AUTH_MODE"]),
+    username: normalizeOptionalString(process.env["TEAMDYNAMIX_USERNAME"]),
+    password: normalizeOptionalString(process.env["TEAMDYNAMIX_PASSWORD"]),
+    beid: normalizeOptionalString(process.env["TEAMDYNAMIX_BEID"]),
+    webServicesKey: normalizeOptionalString(process.env["TEAMDYNAMIX_WEB_SERVICES_KEY"]),
+    defaultTicketAppId: normalizeOptionalNumber(process.env["TEAMDYNAMIX_DEFAULT_TICKET_APP_ID"]),
+    defaultAssetAppId: normalizeOptionalNumber(process.env["TEAMDYNAMIX_DEFAULT_ASSET_APP_ID"]),
+    defaultKnowledgeBaseAppId: normalizeOptionalNumber(process.env["TEAMDYNAMIX_DEFAULT_KB_APP_ID"]),
+    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)
+  };
+}
+function getTeamDynamixConfigStatus(config = getTeamDynamixConfig()) {
+  const missing = /* @__PURE__ */ new Set();
+  if (!config.baseUrl) {
+    missing.add("TEAMDYNAMIX_BASE_URL");
+  }
+  if (config.authMode === "admin") {
+    if (!config.beid) missing.add("TEAMDYNAMIX_BEID");
+    if (!config.webServicesKey) missing.add("TEAMDYNAMIX_WEB_SERVICES_KEY");
+  } else {
+    if (!config.username) missing.add("TEAMDYNAMIX_USERNAME");
+    if (!config.password) missing.add("TEAMDYNAMIX_PASSWORD");
+  }
+  return {
+    configured: missing.size === 0,
+    missing: [...missing],
+    authMode: config.authMode
+  };
+}
+
+// src/resources/teamdynamix.resources.ts
+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,
+    authMode: config.authMode,
+    username: config.username ? "[configured]" : null,
+    password: config.password ? "[configured]" : null,
+    beid: config.beid ? "[configured]" : null,
+    webServicesKey: config.webServicesKey ? "[configured]" : null,
+    defaultTicketAppId: config.defaultTicketAppId ?? null,
+    defaultAssetAppId: config.defaultAssetAppId ?? null,
+    defaultKnowledgeBaseAppId: config.defaultKnowledgeBaseAppId ?? null,
+    timeoutMs: config.timeoutMs,
+    maxRetries: config.maxRetries,
+    enableWriteTools: config.enableWriteTools,
+    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";
+
+// src/schemas/teamdynamix/index.ts
+import { z as z3 } from "zod";
+
+// src/schemas/index.ts
+import { z as z2 } from "zod";
+var ResponseFormatSchema = z2.enum(["markdown", "json"]).default("markdown").describe("Output format for the response.");
+var TextTransformModeSchema = z2.enum(["uppercase", "lowercase", "trim", "slug"]).describe("Transformation mode to apply to the input text.");
+
+// src/schemas/teamdynamix/index.ts
+var TeamDynamixAppIdSchema = z3.number().int().positive().describe("TeamDynamix application ID.");
+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."),
+  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."),
+  PriorityIDs: z3.array(z3.number().int()).optional().describe("Filter by ticket priority IDs."),
+  UrgencyIDs: z3.array(z3.number().int()).optional().describe("Filter by ticket urgency IDs."),
+  ImpactIDs: z3.array(z3.number().int()).optional().describe("Filter by ticket impact IDs."),
+  AccountIDs: z3.array(z3.number().int()).optional().describe("Filter by account/department IDs."),
+  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."),
+  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."),
+  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)."),
+  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."),
+  FormID: z3.number().int().positive().optional().describe("Ticket form ID."),
+  Attributes: z3.array(
+    z3.object({
+      ID: z3.number().int(),
+      Value: z3.string()
+    })
+  ).optional().describe("Custom attribute values.")
+});
+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").'
+  ),
+  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."),
+  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)."),
+  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."),
+  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."),
+  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."),
+  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."),
+  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."),
+  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."),
+  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."),
+  MaxResults: z3.number().int().min(1).max(500).optional().default(25).describe("Maximum results (1\u2013500).")
+});
+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."),
+  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).")
+});
+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."),
+  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.")
+});
+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."),
+  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).")
+});
+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."),
+  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).")
+});
+var ProjectRiskCreateSchema = z3.object({
+  Title: z3.string().min(1).describe("Risk title."),
+  Description: z3.string().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).")
+});
+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).")
+});
+var TeamDynamixEntitySchema = z3.record(z3.string(), z3.unknown()).describe("Base TeamDynamix entity with flexible additional fields");
+var TeamDynamixNamedEntitySchema = z3.object({
+  ID: z3.number().int().positive("ID must be a positive integer"),
+  Name: z3.string().optional()
+}).catchall(z3.unknown()).describe("TeamDynamix entity with ID and optional Name");
+var TeamDynamixApplicationSchema = TeamDynamixNamedEntitySchema.extend({
+  Name: z3.string().optional()
+}).describe("TeamDynamix Application entity");
+var TeamDynamixTicketSchema = TeamDynamixNamedEntitySchema.extend({
+  Title: z3.string().optional(),
+  Description: z3.string().optional(),
+  StatusID: z3.number().int().optional(),
+  TypeID: z3.number().int().optional()
+}).describe("TeamDynamix Ticket entity");
+var TeamDynamixKbArticleSchema = TeamDynamixNamedEntitySchema.extend({
+  Subject: z3.string().optional(),
+  Body: z3.string().optional(),
+  IsPublished: z3.boolean().optional()
+}).describe("TeamDynamix Knowledge Base Article entity");
+var TeamDynamixAssetSchema = TeamDynamixNamedEntitySchema.extend({
+  Tag: z3.string().optional(),
+  StatusID: z3.number().int().optional()
+}).describe("TeamDynamix Asset entity");
+var TeamDynamixProjectSchema = TeamDynamixNamedEntitySchema.extend({
+  Status: z3.string().optional()
+}).describe("TeamDynamix Project entity");
+var TeamDynamixGroupSchema = TeamDynamixNamedEntitySchema.extend({
+  Description: z3.string().optional()
+}).describe("TeamDynamix Group entity");
+var TeamDynamixUserSchema = z3.object({
+  UID: z3.string({ error: "User UID is required" }),
+  FullName: z3.string().optional(),
+  Email: z3.string().email().optional(),
+  IsActive: z3.boolean().optional()
+}).catchall(z3.unknown()).describe("TeamDynamix User entity");
+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."
+    );
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+function normalizePath(path) {
+  return path.startsWith("/") ? path : `/${path}`;
+}
+var TeamDynamixClient = 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);
+  }
+  async getAccount(accountId) {
+    return await this.requestJson(`/api/accounts/${accountId}`);
+  }
+  async listLocations() {
+    return await this.requestJson("/api/locations");
+  }
+  async listFunctionalRoles() {
+    return await this.requestJson("/api/functionalroles");
+  }
+  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}`);
+  }
+  async listTicketStatuses(appId) {
+    return await this.requestJson(`/api/${appId}/tickets/statuses`);
+  }
+  async listTicketTypes(appId) {
+    return await this.requestJson(`/api/${appId}/tickets/types`);
+  }
+  async listTicketPriorities(appId) {
+    return await this.requestJson(`/api/${appId}/tickets/priorities`);
+  }
+  async listTicketUrgencies(appId) {
+    return await this.requestJson(`/api/${appId}/tickets/urgencies`);
+  }
+  async listTicketImpacts(appId) {
+    return await this.requestJson(`/api/${appId}/tickets/impacts`);
+  }
+  async listTicketSources(appId) {
+    return await this.requestJson(`/api/${appId}/tickets/sources`);
+  }
+  async getTicket(appId, ticketId) {
+    return await this.requestJson(`/api/${appId}/tickets/${ticketId}`);
+  }
+  async searchTickets(appId, body) {
+    return await this.requestJson(`/api/${appId}/tickets/search`, {
+      method: "POST",
+      body: JSON.stringify(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)
+      }
+    );
+  }
+  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)
+    });
+  }
+  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
+      })
+    });
+  }
+  async getTicketFeed(appId, ticketId) {
+    return await this.requestJson(`/api/${appId}/tickets/${ticketId}/feed`);
+  }
+  async getTicketTasks(appId, ticketId) {
+    return await this.requestJson(`/api/${appId}/tickets/${ticketId}/tasks`);
+  }
+  async createTicketTask(appId, ticketId, body) {
+    return await this.requestJson(`/api/${appId}/tickets/${ticketId}/tasks`, {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+  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({})
+    });
+  }
+  async removeTicketAsset(appId, ticketId, assetId) {
+    await this.requestJson(`/api/${appId}/tickets/${ticketId}/assets/${assetId}`, { method: "DELETE" });
+  }
+  // -------------------------------------------------------------------------
+  // People & Groups
+  // -------------------------------------------------------------------------
+  async getUser(uid) {
+    return await this.requestJson(`/api/people/${encodeURIComponent(uid)}`);
+  }
+  async searchUsers(body) {
+    return await this.requestJson("/api/people/search", {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+  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)
+    });
+  }
+  async getGroupMembers(groupId) {
+    return await this.requestJson(`/api/groups/${groupId}/members`);
+  }
+  // -------------------------------------------------------------------------
+  // 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)
+    });
+  }
+  async listKbCategories(appId) {
+    return await this.requestJson(`/api/${appId}/knowledgebase/categories`);
+  }
+  async createKbArticle(appId, body) {
+    return await this.requestJson(`/api/${appId}/knowledgebase`, {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+  async updateKbArticle(appId, articleId, body) {
+    return await this.requestJson(`/api/${appId}/knowledgebase/${articleId}`, {
+      method: "PUT",
+      body: JSON.stringify(body)
+    });
+  }
+  // -------------------------------------------------------------------------
+  // Assets / CMDB
+  // -------------------------------------------------------------------------
+  async getAsset(appId, assetId) {
+    return await this.requestJson(`/api/${appId}/assets/${assetId}`);
+  }
+  async searchAssets(appId, body) {
+    return await this.requestJson(`/api/${appId}/assets/search`, {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+  async listAssetStatuses(appId) {
+    return await this.requestJson(`/api/${appId}/assets/statuses`);
+  }
+  async listProductModels(appId) {
+    return await this.requestJson(`/api/${appId}/assets/models`);
+  }
+  async listVendors(appId) {
+    return await this.requestJson(`/api/${appId}/assets/vendors`);
+  }
+  async getConfigurationItem(appId, ciId) {
+    return await this.requestJson(`/api/${appId}/cmdb/${ciId}`);
+  }
+  async searchConfigurationItems(appId, body) {
+    return await this.requestJson(`/api/${appId}/cmdb/search`, {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+  async listCiTypes(appId) {
+    return await this.requestJson(`/api/${appId}/cmdb/types`);
+  }
+  async listCiRelationshipTypes() {
+    return await this.requestJson("/api/cmdb/relationshiptypes");
+  }
+  // -------------------------------------------------------------------------
+  // Service Catalog
+  // -------------------------------------------------------------------------
+  async listServiceCatalog(appId) {
+    return await this.requestJson(`/api/${appId}/services`);
+  }
+  async getService(appId, serviceId) {
+    return await this.requestJson(`/api/${appId}/services/${serviceId}`);
+  }
+  async searchServices(appId, body) {
+    return await this.requestJson(`/api/${appId}/services/search`, {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+  // -------------------------------------------------------------------------
+  // 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)
+    });
+  }
+  async listProjectTypes() {
+    return await this.requestJson("/api/projects/types");
+  }
+  async getProjectPlans(projectId) {
+    return await this.requestJson(`/api/projects/${projectId}/plans`);
+  }
+  async getProjectIssues(projectId) {
+    return await this.requestJson(`/api/projects/${projectId}/issues`);
+  }
+  async getProjectRisks(projectId) {
+    return await this.requestJson(`/api/projects/${projectId}/risks`);
+  }
+  async createProjectIssue(projectId, body) {
+    return await this.requestJson(`/api/projects/${projectId}/issues`, {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+  async createProjectRisk(projectId, body) {
+    return await this.requestJson(`/api/projects/${projectId}/risks`, {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+  async listTimeTypes() {
+    return await this.requestJson("/api/time/types");
+  }
+  async getMyTimeEntries(startDate, endDate) {
+    const qs = new URLSearchParams({ startDate, endDate });
+    return await this.requestJson(`/api/time/entries?${qs}`);
+  }
+  async getTicketContacts(appId, ticketId) {
+    return await this.requestJson(`/api/${appId}/tickets/${ticketId}/contacts`);
+  }
+  async addTicketContact(appId, ticketId, contactUid) {
+    return await this.requestJson(`/api/${appId}/tickets/${ticketId}/contacts/${contactUid}`, {
+      method: "PUT"
+    });
+  }
+  async removeTicketContact(appId, ticketId, contactUid) {
+    await this.requestJson(`/api/${appId}/tickets/${ticketId}/contacts/${contactUid}`, {
+      method: "DELETE"
+    });
+  }
+  async listServiceCategories(appId) {
+    return await this.requestJson(`/api/${appId}/services/categories`);
+  }
+  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.`
+      );
+    }
+    if (requireAdmin && this.config.authMode !== "admin") {
+      throw new Error(
+        "This TeamDynamix action requires admin authentication, but TEAMDYNAMIX_AUTH_MODE is not set to admin."
+      );
+    }
+    const expiresAtMs = this.cachedToken?.expiresAtMs;
+    if (this.cachedToken && (!expiresAtMs || expiresAtMs > Date.now() + 6e4)) {
+      return this.cachedToken.token;
+    }
+    const token = await this.login();
+    return token;
+  }
+  async login() {
+    if (!this.config.baseUrl) {
+      throw new Error("TeamDynamix base URL is not configured. Set TEAMDYNAMIX_BASE_URL.");
+    }
+    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}).`);
+    }
+    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;
+  }
+};
+function createConfiguredTeamDynamixClient() {
+  return new TeamDynamixClient(getTeamDynamixConfig());
+}
+
+// src/tools/teamdynamix.domain-gateways.tools.ts
+var teamdynamixDiscoveryActionSchema = z4.enum([
+  "server_status",
+  "get_current_user",
+  "list_applications",
+  "list_ticket_statuses"
+]);
+var teamdynamixTicketActionSchema = z4.enum([
+  "list_ticket_types",
+  "list_ticket_priorities",
+  "list_ticket_urgencies",
+  "list_ticket_impacts",
+  "list_ticket_sources",
+  "get_ticket",
+  "search_tickets",
+  "create_ticket",
+  "update_ticket",
+  "add_ticket_comment",
+  "get_ticket_feed"
+]);
+var teamdynamixTicketRelationshipActionSchema = z4.enum([
+  "get_ticket_tasks",
+  "create_ticket_task",
+  "list_ticket_assets",
+  "add_ticket_asset",
+  "remove_ticket_asset",
+  "get_ticket_contacts",
+  "add_ticket_contact",
+  "remove_ticket_contact"
+]);
+var teamdynamixPeopleActionSchema = z4.enum([
+  "get_user",
+  "search_users",
+  "get_group",
+  "search_groups",
+  "get_group_members"
+]);
+var teamdynamixKnowledgeBaseActionSchema = z4.enum([
+  "get_kb_article",
+  "search_kb_articles",
+  "list_kb_categories",
+  "create_kb_article",
+  "update_kb_article"
+]);
+var teamdynamixAssetsActionSchema = z4.enum([
+  "get_asset",
+  "search_assets",
+  "list_asset_statuses",
+  "list_product_models"
+]);
+var teamdynamixCmdbActionSchema = z4.enum([
+  "get_ci",
+  "search_cis",
+  "list_ci_types",
+  "list_ci_relationship_types",
+  "list_vendors"
+]);
+var teamdynamixServicesActionSchema = z4.enum([
+  "list_services",
+  "get_service",
+  "search_services",
+  "list_service_categories"
+]);
+var teamdynamixProjectsActionSchema = z4.enum([
+  "get_project",
+  "search_projects",
+  "list_project_types",
+  "get_project_plans",
+  "get_project_issues",
+  "get_project_risks",
+  "create_project_issue",
+  "create_project_risk"
+]);
+var teamdynamixTimeActionSchema = z4.enum(["list_time_types", "get_my_time_entries"]);
+var teamdynamixReferenceDataActionSchema = z4.enum([
+  "list_accounts",
+  "get_account",
+  "list_locations",
+  "list_functional_roles",
+  "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);
+}
+function toStructuredContent(payload) {
+  if (typeof payload === "object" && payload !== null && !Array.isArray(payload)) {
+    return payload;
+  }
+  return {
+    data: payload
+  };
+}
+function parsePayload(schema, payload, action) {
+  const parsed = schema.safeParse(payload);
+  if (!parsed.success) {
+    const details = parsed.error.issues.map((issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`).join("; ");
+    throw new Error(`Invalid payload for action "${action}": ${details}`);
+  }
+  return parsed.data;
+}
+function toSuccessResponse(payload, responseFormat) {
+  return {
+    content: [{ type: "text", text: render(payload, responseFormat) }],
+    structuredContent: toStructuredContent(payload)
+  };
+}
+function toErrorResponse(error) {
+  const message = messageFromError(error);
+  return {
+    content: [{ type: "text", text: `Error: ${message}` }],
+    structuredContent: {
+      ok: false,
+      kind: "unknown",
+      message
+    },
+    isError: true
+  };
+}
+var teamdynamixDiscoveryTool = `${TEAMDYNAMIX_TOOL_PREFIX}_discovery`;
+var teamdynamixTicketsTool = `${TEAMDYNAMIX_TOOL_PREFIX}_tickets`;
+var teamdynamixTicketRelationshipsTool = `${TEAMDYNAMIX_TOOL_PREFIX}_ticket_relationships`;
+var teamdynamixPeopleTool = `${TEAMDYNAMIX_TOOL_PREFIX}_people`;
+var teamdynamixKnowledgeBaseTool = `${TEAMDYNAMIX_TOOL_PREFIX}_knowledge_base`;
+var teamdynamixAssetsTool = `${TEAMDYNAMIX_TOOL_PREFIX}_assets`;
+var teamdynamixCmdbTool = `${TEAMDYNAMIX_TOOL_PREFIX}_cmdb`;
+var teamdynamixServicesTool = `${TEAMDYNAMIX_TOOL_PREFIX}_services`;
+var teamdynamixProjectsTool = `${TEAMDYNAMIX_TOOL_PREFIX}_projects`;
+var teamdynamixTimeTool = `${TEAMDYNAMIX_TOOL_PREFIX}_time`;
+var teamdynamixReferenceDataTool = `${TEAMDYNAMIX_TOOL_PREFIX}_reference_data`;
+var TEAMDYNAMIX_GATEWAY_SURFACE = {
+  discovery: {
+    tool: teamdynamixDiscoveryTool,
+    actions: teamdynamixDiscoveryActionSchema.options
+  },
+  tickets: {
+    tool: teamdynamixTicketsTool,
+    actions: teamdynamixTicketActionSchema.options
+  },
+  ticketRelationships: {
+    tool: teamdynamixTicketRelationshipsTool,
+    actions: teamdynamixTicketRelationshipActionSchema.options
+  },
+  people: {
+    tool: teamdynamixPeopleTool,
+    actions: teamdynamixPeopleActionSchema.options
+  },
+  knowledgeBase: {
+    tool: teamdynamixKnowledgeBaseTool,
+    actions: teamdynamixKnowledgeBaseActionSchema.options
+  },
+  assets: {
+    tool: teamdynamixAssetsTool,
+    actions: teamdynamixAssetsActionSchema.options
+  },
+  cmdb: {
+    tool: teamdynamixCmdbTool,
+    actions: teamdynamixCmdbActionSchema.options
+  },
+  services: {
+    tool: teamdynamixServicesTool,
+    actions: teamdynamixServicesActionSchema.options
+  },
+  projects: {
+    tool: teamdynamixProjectsTool,
+    actions: teamdynamixProjectsActionSchema.options
+  },
+  time: {
+    tool: teamdynamixTimeTool,
+    actions: teamdynamixTimeActionSchema.options
+  },
+  referenceData: {
+    tool: teamdynamixReferenceDataTool,
+    actions: teamdynamixReferenceDataActionSchema.options
+  }
+};
+function registerTeamDynamixDomainGatewayTools(server2) {
+  registerTeamDynamixDiscoveryGateway(server2);
+  registerTeamDynamixTicketsGateway(server2);
+  registerTeamDynamixTicketRelationshipsGateway(server2);
+  registerTeamDynamixPeopleGateway(server2);
+  registerTeamDynamixKnowledgeBaseGateway(server2);
+  registerTeamDynamixAssetsGateway(server2);
+  registerTeamDynamixCmdbGateway(server2);
+  registerTeamDynamixServicesGateway(server2);
+  registerTeamDynamixProjectsGateway(server2);
+  registerTeamDynamixTimeGateway(server2);
+  registerTeamDynamixReferenceDataGateway(server2);
+}
+function registerTeamDynamixDiscoveryGateway(server2) {
+  server2.registerTool(
+    teamdynamixDiscoveryTool,
+    {
+      title: "TeamDynamix Discovery Gateway",
+      description: "Gateway for discovery operations: server status, current user, applications, and ticket status lookup.",
+      inputSchema: {
+        action: teamdynamixDiscoveryActionSchema,
+        payload: gatewayPayloadSchema,
+        response_format: TeamDynamixResponseFormatSchema
+      },
+      annotations: { readOnlyHint: true, idempotentHint: false, destructiveHint: false, openWorldHint: true }
+    },
+    async ({ action, payload, response_format }) => {
+      try {
+        const client = createConfiguredTeamDynamixClient();
+        switch (action) {
+          case "server_status": {
+            const config = getTeamDynamixConfig();
+            const status = getTeamDynamixConfigStatus(config);
+            const result = {
+              status,
+              config: redactTeamDynamixConfig(config),
+              gateway: "discovery",
+              actions: TEAMDYNAMIX_GATEWAY_SURFACE.discovery.actions
+            };
+            return toSuccessResponse(result, response_format);
+          }
+          case "get_current_user": {
+            const user = await client.getCurrentUser();
+            return toSuccessResponse(user, response_format);
+          }
+          case "list_applications": {
+            const applications = await client.listApplications();
+            return toSuccessResponse({ count: applications.length, applications }, response_format);
+          }
+          case "list_ticket_statuses": {
+            const parsed = parsePayload(z4.object({ app_id: TeamDynamixAppIdSchema.optional() }), payload, action);
+            const config = getTeamDynamixConfig();
+            const effectiveAppId = parsed.app_id ?? config.defaultTicketAppId;
+            if (!effectiveAppId) {
+              throw new Error(
+                "No TeamDynamix ticket application ID was provided. Supply payload.app_id or configure TEAMDYNAMIX_DEFAULT_TICKET_APP_ID."
+              );
+            }
+            const statuses = await client.listTicketStatuses(effectiveAppId);
+            return toSuccessResponse({ appId: effectiveAppId, count: statuses.length, statuses }, response_format);
+          }
+        }
+      } catch (error) {
+        return toErrorResponse(error);
+      }
+    }
+  );
+}
+function registerTeamDynamixTicketsGateway(server2) {
+  server2.registerTool(
+    teamdynamixTicketsTool,
+    {
+      title: "TeamDynamix Tickets Gateway",
+      description: "Gateway for ticket metadata, read/search, create/update, comments, and feed operations.",
+      inputSchema: {
+        action: teamdynamixTicketActionSchema,
+        payload: gatewayPayloadSchema,
+        response_format: TeamDynamixResponseFormatSchema
+      },
+      annotations: { readOnlyHint: false, idempotentHint: false, destructiveHint: true, openWorldHint: true }
+    },
+    async ({ action, payload, response_format }) => {
+      try {
+        const client = createConfiguredTeamDynamixClient();
+        switch (action) {
+          case "list_ticket_types": {
+            const parsed = parsePayload(z4.object({ app_id: TeamDynamixAppIdSchema }), payload, action);
+            const types = await client.listTicketTypes(parsed.app_id);
+            return toSuccessResponse({ appId: parsed.app_id, types }, response_format);
+          }
+          case "list_ticket_priorities": {
+            const parsed = parsePayload(z4.object({ app_id: TeamDynamixAppIdSchema }), payload, action);
+            const priorities = await client.listTicketPriorities(parsed.app_id);
+            return toSuccessResponse({ appId: parsed.app_id, priorities }, response_format);
+          }
+          case "list_ticket_urgencies": {
+            const parsed = parsePayload(z4.object({ app_id: TeamDynamixAppIdSchema }), payload, action);
+            const urgencies = await client.listTicketUrgencies(parsed.app_id);
+            return toSuccessResponse({ appId: parsed.app_id, urgencies }, response_format);
+          }
+          case "list_ticket_impacts": {
+            const parsed = parsePayload(z4.object({ app_id: TeamDynamixAppIdSchema }), payload, action);
+            const impacts = await client.listTicketImpacts(parsed.app_id);
+            return toSuccessResponse({ appId: parsed.app_id, impacts }, response_format);
+          }
+          case "list_ticket_sources": {
+            const parsed = parsePayload(z4.object({ app_id: TeamDynamixAppIdSchema }), payload, action);
+            const sources = await client.listTicketSources(parsed.app_id);
+            return toSuccessResponse({ appId: parsed.app_id, sources }, response_format);
+          }
+          case "get_ticket": {
+            const parsed = parsePayload(
+              z4.object({ app_id: TeamDynamixAppIdSchema, ticket_id: z4.number().int().positive() }),
+              payload,
+              action
+            );
+            const ticket = await client.getTicket(parsed.app_id, parsed.ticket_id);
+            return toSuccessResponse(ticket, response_format);
+          }
+          case "search_tickets": {
+            const parsed = parsePayload(
+              z4.object({ app_id: TeamDynamixAppIdSchema, search: TicketSearchSchema }),
+              payload,
+              action
+            );
+            const tickets = await client.searchTickets(parsed.app_id, parsed.search);
+            return toSuccessResponse({ appId: parsed.app_id, count: tickets.length, tickets }, response_format);
+          }
+          case "create_ticket": {
+            const parsed = parsePayload(
+              z4.object({
+                app_id: TeamDynamixAppIdSchema,
+                ticket: TicketCreateSchema,
+                notify_requestor: z4.boolean().optional().default(false),
+                notify_responsible: z4.boolean().optional().default(false)
+              }),
+              payload,
+              action
+            );
+            assertWriteToolsEnabled(getTeamDynamixConfig());
+            const created = await client.createTicket(
+              parsed.app_id,
+              parsed.ticket,
+              parsed.notify_requestor,
+              parsed.notify_responsible
+            );
+            return toSuccessResponse(created, response_format);
+          }
+          case "update_ticket": {
+            const parsed = parsePayload(
+              z4.object({ app_id: TeamDynamixAppIdSchema, patch: TicketPatchSchema }),
+              payload,
+              action
+            );
+            assertWriteToolsEnabled(getTeamDynamixConfig());
+            const updated = await client.updateTicket(
+              parsed.app_id,
+              parsed.patch.TicketID,
+              parsed.patch.Attributes,
+              parsed.patch.NotifyRequestor ?? false,
+              parsed.patch.NotifyResponsible ?? false,
+              parsed.patch.Comments ?? "",
+              parsed.patch.IsPrivate ?? false
+            );
+            return toSuccessResponse(updated, response_format);
+          }
+          case "add_ticket_comment": {
+            const parsed = parsePayload(
+              z4.object({ app_id: TeamDynamixAppIdSchema, comment: TicketCommentSchema }),
+              payload,
+              action
+            );
+            assertWriteToolsEnabled(getTeamDynamixConfig());
+            const entry = await client.addTicketComment(
+              parsed.app_id,
+              parsed.comment.TicketID,
+              parsed.comment.Body,
+              parsed.comment.IsPrivate ?? false,
+              parsed.comment.NotifyRequestor ?? false,
+              parsed.comment.NotifyResponsible ?? false
+            );
+            return toSuccessResponse(entry, response_format);
+          }
+          case "get_ticket_feed": {
+            const parsed = parsePayload(
+              z4.object({ app_id: TeamDynamixAppIdSchema, ticket_id: z4.number().int().positive() }),
+              payload,
+              action
+            );
+            const feed = await client.getTicketFeed(parsed.app_id, parsed.ticket_id);
+            return toSuccessResponse(
+              { appId: parsed.app_id, ticketId: parsed.ticket_id, entries: feed },
+              response_format
+            );
+          }
+        }
+      } catch (error) {
+        return toErrorResponse(error);
+      }
+    }
+  );
+}
+function registerTeamDynamixTicketRelationshipsGateway(server2) {
+  server2.registerTool(
+    teamdynamixTicketRelationshipsTool,
+    {
+      title: "TeamDynamix Ticket Relationships Gateway",
+      description: "Gateway for ticket tasks, linked assets, and linked contacts operations.",
+      inputSchema: {
+        action: teamdynamixTicketRelationshipActionSchema,
+        payload: gatewayPayloadSchema,
+        response_format: TeamDynamixResponseFormatSchema
+      },
+      annotations: { readOnlyHint: false, idempotentHint: false, destructiveHint: true, openWorldHint: true }
+    },
+    async ({ action, payload, response_format }) => {
+      try {
+        const client = createConfiguredTeamDynamixClient();
+        switch (action) {
+          case "get_ticket_tasks": {
+            const parsed = parsePayload(
+              z4.object({ app_id: TeamDynamixAppIdSchema, ticket_id: z4.number().int().positive() }),
+              payload,
+              action
+            );
+            const tasks = await client.getTicketTasks(parsed.app_id, parsed.ticket_id);
+            return toSuccessResponse(
+              { appId: parsed.app_id, ticketId: parsed.ticket_id, count: tasks.length, tasks },
+              response_format
+            );
+          }
+          case "create_ticket_task": {
+            const parsed = parsePayload(
+              z4.object({ app_id: TeamDynamixAppIdSchema, task: TicketTaskCreateSchema }),
+              payload,
+              action
+            );
+            assertWriteToolsEnabled(getTeamDynamixConfig());
+            const created = await client.createTicketTask(
+              parsed.app_id,
+              parsed.task.TicketID,
+              parsed.task
+            );
+            return toSuccessResponse(created, response_format);
+          }
+          case "list_ticket_assets": {
+            const parsed = parsePayload(
+              z4.object({ app_id: TeamDynamixAppIdSchema, ticket_id: z4.number().int().positive() }),
+              payload,
+              action
+            );
+            const assets = await client.listTicketAssets(parsed.app_id, parsed.ticket_id);
+            return toSuccessResponse(
+              { appId: parsed.app_id, ticketId: parsed.ticket_id, count: assets.length, assets },
+              response_format
+            );
+          }
+          case "add_ticket_asset": {
+            const parsed = parsePayload(
+              z4.object({
+                app_id: TeamDynamixAppIdSchema,
+                ticket_id: z4.number().int().positive(),
+                asset_id: z4.number().int().positive()
+              }),
+              payload,
+              action
+            );
+            assertWriteToolsEnabled(getTeamDynamixConfig());
+            const result = await client.addTicketAsset(parsed.app_id, parsed.ticket_id, parsed.asset_id);
+            return toSuccessResponse(result, response_format);
+          }
+          case "remove_ticket_asset": {
+            const parsed = parsePayload(
+              z4.object({
+                app_id: TeamDynamixAppIdSchema,
+                ticket_id: z4.number().int().positive(),
+                asset_id: z4.number().int().positive(),
+                confirm: z4.literal(true)
+              }),
+              payload,
+              action
+            );
+            assertWriteToolsEnabled(getTeamDynamixConfig());
+            await client.removeTicketAsset(parsed.app_id, parsed.ticket_id, parsed.asset_id);
+            return toSuccessResponse(
+              {
+                appId: parsed.app_id,
+                ticketId: parsed.ticket_id,
+                assetId: parsed.asset_id,
+                unlinked: true
+              },
+              response_format
+            );
+          }
+          case "get_ticket_contacts": {
+            const parsed = parsePayload(
+              z4.object({ app_id: TeamDynamixAppIdSchema, ticket_id: z4.number().int().positive() }),
+              payload,
+              action
+            );
+            const contacts = await client.getTicketContacts(parsed.app_id, parsed.ticket_id);
+            return toSuccessResponse(
+              { appId: parsed.app_id, ticketId: parsed.ticket_id, count: contacts.length, contacts },
+              response_format
+            );
+          }
+          case "add_ticket_contact": {
+            const parsed = parsePayload(
+              z4.object({
+                app_id: TeamDynamixAppIdSchema,
+                ticket_id: z4.number().int().positive(),
+                contact_uid: TeamDynamixGuidSchema
+              }),
+              payload,
+              action
+            );
+            assertWriteToolsEnabled(getTeamDynamixConfig());
+            const result = await client.addTicketContact(parsed.app_id, parsed.ticket_id, parsed.contact_uid);
+            return toSuccessResponse(result, response_format);
+          }
+          case "remove_ticket_contact": {
+            const parsed = parsePayload(
+              z4.object({
+                app_id: TeamDynamixAppIdSchema,
+                ticket_id: z4.number().int().positive(),
+                contact_uid: TeamDynamixGuidSchema,
+                confirm: z4.literal(true)
+              }),
+              payload,
+              action
+            );
+            assertWriteToolsEnabled(getTeamDynamixConfig());
+            await client.removeTicketContact(parsed.app_id, parsed.ticket_id, parsed.contact_uid);
+            return toSuccessResponse(
+              {
+                appId: parsed.app_id,
+                ticketId: parsed.ticket_id,
+                contactUid: parsed.contact_uid,
+                removed: true
+              },
+              response_format
+            );
+          }
+        }
+      } catch (error) {
+        return toErrorResponse(error);
+      }
+    }
+  );
+}
+function registerTeamDynamixPeopleGateway(server2) {
+  server2.registerTool(
+    teamdynamixPeopleTool,
+    {
+      title: "TeamDynamix People Gateway",
+      description: "Gateway for user and group retrieval/search operations.",
+      inputSchema: {
+        action: teamdynamixPeopleActionSchema,
+        payload: gatewayPayloadSchema,
+        response_format: TeamDynamixResponseFormatSchema
+      },
+      annotations: { readOnlyHint: true, idempotentHint: false, destructiveHint: false, openWorldHint: true }
+    },
+    async ({ action, payload, response_format }) => {
+      try {
+        const client = createConfiguredTeamDynamixClient();
+        switch (action) {
+          case "get_user": {
+            const parsed = parsePayload(z4.object({ uid: TeamDynamixGuidSchema }), payload, action);
+            const user = await client.getUser(parsed.uid);
+            return toSuccessResponse(user, response_format);
+          }
+          case "search_users": {
+            const parsed = parsePayload(z4.object({ search: UserSearchSchema }), payload, action);
+            const users = await client.searchUsers(parsed.search);
+            return toSuccessResponse({ count: users.length, users }, response_format);
+          }
+          case "get_group": {
+            const parsed = parsePayload(z4.object({ group_id: z4.number().int().positive() }), payload, action);
+            const group = await client.getGroup(parsed.group_id);
+            return toSuccessResponse(group, response_format);
+          }
+          case "search_groups": {
+            const parsed = parsePayload(z4.object({ search: GroupSearchSchema }), payload, action);
+            const groups = await client.searchGroups(parsed.search);
+            return toSuccessResponse({ count: groups.length, groups }, response_format);
+          }
+          case "get_group_members": {
+            const parsed = parsePayload(z4.object({ group_id: z4.number().int().positive() }), payload, action);
+            const members = await client.getGroupMembers(parsed.group_id);
+            return toSuccessResponse({ groupId: parsed.group_id, count: members.length, members }, response_format);
+          }
+        }
+      } catch (error) {
+        return toErrorResponse(error);
+      }
+    }
+  );
+}
+function registerTeamDynamixKnowledgeBaseGateway(server2) {
+  server2.registerTool(
+    teamdynamixKnowledgeBaseTool,
+    {
+      title: "TeamDynamix Knowledge Base Gateway",
+      description: "Gateway for TeamDynamix Knowledge Base retrieval, search, and write operations.",
+      inputSchema: {
+        action: teamdynamixKnowledgeBaseActionSchema,
+        payload: gatewayPayloadSchema,
+        response_format: TeamDynamixResponseFormatSchema
+      },
+      annotations: { readOnlyHint: false, idempotentHint: false, destructiveHint: true, openWorldHint: true }
+    },
+    async ({ action, payload, response_format }) => {
+      try {
+        const client = createConfiguredTeamDynamixClient();
+        switch (action) {
+          case "get_kb_article": {
+            const parsed = parsePayload(
+              z4.object({ app_id: TeamDynamixAppIdSchema, article_id: z4.number().int().positive() }),
+              payload,
+              action
+            );
+            const article = await client.getKbArticle(parsed.app_id, parsed.article_id);
+            return toSuccessResponse(article, response_format);
+          }
+          case "search_kb_articles": {
+            const parsed = parsePayload(
+              z4.object({ app_id: TeamDynamixAppIdSchema, search: KbArticleSearchSchema }),
+              payload,
+              action
+            );
+            const articles = await client.searchKbArticles(parsed.app_id, parsed.search);
+            return toSuccessResponse({ appId: parsed.app_id, count: articles.length, articles }, response_format);
+          }
+          case "list_kb_categories": {
+            const parsed = parsePayload(z4.object({ app_id: TeamDynamixAppIdSchema }), payload, action);
+            const categories = await client.listKbCategories(parsed.app_id);
+            return toSuccessResponse({ appId: parsed.app_id, count: categories.length, categories }, response_format);
+          }
+          case "create_kb_article": {
+            const parsed = parsePayload(
+              z4.object({ app_id: TeamDynamixAppIdSchema, article: KbArticleCreateSchema }),
+              payload,
+              action
+            );
+            assertWriteToolsEnabled(getTeamDynamixConfig());
+            const created = await client.createKbArticle(parsed.app_id, parsed.article);
+            return toSuccessResponse(created, response_format);
+          }
+          case "update_kb_article": {
+            const parsed = parsePayload(
+              z4.object({ app_id: TeamDynamixAppIdSchema, article: KbArticleUpdateSchema }),
+              payload,
+              action
+            );
+            assertWriteToolsEnabled(getTeamDynamixConfig());
+            const { ArticleID, ...body } = parsed.article;
+            const updated = await client.updateKbArticle(parsed.app_id, ArticleID, body);
+            return toSuccessResponse(updated, response_format);
+          }
+        }
+      } catch (error) {
+        return toErrorResponse(error);
+      }
+    }
+  );
+}
+function registerTeamDynamixAssetsGateway(server2) {
+  server2.registerTool(
+    teamdynamixAssetsTool,
+    {
+      title: "TeamDynamix Assets Gateway",
+      description: "Gateway for TeamDynamix asset retrieval, search, and lookup enumerations.",
+      inputSchema: {
+        action: teamdynamixAssetsActionSchema,
+        payload: gatewayPayloadSchema,
+        response_format: TeamDynamixResponseFormatSchema
+      },
+      annotations: { readOnlyHint: true, idempotentHint: false, destructiveHint: false, openWorldHint: true }
+    },
+    async ({ action, payload, response_format }) => {
+      try {
+        const client = createConfiguredTeamDynamixClient();
+        switch (action) {
+          case "get_asset": {
+            const parsed = parsePayload(
+              z4.object({ app_id: TeamDynamixAppIdSchema, asset_id: z4.number().int().positive() }),
+              payload,
+              action
+            );
+            const asset = await client.getAsset(parsed.app_id, parsed.asset_id);
+            return toSuccessResponse(asset, response_format);
+          }
+          case "search_assets": {
+            const parsed = parsePayload(
+              z4.object({ app_id: TeamDynamixAppIdSchema, search: AssetSearchSchema }),
+              payload,
+              action
+            );
+            const assets = await client.searchAssets(parsed.app_id, parsed.search);
+            return toSuccessResponse({ appId: parsed.app_id, count: assets.length, assets }, response_format);
+          }
+          case "list_asset_statuses": {
+            const parsed = parsePayload(z4.object({ app_id: TeamDynamixAppIdSchema }), payload, action);
+            const statuses = await client.listAssetStatuses(parsed.app_id);
+            return toSuccessResponse({ appId: parsed.app_id, count: statuses.length, statuses }, response_format);
+          }
+          case "list_product_models": {
+            const parsed = parsePayload(z4.object({ app_id: TeamDynamixAppIdSchema }), payload, action);
+            const models = await client.listProductModels(parsed.app_id);
+            return toSuccessResponse({ appId: parsed.app_id, count: models.length, models }, response_format);
+          }
+        }
+      } catch (error) {
+        return toErrorResponse(error);
+      }
+    }
+  );
+}
+function registerTeamDynamixCmdbGateway(server2) {
+  server2.registerTool(
+    teamdynamixCmdbTool,
+    {
+      title: "TeamDynamix CMDB Gateway",
+      description: "Gateway for CI/CMDB retrieval, search, types, relationship types, and vendors.",
+      inputSchema: {
+        action: teamdynamixCmdbActionSchema,
+        payload: gatewayPayloadSchema,
+        response_format: TeamDynamixResponseFormatSchema
+      },
+      annotations: { readOnlyHint: true, idempotentHint: false, destructiveHint: false, openWorldHint: true }
+    },
+    async ({ action, payload, response_format }) => {
+      try {
+        const client = createConfiguredTeamDynamixClient();
+        switch (action) {
+          case "get_ci": {
+            const parsed = parsePayload(
+              z4.object({ app_id: TeamDynamixAppIdSchema, ci_id: z4.number().int().positive() }),
+              payload,
+              action
+            );
+            const ci = await client.getConfigurationItem(parsed.app_id, parsed.ci_id);
+            return toSuccessResponse(ci, response_format);
+          }
+          case "search_cis": {
+            const parsed = parsePayload(
+              z4.object({ app_id: TeamDynamixAppIdSchema, search: CiSearchSchema }),
+              payload,
+              action
+            );
+            const results = await client.searchConfigurationItems(
+              parsed.app_id,
+              parsed.search
+            );
+            return toSuccessResponse({ appId: parsed.app_id, count: results.length, results }, response_format);
+          }
+          case "list_ci_types": {
+            const parsed = parsePayload(z4.object({ app_id: TeamDynamixAppIdSchema }), payload, action);
+            const types = await client.listCiTypes(parsed.app_id);
+            return toSuccessResponse({ appId: parsed.app_id, count: types.length, types }, response_format);
+          }
+          case "list_ci_relationship_types": {
+            const types = await client.listCiRelationshipTypes();
+            return toSuccessResponse({ count: types.length, types }, response_format);
+          }
+          case "list_vendors": {
+            const parsed = parsePayload(z4.object({ app_id: TeamDynamixAppIdSchema }), payload, action);
+            const vendors = await client.listVendors(parsed.app_id);
+            return toSuccessResponse({ appId: parsed.app_id, count: vendors.length, vendors }, response_format);
+          }
+        }
+      } catch (error) {
+        return toErrorResponse(error);
+      }
+    }
+  );
+}
+function registerTeamDynamixServicesGateway(server2) {
+  server2.registerTool(
+    teamdynamixServicesTool,
+    {
+      title: "TeamDynamix Services Gateway",
+      description: "Gateway for TeamDynamix service catalog list/get/search/category operations.",
+      inputSchema: {
+        action: teamdynamixServicesActionSchema,
+        payload: gatewayPayloadSchema,
+        response_format: TeamDynamixResponseFormatSchema
+      },
+      annotations: { readOnlyHint: true, idempotentHint: false, destructiveHint: false, openWorldHint: true }
+    },
+    async ({ action, payload, response_format }) => {
+      try {
+        const client = createConfiguredTeamDynamixClient();
+        switch (action) {
+          case "list_services": {
+            const parsed = parsePayload(z4.object({ app_id: TeamDynamixAppIdSchema }), payload, action);
+            const services = await client.listServiceCatalog(parsed.app_id);
+            return toSuccessResponse({ appId: parsed.app_id, count: services.length, services }, response_format);
+          }
+          case "get_service": {
+            const parsed = parsePayload(
+              z4.object({ app_id: TeamDynamixAppIdSchema, service_id: z4.number().int().positive() }),
+              payload,
+              action
+            );
+            const service = await client.getService(parsed.app_id, parsed.service_id);
+            return toSuccessResponse(service, response_format);
+          }
+          case "search_services": {
+            const parsed = parsePayload(
+              z4.object({ app_id: TeamDynamixAppIdSchema, search: ServiceSearchSchema }),
+              payload,
+              action
+            );
+            const services = await client.searchServices(parsed.app_id, parsed.search);
+            return toSuccessResponse({ appId: parsed.app_id, count: services.length, services }, response_format);
+          }
+          case "list_service_categories": {
+            const parsed = parsePayload(z4.object({ app_id: TeamDynamixAppIdSchema }), payload, action);
+            const categories = await client.listServiceCategories(parsed.app_id);
+            return toSuccessResponse({ appId: parsed.app_id, count: categories.length, categories }, response_format);
+          }
+        }
+      } catch (error) {
+        return toErrorResponse(error);
+      }
+    }
+  );
+}
+function registerTeamDynamixProjectsGateway(server2) {
+  server2.registerTool(
+    teamdynamixProjectsTool,
+    {
+      title: "TeamDynamix Projects Gateway",
+      description: "Gateway for TeamDynamix projects retrieval/search and project issue/risk operations.",
+      inputSchema: {
+        action: teamdynamixProjectsActionSchema,
+        payload: gatewayPayloadSchema,
+        response_format: TeamDynamixResponseFormatSchema
+      },
+      annotations: { readOnlyHint: false, idempotentHint: false, destructiveHint: true, openWorldHint: true }
+    },
+    async ({ action, payload, response_format }) => {
+      try {
+        const client = createConfiguredTeamDynamixClient();
+        switch (action) {
+          case "get_project": {
+            const parsed = parsePayload(z4.object({ project_id: z4.number().int().positive() }), payload, action);
+            const project = await client.getProject(parsed.project_id);
+            return toSuccessResponse(project, response_format);
+          }
+          case "search_projects": {
+            const parsed = parsePayload(z4.object({ search: ProjectSearchSchema }), payload, action);
+            const projects = await client.searchProjects(parsed.search);
+            return toSuccessResponse({ count: projects.length, projects }, response_format);
+          }
+          case "list_project_types": {
+            const types = await client.listProjectTypes();
+            return toSuccessResponse({ count: types.length, types }, response_format);
+          }
+          case "get_project_plans": {
+            const parsed = parsePayload(z4.object({ project_id: z4.number().int().positive() }), payload, action);
+            const plans = await client.getProjectPlans(parsed.project_id);
+            return toSuccessResponse({ projectId: parsed.project_id, count: plans.length, plans }, response_format);
+          }
+          case "get_project_issues": {
+            const parsed = parsePayload(z4.object({ project_id: z4.number().int().positive() }), payload, action);
+            const issues = await client.getProjectIssues(parsed.project_id);
+            return toSuccessResponse({ projectId: parsed.project_id, count: issues.length, issues }, response_format);
+          }
+          case "get_project_risks": {
+            const parsed = parsePayload(z4.object({ project_id: z4.number().int().positive() }), payload, action);
+            const risks = await client.getProjectRisks(parsed.project_id);
+            return toSuccessResponse({ projectId: parsed.project_id, count: risks.length, risks }, response_format);
+          }
+          case "create_project_issue": {
+            const parsed = parsePayload(
+              z4.object({ project_id: z4.number().int().positive(), issue: ProjectIssueCreateSchema }),
+              payload,
+              action
+            );
+            assertWriteToolsEnabled(getTeamDynamixConfig());
+            const created = await client.createProjectIssue(parsed.project_id, parsed.issue);
+            return toSuccessResponse(created, response_format);
+          }
+          case "create_project_risk": {
+            const parsed = parsePayload(
+              z4.object({ project_id: z4.number().int().positive(), risk: ProjectRiskCreateSchema }),
+              payload,
+              action
+            );
+            assertWriteToolsEnabled(getTeamDynamixConfig());
+            const created = await client.createProjectRisk(parsed.project_id, parsed.risk);
+            return toSuccessResponse(created, response_format);
+          }
+        }
+      } catch (error) {
+        return toErrorResponse(error);
+      }
+    }
+  );
+}
+function registerTeamDynamixTimeGateway(server2) {
+  server2.registerTool(
+    teamdynamixTimeTool,
+    {
+      title: "TeamDynamix Time Gateway",
+      description: "Gateway for TeamDynamix time type lookup and authenticated user time entries.",
+      inputSchema: {
+        action: teamdynamixTimeActionSchema,
+        payload: gatewayPayloadSchema,
+        response_format: TeamDynamixResponseFormatSchema
+      },
+      annotations: { readOnlyHint: true, idempotentHint: false, destructiveHint: false, openWorldHint: true }
+    },
+    async ({ action, payload, response_format }) => {
+      try {
+        const client = createConfiguredTeamDynamixClient();
+        switch (action) {
+          case "list_time_types": {
+            const types = await client.listTimeTypes();
+            return toSuccessResponse({ count: types.length, types }, response_format);
+          }
+          case "get_my_time_entries": {
+            const parsed = parsePayload(z4.object({ query: TimeEntryQuerySchema }), payload, action);
+            const entries = await client.getMyTimeEntries(parsed.query.StartDate, parsed.query.EndDate);
+            return toSuccessResponse({ count: entries.length, entries }, response_format);
+          }
+        }
+      } catch (error) {
+        return toErrorResponse(error);
+      }
+    }
+  );
+}
+function registerTeamDynamixReferenceDataGateway(server2) {
+  server2.registerTool(
+    teamdynamixReferenceDataTool,
+    {
+      title: "TeamDynamix Reference Data Gateway",
+      description: "Gateway for TeamDynamix reference/enumeration lookups such as accounts, locations, roles, and custom attributes.",
+      inputSchema: {
+        action: teamdynamixReferenceDataActionSchema,
+        payload: gatewayPayloadSchema,
+        response_format: TeamDynamixResponseFormatSchema
+      },
+      annotations: { readOnlyHint: true, idempotentHint: false, destructiveHint: false, openWorldHint: true }
+    },
+    async ({ action, payload, response_format }) => {
+      try {
+        const client = createConfiguredTeamDynamixClient();
+        switch (action) {
+          case "list_accounts": {
+            const parsed = parsePayload(z4.object({ app_id: TeamDynamixAppIdSchema.optional() }), payload, action);
+            const accounts = await client.listAccounts(parsed.app_id);
+            return toSuccessResponse({ count: accounts.length, accounts }, response_format);
+          }
+          case "get_account": {
+            const parsed = parsePayload(z4.object({ account_id: z4.number().int().positive() }), payload, action);
+            const account = await client.getAccount(parsed.account_id);
+            return toSuccessResponse(account, response_format);
+          }
+          case "list_locations": {
+            const locations = await client.listLocations();
+            return toSuccessResponse({ count: locations.length, locations }, response_format);
+          }
+          case "list_functional_roles": {
+            const roles = await client.listFunctionalRoles();
+            return toSuccessResponse({ count: roles.length, roles }, response_format);
+          }
+          case "list_custom_attributes": {
+            const parsed = parsePayload(
+              z4.object({
+                component_id: CustomAttributeComponentIdSchema,
+                app_id: TeamDynamixAppIdSchema.optional(),
+                associated_type_id: z4.number().int().positive().optional()
+              }),
+              payload,
+              action
+            );
+            const attributes = await client.listCustomAttributes(
+              parsed.component_id,
+              parsed.app_id,
+              parsed.associated_type_id
+            );
+            return toSuccessResponse(
+              { componentId: parsed.component_id, count: attributes.length, attributes },
+              response_format
+            );
+          }
+        }
+      } catch (error) {
+        return toErrorResponse(error);
+      }
+    }
+  );
+}
+
+// src/resources/teamdynamix.resources.ts
+function stringify(data) {
+  return JSON.stringify(data, null, 2);
+}
+function registerTeamDynamixResources(server2) {
+  const resourceConfig = { list: void 0 };
+  server2.registerResource(
+    "teamdynamix_capabilities",
+    new ResourceTemplate("teamdynamix://capabilities", resourceConfig),
+    {
+      title: "TeamDynamix Capabilities",
+      description: "Read-only snapshot of the currently implemented TeamDynamix MCP surface.",
+      mimeType: "application/json"
+    },
+    async (uri) => {
+      const capabilities = {
+        toolGroups: {
+          discovery: [TEAMDYNAMIX_GATEWAY_SURFACE.discovery.tool],
+          tickets: [TEAMDYNAMIX_GATEWAY_SURFACE.tickets.tool],
+          ticket_relationships: [TEAMDYNAMIX_GATEWAY_SURFACE.ticketRelationships.tool],
+          people: [TEAMDYNAMIX_GATEWAY_SURFACE.people.tool],
+          knowledge_base: [TEAMDYNAMIX_GATEWAY_SURFACE.knowledgeBase.tool],
+          assets: [TEAMDYNAMIX_GATEWAY_SURFACE.assets.tool],
+          cmdb: [TEAMDYNAMIX_GATEWAY_SURFACE.cmdb.tool],
+          services: [TEAMDYNAMIX_GATEWAY_SURFACE.services.tool],
+          projects: [TEAMDYNAMIX_GATEWAY_SURFACE.projects.tool],
+          time: [TEAMDYNAMIX_GATEWAY_SURFACE.time.tool],
+          reference_data: [TEAMDYNAMIX_GATEWAY_SURFACE.referenceData.tool]
+        },
+        gatewayActions: {
+          discovery: TEAMDYNAMIX_GATEWAY_SURFACE.discovery.actions,
+          tickets: TEAMDYNAMIX_GATEWAY_SURFACE.tickets.actions,
+          ticket_relationships: TEAMDYNAMIX_GATEWAY_SURFACE.ticketRelationships.actions,
+          people: TEAMDYNAMIX_GATEWAY_SURFACE.people.actions,
+          knowledge_base: TEAMDYNAMIX_GATEWAY_SURFACE.knowledgeBase.actions,
+          assets: TEAMDYNAMIX_GATEWAY_SURFACE.assets.actions,
+          cmdb: TEAMDYNAMIX_GATEWAY_SURFACE.cmdb.actions,
+          services: TEAMDYNAMIX_GATEWAY_SURFACE.services.actions,
+          projects: TEAMDYNAMIX_GATEWAY_SURFACE.projects.actions,
+          time: TEAMDYNAMIX_GATEWAY_SURFACE.time.actions,
+          reference_data: TEAMDYNAMIX_GATEWAY_SURFACE.referenceData.actions
+        },
+        implementedDomains: [
+          "discovery",
+          "tickets",
+          "ticket_relationships",
+          "people",
+          "knowledge_base",
+          "assets",
+          "cmdb",
+          "services",
+          "projects",
+          "time",
+          "reference_data"
+        ]
+      };
+      return {
+        contents: [{ uri: uri.toString(), mimeType: "application/json", text: stringify(capabilities) }]
+      };
+    }
+  );
+  server2.registerResource(
+    "teamdynamix_config",
+    new ResourceTemplate("teamdynamix://config", resourceConfig),
+    {
+      title: "TeamDynamix Runtime Config",
+      description: "Read-only sanitized TeamDynamix configuration and readiness metadata.",
+      mimeType: "application/json"
+    },
+    async (uri) => {
+      const runtimeConfig = getTeamDynamixConfig();
+      const config = {
+        status: getTeamDynamixConfigStatus(runtimeConfig),
+        config: redactTeamDynamixConfig(runtimeConfig)
+      };
+      return {
+        contents: [{ uri: uri.toString(), mimeType: "application/json", text: stringify(config) }]
+      };
+    }
+  );
+}
+
+// src/index.ts
+var server = new McpServer2({
+  name: SERVER_NAME_OVERRIDE ?? SERVER_NAME,
+  version: SERVER_VERSION_OVERRIDE ?? SERVER_VERSION
+});
+registerTeamDynamixDomainGatewayTools(server);
+registerTeamDynamixResources(server);
+async function main() {
+  console.error(`[teamdynamix-mcp] log level: ${LOG_LEVEL}`);
+  if (LOG_LEVEL === "debug") {
+    const config = getTeamDynamixConfig();
+    console.error(`[teamdynamix-mcp] sanitized config: ${JSON.stringify(redactTeamDynamixConfig(config))}`);
+  }
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`Server startup failed: ${message}`);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map