@kynver-app/mcp-estimator 0.1.1

package/src/lib/mcp-sse-server.ts

@@ -0,0 +1,249 @@
+// @generated — synced from packages/kynver-mcp-sse-lib/src/index.ts via scripts/sync-mcp-sse-server.mjs
+// Do not edit by hand; change the canonical file and re-run the sync script.
+
+import { createServer, type IncomingMessage, type ServerResponse } from "node:http";
+import { timingSafeEqual } from "node:crypto";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+export const MAX_SSE_BODY_BYTES = 1 * 1024 * 1024;
+
+export type SessionAuth =
+  | { kind: "apiKey"; apiKey: string }
+  | { kind: "internal"; userId: string };
+
+type SessionEntry = {
+  transport: SSEServerTransport;
+  userId: string;
+  auth: SessionAuth;
+};
+
+type RequestContextStore = {
+  run: <T>(store: { userId?: string }, fn: () => Promise<T>) => Promise<T>;
+};
+
+export type StartKynverMcpSseServerOptions = {
+  label: string;
+  defaultPort: number;
+  createMcpServer: () => McpServer | Promise<McpServer>;
+  requestContext: RequestContextStore;
+};
+
+const FORBIDDEN_QUERY_KEYS = ["secret", "userId"] as const;
+
+export function headerValue(req: IncomingMessage, name: string): string | null {
+  const v = req.headers[name];
+  return typeof v === "string" ? v : Array.isArray(v) ? (v[0] ?? null) : null;
+}
+
+export function timingSafeEqualString(a: string, b: string): boolean {
+  const left = Buffer.from(a);
+  const right = Buffer.from(b);
+  if (left.length !== right.length) return false;
+  return timingSafeEqual(left, right);
+}
+
+export function hasForbiddenQueryAuth(url: URL): boolean {
+  return FORBIDDEN_QUERY_KEYS.some((key) => url.searchParams.has(key));
+}
+
+function queryApiKey(url: URL): string {
+  return url.searchParams.get("apiKey")?.trim() ?? "";
+}
+
+export function resolveListenHost(): string {
+  const configured = process.env.MCP_SSE_HOST?.trim();
+  return configured || "127.0.0.1";
+}
+
+export function parseJsonBody(req: IncomingMessage, maxBytes = MAX_SSE_BODY_BYTES): Promise<unknown> {
+  return new Promise((resolve, reject) => {
+    const chunks: Buffer[] = [];
+    let totalSize = 0;
+    req.on("data", (chunk: Buffer) => {
+      totalSize += chunk.length;
+      if (totalSize > maxBytes) {
+        req.destroy();
+        reject(new Error("Request body too large"));
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => {
+      try {
+        resolve(JSON.parse(Buffer.concat(chunks).toString()));
+      } catch (error) {
+        reject(error);
+      }
+    });
+    req.on("error", reject);
+  });
+}
+
+export function validateMcporterServerName(name: string): string {
+  const trimmed = name.trim();
+  if (!/^[a-zA-Z0-9_-]+$/.test(trimmed)) {
+    throw new Error("Invalid mcporter server name.");
+  }
+  return trimmed;
+}
+
+function bearerToken(req: IncomingMessage): string {
+  const auth = headerValue(req, "authorization");
+  if (!auth) return "";
+  const match = /^Bearer\s+(.+)$/i.exec(auth);
+  return match?.[1]?.trim() ?? "";
+}
+
+function resolveInternalAuth(
+  req: IncomingMessage,
+  serviceSecret: string,
+): { userId: string; auth: SessionAuth } | null {
+  const internalUserId = headerValue(req, "x-kynver-user-id");
+  const internalSecret = headerValue(req, "x-kynver-service-secret");
+  if (!internalUserId || !serviceSecret || !internalSecret) return null;
+  if (!timingSafeEqualString(internalSecret, serviceSecret)) return null;
+  return { userId: internalUserId, auth: { kind: "internal", userId: internalUserId } };
+}
+
+function verifyPostAuth(
+  req: IncomingMessage,
+  url: URL,
+  sessionAuth: SessionAuth,
+  serviceSecret: string,
+): boolean {
+  if (sessionAuth.kind === "apiKey") {
+    const token = bearerToken(req) || queryApiKey(url);
+    return token.length > 0 && timingSafeEqualString(token, sessionAuth.apiKey);
+  }
+  const internal = resolveInternalAuth(req, serviceSecret);
+  return (
+    internal !== null &&
+    internal.userId === sessionAuth.userId &&
+    internal.auth.kind === "internal"
+  );
+}
+
+async function resolveUserFromApiKey(baseUrl: string, apiKey: string): Promise<string | null> {
+  try {
+    const res = await fetch(`${baseUrl.replace(/\/$/, "")}/api/users/me`, {
+      headers: { Authorization: `Bearer ${apiKey}` },
+    });
+    if (!res.ok) return null;
+    const data = (await res.json()) as { id?: string };
+    return data.id ?? null;
+  } catch {
+    return null;
+  }
+}
+
+function parseUrl(req: IncomingMessage, port: number): URL {
+  return new URL(req.url ?? "/", `http://localhost:${port}`);
+}
+
+function json(res: ServerResponse, status: number, body: Record<string, unknown>) {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(body));
+}
+
+export function startKynverMcpSseServer(options: StartKynverMcpSseServerOptions): void {
+  const port = parseInt(process.env.PORT ?? String(options.defaultPort), 10);
+  const baseUrl = process.env.KYNVER_API_URL ?? "https://kynver.com";
+  const serviceSecret = process.env.KYNVER_SERVICE_SECRET ?? "";
+  const host = resolveListenHost();
+  const sessions: Record<string, SessionEntry> = {};
+
+  const httpServer = createServer(async (req: IncomingMessage, res: ServerResponse) => {
+    const url = parseUrl(req, port);
+    const path = url.pathname;
+
+    if (req.method === "GET" && path === "/sse") {
+      if (hasForbiddenQueryAuth(url)) {
+        json(res, 400, {
+          error:
+            "Internal auth via query params is not allowed. Use X-Kynver-User-Id and X-Kynver-Service-Secret headers.",
+        });
+        return;
+      }
+
+      if (url.searchParams.has("apiKey")) {
+        console.warn("[MCP SSE] WARNING: apiKey in query string may leak via logs. Prefer Authorization header when your client supports it.");
+      }
+
+      let userId: string | null = null;
+      let auth: SessionAuth | null = null;
+
+      const internal = serviceSecret ? resolveInternalAuth(req, serviceSecret) : null;
+      if (internal) {
+        userId = internal.userId;
+        auth = internal.auth;
+      } else {
+        const apiKey = bearerToken(req) || queryApiKey(url);
+        if (apiKey) {
+          userId = await resolveUserFromApiKey(baseUrl, apiKey);
+          if (userId) auth = { kind: "apiKey", apiKey };
+        }
+      }
+
+      if (!userId || !auth) {
+        json(res, 401, {
+          error:
+            "Unauthorized. Pass API key via Authorization: Bearer <key> or internal X-Kynver-User-Id + X-Kynver-Service-Secret headers.",
+        });
+        return;
+      }
+
+      console.log(`[MCP SSE] New connection (${options.label}, user: ${userId.slice(0, 8)}...)`);
+
+      const transport = new SSEServerTransport("/messages", res);
+      sessions[transport.sessionId] = { transport, userId, auth };
+
+      res.on("close", () => {
+        delete sessions[transport.sessionId];
+      });
+
+      const server = await options.createMcpServer();
+      await server.connect(transport);
+      return;
+    }
+
+    if (req.method === "POST" && path === "/messages") {
+      const sessionId = url.searchParams.get("sessionId");
+      const entry = sessionId ? sessions[sessionId] : undefined;
+
+      if (!entry) {
+        json(res, 400, { error: "No active SSE session for this sessionId" });
+        return;
+      }
+
+      if (!verifyPostAuth(req, url, entry.auth, serviceSecret)) {
+        json(res, 401, { error: "Unauthorized. Re-send the same credentials used to open the SSE session." });
+        return;
+      }
+
+      try {
+        const body = await parseJsonBody(req);
+        await options.requestContext.run({ userId: entry.userId }, async () => {
+          await entry.transport.handlePostMessage(req, res, body);
+        });
+      } catch (error) {
+        json(res, 400, {
+          error: error instanceof Error ? error.message : "Invalid request body",
+        });
+      }
+      return;
+    }
+
+    if (req.method === "GET" && path === "/health") {
+      res.writeHead(200, { "Content-Type": "text/plain" });
+      res.end("ok");
+      return;
+    }
+
+    json(res, 404, { error: "Not found" });
+  });
+
+  httpServer.listen(port, host, () => {
+    console.log(`[MCP SSE] ${options.label} listening on ${host}:${port}`);
+  });
+}

package/src/server.ts

@@ -0,0 +1,101 @@
+/**
+ * Creates and configures the estimator MCP server with all tools registered.
+ * Separated from transport so it can be used with stdio (CLI) or SSE (hosted).
+ */
+
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as catalogTools from "./tools/catalog-tools.js";
+import * as estimateTools from "./tools/estimate-tools.js";
+import * as templateTools from "./tools/template-tools.js";
+import * as versionTools from "./tools/version-tools.js";
+import * as photoTools from "./tools/photo-tools.js";
+import * as statsPdfTools from "./tools/stats-pdf-tools.js";
+import * as visionTools from "./tools/vision-tools.js";
+import * as companyTools from "./tools/company-tools.js";
+import * as clientTools from "./tools/client-tools.js";
+
+type ToolConfig = { description: string; inputSchema: unknown };
+
+function toolResult(text: string) {
+  return { content: [{ type: "text" as const, text }] };
+}
+
+export function createEstimatorServer(): McpServer {
+  const server = new McpServer(
+    { name: "kynver-mcp-estimator", version: "0.1.0" },
+    { capabilities: { tools: {} } }
+  );
+
+  function register(
+    name: string,
+    config: ToolConfig,
+    run: (args: unknown) => Promise<string>
+  ) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    server.registerTool(name, config as any, async (args: any) => toolResult(await run(args)));
+  }
+
+  // --- Catalog tools (8) ---
+  register(catalogTools.importCatalog.name, { description: catalogTools.importCatalog.description, inputSchema: catalogTools.importCatalog.inputSchemaZod }, (args) => catalogTools.importCatalog.execute(args as any));
+  register(catalogTools.reviewImport.name, { description: catalogTools.reviewImport.description, inputSchema: catalogTools.reviewImport.inputSchemaZod }, (args) => catalogTools.reviewImport.execute(args as any));
+  register(catalogTools.commitImport.name, { description: catalogTools.commitImport.description, inputSchema: catalogTools.commitImport.inputSchemaZod }, (args) => catalogTools.commitImport.execute(args as any));
+  register(catalogTools.setupPrice.name, { description: catalogTools.setupPrice.description, inputSchema: catalogTools.setupPrice.inputSchemaZod }, (args) => catalogTools.setupPrice.execute(args as any));
+  register(catalogTools.updatePrice.name, { description: catalogTools.updatePrice.description, inputSchema: catalogTools.updatePrice.inputSchemaZod }, (args) => catalogTools.updatePrice.execute(args as any));
+  register(catalogTools.getCatalog.name, { description: catalogTools.getCatalog.description, inputSchema: catalogTools.getCatalog.inputSchemaZod }, (args) => catalogTools.getCatalog.execute(args as any));
+  register(catalogTools.getConfig.name, { description: catalogTools.getConfig.description, inputSchema: catalogTools.getConfig.inputSchemaZod }, (args) => catalogTools.getConfig.execute(args as any));
+  register(catalogTools.updateConfig.name, { description: catalogTools.updateConfig.description, inputSchema: catalogTools.updateConfig.inputSchemaZod }, (args) => catalogTools.updateConfig.execute(args as any));
+  register(catalogTools.importTemplate.name, { description: catalogTools.importTemplate.description, inputSchema: catalogTools.importTemplate.inputSchemaZod }, (args) => catalogTools.importTemplate.execute(args as any));
+
+  // --- Estimate tools (11) ---
+  register(estimateTools.createReplacement.name, { description: estimateTools.createReplacement.description, inputSchema: estimateTools.createReplacement.inputSchemaZod }, (args) => estimateTools.createReplacement.execute(args as any));
+  register(estimateTools.createRepair.name, { description: estimateTools.createRepair.description, inputSchema: estimateTools.createRepair.inputSchemaZod }, (args) => estimateTools.createRepair.execute(args as any));
+  register(estimateTools.getEstimate.name, { description: estimateTools.getEstimate.description, inputSchema: estimateTools.getEstimate.inputSchemaZod }, (args) => estimateTools.getEstimate.execute(args as any));
+  register(estimateTools.listEstimates.name, { description: estimateTools.listEstimates.description, inputSchema: estimateTools.listEstimates.inputSchemaZod }, (args) => estimateTools.listEstimates.execute(args as any));
+  register(estimateTools.addLineItem.name, { description: estimateTools.addLineItem.description, inputSchema: estimateTools.addLineItem.inputSchemaZod }, (args) => estimateTools.addLineItem.execute(args as any));
+  register(estimateTools.removeLineItem.name, { description: estimateTools.removeLineItem.description, inputSchema: estimateTools.removeLineItem.inputSchemaZod }, (args) => estimateTools.removeLineItem.execute(args as any));
+  register(estimateTools.updateLineItem.name, { description: estimateTools.updateLineItem.description, inputSchema: estimateTools.updateLineItem.inputSchemaZod }, (args) => estimateTools.updateLineItem.execute(args as any));
+  register(estimateTools.adjustToTarget.name, { description: estimateTools.adjustToTarget.description, inputSchema: estimateTools.adjustToTarget.inputSchemaZod }, (args) => estimateTools.adjustToTarget.execute(args as any));
+  register(estimateTools.updateEstimate.name, { description: estimateTools.updateEstimate.description, inputSchema: estimateTools.updateEstimate.inputSchemaZod }, (args) => estimateTools.updateEstimate.execute(args as any));
+  register(estimateTools.deleteEstimate.name, { description: estimateTools.deleteEstimate.description, inputSchema: estimateTools.deleteEstimate.inputSchemaZod }, (args) => estimateTools.deleteEstimate.execute(args as any));
+  register(estimateTools.duplicateEstimate.name, { description: estimateTools.duplicateEstimate.description, inputSchema: estimateTools.duplicateEstimate.inputSchemaZod }, (args) => estimateTools.duplicateEstimate.execute(args as any));
+
+  // --- Template tools (4) ---
+  register(templateTools.saveTemplate.name, { description: templateTools.saveTemplate.description, inputSchema: templateTools.saveTemplate.inputSchemaZod }, (args) => templateTools.saveTemplate.execute(args as any));
+  register(templateTools.listTemplates.name, { description: templateTools.listTemplates.description, inputSchema: templateTools.listTemplates.inputSchemaZod }, (args) => templateTools.listTemplates.execute(args as any));
+  register(templateTools.deleteTemplate.name, { description: templateTools.deleteTemplate.description, inputSchema: templateTools.deleteTemplate.inputSchemaZod }, (args) => templateTools.deleteTemplate.execute(args as any));
+  register(templateTools.createFromTemplate.name, { description: templateTools.createFromTemplate.description, inputSchema: templateTools.createFromTemplate.inputSchemaZod }, (args) => templateTools.createFromTemplate.execute(args as any));
+
+  // --- Version tools (2) ---
+  register(versionTools.listVersions.name, { description: versionTools.listVersions.description, inputSchema: versionTools.listVersions.inputSchemaZod }, (args) => versionTools.listVersions.execute(args as any));
+  register(versionTools.getVersion.name, { description: versionTools.getVersion.description, inputSchema: versionTools.getVersion.inputSchemaZod }, (args) => versionTools.getVersion.execute(args as any));
+
+  // --- Photo tools (3) ---
+  register(photoTools.uploadPhoto.name, { description: photoTools.uploadPhoto.description, inputSchema: photoTools.uploadPhoto.inputSchemaZod }, (args) => photoTools.uploadPhoto.execute(args as any));
+  register(photoTools.listPhotos.name, { description: photoTools.listPhotos.description, inputSchema: photoTools.listPhotos.inputSchemaZod }, (args) => photoTools.listPhotos.execute(args as any));
+  register(photoTools.deletePhoto.name, { description: photoTools.deletePhoto.description, inputSchema: photoTools.deletePhoto.inputSchemaZod }, (args) => photoTools.deletePhoto.execute(args as any));
+
+  // --- Stats / PDF tools (3) ---
+  register(statsPdfTools.getStats.name, { description: statsPdfTools.getStats.description, inputSchema: statsPdfTools.getStats.inputSchemaZod }, (args) => statsPdfTools.getStats.execute(args as any));
+  register(statsPdfTools.exportPdf.name, { description: statsPdfTools.exportPdf.description, inputSchema: statsPdfTools.exportPdf.inputSchemaZod }, (args) => statsPdfTools.exportPdf.execute(args as any));
+  register(statsPdfTools.updateOutputConfig.name, { description: statsPdfTools.updateOutputConfig.description, inputSchema: statsPdfTools.updateOutputConfig.inputSchemaZod }, (args) => statsPdfTools.updateOutputConfig.execute(args as any));
+
+  // --- Vision tools (2) ---
+  register(visionTools.analyzePhotos.name, { description: visionTools.analyzePhotos.description, inputSchema: visionTools.analyzePhotos.inputSchemaZod }, (args) => visionTools.analyzePhotos.execute(args as any));
+  register(visionTools.analyzeDocument.name, { description: visionTools.analyzeDocument.description, inputSchema: visionTools.analyzeDocument.inputSchemaZod }, (args) => visionTools.analyzeDocument.execute(args as any));
+
+  // --- Company tools (5) ---
+  register(companyTools.createCompany.name, { description: companyTools.createCompany.description, inputSchema: companyTools.createCompany.inputSchemaZod }, (args) => companyTools.createCompany.execute(args as any));
+  register(companyTools.listCompanies.name, { description: companyTools.listCompanies.description, inputSchema: companyTools.listCompanies.inputSchemaZod }, (args) => companyTools.listCompanies.execute(args as any));
+  register(companyTools.getCompany.name, { description: companyTools.getCompany.description, inputSchema: companyTools.getCompany.inputSchemaZod }, (args) => companyTools.getCompany.execute(args as any));
+  register(companyTools.updateCompany.name, { description: companyTools.updateCompany.description, inputSchema: companyTools.updateCompany.inputSchemaZod }, (args) => companyTools.updateCompany.execute(args as any));
+  register(companyTools.deleteCompany.name, { description: companyTools.deleteCompany.description, inputSchema: companyTools.deleteCompany.inputSchemaZod }, (args) => companyTools.deleteCompany.execute(args as any));
+
+  // --- Client tools (5) ---
+  register(clientTools.createClient.name, { description: clientTools.createClient.description, inputSchema: clientTools.createClient.inputSchemaZod }, (args) => clientTools.createClient.execute(args as any));
+  register(clientTools.listClients.name, { description: clientTools.listClients.description, inputSchema: clientTools.listClients.inputSchemaZod }, (args) => clientTools.listClients.execute(args as any));
+  register(clientTools.getClient.name, { description: clientTools.getClient.description, inputSchema: clientTools.getClient.inputSchemaZod }, (args) => clientTools.getClient.execute(args as any));
+  register(clientTools.updateClient.name, { description: clientTools.updateClient.description, inputSchema: clientTools.updateClient.inputSchemaZod }, (args) => clientTools.updateClient.execute(args as any));
+  register(clientTools.deleteClient.name, { description: clientTools.deleteClient.description, inputSchema: clientTools.deleteClient.inputSchemaZod }, (args) => clientTools.deleteClient.execute(args as any));
+
+  return server;
+}

