@procurementexpress.com/mcp 1.0.0

package/dist/tools/invoices.js

@@ -0,0 +1,132 @@
+import { z } from "zod";
+import { jsonResponse, withErrorHandling } from "../tool-helpers.js";
+const invoiceLineItemSchema = z.object({
+    description: z.string().describe("Line item description"),
+    unit_price: z.number().describe("Unit price"),
+    quantity: z.number().describe("Quantity"),
+    vat: z.number().optional().describe("VAT amount"),
+    net_amount: z.number().optional().describe("Net amount"),
+    purchase_order_id: z.number().int().optional().describe("Related PO ID"),
+    purchase_order_item_id: z.number().int().optional().describe("Related PO item ID"),
+});
+export function registerInvoiceTools(server, apiClient) {
+    server.registerTool("list_invoices", {
+        description: "List invoices with pagination and filters (100 per page)",
+        inputSchema: {
+            page: z.number().int().positive().optional().describe("Page number"),
+            archived: z.boolean().optional().describe("Filter by archived status"),
+            requester_id: z.number().int().optional().describe("Filter by requester ID"),
+            approver_id: z.number().int().optional().describe("Filter by approver ID"),
+            supplier_id: z.number().int().optional().describe("Filter by supplier ID"),
+            invoice_date_filter: z.string().optional().describe("Date filter (e.g. 'last 7days')"),
+        },
+    }, withErrorHandling(async (args) => {
+        const params = new URLSearchParams();
+        if (args.page)
+            params.set("page", String(args.page));
+        if (args.archived !== undefined)
+            params.set("archived", String(args.archived));
+        if (args.requester_id)
+            params.set("requester_id", String(args.requester_id));
+        if (args.approver_id)
+            params.set("approver_id", String(args.approver_id));
+        if (args.supplier_id)
+            params.set("supplier_id", String(args.supplier_id));
+        if (args.invoice_date_filter)
+            params.set("invoice_date_filter", args.invoice_date_filter);
+        const query = params.toString();
+        const path = `${apiClient.buildPath("/invoices")}${query ? `?${query}` : ""}`;
+        const result = await apiClient.get(path);
+        return jsonResponse(result);
+    }));
+    server.registerTool("get_invoice", {
+        description: "Get invoice details by ID",
+        inputSchema: {
+            id: z.number().int().positive().describe("Invoice ID"),
+        },
+    }, withErrorHandling(async (args) => {
+        const invoice = await apiClient.get(apiClient.buildPath(`/invoices/${args.id}`));
+        return jsonResponse(invoice);
+    }));
+    server.registerTool("create_invoice", {
+        description: "Create a new invoice",
+        inputSchema: {
+            invoice_number: z.string().optional().describe("Invoice number"),
+            issue_date: z.string().optional().describe("Issue date"),
+            supplier_id: z.number().int().optional().describe("Supplier ID"),
+            received_date: z.string().optional().describe("Received date"),
+            due_date: z.string().optional().describe("Due date"),
+            gross_amount: z.number().describe("Gross amount"),
+            currency_id: z.number().int().describe("Currency ID"),
+            company_id: z.number().int().describe("Company ID"),
+            line_items: z.array(invoiceLineItemSchema).optional().describe("Invoice line items"),
+        },
+    }, withErrorHandling(async (args) => {
+        const { line_items, ...invoiceData } = args;
+        const body = {
+            invoice: {
+                ...invoiceData,
+                ...(line_items ? { invoice_line_items_attributes: line_items } : {}),
+            },
+        };
+        const invoice = await apiClient.post(apiClient.buildPath("/invoices"), body);
+        return jsonResponse(invoice);
+    }));
+    server.registerTool("update_invoice", {
+        description: "Update an existing invoice",
+        inputSchema: {
+            id: z.number().int().positive().describe("Invoice ID"),
+            invoice_number: z.string().optional().describe("Invoice number"),
+            issue_date: z.string().optional().describe("Issue date"),
+            supplier_id: z.number().int().optional().describe("Supplier ID"),
+            due_date: z.string().optional().describe("Due date"),
+            gross_amount: z.number().optional().describe("Gross amount"),
+        },
+    }, withErrorHandling(async (args) => {
+        const { id, ...data } = args;
+        const invoice = await apiClient.put(apiClient.buildPath(`/invoices/${id}`), { invoice: data });
+        return jsonResponse(invoice);
+    }));
+    server.registerTool("accept_invoice", {
+        description: "Accept an invoice that is awaiting review",
+        inputSchema: { id: z.number().int().positive().describe("Invoice ID") },
+    }, withErrorHandling(async (args) => {
+        const result = await apiClient.put(apiClient.buildPath(`/invoices/${args.id}/accept`));
+        return jsonResponse(result);
+    }));
+    server.registerTool("approve_invoice", {
+        description: "Approve an invoice",
+        inputSchema: { id: z.number().int().positive().describe("Invoice ID") },
+    }, withErrorHandling(async (args) => {
+        const result = await apiClient.put(apiClient.buildPath(`/invoices/${args.id}/approve`));
+        return jsonResponse(result);
+    }));
+    server.registerTool("reject_invoice", {
+        description: "Reject an invoice",
+        inputSchema: { id: z.number().int().positive().describe("Invoice ID") },
+    }, withErrorHandling(async (args) => {
+        const result = await apiClient.put(apiClient.buildPath(`/invoices/${args.id}/reject`));
+        return jsonResponse(result);
+    }));
+    server.registerTool("cancel_invoice", {
+        description: "Cancel an invoice",
+        inputSchema: { id: z.number().int().positive().describe("Invoice ID") },
+    }, withErrorHandling(async (args) => {
+        const result = await apiClient.put(apiClient.buildPath(`/invoices/${args.id}/cancel`));
+        return jsonResponse(result);
+    }));
+    server.registerTool("archive_invoice", {
+        description: "Archive an invoice",
+        inputSchema: { id: z.number().int().positive().describe("Invoice ID") },
+    }, withErrorHandling(async (args) => {
+        const result = await apiClient.put(apiClient.buildPath(`/invoices/${args.id}/archive`));
+        return jsonResponse(result);
+    }));
+    server.registerTool("dearchive_invoice", {
+        description: "Restore an archived invoice",
+        inputSchema: { id: z.number().int().positive().describe("Invoice ID") },
+    }, withErrorHandling(async (args) => {
+        const result = await apiClient.put(apiClient.buildPath(`/invoices/${args.id}/dearchive`));
+        return jsonResponse(result);
+    }));
+}

