@procurementexpress.com/mcp 1.0.0

package/dist/index.js

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { ApiClient } from "./api-client.js";
+import { AuthManager } from "./auth.js";
+import { jsonResponse, textResponse, withErrorHandling } from "./tool-helpers.js";
+import { registerApprovalFlowTools } from "./tools/approval-flows.js";
+import { registerBudgetTools } from "./tools/budgets.js";
+import { registerCommentTools } from "./tools/comments.js";
+import { registerCompanyTools } from "./tools/companies.js";
+import { registerDepartmentTools } from "./tools/departments.js";
+import { registerInvoiceTools } from "./tools/invoices.js";
+import { registerPaymentTools } from "./tools/payments.js";
+import { registerProductTools } from "./tools/products.js";
+import { registerPurchaseOrderTools } from "./tools/purchase-orders.js";
+import { registerSupplementaryTools } from "./tools/supplementary.js";
+import { registerSupplierTools } from "./tools/suppliers.js";
+import { registerTaxRateTools } from "./tools/tax-rates.js";
+import { registerUserTools } from "./tools/users.js";
+import { registerWebhookTools } from "./tools/webhooks.js";
+// Create API client and auth manager
+const apiClient = new ApiClient();
+const authManager = new AuthManager(apiClient);
+const isV1 = authManager.isV1();
+// Create MCP server
+const server = new McpServer({
+    name: "procurementexpress",
+    version: "1.0.0",
+    description: `MCP server for ProcurementExpress API (${apiClient.getApiVersion()}) - manage purchase orders, invoices, budgets, suppliers, and procurement workflows`,
+});
+// Register version-appropriate authentication tools
+if (isV1) {
+    // V1: Token-based authentication
+    server.registerTool("authenticate", {
+        description: "Authenticate with ProcurementExpress V1 API using a static authentication token and company ID. " +
+            "Reads from PROCUREMENTEXPRESS_AUTH_TOKEN and PROCUREMENTEXPRESS_COMPANY_ID environment variables if not provided.",
+        inputSchema: {
+            authentication_token: z
+                .string()
+                .optional()
+                .describe("Authentication token (reads from PROCUREMENTEXPRESS_AUTH_TOKEN env var if omitted)"),
+            company_id: z
+                .string()
+                .optional()
+                .describe("Company ID (reads from PROCUREMENTEXPRESS_COMPANY_ID env var if omitted)"),
+        },
+    }, withErrorHandling(async (args) => {
+        const token = args.authentication_token || process.env.PROCUREMENTEXPRESS_AUTH_TOKEN || "";
+        const companyId = args.company_id || process.env.PROCUREMENTEXPRESS_COMPANY_ID || "";
+        if (!token) {
+            return textResponse("Error: No authentication token provided. Pass it as a parameter or set PROCUREMENTEXPRESS_AUTH_TOKEN environment variable.");
+        }
+        if (!companyId) {
+            return textResponse("Error: No company ID provided. Pass it as a parameter or set PROCUREMENTEXPRESS_COMPANY_ID environment variable.");
+        }
+        authManager.authenticateV1(token, companyId);
+        return textResponse(`Authenticated with V1 API. Company ID set to ${companyId}. You can now make API calls.`);
+    }));
+}
+else {
+    // V3: OAuth2 authentication
+    server.registerTool("authenticate", {
+        description: "Sign in to ProcurementExpress via OAuth2. Returns a bearer token for subsequent API calls. " +
+            "Requires PROCUREMENTEXPRESS_CLIENT_ID and PROCUREMENTEXPRESS_CLIENT_SECRET environment variables.",
+        inputSchema: {
+            email: z.string().email().describe("User email address"),
+            password: z.string().describe("User password"),
+        },
+    }, withErrorHandling(async (args) => {
+        const response = await authManager.authenticateV3(args.email, args.password);
+        return textResponse(`Authenticated successfully via OAuth2. Token expires in ${response.expires_in} seconds. Use set_active_company to select a company before making API calls.`);
+    }));
+}
+server.registerTool("validate_token", {
+    description: isV1
+        ? "Validate the current V1 authentication token by fetching the current user"
+        : "Check if the current OAuth2 token is valid and get token metadata",
+    inputSchema: {},
+}, withErrorHandling(async () => {
+    const info = await authManager.validateToken();
+    return jsonResponse(info);
+}));
+server.registerTool("revoke_token", {
+    description: isV1
+        ? "Clear the current authentication token from the session"
+        : "Sign out and revoke the current OAuth2 token",
+    inputSchema: {},
+}, withErrorHandling(async () => {
+    await authManager.revokeToken();
+    return textResponse(isV1
+        ? "Token cleared. You are now signed out."
+        : "Token revoked successfully. You are now signed out.");
+}));
+// Register all tool groups
+registerUserTools(server, apiClient);
+registerBudgetTools(server, apiClient);
+registerCompanyTools(server, apiClient);
+registerDepartmentTools(server, apiClient);
+registerSupplierTools(server, apiClient);
+registerProductTools(server, apiClient);
+registerPurchaseOrderTools(server, apiClient);
+registerInvoiceTools(server, apiClient);
+registerApprovalFlowTools(server, apiClient);
+registerCommentTools(server, apiClient);
+registerPaymentTools(server, apiClient);
+registerTaxRateTools(server, apiClient);
+registerWebhookTools(server, apiClient);
+registerSupplementaryTools(server, apiClient);
+// Start the server
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error(`ProcurementExpress MCP Server running on stdio (API version: ${apiClient.getApiVersion()})`);
+}
+main().catch((error) => {
+    console.error("Fatal error in main():", error);
+    process.exit(1);
+});