package/src/sse.ts

@@ -0,0 +1,10 @@
+import { startKynverMcpSseServer } from "./lib/mcp-sse-server.js";
+import { createEstimatorServer } from "./server.js";
+import { requestContext } from "./lib/kynver-client.js";
+
+startKynverMcpSseServer({
+  label: "Estimator server",
+  defaultPort: 3100,
+  createMcpServer: createEstimatorServer,
+  requestContext,
+});

package/src/tools/catalog-tools.ts

@@ -0,0 +1,217 @@
+import { z } from "zod";
+import * as client from "../lib/kynver-client.js";
+
+// --- estimator_import_catalog ---
+
+const importCatalogSchema = z.object({
+  message: z.string(),
+});
+
+export const importCatalog = {
+  name: "estimator_import_catalog",
+  description:
+    "Start a catalog import from a file. This is a placeholder — MCP cannot do file uploads. Describe the import request in the message field and the system will guide the user through the upload flow.",
+  inputSchemaZod: importCatalogSchema,
+  execute: async (args: z.infer<typeof importCatalogSchema>): Promise<string> => {
+    if (!client.hasApiKey()) return client.noApiKeyMessage();
+    const data = await client.post("/v1/agents/kynver-estimator/chat", {
+      message: args.message,
+    });
+    return JSON.stringify(data);
+  },
+};
+
+// --- estimator_review_import ---
+
+const reviewImportSchema = z.object({
+  importId: z.string(),
+  approved: z.boolean().optional(),
+  changes: z
+    .array(
+      z.object({
+        index: z.number(),
+        action: z.enum(["keep", "skip", "edit"]),
+        edits: z.record(z.unknown()).optional(),
+      })
+    )
+    .optional(),
+});
+
+export const reviewImport = {
+  name: "estimator_review_import",
+  description: "Review a pending catalog import batch before committing. Shows parsed rows with suggested service codes, categories, and pricing. You can approve all, skip individual rows, or edit values before committing. Requires an importId from a previous import.",
+  inputSchemaZod: reviewImportSchema,
+  execute: async (args: z.infer<typeof reviewImportSchema>): Promise<string> => {
+    if (!client.hasApiKey()) return client.noApiKeyMessage();
+    const { importId, ...body } = args;
+    const data = await client.patch(`/estimator/import/${importId}`, body);
+    return JSON.stringify(data);
+  },
+};
+
+// --- estimator_commit_import ---
+
+const commitImportSchema = z.object({
+  importId: z.string(),
+});
+
+export const commitImport = {
+  name: "estimator_commit_import",
+  description: "Finalize a reviewed catalog import, writing all approved rows into the user's service catalog. Requires an importId that has been reviewed. This action cannot be undone — rows are added permanently.",
+  inputSchemaZod: commitImportSchema,
+  execute: async (args: z.infer<typeof commitImportSchema>): Promise<string> => {
+    if (!client.hasApiKey()) return client.noApiKeyMessage();
+    const data = await client.post(`/estimator/import/${args.importId}/commit`, {});
+    return JSON.stringify(data);
+  },
+};
+
+// --- estimator_setup_price ---
+
+const setupPriceSchema = z.object({
+  name: z.string(),
+  serviceCode: z.string(),
+  category: z.string(),
+  materialType: z.string().nullable().optional(),
+  unit: z.string(),
+  materialCost: z.number().min(0),
+  laborCost: z.number().min(0),
+  minCharge: z.number().min(0).optional(),
+  notes: z.string().optional(),
+});
+
+export const setupPrice = {
+  name: "estimator_setup_price",
+  description: "Add a new service to the user's price book (service catalog). Every service needs: a unique serviceCode (e.g., ROOF_INSPECT, SHINGLE_REPAIR), a display name, category (tear_off, decking, underlayment, field_install, flashing, ridge_cap, ventilation, gutters, cleanup, permit, misc, etc.), unit (sq_ft, linear_ft, each, sheet, roll, bundle, hour, lump), and material/labor costs. Items in the catalog are used when creating estimates.",
+  inputSchemaZod: setupPriceSchema,
+  execute: async (args: z.infer<typeof setupPriceSchema>): Promise<string> => {
+    if (!client.hasApiKey()) return client.noApiKeyMessage();
+    const data = await client.post("/estimator/catalog", args);
+    return JSON.stringify(data);
+  },
+};
+
+// --- estimator_update_price ---
+
+const updatePriceSchema = z.object({
+  itemId: z.string(),
+  name: z.string().optional(),
+  serviceCode: z.string().optional(),
+  category: z.string().optional(),
+  materialType: z.string().nullable().optional(),
+  unit: z.string().optional(),
+  materialCost: z.number().min(0).optional(),
+  laborCost: z.number().min(0).optional(),
+  minCharge: z.number().min(0).optional(),
+  notes: z.string().optional(),
+});
+
+export const updatePrice = {
+  name: "estimator_update_price",
+  description: "Update an existing item in the service catalog. Use estimator_get_catalog first to find the itemId. You can change the name, service code, category, unit, material cost, labor cost, minimum charge, or notes.",
+  inputSchemaZod: updatePriceSchema,
+  execute: async (args: z.infer<typeof updatePriceSchema>): Promise<string> => {
+    if (!client.hasApiKey()) return client.noApiKeyMessage();
+    const { itemId, ...body } = args;
+    const data = await client.patch(`/estimator/catalog/${itemId}`, body);
+    return JSON.stringify(data);
+  },
+};
+
+// --- estimator_get_catalog ---
+
+const getCatalogSchema = z.object({
+  category: z.string().optional(),
+  materialType: z.string().optional(),
+  limit: z.number().optional(),
+  cursor: z.string().optional(),
+});
+
+export const getCatalog = {
+  name: "estimator_get_catalog",
+  description:
+    "List all items in the user's service catalog (price book). Returns service codes, names, categories, units, and material/labor costs. IMPORTANT: Always call this before creating estimates to get valid service codes. Optional filters: category (tear_off, decking, underlayment, field_install, ridge_hip, flashing, misc, …) and materialType (asphalt_architectural, asphalt_3tab, metal_standing_seam, tpo, …) must match those exact enum strings — when unsure, omit both to fetch the full catalog.",
+  inputSchemaZod: getCatalogSchema,
+  execute: async (args: z.infer<typeof getCatalogSchema>): Promise<string> => {
+    if (!client.hasApiKey()) return client.noApiKeyMessage();
+
+    const params = new URLSearchParams();
+    if (args.category) params.set("category", args.category);
+    if (args.materialType) params.set("materialType", args.materialType);
+    if (args.limit != null) params.set("limit", String(args.limit));
+    if (args.cursor) params.set("cursor", args.cursor);
+
+    const q = params.toString();
+    const path = q ? `/estimator/catalog?${q}` : "/estimator/catalog";
+
+    const data = await client.get<unknown>(path);
+    return JSON.stringify(data);
+  },
+};
+
+// --- estimator_get_config ---
+
+const getConfigSchema = z.object({});
+
+export const getConfig = {
+  name: "estimator_get_config",
+  description: "Get the user's estimator settings — company name, default markup/waste percentage, tax rate, currency, contact info, license number, and default notes/terms for estimates.",
+  inputSchemaZod: getConfigSchema,
+  execute: async (_args: z.infer<typeof getConfigSchema>): Promise<string> => {
+    if (!client.hasApiKey()) return client.noApiKeyMessage();
+    const data = await client.get<unknown>("/estimator/config");
+    return JSON.stringify(data);
+  },
+};
+
+// --- estimator_update_config ---
+
+const updateConfigSchema = z.object({
+  defaultMarkup: z.number().optional(),
+  taxRate: z.number().optional(),
+  companyName: z.string().optional(),
+  companyPhone: z.string().optional(),
+  companyEmail: z.string().optional(),
+  companyAddress: z.string().optional(),
+  companyLogo: z.string().optional(),
+  licenseNumber: z.string().optional(),
+  defaultNotes: z.string().optional(),
+  defaultTerms: z.string().optional(),
+});
+
+export const updateConfig = {
+  name: "estimator_update_config",
+  description: "Update the user's estimator settings. You can set: companyName, defaultMarkup (waste %), taxRate, companyPhone, companyEmail, companyAddress, companyLogo (URL), licenseNumber, defaultNotes (appended to every estimate), and defaultTerms (terms & conditions).",
+  inputSchemaZod: updateConfigSchema,
+  execute: async (args: z.infer<typeof updateConfigSchema>): Promise<string> => {
+    if (!client.hasApiKey()) return client.noApiKeyMessage();
+    const data = await client.patch("/estimator/config", args);
+    return JSON.stringify(data);
+  },
+};
+
+// --- estimator_import_template ---
+
+const importTemplateSchema = z.object({
+  templateId: z.string().optional(),
+});
+
+export const importTemplate = {
+  name: "estimator_import_template",
+  description:
+    "Import a pre-built pricing catalog template into the user's service catalog. Call without arguments to see available templates (returns id, name, description, item count). Call with a templateId to import all items. These are MATERIAL COSTS ONLY — users should add their own labor rates after import. Items that already exist in the user's catalog are skipped (never overwritten).",
+  inputSchemaZod: importTemplateSchema,
+  execute: async (args: z.infer<typeof importTemplateSchema>): Promise<string> => {
+    if (!client.hasApiKey()) return client.noApiKeyMessage();
+
+    if (!args.templateId) {
+      const data = await client.get("/estimator/catalog/templates");
+      return JSON.stringify(data);
+    }
+
+    const data = await client.post("/estimator/catalog/templates", {
+      templateId: args.templateId,
+    });
+    return JSON.stringify(data);
+  },
+};