Conceptual MCP server: four business tools

import { z } from "zod";

type Principal = { userId: string; tenantId: string; scopes: readonly string[] };
type Services = {
  customerForCaller(p: Principal, customerId: string): Promise<unknown>;
  orderForCaller(p: Principal, orderId: string): Promise<unknown>;
  createTicket(p: Principal, subject: string, body: string, key: string): Promise<unknown>;
  searchKnowledge(p: Principal, query: string): Promise<unknown>;
};
const Id = z.string().regex(/^[A-Za-z0-9_-]{1,80}$/);
const registry = {
  customer_lookup: { schema: z.object({ customerId: Id }).strict(), scope: "customer:read" },
  order_lookup: { schema: z.object({ orderId: Id }).strict(), scope: "order:read" },
  ticket_create: {
    schema: z.object({
      subject: z.string().min(1).max(200),
      body: z.string().min(1).max(5000),
    }).strict(),
    scope: "ticket:create",
  },
  knowledge_search: {
    schema: z.object({ query: z.string().min(1).max(1000) }).strict(),
    scope: "knowledge:read",
  },
} as const;

async function executeTool(
  name: string, raw: unknown, principal: Principal, services: Services,
  operationKey?: string,
): Promise<unknown> {
  // principal comes from verified middleware, never model-supplied JSON.
  if (!Object.prototype.hasOwnProperty.call(registry, name)) {
    throw new Error("Unknown tool");
  }
  const toolName = name as keyof typeof registry;
  if (!principal.scopes.includes(registry[toolName].scope)) {
    throw new Error("Tool scope denied");
  }
  switch (toolName) {
    case "customer_lookup": {
      const a = registry.customer_lookup.schema.parse(raw);
      return services.customerForCaller(principal, a.customerId);
    }
    case "order_lookup": {
      const a = registry.order_lookup.schema.parse(raw);
      return services.orderForCaller(principal, a.orderId);
    }
    case "ticket_create": {
      const a = registry.ticket_create.schema.parse(raw);
      // Reuse the host's persisted key for this logical write across retries.
      // The model cannot mint a new key to turn a retry into another ticket.
      const key = Id.parse(operationKey);
      return services.createTicket(principal, a.subject, a.body, key);
    }
    case "knowledge_search": {
      const a = registry.knowledge_search.schema.parse(raw);
      return services.searchKnowledge(principal, a.query);
    }
  }
}