package/dist/tool-helpers.d.ts

@@ -0,0 +1,34 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+/**
+ * Returns a text content response for MCP tools.
+ */
+export declare function textResponse(text: string): {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+};
+/**
+ * Returns a JSON-formatted text content response for MCP tools.
+ */
+export declare function jsonResponse(data: unknown): {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+};
+/**
+ * Wraps a tool handler with standard error handling.
+ */
+export declare function withErrorHandling<T>(handler: (args: T) => Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>): (args: T) => Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export type Server = McpServer;

package/dist/tool-helpers.js

@@ -0,0 +1,26 @@
+/**
+ * Returns a text content response for MCP tools.
+ */
+export function textResponse(text) {
+    return { content: [{ type: "text", text }] };
+}
+/**
+ * Returns a JSON-formatted text content response for MCP tools.
+ */
+export function jsonResponse(data) {
+    return textResponse(JSON.stringify(data, null, 2));
+}
+/**
+ * Wraps a tool handler with standard error handling.
+ */
+export function withErrorHandling(handler) {
+    return async (args) => {
+        try {
+            return await handler(args);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return textResponse(`Error: ${message}`);
+        }
+    };
+}

package/dist/tools/approval-flows.d.ts

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

package/dist/tools/approval-flows.js

@@ -0,0 +1,121 @@
+import { z } from "zod";
+import { jsonResponse, withErrorHandling } from "../tool-helpers.js";
+const approvalConditionSchema = z.object({
+    property: z.string().describe("Condition property (budget, department, supplier, requester, gross_amount, net_amount, custom_field_xxx)"),
+    operator: z.string().describe("Operator: equals(0), not_equals(1), greater_than(2), less_than(3), contains(4), not_contains(5)"),
+    value: z.string().describe("Condition value (single ID or comma-separated IDs)"),
+    custom_field_id: z.number().int().optional().describe("Custom field ID (for custom_field properties)"),
+});
+const approvalStepSchema = z.object({
+    step_no: z.number().int().describe("Step number"),
+    all_should_approve: z.boolean().describe("Whether all approvers in step must approve"),
+    approver_user_ids: z.array(z.number().int()).describe("Approver user IDs"),
+    conditions: z.array(approvalConditionSchema).optional().describe("Step-level conditions"),
+});
+export function registerApprovalFlowTools(server, apiClient) {
+    server.registerTool("list_approval_flows", {
+        description: "List approval flows with search and pagination",
+        inputSchema: {
+            search: z.string().optional().describe("Search term"),
+            page: z.number().int().positive().optional().describe("Page number"),
+            per_page: z.number().int().positive().optional().describe("Results per page"),
+            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.search)
+            params.set("search", args.search);
+        if (args.page)
+            params.set("page", String(args.page));
+        if (args.per_page)
+            params.set("per_page", String(args.per_page));
+        if (args.sort)
+            params.set("sort", args.sort);
+        if (args.direction)
+            params.set("direction", args.direction);
+        const query = params.toString();
+        const path = `${apiClient.buildPath("/approval_flows")}${query ? `?${query}` : ""}`;
+        const result = await apiClient.get(path);
+        return jsonResponse(result);
+    }));
+    server.registerTool("get_approval_flow", {
+        description: "Get approval flow details including steps, approvers, and conditions",
+        inputSchema: {
+            id: z.number().int().positive().describe("Approval Flow ID"),
+        },
+    }, withErrorHandling(async (args) => {
+        const flow = await apiClient.get(apiClient.buildPath(`/approval_flows/${args.id}`));
+        return jsonResponse(flow);
+    }));
+    server.registerTool("create_approval_flow", {
+        description: "Create an approval flow with steps, approvers, and conditions. document_type: 0=purchase_order, 1=invoice",
+        inputSchema: {
+            name: z.string().describe("Flow name"),
+            document_type: z.number().int().min(0).max(1).describe("0=purchase_order, 1=invoice"),
+            self_approval_allowed: z.boolean().optional().describe("Allow self-approval"),
+            steps: z.array(approvalStepSchema).describe("Approval steps with approvers"),
+            conditions: z.array(approvalConditionSchema).optional().describe("Flow-level conditions"),
+        },
+    }, withErrorHandling(async (args) => {
+        const body = {
+            approval_flow: {
+                name: args.name,
+                document_type: args.document_type,
+                self_approval_allowed: args.self_approval_allowed,
+                approval_steps_attributes: args.steps.map((step) => ({
+                    step_no: step.step_no,
+                    all_should_approve: step.all_should_approve,
+                    approval_step_approvers_attributes: step.approver_user_ids.map((uid) => ({
+                        user_id: uid,
+                    })),
+                    ...(step.conditions
+                        ? { approval_conditions_attributes: step.conditions }
+                        : {}),
+                })),
+                ...(args.conditions
+                    ? { approval_conditions_attributes: args.conditions }
+                    : {}),
+            },
+        };
+        const flow = await apiClient.post(apiClient.buildPath("/approval_flows"), body);
+        return jsonResponse(flow);
+    }));
+    server.registerTool("delete_approval_flow", {
+        description: "Delete an approval flow",
+        inputSchema: { id: z.number().int().positive().describe("Approval Flow ID") },
+    }, withErrorHandling(async (args) => {
+        const result = await apiClient.delete(apiClient.buildPath(`/approval_flows/${args.id}`));
+        return jsonResponse(result);
+    }));
+    server.registerTool("archive_approval_flow", {
+        description: "Archive an approval flow",
+        inputSchema: { id: z.number().int().positive().describe("Approval Flow ID") },
+    }, withErrorHandling(async (args) => {
+        const result = await apiClient.put(apiClient.buildPath(`/approval_flows/${args.id}/archive`));
+        return jsonResponse(result);
+    }));
+    server.registerTool("list_approval_flow_runs", {
+        description: "List runs for an approval flow with status and date filters",
+        inputSchema: {
+            id: z.number().int().positive().describe("Approval Flow ID"),
+            status: z.enum(["in_progress", "completed", "rejected"]).optional().describe("Filter by status"),
+            keyword: z.string().optional().describe("Search keyword"),
+            date_range: z.enum(["24h", "7d", "30d", "60d", "custom"]).optional().describe("Date range filter"),
+            date_from: z.string().optional().describe("Start date (MM/DD/YYYY) for custom range"),
+            date_to: z.string().optional().describe("End date (MM/DD/YYYY) for custom range"),
+            page: z.number().int().positive().optional().describe("Page number"),
+        },
+    }, withErrorHandling(async (args) => {
+        const { id, ...filters } = args;
+        const params = new URLSearchParams();
+        for (const [key, value] of Object.entries(filters)) {
+            if (value !== undefined)
+                params.set(key, String(value));
+        }
+        const query = params.toString();
+        const path = `${apiClient.buildPath(`/approval_flows/${id}/runs`)}${query ? `?${query}` : ""}`;
+        const result = await apiClient.get(path);
+        return jsonResponse(result);
+    }));
+}