package/dist/tools/payments.d.ts

@@ -0,0 +1,3 @@
+import type { ApiClient } from "../api-client.js";
+import type { Server } from "../tool-helpers.js";
+export declare function registerPaymentTools(server: Server, apiClient: ApiClient): void;

package/dist/tools/payments.js

@@ -0,0 +1,65 @@
+import { z } from "zod";
+import { jsonResponse, withErrorHandling } from "../tool-helpers.js";
+export function registerPaymentTools(server, apiClient) {
+    server.registerTool("create_payment", {
+        description: "Create a payment (feature flagged). ptype values: bank_transfer, card, credit_card, check, cash, one_time_card, letter_of_credit, other",
+        inputSchema: {
+            user_id: z.number().int().describe("Payment creator user ID"),
+            reference: z.string().optional().describe("Reference number"),
+            supplier_id: z.number().int().describe("Supplier ID"),
+            ptype: z
+                .enum([
+                "bank_transfer",
+                "card",
+                "credit_card",
+                "check",
+                "cash",
+                "one_time_card",
+                "letter_of_credit",
+                "other",
+            ])
+                .describe("Payment type"),
+            date: z.string().describe("Payment date"),
+            currency_id: z.number().int().describe("Currency ID"),
+            amount: z.number().describe("Total amount (must match sum of invoice amounts)"),
+            invoices: z
+                .array(z.object({
+                invoice_id: z.number().int().describe("Invoice ID"),
+                gross_amount: z.number().describe("Amount for this invoice"),
+            }))
+                .describe("Invoices to pay"),
+        },
+    }, withErrorHandling(async (args) => {
+        const { invoices, ...paymentData } = args;
+        const body = {
+            npayment: {
+                ...paymentData,
+                npayment_invoices_attributes: invoices,
+            },
+        };
+        const payment = await apiClient.post(apiClient.buildPath("/npayments"), body);
+        return jsonResponse(payment);
+    }));
+    server.registerTool("create_po_payment", {
+        description: "Create a payment for a purchase order",
+        inputSchema: {
+            purchase_order_id: z.number().int().positive().describe("Purchase Order ID"),
+            note: z.string().optional().describe("Payment note"),
+            item_payments: z
+                .array(z.object({
+                purchase_order_item_id: z.number().int().describe("PO item ID"),
+                amount: z.number().describe("Payment amount for this item"),
+            }))
+                .describe("Item-level payment amounts"),
+        },
+    }, withErrorHandling(async (args) => {
+        const body = {
+            payment: {
+                note: args.note,
+                purchase_order_item_payments_attributes: args.item_payments,
+            },
+        };
+        const result = await apiClient.post(apiClient.buildPath(`/purchase_orders/${args.purchase_order_id}/payments`), body);
+        return jsonResponse(result);
+    }));
+}

