@fruggr/zendesk-mcp-server 2.2.0 → 2.3.1

package/README.md

@@ -7,20 +7,55 @@
 [![Renovate enabled](https://img.shields.io/badge/renovate-enabled-brightgreen?logo=renovatebot&logoColor=white)](https://renovatebot.com)
 [![semantic-release](https://img.shields.io/badge/semantic--release-e10079?logo=semantic-release&logoColor=white)](https://github.com/semantic-release/semantic-release)
 
-A [Model Context Protocol](https://modelcontextprotocol.io) (MCP) server that connects LLMs to the **Zendesk Support & Help Center APIs** — with per-user OAuth 2.1 PKCE authentication and fine-grained tool visibility controls. Runs locally over **stdio** or as a private **remote MCP server** over HTTP.
-
-## Why this server?
-
-Most Zendesk integrations use a shared admin API key, giving every user full access to every ticket. This server takes a different approach:
-
-- **Per-user authentication, OAuth-only** — In both transports, auth is OAuth 2.1 PKCE: each user authenticates with their own Zendesk credentials, so the LLM sees exactly what the user is allowed to see. Static API tokens are deliberately **not** supported (see [below](#what-this-server-does-not-do)).
+**Bring Zendesk Support & the Help Center into your AI assistant.** A
+[Model Context Protocol](https://modelcontextprotocol.io) (MCP) server that lets
+your assistant search articles, answer questions, and create, track and update
+tickets in plain language — **without switching apps**.
+
+Think of it as the [Zendesk agent for Microsoft 365 Copilot](https://support.zendesk.com/hc/en-us/articles/9958331458458-Using-the-Zendesk-agent-in-Microsoft-365-Copilot),
+but **vendor-neutral** — it drops into any MCP client (Claude Desktop, Claude
+Code, Cursor, VS Code, …) instead of being tied to one assistant — and it always
+acts with **each user's own Zendesk permissions**, never a shared admin key.
+
+## What your assistant can do
+
+Ask in natural language; the assistant figures out context and intent, then calls
+the right tools on your behalf:
+
+- **Find answers in the Help Center** — "how do I request a software license?" or
+  "what's the time-off policy?" surfaces the right article, by meaning, not just
+  keywords.
+- **Create, view and update tickets without leaving the conversation** — open a
+  ticket, check its status, add a public reply or an internal note, change the
+  priority or assignee, or mark it solved.
+- **Summarize a ticket for reporting or a quick decision** — pull the details and
+  the full comment thread and get the gist in a sentence.
+- **Search and triage your queue in plain language** — "show me my open tickets
+  about billing from this week."
+- **Draft and maintain knowledge-base articles** — write a new article, or revise
+  a large one **one section at a time** so the whole HTML body never has to
+  round-trip through the model.
+
+Because it runs on the **user's own OAuth session**, the assistant only ever sees
+and touches what that person is allowed to — the same scoping you'd get signing
+into Zendesk directly.
+
+## How it's different
+
+Most Zendesk integrations use a shared admin API key, giving every user full
+access to every ticket, and bolt on a fixed set of tools. This server is built
+differently:
+
+- **Per-user authentication, OAuth-only** — In both transports, auth is OAuth 2.1 PKCE: each user authenticates with their own Zendesk credentials, so the assistant sees exactly what the user is allowed to see. Static API tokens are deliberately **not** supported (see [below](#what-this-server-does-not-do)).
 - **Two deployment shapes, same auth story** — Run it on your laptop as a stdio MCP server (Claude Desktop / Claude Code / VS Code) or deploy it as a private remote MCP server with one user, one Zendesk session per HTTP request.
 - **Context-friendly tool modes** — Expose every operation as its own tool, group them into namespace proxies, or collapse to a single unified tool. Tools are segmented into namespaces you can selectively enable, so each context loads only the surface it needs.
-- **Section-based article editing** — For large Help Center articles, read and rewrite one section at a time (parsed by h1/h2/h3 headings) instead of shuffling the full HTML body through the LLM. Reduces tokens by 10–100× on targeted edits.
+- **Section-based article editing** — For large Help Center articles, read and rewrite one section at a time (parsed by h1/h2/h3 headings) instead of shuffling the full HTML body through the assistant. Reduces tokens by 10–100× on targeted edits.
 - **Read-only mode** — Restrict the server to read operations only, ideal for assistants that should never modify data.
 - **Lean stack** — Built on the official `@modelcontextprotocol/sdk` plus `zod`.
 
-> Built and maintained by [Digital4better](https://digital4better.com) for the [Fruggr](https://www.fruggr.io) project.
+Under the hood it speaks to the **Zendesk Support & Help Center (Guide) APIs**,
+runs locally over **stdio** or as a private **remote MCP server** over HTTP, and
+ships fine-grained tool-visibility controls — the specifics are below.
 
 ## When to use this server
 
@@ -87,11 +122,12 @@ zendesk-mcp-server acme --namespace tickets
 
 | Tool | Description | Mode |
 |------|-------------|------|
-| `get_ticket` | Retrieve a ticket by ID with optional comments | read |
+| `get_ticket` | Retrieve a ticket by ID with optional comments and its live SLA state (resolved via a scoped search) | read |
 | `get_ticket_attachments` | Download ticket attachments (images as base64, others as references) | read |
-| `search_tickets` | Search tickets using Zendesk query syntax | read |
+| `search_tickets` | Search tickets using Zendesk query syntax, with per-result SLA state | read |
 | `list_tickets` | List tickets with cursor-based pagination | read |
 | `get_linked_incidents` | Get incidents linked to a problem ticket | read |
+| `list_sla_policies` | List SLA policies with filter conditions and per-priority targets (requires an admin token, or a custom role with the SLA-management permission) | read |
 | `create_ticket` | Create a new ticket with subject, description, priority, tags... | write |
 | `update_ticket` | Update ticket status, priority, assignee, tags, custom fields | write |
 | `add_private_note` | Add an internal note (not visible to requester) | write |
@@ -651,3 +687,7 @@ Every PR is reviewed automatically by [CodeRabbit](https://www.coderabbit.ai) in
 ## License
 
 [MIT](LICENSE)
+
+---
+
+> Built and maintained by [Digital4better](https://digital4better.com) for the [Fruggr](https://www.fruggr.io) project.

package/dist/index.js

@@ -34,7 +34,7 @@ const MCP_LEVEL = {
 	warn: "warning",
 	error: "error"
 };
-const REDACTED_KEYS = new Set([
+const REDACTED_KEYS = /* @__PURE__ */ new Set([
 	"token",
 	"accesstoken",
 	"refreshtoken",
@@ -846,6 +846,43 @@ const formatTicket = (ticket) => [
 	`- **Created**: ${ticket.created_at} | **Updated**: ${ticket.updated_at}`,
 	ticket.description ? `\n${ticket.description}` : ""
 ].filter(Boolean).join("\n");
+const formatConditionValue = (value) => value === null || value === void 0 ? "" : typeof value === "object" ? JSON.stringify(value) : String(value);
+const formatSlaPolicy = (policy) => {
+	const conditions = [...policy.filter.all.map((c) => `all: ${c.field} ${c.operator} ${formatConditionValue(c.value)}`.trim()), ...policy.filter.any.map((c) => `any: ${c.field} ${c.operator} ${formatConditionValue(c.value)}`.trim())];
+	const targets = policy.policy_metrics.map((m) => `  - ${m.priority} / ${m.metric}: ${m.target} min${m.business_hours ? " (business)" : ""}`);
+	return [
+		`## SLA policy: ${policy.title} (${policy.id})`,
+		policy.description ? `- **Description**: ${policy.description}` : "",
+		`- **Position**: ${policy.position}`,
+		conditions.length > 0 ? `- **Conditions**: ${conditions.join("; ")}` : "",
+		targets.length > 0 ? "- **Targets**:" : "",
+		...targets
+	].filter(Boolean).join("\n");
+};
+const minutesUntil = (iso) => {
+	const t = Date.parse(iso);
+	return Number.isNaN(t) ? null : Math.round((t - Date.now()) / 6e4);
+};
+const formatSlaMetric = (m) => {
+	const stage = m.stage ?? "unknown";
+	const due = m.breach_at ?? null;
+	const parts = [`- **${m.metric}** — ${stage}`];
+	if (due) {
+		const remaining = minutesUntil(due);
+		if (stage === "paused" || stage === "achieved" || stage === "fulfilled" || remaining == null) parts.push(`due ${due}`);
+		else if (remaining < 0) parts.push(`due ${due} — breached (${Math.abs(remaining)} min overdue)`);
+		else parts.push(`due ${due} — ${remaining} min remaining`);
+	}
+	return parts.join("; ");
+};
+const formatSlaBlock = (entry) => {
+	if (!entry?.policy_metrics || entry.policy_metrics.length === 0) return "";
+	const lines = ["### SLA"];
+	const futureBreaches = entry.policy_metrics.map((m) => m.breach_at).map((d) => d ? Date.parse(d) : NaN).filter((t) => !Number.isNaN(t) && t > Date.now());
+	if (futureBreaches.length > 0) lines.push(`- **Next breach**: ${new Date(Math.min(...futureBreaches)).toISOString()}`);
+	for (const m of entry.policy_metrics) lines.push(formatSlaMetric(m));
+	return `\n\n${lines.join("\n")}`;
+};
 const formatComment = (comment) => {
 	const lines = [`### ${comment.public ? "Public comment" : "Internal note"} by ${comment.author_id}`, `*${comment.created_at}*`];
 	if (comment.attachments?.length) {
@@ -915,10 +952,10 @@ const buildOffsetParams = (perPage, page) => {
 	if (page && page > 1) params["page"] = String(page);
 	return params;
 };
-const extractPaginationMeta = (response) => ({
+const extractPaginationMeta = (response, itemCount) => ({
 	has_more: response.meta?.has_more ?? response.next_page != null,
 	after_cursor: response.meta?.after_cursor ?? null,
-	count: response.count ?? 0
+	count: response.count ?? itemCount
 });
 const extractSearchPaginationMeta = (response, perPage, page) => {
 	const count = response.count ?? 0;
@@ -947,13 +984,15 @@ const fetchTopology = async (subdomain, token) => {
 		zendeskGet(subdomain, token, "/guide/permission_groups"),
 		zendeskGet(subdomain, token, "/users/me")
 	]);
+	const categories = categoriesRes.categories ?? [];
+	const sections = sectionsRes.sections ?? [];
 	return {
 		subdomain,
 		locales,
-		categories: categoriesRes.categories ?? [],
-		sections: sectionsRes.sections ?? [],
-		sectionsHasMore: extractPaginationMeta(sectionsRes).has_more,
-		categoriesHasMore: extractPaginationMeta(categoriesRes).has_more,
+		categories,
+		sections,
+		sectionsHasMore: extractPaginationMeta(sectionsRes, sections.length).has_more,
+		categoriesHasMore: extractPaginationMeta(categoriesRes, categories.length).has_more,
 		userSegments: segmentsRes.user_segments ?? [],
 		permissionGroups: permsRes.permission_groups ?? [],
 		currentUser: meRes.user
@@ -1055,7 +1094,7 @@ const groupByNamespace = (tools) => {
 };
 //#endregion
 //#region src/utils/article-sections.ts
-const HEADING_LEVELS = new Set([
+const HEADING_LEVELS = /* @__PURE__ */ new Set([
 	"h1",
 	"h2",
 	"h3"
@@ -1242,9 +1281,10 @@ const createHelpCenterTools = (ctx) => {
 			handler: async (params) => {
 				const { locale, page_size, cursor } = params;
 				const response = await helpCenterGet(subdomain, await getToken(), locale ? `/${locale}/categories` : "/categories", buildCursorParams(page_size, cursor));
+				const categories = response.categories ?? [];
 				return { content: [{
 					type: "text",
-					text: formatList(response.categories ?? [], formatCategory, extractPaginationMeta(response))
+					text: formatList(categories, formatCategory, extractPaginationMeta(response, categories.length))
 				}] };
 			}
 		},
@@ -1269,9 +1309,10 @@ const createHelpCenterTools = (ctx) => {
 			handler: async (params) => {
 				const { category_id, locale, page_size, cursor } = params;
 				const response = await helpCenterGet(subdomain, await getToken(), category_id && locale ? `/${locale}/categories/${category_id}/sections` : category_id ? `/categories/${category_id}/sections` : locale ? `/${locale}/sections` : "/sections", buildCursorParams(page_size, cursor));
+				const sections = response.sections ?? [];
 				return { content: [{
 					type: "text",
-					text: formatList(response.sections ?? [], formatSection, extractPaginationMeta(response))
+					text: formatList(sections, formatSection, extractPaginationMeta(response, sections.length))
 				}] };
 			}
 		},
@@ -1284,8 +1325,8 @@ const createHelpCenterTools = (ctx) => {
 			inputSchema: z.object({
 				section_id: z.number().int().optional(),
 				locale: z.string().optional(),
-				page_size: z.number().int().min(1).max(100).default(100),
-				cursor: z.string().optional(),
+				page_size: z.number().int().min(1).max(100).default(100).describe("Articles per page (1-100, default 100)."),
+				cursor: z.string().optional().describe("Pagination cursor from a previous response; omit for the first page."),
 				sort_by: z.enum([
 					"created_at",
 					"updated_at",
@@ -1312,14 +1353,14 @@ const createHelpCenterTools = (ctx) => {
 				const articles = response.articles ?? [];
 				if (!include_translations) return { content: [{
 					type: "text",
-					text: formatList(articles, formatArticleSummary, extractPaginationMeta(response))
+					text: formatList(articles, formatArticleSummary, extractPaginationMeta(response, articles.length))
 				}] };
 				const formatted = await Promise.all(articles.map(async (article) => {
 					const { translations } = await helpCenterGet(subdomain, token, `/articles/${article.id}/translations`);
 					const locales = translations.map((t) => t.locale).join(", ");
 					return `${formatArticleSummary(article)}\n- **Translations**: ${locales}`;
 				}));
-				const meta = extractPaginationMeta(response);
+				const meta = extractPaginationMeta(response, articles.length);
 				return { content: [{
 					type: "text",
 					text: truncateIfNeeded([meta.count ? `Results: ${meta.count}${meta.has_more ? ` | More available (cursor: ${meta.after_cursor})` : ""}` : "", ...formatted].filter(Boolean).join("\n\n"))
@@ -1907,6 +1948,25 @@ const collectAttachmentBlocks = async (subdomain, token, attachments) => {
 	}
 	return blocks;
 };
+const fetchTicketSla = async (subdomain, token, ticket) => {
+	const day = ticket.created_at.slice(0, 10);
+	if (!/^\d{4}-\d{2}-\d{2}$/.test(day)) return void 0;
+	const shiftDay = (offset) => {
+		const d = /* @__PURE__ */ new Date(`${day}T00:00:00Z`);
+		d.setUTCDate(d.getUTCDate() + offset);
+		return d.toISOString().slice(0, 10);
+	};
+	try {
+		const { results } = await zendeskGet(subdomain, token, "/search", {
+			query: `type:ticket requester:${ticket.requester_id} created>${shiftDay(-1)} created<${shiftDay(1)}`,
+			include: "tickets(slas)",
+			...buildOffsetParams(100, 1)
+		});
+		return (results ?? []).find((r) => r.id === ticket.id)?.slas;
+	} catch {
+		return;
+	}
+};
 const createTicketTools = (ctx) => {
 	const { subdomain, getToken } = ctx;
 	return [
@@ -1915,7 +1975,7 @@ const createTicketTools = (ctx) => {
 			namespace: "tickets",
 			readOnly: true,
 			title: "Get Zendesk Ticket",
-			description: "Retrieve a Zendesk ticket by ID, including its comments if requested. Returns ticket details (subject, status, priority, assignee, tags, description) and optionally all comments/internal notes.",
+			description: "Retrieve a Zendesk ticket by ID, including its live SLA state (per-metric stage and breach countdown) when an SLA policy applies, plus its comments if requested. Returns ticket details (subject, status, priority, assignee, tags, description) and optionally all comments/internal notes. The per-ticket Show endpoint exposes no SLA, so the SLA block is resolved via a scoped search and may be absent for a very high-volume requester or a just-updated ticket; SLA targets and policy conditions live in list_sla_policies.",
 			inputSchema: z.object({
 				ticket_id: z.number().int().describe("Ticket ID"),
 				include_comments: z.boolean().default(false).describe("Include ticket comments")
@@ -1930,7 +1990,7 @@ const createTicketTools = (ctx) => {
 				const { ticket_id, include_comments } = params;
 				const token = await getToken();
 				const { ticket } = await zendeskGet(subdomain, token, `/tickets/${ticket_id}`);
-				let text = formatTicket(ticket);
+				let text = formatTicket(ticket) + formatSlaBlock(await fetchTicketSla(subdomain, token, ticket));
 				if (include_comments) {
 					const { comments } = await zendeskGet(subdomain, token, `/tickets/${ticket_id}/comments`);
 					text += `\n\n---\n# Comments\n\n${comments.map(formatComment).join("\n\n")}`;
@@ -1986,7 +2046,7 @@ const createTicketTools = (ctx) => {
 			namespace: "tickets",
 			readOnly: true,
 			title: "Search Zendesk Tickets",
-			description: "Search tickets using Zendesk query syntax (e.g., \"status:open assignee:me\", \"priority:urgent type:incident\"). Returns total count.",
+			description: "Search tickets using Zendesk query syntax, returning each result with its live SLA state (per-metric stage and breach countdown) when an SLA policy applies. Examples: \"status:open assignee:me\", \"priority:urgent type:incident\". Returns total count, so queue triage like \"breaching today\" works without a per-ticket fetch.",
 			inputSchema: z.object({
 				query: z.string().min(1).describe("Zendesk search query string"),
 				per_page: z.number().int().min(1).max(100).default(100).describe("Results per page"),
@@ -2002,11 +2062,13 @@ const createTicketTools = (ctx) => {
 				const { query, per_page, page } = params;
 				const response = await zendeskGet(subdomain, await getToken(), "/search", {
 					query: `type:ticket ${query}`,
+					include: "tickets(slas)",
 					...buildOffsetParams(per_page, page)
 				});
+				const formatTicketWithSla = (ticket) => formatTicket(ticket) + formatSlaBlock(ticket.slas);
 				return { content: [{
 					type: "text",
-					text: formatList(response.results ?? [], formatTicket, extractSearchPaginationMeta(response, per_page, page))
+					text: formatList(response.results ?? [], formatTicketWithSla, extractSearchPaginationMeta(response, per_page, page))
 				}] };
 			}
 		},
@@ -2171,10 +2233,10 @@ const createTicketTools = (ctx) => {
 			namespace: "tickets",
 			readOnly: true,
 			title: "List Zendesk Tickets",
-			description: "List tickets with cursor-based pagination, sorted by most recently updated.",
+			description: "List tickets with cursor-based pagination, sorted by most recently updated. Page size is controlled by page_size (not per_page, which is the offset-based parameter used by search_tickets); paginate by passing the returned cursor.",
 			inputSchema: z.object({
-				page_size: z.number().int().min(1).max(100).default(100),
-				cursor: z.string().optional().describe("Pagination cursor")
+				page_size: z.number().int().min(1).max(100).default(100).describe("Tickets per page (1-100, default 100)."),
+				cursor: z.string().optional().describe("Pagination cursor from a previous response; omit for the first page.")
 			}),
 			annotations: {
 				readOnlyHint: true,
@@ -2185,9 +2247,10 @@ const createTicketTools = (ctx) => {
 			handler: async (params) => {
 				const { page_size, cursor } = params;
 				const response = await zendeskGet(subdomain, await getToken(), "/tickets", buildCursorParams(page_size, cursor));
+				const tickets = response.tickets ?? [];
 				return { content: [{
 					type: "text",
-					text: formatList(response.tickets ?? [], formatTicket, extractPaginationMeta(response))
+					text: formatList(tickets, formatTicket, extractPaginationMeta(response, tickets.length))
 				}] };
 			}
 		},
@@ -2247,6 +2310,43 @@ const createTicketTools = (ctx) => {
 					text: `Tags updated on ticket #${ticket_id}. Current: ${updated.tags.join(", ") || "none"}`
 				}] };
 			}
+		},
+		{
+			name: "list_sla_policies",
+			namespace: "tickets",
+			readOnly: true,
+			title: "List SLA Policies",
+			description: "List the configured SLA policies with their filter conditions and per-priority reply/resolution targets. Use this to explain why a given target applies to a ticket and to reconstruct deadlines deterministically instead of hard-coding the policy matrix. Requires an admin token (or a custom role granted the SLA-management permission); a standard agent token gets 403 here, though it can still read live per-ticket SLA via get_ticket / search_tickets.",
+			inputSchema: z.object({
+				per_page: z.number().int().min(1).max(100).default(100).describe("Results per page"),
+				page: z.number().int().min(1).default(1).describe("Page number")
+			}),
+			annotations: {
+				readOnlyHint: true,
+				destructiveHint: false,
+				idempotentHint: true,
+				openWorldHint: true
+			},
+			handler: async (params) => {
+				const { per_page, page } = params;
+				const token = await getToken();
+				let response;
+				try {
+					response = await zendeskGet(subdomain, token, "/slas/policies", buildOffsetParams(per_page, page));
+				} catch (error) {
+					if (error instanceof ZendeskApiError && error.status === 403) throw new Error("list_sla_policies reads SLA policy *configuration* (GET /slas/policies), which Zendesk restricts to admins (or a custom role granted the SLA-management permission). The current token lacks that permission (HTTP 403). This does not affect live SLA on tickets: per-metric SLA stage and breach countdown are available to any agent via get_ticket and search_tickets -- use those for triage and prioritization.", { cause: error });
+					throw error;
+				}
+				const policies = response.sla_policies ?? [];
+				return { content: [{
+					type: "text",
+					text: formatList(policies, formatSlaPolicy, response.count != null ? extractSearchPaginationMeta(response, per_page, page) : {
+						count: policies.length,
+						has_more: false,
+						after_cursor: null
+					})
+				}] };
+			}
 		}
 	];
 };
@@ -2368,9 +2468,10 @@ const createUserTools = (ctx) => {
 			handler: async (params) => {
 				const { page_size, cursor } = params;
 				const response = await zendeskGet(subdomain, await getToken(), "/organizations", buildCursorParams(page_size, cursor));
+				const organizations = response.organizations ?? [];
 				return { content: [{
 					type: "text",
-					text: formatList(response.organizations ?? [], formatOrganization, extractPaginationMeta(response))
+					text: formatList(organizations, formatOrganization, extractPaginationMeta(response, organizations.length))
 				}] };
 			}
 		}
@@ -2385,6 +2486,35 @@ const createAllTools = (ctx) => [
 	...createUserTools(ctx)
 ];
 //#endregion
+//#region src/utils/validation.ts
+/**
+* Build a strict params parser for a tool's input schema, computing the strict
+* schema and the valid-key list once (at proxy-dispatch construction) rather
+* than per call.
+*
+* Zod objects default to `strip`, which silently drops unknown keys. That hid
+* #100: a caller passing `per_page` to list_tickets (whose parameter is
+* `page_size`) had the key dropped, so `page_size` fell back to its default and
+* a large unpaginated page came back. The returned parser rejects unknown keys
+* and rewrites the raw Zod error into a message that names the offending keys
+* and lists the valid parameters so a mistyped/misremembered name fails loudly.
+*
+* Used on the proxy dispatch path (namespace/single modes), where this code
+* owns the parse. In `all` mode the SDK validates against the strict schema we
+* register and produces its own (also explicit) "Unrecognized key" message.
+*/
+const createStrictParamsParser = (schema) => {
+	const strict = schema.strict();
+	const validKeys = Object.keys(schema.shape).sort().join(", ");
+	return (params) => {
+		const result = strict.safeParse(params);
+		if (result.success) return result.data;
+		const unknownKeys = result.error.issues.filter((issue) => issue.code === "unrecognized_keys").flatMap((issue) => issue.keys ?? []);
+		if (unknownKeys.length > 0) throw new Error(`Unknown parameter(s): ${unknownKeys.join(", ")}. Valid parameters: ${validKeys || "(none)"}.`);
+		throw result.error;
+	};
+};
+//#endregion
 //#region src/server.ts
 /**
 * Invoke a tool handler, notifying `onUnauthorized` when Zendesk rejects the
@@ -2436,15 +2566,19 @@ const aggregateAnnotations = (tools) => ({
 });
 const buildProxyDispatch = (tools, onUnauthorized) => {
 	const operationNames = tools.map((t) => t.name);
-	const localHandlers = new Map(tools.map((t) => [t.name, t]));
+	const localHandlers = new Map(tools.map((t) => [t.name, {
+		def: t,
+		parseParams: createStrictParamsParser(t.inputSchema)
+	}]));
 	return async (args) => {
 		const { operation, params } = args;
-		const def = localHandlers.get(operation);
-		if (!def) return { content: [{
+		const entry = localHandlers.get(operation);
+		if (!entry) return { content: [{
 			type: "text",
 			text: `Unknown operation "${operation}". Available: ${operationNames.join(", ")}`
 		}] };
-		return runHandler(def, def.inputSchema.parse(params), onUnauthorized);
+		const validated = entry.parseParams(params);
+		return runHandler(entry.def, validated, onUnauthorized);
 	};
 };
 const registerProxyTool = (server, toolName, title, tools, readOnlyMode, onUnauthorized) => {
@@ -2487,7 +2621,7 @@ const createMcpServer = (config, getToken, logger = silentLogger, onUnauthorized
 			for (const tool of filteredTools) server.registerTool(tool.name, {
 				title: tool.title,
 				description: tool.description,
-				inputSchema: tool.inputSchema.shape,
+				inputSchema: tool.inputSchema.strict(),
 				annotations: tool.annotations
 			}, async (params) => runHandler(tool, params, onUnauthorized));
 			break;
@@ -2523,7 +2657,7 @@ const createMcpServer = (config, getToken, logger = silentLogger, onUnauthorized
 };
 //#endregion
 //#region src/transports/http.ts
-const WILDCARD_HOSTS = new Set([
+const WILDCARD_HOSTS = /* @__PURE__ */ new Set([
 	"0.0.0.0",
 	"::",
 	"*"
@@ -2542,12 +2676,12 @@ const CORS_ALLOWED_METHODS = "GET, POST, DELETE, OPTIONS";
 const CORS_ALLOWED_HEADERS = "Authorization, Content-Type, Accept, mcp-session-id, mcp-protocol-version, last-event-id";
 const CORS_EXPOSE_HEADERS = "mcp-session-id";
 const CORS_MAX_AGE = "600";
-const LOCALHOST_HOSTNAMES = new Set([
+const LOCALHOST_HOSTNAMES = /* @__PURE__ */ new Set([
 	"localhost",
 	"127.0.0.1",
 	"[::1]"
 ]);
-const ALLOWED_PROTOCOLS = new Set(["http:", "https:"]);
+const ALLOWED_PROTOCOLS = /* @__PURE__ */ new Set(["http:", "https:"]);
 /**
 * Returns the origin string to reflect in `Access-Control-Allow-Origin`, or
 * `undefined` if the origin is not allowed.