package/dist/tools/budgets.d.ts

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

package/dist/tools/budgets.js

@@ -0,0 +1,73 @@
+import { z } from "zod";
+import { jsonResponse, withErrorHandling } from "../tool-helpers.js";
+export function registerBudgetTools(server, apiClient) {
+    server.registerTool("list_budgets", {
+        description: "List budgets with pagination. Filter by department, archived status, or active only",
+        inputSchema: {
+            page: z.number().int().positive().optional().describe("Page number (default: 1)"),
+            archived: z.boolean().optional().describe("Filter by archived status"),
+            only_active: z.boolean().optional().describe("Show only active budgets"),
+            department_id: z.number().int().optional().describe("Filter by department ID"),
+        },
+    }, 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.only_active)
+            params.set("only_active", "true");
+        if (args.department_id)
+            params.set("department_id", String(args.department_id));
+        const query = params.toString();
+        const path = `${apiClient.buildPath("/budgets")}${query ? `?${query}` : ""}`;
+        const result = await apiClient.get(path);
+        return jsonResponse(result);
+    }));
+    server.registerTool("get_budget", {
+        description: "Get a specific budget by ID, including remaining amount",
+        inputSchema: {
+            id: z.number().int().positive().describe("Budget ID"),
+        },
+    }, withErrorHandling(async (args) => {
+        const budget = await apiClient.get(apiClient.buildPath(`/budgets/${args.id}`));
+        return jsonResponse(budget);
+    }));
+    server.registerTool("create_budget", {
+        description: "Create a new budget",
+        inputSchema: {
+            name: z.string().describe("Budget name"),
+            amount: z.number().describe("Budget amount"),
+            currency_id: z.number().int().describe("Currency ID"),
+            creator_id: z.number().int().describe("Creator user ID"),
+            cost_code: z.string().optional().describe("Cost code"),
+            cost_type: z.string().optional().describe("Cost type"),
+            start_date: z.string().optional().describe("Start date (must match company date format)"),
+            end_date: z.string().optional().describe("End date"),
+            allow_anyone_to_approve_a_po: z.boolean().optional().describe("Allow anyone to approve"),
+            approver_ids: z.array(z.number().int()).optional().describe("Approver user IDs"),
+            department_ids: z.array(z.number().int()).optional().describe("Department IDs"),
+        },
+    }, withErrorHandling(async (args) => {
+        const budget = await apiClient.post(apiClient.buildPath("/budgets"), { budget: args });
+        return jsonResponse(budget);
+    }));
+    server.registerTool("update_budget", {
+        description: "Update an existing budget",
+        inputSchema: {
+            id: z.number().int().positive().describe("Budget ID"),
+            name: z.string().optional().describe("Budget name"),
+            amount: z.number().optional().describe("Budget amount"),
+            cost_code: z.string().optional().describe("Cost code"),
+            cost_type: z.string().optional().describe("Cost type"),
+            start_date: z.string().optional().describe("Start date"),
+            end_date: z.string().optional().describe("End date"),
+            approver_ids: z.array(z.number().int()).optional().describe("Approver user IDs"),
+            department_ids: z.array(z.number().int()).optional().describe("Department IDs"),
+        },
+    }, withErrorHandling(async (args) => {
+        const { id, ...data } = args;
+        const budget = await apiClient.put(apiClient.buildPath(`/budgets/${id}`), { budget: data });
+        return jsonResponse(budget);
+    }));
+}