package/dist/tools/products.d.ts

@@ -0,0 +1,3 @@
+import type { ApiClient } from "../api-client.js";
+import type { Server } from "../tool-helpers.js";
+export declare function registerProductTools(server: Server, apiClient: ApiClient): void;

package/dist/tools/products.js

@@ -0,0 +1,57 @@
+import { z } from "zod";
+import { jsonResponse, withErrorHandling } from "../tool-helpers.js";
+export function registerProductTools(server, apiClient) {
+    server.registerTool("list_products", {
+        description: "List products with optional filters for supplier and archived status",
+        inputSchema: {
+            supplier_id: z.number().int().optional().describe("Filter by supplier ID"),
+            archived: z.boolean().optional().describe("Filter by archived status"),
+        },
+    }, withErrorHandling(async (args) => {
+        const params = new URLSearchParams();
+        if (args.supplier_id)
+            params.set("supplier_id", String(args.supplier_id));
+        if (args.archived !== undefined)
+            params.set("archived", String(args.archived));
+        const query = params.toString();
+        const path = `${apiClient.buildPath("/products")}${query ? `?${query}` : ""}`;
+        const products = await apiClient.get(path);
+        return jsonResponse(products);
+    }));
+    server.registerTool("get_product", {
+        description: "Get a specific product by ID",
+        inputSchema: {
+            id: z.number().int().positive().describe("Product ID"),
+        },
+    }, withErrorHandling(async (args) => {
+        const product = await apiClient.get(apiClient.buildPath(`/products/${args.id}`));
+        return jsonResponse(product);
+    }));
+    server.registerTool("create_product", {
+        description: "Create a new product",
+        inputSchema: {
+            description: z.string().describe("Product description (required)"),
+            sku: z.string().optional().describe("SKU code"),
+            unit_price: z.number().optional().describe("Unit price"),
+            supplier_id: z.number().int().optional().describe("Supplier ID"),
+        },
+    }, withErrorHandling(async (args) => {
+        const product = await apiClient.post(apiClient.buildPath("/products"), { product: args });
+        return jsonResponse(product);
+    }));
+    server.registerTool("update_product", {
+        description: "Update an existing product",
+        inputSchema: {
+            id: z.number().int().positive().describe("Product ID"),
+            description: z.string().optional().describe("Product description"),
+            sku: z.string().optional().describe("SKU code"),
+            unit_price: z.number().optional().describe("Unit price"),
+            supplier_id: z.number().int().optional().describe("Supplier ID"),
+            archived: z.boolean().optional().describe("Archive status"),
+        },
+    }, withErrorHandling(async (args) => {
+        const { id, ...data } = args;
+        const product = await apiClient.put(apiClient.buildPath(`/products/${id}`), { product: data });
+        return jsonResponse(product);
+    }));
+}

package/dist/tools/purchase-orders.d.ts

@@ -0,0 +1,3 @@
+import type { ApiClient } from "../api-client.js";
+import type { Server } from "../tool-helpers.js";
+export declare function registerPurchaseOrderTools(server: Server, apiClient: ApiClient): void;

package/dist/tools/purchase-orders.js