package/dist/tools/comments.d.ts

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

package/dist/tools/comments.js

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import { jsonResponse, withErrorHandling } from "../tool-helpers.js";
+export function registerCommentTools(server, apiClient) {
+    server.registerTool("add_purchase_order_comment", {
+        description: "Add a comment to a purchase order",
+        inputSchema: {
+            purchase_order_id: z.number().int().positive().describe("Purchase Order ID"),
+            comment: z.string().describe("Comment text"),
+        },
+    }, withErrorHandling(async (args) => {
+        const result = await apiClient.post(apiClient.buildPath(`/purchase_order/${args.purchase_order_id}/comments`), { comment: args.comment });
+        return jsonResponse(result);
+    }));
+    server.registerTool("add_invoice_comment", {
+        description: "Add a comment to an invoice",
+        inputSchema: {
+            invoice_id: z.number().int().positive().describe("Invoice ID"),
+            comment: z.string().describe("Comment text"),
+        },
+    }, withErrorHandling(async (args) => {
+        const result = await apiClient.post(apiClient.buildPath(`/invoices/${args.invoice_id}/create_comment`), { comment: args.comment });
+        return jsonResponse(result);
+    }));
+}

package/dist/tools/companies.d.ts

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

package/dist/tools/companies.js

@@ -0,0 +1,67 @@
+import { z } from "zod";
+import { jsonResponse, textResponse, withErrorHandling } from "../tool-helpers.js";
+export function registerCompanyTools(server, apiClient) {
+    server.registerTool("list_companies", {
+        description: "List all companies the current user belongs to",
+        inputSchema: {},
+    }, withErrorHandling(async () => {
+        const companies = await apiClient.get(apiClient.buildPath("/companies"));
+        return jsonResponse(companies);
+    }));
+    server.registerTool("get_company", {
+        description: "Get company details including settings, custom fields, and supported currencies",
+        inputSchema: {
+            id: z.number().int().positive().describe("Company ID"),
+        },
+    }, withErrorHandling(async (args) => {
+        const company = await apiClient.get(apiClient.buildPath(`/companies/${args.id}`));
+        return jsonResponse(company);
+    }));
+    server.registerTool("set_active_company", {
+        description: "Set the active company ID for subsequent API calls. Required before most operations.",
+        inputSchema: {
+            company_id: z.string().describe("Company ID to use for subsequent requests"),
+        },
+    }, withErrorHandling(async (args) => {
+        apiClient.setCompanyId(args.company_id);
+        return textResponse(`Active company set to ${args.company_id}`);
+    }));
+    server.registerTool("list_approvers", {
+        description: "List approvers filtered by department (respects auto-approval settings)",
+        inputSchema: {
+            department_id: z.number().int().positive().describe("Department ID to filter approvers"),
+        },
+    }, withErrorHandling(async (args) => {
+        const approvers = await apiClient.get(`${apiClient.buildPath("/companies/approvers")}?department_id=${args.department_id}`);
+        return jsonResponse(approvers);
+    }));
+    server.registerTool("list_all_approvers", {
+        description: "List all approvers regardless of auto-approval routing",
+        inputSchema: {},
+    }, withErrorHandling(async () => {
+        const approvers = await apiClient.get(apiClient.buildPath("/companies/all_approvers"));
+        return jsonResponse(approvers);
+    }));
+    server.registerTool("list_employees", {
+        description: "List all employees of the current company with their roles",
+        inputSchema: {},
+    }, withErrorHandling(async () => {
+        const employees = await apiClient.get(apiClient.buildPath("/companies/employees"));
+        return jsonResponse(employees);
+    }));
+    server.registerTool("invite_user", {
+        description: "Invite a user to the company. Roles: companyadmin, approver, finance, teammember",
+        inputSchema: {
+            email: z.string().email().describe("Email address to invite"),
+            name: z.string().describe("Name of the user"),
+            roles: z
+                .array(z.enum(["companyadmin", "approver", "finance", "teammember"]))
+                .describe("Roles to assign"),
+        },
+    }, withErrorHandling(async (args) => {
+        const result = await apiClient.post(apiClient.buildPath("/companies/send_user_invite"), {
+            invite_user: args,
+        });
+        return jsonResponse(result);
+    }));
+}