@@ -0,0 +1,152 @@
+import { z } from "zod";
+import { jsonResponse, textResponse, withErrorHandling } from "../tool-helpers.js";
+const lineItemSchema = z.object({
+    description: z.string().describe("Item description"),
+    quantity: z.number().describe("Quantity"),
+    unit_price: z.number().describe("Unit price"),
+    budget_id: z.number().int().optional().describe("Budget ID"),
+    vat: z.number().optional().describe("VAT amount"),
+    item_number: z.string().optional().describe("Item number"),
+    sequence_no: z.number().int().optional().describe("Sequence number"),
+    tax_rate_id: z.number().int().optional().describe("Tax rate ID"),
+});
+export function registerPurchaseOrderTools(server, apiClient) {
+    server.registerTool("list_purchase_orders", {
+        description: "List purchase orders with pagination and search",
+        inputSchema: {
+            orders_page: z.number().int().positive().optional().describe("Page number (default: 1)"),
+            search: z.string().optional().describe("Search term"),
+            requests: z.boolean().optional().describe("Set to true to list pending approval requests"),
+            sort: z.string().optional().describe("Sort field"),
+            direction: z.enum(["asc", "desc"]).optional().describe("Sort direction"),
+        },
+    }, withErrorHandling(async (args) => {
+        const params = new URLSearchParams();
+        if (args.orders_page)
+            params.set("orders_page", String(args.orders_page));
+        if (args.search)
+            params.set("search", args.search);
+        if (args.requests)
+            params.set("requests", "true");
+        if (args.sort)
+            params.set("sort", args.sort);
+        if (args.direction)
+            params.set("direction", args.direction);
+        const query = params.toString();
+        const path = `${apiClient.buildPath("/purchase_orders")}${query ? `?${query}` : ""}`;
+        const result = await apiClient.get(path);
+        return jsonResponse(result);
+    }));
+    server.registerTool("get_purchase_order", {
+        description: "Get purchase order details including line items, comments, approvals, and status flags",
+        inputSchema: {
+            id: z.number().int().positive().describe("Purchase Order ID"),
+        },
+    }, withErrorHandling(async (args) => {
+        const po = await apiClient.get(apiClient.buildPath(`/purchase_orders/${args.id}`));
+        return jsonResponse(po);
+    }));
+    server.registerTool("create_purchase_order", {
+        description: "Create a new purchase order. Use commit='Send' to submit or 'Draft' to save as draft",
+        inputSchema: {
+            commit: z.enum(["Send", "Draft"]).describe("'Send' to submit for approval, 'Draft' to save as draft"),
+            department_id: z.number().int().optional().describe("Department ID"),
+            creator_id: z.number().int().describe("Creator user ID"),
+            supplier_id: z.number().int().optional().describe("Supplier ID"),
+            supplier_name: z.string().optional().describe("Supplier name (for new suppliers)"),
+            currency_id: z.number().int().describe("Currency ID"),
+            notes: z.string().optional().describe("PO notes"),
+            line_items: z.array(lineItemSchema).min(1).describe("Line items (at least one required)"),
+            approver_list: z.array(z.number().int()).optional().describe("Approver IDs"),
+        },
+    }, withErrorHandling(async (args) => {
+        const { commit, line_items, approver_list, ...poData } = args;
+        const body = {
+            commit,
+            purchase_order: {
+                ...poData,
+                purchase_order_items_attributes: line_items,
+                ...(approver_list ? { approver_list } : {}),
+            },
+        };
+        const po = await apiClient.post(apiClient.buildPath("/purchase_orders"), body);
+        return jsonResponse(po);
+    }));
+    server.registerTool("approve_purchase_order", {
+        description: "Approve a purchase order using the accept token from the approver request",
+        inputSchema: {
+            id: z.number().int().positive().describe("Purchase Order ID"),
+            token: z.string().describe("Accept token from the approver request"),
+        },
+    }, withErrorHandling(async (args) => {
+        const result = await apiClient.get(`${apiClient.buildPath(`/purchase_orders/${args.id}/approve`)}?token=${args.token}`);
+        return jsonResponse(result);
+    }));
+    server.registerTool("reject_purchase_order", {
+        description: "Reject a purchase order using the reject token from the approver request",
+        inputSchema: {
+            id: z.number().int().positive().describe("Purchase Order ID"),
+            token: z.string().describe("Reject token from the approver request"),
+        },
+    }, withErrorHandling(async (args) => {
+        const result = await apiClient.get(`${apiClient.buildPath(`/purchase_orders/${args.id}/reject`)}?token=${args.token}`);
+        return jsonResponse(result);
+    }));
+    server.registerTool("override_and_approve_purchase_order", {
+        description: "Override and approve a purchase order (finance users only, no token required)",
+        inputSchema: {
+            id: z.number().int().positive().describe("Purchase Order ID"),
+        },
+    }, withErrorHandling(async (args) => {
+        const result = await apiClient.get(apiClient.buildPath(`/purchase_orders/${args.id}/override_and_approve`));
+        return jsonResponse(result);
+    }));
+    server.registerTool("cancel_purchase_order", {
+        description: "Cancel a purchase order",
+        inputSchema: {
+            id: z.number().int().positive().describe("Purchase Order ID"),
+        },
+    }, withErrorHandling(async (args) => {
+        const result = await apiClient.post(apiClient.buildPath(`/purchase_orders/${args.id}/cancel`));
+        return jsonResponse(result);
+    }));
+    server.registerTool("archive_purchase_order", {
+        description: "Archive a purchase order",
+        inputSchema: {
+            id: z.number().int().positive().describe("Purchase Order ID"),
+        },
+    }, withErrorHandling(async (args) => {
+        const result = await apiClient.post(apiClient.buildPath(`/purchase_orders/${args.id}/archive`));
+        return jsonResponse(result);
+    }));
+    server.registerTool("get_pending_request_count", {
+        description: "Get the count of pending approval requests",
+        inputSchema: {},
+    }, withErrorHandling(async () => {
+        const result = await apiClient.get(apiClient.buildPath("/purchase_orders/pending_request_count"));
+        return textResponse(`Pending requests: ${result.total_pending_request}`);
+    }));
+    server.registerTool("receive_purchase_order_items", {
+        description: "Mark items as received for a purchase order",
+        inputSchema: {
+            id: z.number().int().positive().describe("Purchase Order ID"),
+            items: z
+                .array(z.object({
+                id: z.number().int().describe("PO item ID"),
+                quantity: z.number().describe("Quantity received"),
+            }))
+                .describe("Items with received quantities"),
+            delivered_on: z.string().describe("Delivery date"),
+            notes: z.string().optional().describe("Delivery notes"),
+        },
+    }, withErrorHandling(async (args) => {
+        const result = await apiClient.post(apiClient.buildPath(`/purchase_orders/${args.id}/receiving_items`), {
+            purchase_order: {
+                items: args.items,
+                delivered_on: args.delivered_on,
+                notes: args.notes,
+            },
+        });
+        return jsonResponse(result);
+    }));
+}

package/dist/tools/supplementary.d.ts

@@ -0,0 +1,3 @@
+import type { ApiClient } from "../api-client.js";
+import type { Server } from "../tool-helpers.js";
+export declare function registerSupplementaryTools(server: Server, apiClient: ApiClient): void;

package/dist/tools/supplementary.js

@@ -0,0 +1,70 @@
+import { z } from "zod";
+import { jsonResponse, withErrorHandling } from "../tool-helpers.js";
+export function registerSupplementaryTools(server, apiClient) {
+    server.registerTool("list_chart_of_accounts", {
+        description: "List chart of accounts with optional search",
+        inputSchema: {
+            search: z.string().optional().describe("Search term"),
+        },
+    }, withErrorHandling(async (args) => {
+        const params = new URLSearchParams();
+        if (args.search)
+            params.set("search", args.search);
+        const query = params.toString();
+        const path = `${apiClient.buildPath("/chart_of_accounts")}${query ? `?${query}` : ""}`;
+        const result = await apiClient.get(path);
+        return jsonResponse(result);
+    }));
+    server.registerTool("list_qbo_customers", {
+        description: "List QuickBooks customers with optional search",
+        inputSchema: {
+            search: z.string().optional().describe("Search term"),
+        },
+    }, withErrorHandling(async (args) => {
+        const params = new URLSearchParams();
+        if (args.search)
+            params.set("search", args.search);
+        const query = params.toString();
+        const path = `${apiClient.buildPath("/qbo_customers")}${query ? `?${query}` : ""}`;
+        const result = await apiClient.get(path);
+        return jsonResponse(result);
+    }));
+    server.registerTool("list_qbo_classes", {
+        description: "List QuickBooks classes with optional search",
+        inputSchema: {
+            search: z.string().optional().describe("Search term"),
+        },
+    }, withErrorHandling(async (args) => {
+        const params = new URLSearchParams();
+        if (args.search)
+            params.set("search", args.search);
+        const query = params.toString();
+        const path = `${apiClient.buildPath("/qbo_classes")}${query ? `?${query}` : ""}`;
+        const result = await apiClient.get(path);
+        return jsonResponse(result);
+    }));
+    server.registerTool("list_send_to_supplier_templates", {
+        description: "List email templates for sending POs to suppliers",
+        inputSchema: {},
+    }, withErrorHandling(async () => {
+        const templates = await apiClient.get(apiClient.buildPath("/send_to_supplier_templates"));
+        return jsonResponse(templates);
+    }));
+    server.registerTool("forward_purchase_order", {
+        description: "Forward a purchase order to supplier(s) via email",
+        inputSchema: {
+            purchase_order_id: z.number().int().positive().describe("Purchase Order ID"),
+            emails: z.array(z.string().email()).describe("Recipient email addresses"),
+            cc: z.string().email().optional().describe("CC email address"),
+            notes: z.string().optional().describe("Email body / template text"),
+            email_subject: z.string().optional().describe("Email subject"),
+            template_label: z.string().optional().describe("Template label"),
+            save_template: z.boolean().optional().describe("Save as new template"),
+            is_default: z.boolean().optional().describe("Mark as default template"),
+        },
+    }, withErrorHandling(async (args) => {
+        const { purchase_order_id, ...data } = args;
+        const result = await apiClient.post(apiClient.buildPath(`/purchase_orders/${purchase_order_id}/forward`), data);
+        return jsonResponse(result);
+    }));
+}