package/dist/tools/departments.d.ts

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

package/dist/tools/departments.js

@@ -0,0 +1,69 @@
+import { z } from "zod";
+import { jsonResponse, withErrorHandling } from "../tool-helpers.js";
+export function registerDepartmentTools(server, apiClient) {
+    server.registerTool("list_departments", {
+        description: "List departments with optional filters for archived status and company-specific",
+        inputSchema: {
+            archived: z.boolean().optional().describe("Filter by archived status"),
+            company_specific: z.boolean().optional().describe("Show only company-specific departments"),
+        },
+    }, withErrorHandling(async (args) => {
+        const params = new URLSearchParams();
+        if (args.archived !== undefined)
+            params.set("archived", String(args.archived));
+        if (args.company_specific !== undefined)
+            params.set("company_specific", String(args.company_specific));
+        const query = params.toString();
+        const path = `${apiClient.buildPath("/departments")}${query ? `?${query}` : ""}`;
+        const departments = await apiClient.get(path);
+        return jsonResponse(departments);
+    }));
+    server.registerTool("get_department", {
+        description: "Get a specific department by ID",
+        inputSchema: {
+            id: z.number().int().positive().describe("Department ID"),
+        },
+    }, withErrorHandling(async (args) => {
+        const department = await apiClient.get(apiClient.buildPath(`/departments/${args.id}`));
+        return jsonResponse(department);
+    }));
+    server.registerTool("create_department", {
+        description: "Create a new department",
+        inputSchema: {
+            name: z.string().describe("Department name"),
+            contact_person: z.string().optional().describe("Contact person"),
+            phone_number: z.string().optional().describe("Phone number"),
+            email: z.string().email().optional().describe("Email"),
+            address: z.string().optional().describe("Address"),
+            tax_number: z.string().optional().describe("Tax number"),
+            budget_ids: z.array(z.number().int()).optional().describe("Budget IDs to associate"),
+            user_ids: z.array(z.number().int()).optional().describe("User IDs to associate"),
+        },
+    }, withErrorHandling(async (args) => {
+        const department = await apiClient.post(apiClient.buildPath("/departments"), {
+            department: args,
+        });
+        return jsonResponse(department);
+    }));
+    server.registerTool("update_department", {
+        description: "Update an existing department",
+        inputSchema: {
+            id: z.number().int().positive().describe("Department ID"),
+            name: z.string().optional().describe("Department name"),
+            archived: z.boolean().optional().describe("Archive status"),
+            contact_person: z.string().optional().describe("Contact person"),
+            phone_number: z.string().optional().describe("Phone number"),
+            email: z.string().email().optional().describe("Email"),
+            address: z.string().optional().describe("Address"),
+            tax_number: z.string().optional().describe("Tax number"),
+            budget_ids: z.array(z.number().int()).optional().describe("Budget IDs"),
+            user_ids: z.array(z.number().int()).optional().describe("User IDs"),
+        },
+    }, withErrorHandling(async (args) => {
+        const { id, ...data } = args;
+        const department = await apiClient.put(apiClient.buildPath(`/departments/${id}`), {
+            department: data,
+        });
+        return jsonResponse(department);
+    }));
+}

package/dist/tools/invoices.d.ts

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