package/dist/tools/suppliers.d.ts

@@ -0,0 +1,3 @@
+import type { ApiClient } from "../api-client.js";
+import type { Server } from "../tool-helpers.js";
+export declare function registerSupplierTools(server: Server, apiClient: ApiClient): void;

package/dist/tools/suppliers.js

@@ -0,0 +1,80 @@
+import { z } from "zod";
+import { jsonResponse, withErrorHandling } from "../tool-helpers.js";
+export function registerSupplierTools(server, apiClient) {
+    server.registerTool("list_suppliers", {
+        description: "List suppliers with pagination and filters",
+        inputSchema: {
+            page: z.number().int().positive().optional().describe("Page number"),
+            department_id: z.number().int().optional().describe("Filter by department ID"),
+            archived: z.boolean().optional().describe("Filter by archived status"),
+            top: z.number().int().positive().optional().describe("Limit to top N suppliers"),
+        },
+    }, withErrorHandling(async (args) => {
+        const params = new URLSearchParams();
+        if (args.page)
+            params.set("page", String(args.page));
+        if (args.department_id)
+            params.set("department_id", String(args.department_id));
+        if (args.archived !== undefined)
+            params.set("archived", String(args.archived));
+        if (args.top)
+            params.set("top", String(args.top));
+        const query = params.toString();
+        const path = args.top
+            ? `${apiClient.buildPath("/suppliers/top")}?${query}`
+            : `${apiClient.buildPath("/suppliers")}${query ? `?${query}` : ""}`;
+        const result = await apiClient.get(path);
+        return jsonResponse(result);
+    }));
+    server.registerTool("get_supplier", {
+        description: "Get a specific supplier by ID",
+        inputSchema: {
+            id: z.number().int().positive().describe("Supplier ID"),
+        },
+    }, withErrorHandling(async (args) => {
+        const supplier = await apiClient.get(apiClient.buildPath(`/suppliers/${args.id}`));
+        return jsonResponse(supplier);
+    }));
+    server.registerTool("create_supplier", {
+        description: "Create a new supplier (name must be unique)",
+        inputSchema: {
+            name: z.string().describe("Supplier name (must be unique)"),
+            email: z.string().email().optional().describe("Supplier email"),
+            address: z.string().optional().describe("Address"),
+            notes: z.string().optional().describe("Notes"),
+            payment_details: z.string().optional().describe("Payment details"),
+            phone_number: z.string().optional().describe("Phone number"),
+            tax_number: z.string().optional().describe("Tax number"),
+            contact_person: z.string().optional().describe("Contact person"),
+            department_ids: z.array(z.number().int()).optional().describe("Department IDs"),
+        },
+    }, withErrorHandling(async (args) => {
+        const { department_ids, ...supplierData } = args;
+        const body = { supplier: supplierData };
+        if (department_ids)
+            body.department_ids = department_ids;
+        const supplier = await apiClient.post(apiClient.buildPath("/suppliers"), body);
+        return jsonResponse(supplier);
+    }));
+    server.registerTool("update_supplier", {
+        description: "Update an existing supplier",
+        inputSchema: {
+            id: z.number().int().positive().describe("Supplier ID"),
+            name: z.string().optional().describe("Supplier name"),
+            email: z.string().email().optional().describe("Email"),
+            address: z.string().optional().describe("Address"),
+            notes: z.string().optional().describe("Notes"),
+            payment_details: z.string().optional().describe("Payment details"),
+            phone_number: z.string().optional().describe("Phone number"),
+            archived: z.boolean().optional().describe("Archive status"),
+            tax_number: z.string().optional().describe("Tax number"),
+            contact_person: z.string().optional().describe("Contact person"),
+        },
+    }, withErrorHandling(async (args) => {
+        const { id, ...data } = args;
+        const supplier = await apiClient.put(apiClient.buildPath(`/suppliers/${id}`), {
+            supplier: data,
+        });
+        return jsonResponse(supplier);
+    }));
+}

package/dist/tools/tax-rates.d.ts

@@ -0,0 +1,3 @@
+import type { ApiClient } from "../api-client.js";
+import type { Server } from "../tool-helpers.js";
+export declare function registerTaxRateTools(server: Server, apiClient: ApiClient): void;

package/dist/tools/tax-rates.js

@@ -0,0 +1,44 @@
+import { z } from "zod";
+import { jsonResponse, withErrorHandling } from "../tool-helpers.js";
+export function registerTaxRateTools(server, apiClient) {
+    server.registerTool("list_tax_rates", {
+        description: "List all tax rates (single and combined types)",
+        inputSchema: {},
+    }, withErrorHandling(async () => {
+        const taxRates = await apiClient.get(apiClient.buildPath("/tax_rates"));
+        return jsonResponse(taxRates);
+    }));
+    server.registerTool("get_tax_rate", {
+        description: "Get a specific tax rate by ID",
+        inputSchema: {
+            id: z.number().int().positive().describe("Tax Rate ID"),
+        },
+    }, withErrorHandling(async (args) => {
+        const taxRate = await apiClient.get(apiClient.buildPath(`/tax_rates/${args.id}`));
+        return jsonResponse(taxRate);
+    }));
+    server.registerTool("create_tax_rate", {
+        description: "Create a new tax rate",
+        inputSchema: {
+            name: z.string().describe("Tax rate name"),
+            value: z.number().describe("Tax rate value (percentage)"),
+            company_id: z.number().int().describe("Company ID"),
+        },
+    }, withErrorHandling(async (args) => {
+        const taxRate = await apiClient.post(apiClient.buildPath("/tax_rates"), { tax_rate: args });
+        return jsonResponse(taxRate);
+    }));
+    server.registerTool("update_tax_rate", {
+        description: "Update an existing tax rate",
+        inputSchema: {
+            id: z.number().int().positive().describe("Tax Rate ID"),
+            name: z.string().optional().describe("Tax rate name"),
+            value: z.number().optional().describe("Tax rate value"),
+            archived: z.boolean().optional().describe("Archive status"),
+        },
+    }, withErrorHandling(async (args) => {
+        const { id, ...data } = args;
+        const taxRate = await apiClient.put(apiClient.buildPath(`/tax_rates/${id}`), { tax_rate: data });
+        return jsonResponse(taxRate);
+    }));
+}

package/dist/tools/users.d.ts

@@ -0,0 +1,3 @@
+import type { ApiClient } from "../api-client.js";
+import type { Server } from "../tool-helpers.js";
+export declare function registerUserTools(server: Server, apiClient: ApiClient): void;