@hisaabo/mcp 0.1.0

package/src/tools/dashboard.ts

@@ -0,0 +1,110 @@
+/**
+ * Dashboard tools — business-level summaries and analytics.
+ *
+ * Tools registered:
+ *   dashboard_summary — P&L summary, receivables, payables, cash position
+ */
+
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { HisaaboClient } from "../client.js";
+import { wrapTool } from "../lib/errors.js";
+
+/** Resolve a named period to ISO 8601 date strings for the API. */
+function resolvePeriod(period: string | undefined): { fromDate?: string; toDate?: string } {
+  const now = new Date();
+
+  if (!period || period === "this-fy") {
+    // Financial year logic: April-start default. API computes FY dates server-side when no date range given.
+    return {};
+  }
+
+  if (period === "this-month") {
+    const from = new Date(now.getFullYear(), now.getMonth(), 1);
+    const to = new Date(now.getFullYear(), now.getMonth() + 1, 0, 23, 59, 59, 999);
+    return { fromDate: from.toISOString(), toDate: to.toISOString() };
+  }
+
+  if (period === "last-month") {
+    const from = new Date(now.getFullYear(), now.getMonth() - 1, 1);
+    const to = new Date(now.getFullYear(), now.getMonth(), 0, 23, 59, 59, 999);
+    return { fromDate: from.toISOString(), toDate: to.toISOString() };
+  }
+
+  if (period === "this-quarter") {
+    const quarter = Math.floor(now.getMonth() / 3);
+    const from = new Date(now.getFullYear(), quarter * 3, 1);
+    const to = new Date(now.getFullYear(), (quarter + 1) * 3, 0, 23, 59, 59, 999);
+    return { fromDate: from.toISOString(), toDate: to.toISOString() };
+  }
+
+  if (period === "this-year") {
+    const from = new Date(now.getFullYear(), 0, 1);
+    const to = new Date(now.getFullYear(), 11, 31, 23, 59, 59, 999);
+    return { fromDate: from.toISOString(), toDate: to.toISOString() };
+  }
+
+  // "all" — no date filter
+  return {};
+}
+
+export function registerDashboardTools(server: McpServer, client: HisaaboClient) {
+
+  server.tool(
+    "dashboard_summary",
+    [
+      "Get a financial summary for the active business: total sales, purchases, expenses, receivables, payables, and cash position.",
+      "'receivable' = total amount customers owe you (outstanding invoices).",
+      "'payable' = total amount you owe suppliers.",
+      "'cashInHand' = cash balance across all cash/bank accounts.",
+      "Use period to select the time window. Defaults to the current financial year (April–March for Indian businesses).",
+      "Use this to answer questions like 'How much revenue did we make this month?' or 'What are our total outstanding receivables?'",
+    ].join(" "),
+    {
+      period: z.enum(["this-fy", "this-month", "last-month", "this-quarter", "this-year", "custom"]).optional()
+        .describe(
+          "'this-fy' = current financial year (default). " +
+          "'this-month' = current calendar month. " +
+          "'last-month' = previous calendar month. " +
+          "'this-quarter' = current calendar quarter. " +
+          "'this-year' = current calendar year. " +
+          "'custom' = use from_date and to_date."
+        ),
+      from_date: z.string().datetime().optional()
+        .describe("Custom start date (ISO 8601). Only used when period='custom'."),
+      to_date: z.string().datetime().optional()
+        .describe("Custom end date (ISO 8601). Only used when period='custom'."),
+    },
+    wrapTool(async (input) => {
+      let dateRange: { fromDate?: string; toDate?: string };
+
+      if (input.period === "custom") {
+        dateRange = {
+          fromDate: input.from_date,
+          toDate: input.to_date,
+        };
+      } else {
+        dateRange = resolvePeriod(input.period);
+      }
+
+      const summary = await client.dashboard.summary(
+        Object.keys(dateRange).length > 0 ? dateRange : undefined
+      );
+
+      return {
+        content: [{
+          type: "text" as const,
+          text: JSON.stringify(
+            {
+              ...summary,
+              _period: input.period ?? "this-fy",
+              _note: "All monetary values are decimal strings in the business's currency (default: INR).",
+            },
+            null,
+            2
+          ),
+        }],
+      };
+    })
+  );
+}

package/src/tools/expense.ts

@@ -0,0 +1,175 @@
+/**
+ * Expense tools — track business expenses.
+ *
+ * Tools registered:
+ *   expense_create     — record a business expense
+ *   expense_list       — list expenses with filtering
+ *   expense_update     — update an existing expense record
+ *   expense_delete     — soft-delete an expense
+ *   expense_categories — list all distinct expense categories
+ */
+
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { HisaaboClient } from "../client.js";
+import { wrapTool } from "../lib/errors.js";
+import { MAX_PAGE_SIZE, withPaginationMeta } from "../lib/pagination.js";
+
+const PAYMENT_MODES = ["cash", "bank", "upi", "cheque", "other"] as const;
+
+export function registerExpenseTools(server: McpServer, client: HisaaboClient) {
+
+  server.tool(
+    "expense_create",
+    [
+      "Record a business expense (operating cost, overhead, etc.).",
+      "Category is a free-form label — use consistent names like 'Rent', 'Utilities', 'Salaries', 'Travel'.",
+      "Expenses appear in the dashboard summary's 'totalExpenses' and affect the P&L.",
+    ].join(" "),
+    {
+      category: z.string().min(1).max(100)
+        .describe("Expense category, e.g. 'Rent', 'Electricity', 'Office Supplies', 'Travel'."),
+      amount: z.string().regex(/^\d+(\.\d{1,2})?$/)
+        .describe("Expense amount as decimal string, e.g. '12000.00'."),
+      mode: z.enum(PAYMENT_MODES)
+        .describe("Payment method used: 'cash', 'bank', 'upi', 'cheque', or 'other'."),
+      description: z.string().max(500).optional()
+        .describe("Additional details, e.g. 'Office rent for March 2024'."),
+      expense_date: z.string().datetime().optional()
+        .describe("Date of the expense (ISO 8601). Defaults to today."),
+      reference_number: z.string().max(100).optional()
+        .describe("Bill number, receipt number, or transaction ID."),
+    },
+    wrapTool(async (input) => {
+      const expense = await client.expense.create({
+        category: input.category,
+        amount: input.amount,
+        mode: input.mode,
+        description: input.description,
+        expenseDate: input.expense_date,
+        referenceNumber: input.reference_number,
+      });
+      return {
+        content: [{
+          type: "text" as const,
+          text: JSON.stringify(expense, null, 2),
+        }],
+      };
+    })
+  );
+
+  server.tool(
+    "expense_update",
+    [
+      "Update an existing expense record.",
+      "Only provide fields you want to change — all other fields remain unchanged.",
+    ].join(" "),
+    {
+      expense_id: z.string().uuid()
+        .describe("Expense UUID to update."),
+      category: z.string().min(1).max(100).optional()
+        .describe("Updated expense category."),
+      amount: z.string().regex(/^\d+(\.\d{1,2})?$/).optional()
+        .describe("Updated expense amount as decimal string."),
+      mode: z.enum(PAYMENT_MODES).optional()
+        .describe("Updated payment method."),
+      description: z.string().max(500).optional()
+        .describe("Updated description."),
+      expense_date: z.string().datetime().optional()
+        .describe("Updated expense date (ISO 8601)."),
+      reference_number: z.string().max(100).optional()
+        .describe("Updated bill number or receipt number."),
+    },
+    wrapTool(async (input) => {
+      const expense = await client.expense.update(input.expense_id, {
+        category: input.category,
+        amount: input.amount,
+        mode: input.mode,
+        description: input.description,
+        expenseDate: input.expense_date,
+        referenceNumber: input.reference_number,
+      });
+      return {
+        content: [{
+          type: "text" as const,
+          text: JSON.stringify(expense, null, 2),
+        }],
+      };
+    })
+  );
+
+  server.tool(
+    "expense_delete",
+    [
+      "Soft-delete an expense record. Requires admin role.",
+      "The expense is hidden from all lists and reports after deletion.",
+    ].join(" "),
+    {
+      expense_id: z.string().uuid()
+        .describe("Expense UUID to delete."),
+    },
+    wrapTool(async (input) => {
+      const result = await client.expense.delete(input.expense_id);
+      return {
+        content: [{
+          type: "text" as const,
+          text: JSON.stringify(result, null, 2),
+        }],
+      };
+    })
+  );
+
+  server.tool(
+    "expense_categories",
+    [
+      "Get a list of all distinct expense categories used in the business.",
+      "Use this to discover existing category names before filtering expense_list or creating new expenses with consistent categories.",
+    ].join(" "),
+    {},
+    wrapTool(async (_input) => {
+      const categories = await client.expense.categories();
+      return {
+        content: [{
+          type: "text" as const,
+          text: JSON.stringify(categories, null, 2),
+        }],
+      };
+    })
+  );
+
+  server.tool(
+    "expense_list",
+    [
+      "List business expenses, optionally filtered by category or date range.",
+      "Use this to answer 'How much did we spend on rent this year?' or 'Show me all expenses in March'.",
+    ].join(" "),
+    {
+      category: z.string().max(100).optional()
+        .describe("Filter by expense category (exact match)."),
+      from_date: z.string().datetime().optional()
+        .describe("Start date (ISO 8601)."),
+      to_date: z.string().datetime().optional()
+        .describe("End date (ISO 8601)."),
+      search: z.string().max(200).optional()
+        .describe("Search by description or reference number."),
+      page: z.number().int().min(1).default(1)
+        .describe("Page number for pagination."),
+    },
+    wrapTool(async (input) => {
+      const result = await client.expense.list({
+        category: input.category,
+        fromDate: input.from_date,
+        toDate: input.to_date,
+        search: input.search,
+        page: input.page,
+        limit: MAX_PAGE_SIZE,
+      });
+      return {
+        content: [{
+          type: "text" as const,
+          text: JSON.stringify(withPaginationMeta(result), null, 2),
+        }],
+      };
+    })
+  );
+}

package/src/tools/gst.ts

@@ -0,0 +1,90 @@
+/**
+ * GST reporting tools.
+ *
+ * Tools registered:
+ *   gst_report     — generate GSTR1 or GSTR3B summary data for a given month/year
+ *   gst_report_csv — get GSTR-1 data in CSV format ready for portal upload
+ *
+ * Note: PDF generation is intentionally excluded. AI agents cannot consume
+ * binary content in tool responses. The JSON report is designed to let agents
+ * summarize GST liability, answer questions, and guide filing.
+ */
+
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { HisaaboClient } from "../client.js";
+import { wrapTool } from "../lib/errors.js";
+
+const CURRENT_YEAR = new Date().getFullYear();
+
+export function registerGstTools(server: McpServer, client: HisaaboClient) {
+
+  server.tool(
+    "gst_report_csv",
+    [
+      "Get GSTR-1 data as a CSV string ready for upload to the GST portal.",
+      "Returns the CSV content and a suggested filename (e.g. 'GSTR1_March_2024.csv').",
+      "Save the CSV content to a file and upload it at https://www.gst.gov.in/.",
+      "Month is 1–12 (1 = January, 3 = March, etc.).",
+    ].join(" "),
+    {
+      month: z.number().int().min(1).max(12)
+        .describe("Month number (1 = January, 12 = December)."),
+      year: z.number().int().min(2020).max(CURRENT_YEAR + 1)
+        .describe(`Year, e.g. ${CURRENT_YEAR}.`),
+    },
+    wrapTool(async (input) => {
+      const result = await client.gst.gstr1CSV({ month: input.month, year: input.year });
+      return {
+        content: [{
+          type: "text" as const,
+          text: JSON.stringify(result, null, 2),
+        }],
+      };
+    })
+  );
+
+  server.tool(
+    "gst_report",
+    [
+      "Generate a GST report (GSTR1 or GSTR3B) for a specific month and year.",
+      "GSTR1 = outward supplies summary (sales). GSTR3B = monthly return summary (sales + purchases + ITC).",
+      "Returns JSON data — use this to answer 'What is our GST liability for March 2024?' or 'How much ITC can we claim this month?'",
+      "Month is 1–12 (1 = January, 3 = March, etc.).",
+      "Example: { report_type: 'gstr3b', month: 3, year: 2024 } for March 2024 GSTR3B.",
+    ].join(" "),
+    {
+      report_type: z.enum(["gstr1", "gstr3b"])
+        .describe("'gstr1' for outward supplies (sales) report. 'gstr3b' for monthly summary return."),
+      month: z.number().int().min(1).max(12)
+        .describe("Month number (1 = January, 12 = December)."),
+      year: z.number().int().min(2020).max(CURRENT_YEAR + 1)
+        .describe(`Year, e.g. ${CURRENT_YEAR}.`),
+    },
+    wrapTool(async (input) => {
+      const report = input.report_type === "gstr1"
+        ? await client.gst.gstr1({ month: input.month, year: input.year })
+        : await client.gst.gstr3b({ month: input.month, year: input.year });
+
+      const monthName = new Date(input.year, input.month - 1, 1)
+        .toLocaleString("en-IN", { month: "long" });
+
+      return {
+        content: [{
+          type: "text" as const,
+          text: JSON.stringify(
+            {
+              ...report,
+              _meta: {
+                reportType: input.report_type.toUpperCase(),
+                period: `${monthName} ${input.year}`,
+              },
+            },
+            null,
+            2
+          ),
+        }],
+      };
+    })
+  );
+}

package/src/tools/import.ts

@@ -0,0 +1,298 @@
+/**
+ * Data import tools — batch import parties, items, invoices, and payments.
+ *
+ * Tools registered:
+ *   import_parties  — batch import customers and suppliers
+ *   import_items    — batch import inventory items
+ *   import_invoices — batch import historical invoices with line items
+ *   import_payments — batch import payment records
+ *
+ * All import operations require admin role. Duplicate records (matched by
+ * name or invoice number) are skipped, never overwritten.
+ */
+
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { HisaaboClient } from "../client.js";
+import { wrapTool } from "../lib/errors.js";
+
+export function registerImportTools(server: McpServer, client: HisaaboClient) {
+
+  server.tool(
+    "import_parties",
+    [
+      "Batch import customers and/or suppliers. Requires admin role.",
+      "Duplicates (same name, case-insensitive) are automatically skipped — never overwritten.",
+      "Returns a summary: created (new records), skipped (duplicates), total (input count).",
+      "Use source to tag where the data came from, e.g. 'mybillbook', 'tally', 'excel'.",
+    ].join(" "),
+    {
+      source: z.string().default("excel")
+        .describe("Source system name, e.g. 'mybillbook', 'tally', 'excel'. Used for audit trail."),
+      parties: z.array(z.object({
+        name: z.string().min(1).max(200)
+          .describe("Party name. Duplicate names (case-insensitive) are skipped."),
+        type: z.enum(["customer", "supplier"]).default("customer")
+          .describe("'customer' for buyers, 'supplier' for sellers."),
+        phone: z.string().max(15).optional()
+          .describe("Phone number."),
+        email: z.string().optional()
+          .describe("Email address."),
+        gstin: z.string().optional()
+          .describe("GST Identification Number (15 chars)."),
+        pan: z.string().optional()
+          .describe("PAN number."),
+        opening_balance: z.string().optional()
+          .describe("Opening balance as decimal string. Positive = they owe you. Default '0'."),
+        billing_address: z.string().optional()
+          .describe("Billing address."),
+        shipping_address: z.string().optional()
+          .describe("Shipping address (if different from billing)."),
+        city: z.string().optional()
+          .describe("City."),
+        state: z.string().optional()
+          .describe("State name."),
+        pincode: z.string().optional()
+          .describe("PIN code."),
+      })).min(1).max(5000)
+        .describe("Array of party records to import. Max 5000 per call."),
+    },
+    wrapTool(async (input) => {
+      const result = await client.import.importParties({
+        source: input.source,
+        parties: input.parties.map((p) => ({
+          name: p.name,
+          type: p.type,
+          phone: p.phone,
+          email: p.email,
+          gstin: p.gstin,
+          pan: p.pan,
+          openingBalance: p.opening_balance,
+          billingAddress: p.billing_address,
+          shippingAddress: p.shipping_address,
+          city: p.city,
+          state: p.state,
+          pincode: p.pincode,
+        })),
+      });
+      return {
+        content: [{
+          type: "text" as const,
+          text: JSON.stringify(result, null, 2),
+        }],
+      };
+    })
+  );
+
+  server.tool(
+    "import_items",
+    [
+      "Batch import inventory items or services. Requires admin role.",
+      "Duplicates (same name, case-insensitive) are automatically skipped.",
+      "Returns: created, skipped, total, and unmappedUnits (unit codes that were not recognized and defaulted to 'other').",
+      "Common unit codes are auto-mapped: KGS→kg, PCS→pcs, LTR→l, BOX→box, etc.",
+      "Stock quantity is always set to 0 on import — use import_invoices or item_adjust_stock to build stock from history.",
+    ].join(" "),
+    {
+      source: z.string().default("excel")
+        .describe("Source system name for audit trail."),
+      items: z.array(z.object({
+        name: z.string().min(1).max(200)
+          .describe("Item name. Duplicates (case-insensitive) are skipped."),
+        item_type: z.enum(["product", "service"]).default("product")
+          .describe("'product' for physical goods, 'service' for services."),
+        sale_price: z.string().optional()
+          .describe("Default selling price as decimal string."),
+        purchase_price: z.string().optional()
+          .describe("Default purchase price as decimal string."),
+        tax_percent: z.string().default("0")
+          .describe("GST rate percentage, e.g. '18'. Default '0'."),
+        hsn: z.string().optional()
+          .describe("HSN code for GST compliance."),
+        unit: z.string().default("pcs")
+          .describe("Unit code. Common values: pcs, kg, l, box, m. Auto-mapped from MyBillBook/Tally format."),
+        sku: z.string().optional()
+          .describe("SKU / product code."),
+        category: z.string().optional()
+          .describe("Category name for grouping."),
+      })).min(1).max(5000)
+        .describe("Array of item records to import. Max 5000 per call."),
+    },
+    wrapTool(async (input) => {
+      const result = await client.import.importItems({
+        source: input.source,
+        items: input.items.map((item) => ({
+          name: item.name,
+          itemType: item.item_type,
+          salePrice: item.sale_price,
+          purchasePrice: item.purchase_price,
+          taxPercent: item.tax_percent,
+          hsn: item.hsn,
+          unit: item.unit,
+          sku: item.sku,
+          category: item.category,
+        })),
+      });
+      return {
+        content: [{
+          type: "text" as const,
+          text: JSON.stringify(result, null, 2),
+        }],
+      };
+    })
+  );
+
+  server.tool(
+    "import_invoices",
+    [
+      "Batch import historical invoices with optional line items. Requires admin role.",
+      "Parties referenced by party_name must already exist (import them first with import_parties).",
+      "Invoices with duplicate invoice_number are skipped.",
+      "Set auto_create_payments=true to automatically create payment records for paid invoices.",
+      "Use this for migrating historical data from MyBillBook, Tally, Busy, or Excel.",
+    ].join(" "),
+    {
+      source: z.string().default("excel")
+        .describe("Source system name for audit trail."),
+      auto_create_payments: z.boolean().default(false)
+        .describe("If true, automatically create payment records for invoices with amountPaid > 0."),
+      default_payment_mode: z.enum(["cash", "bank", "upi", "cheque", "other"]).default("cash")
+        .describe("Payment mode to use when auto-creating payments from paid invoices."),
+      invoices: z.array(z.object({
+        invoice_number: z.string().min(1)
+          .describe("Invoice number. Duplicates are skipped."),
+        invoice_date: z.string()
+          .describe("Invoice date (YYYY-MM-DD or DD/MM/YYYY or DD-MM-YYYY)."),
+        due_date: z.string().optional()
+          .describe("Due date (same formats as invoice_date)."),
+        party_name: z.string().min(1)
+          .describe("Exact party name — must match an existing party (case-insensitive)."),
+        type: z.enum(["sale", "purchase"]).default("sale")
+          .describe("'sale' for customer invoice, 'purchase' for supplier bill."),
+        status: z.enum(["draft", "sent", "paid", "partial", "overdue", "cancelled"]).default("sent")
+          .describe("Invoice status. Use 'paid' for fully paid historical invoices."),
+        total_amount: z.string()
+          .describe("Total invoice amount including tax, as decimal string."),
+        amount_paid: z.string().default("0")
+          .describe("Amount already paid. '0' for unpaid, same as total_amount for fully paid."),
+        subtotal: z.string().default("0")
+          .describe("Pre-tax subtotal as decimal string."),
+        tax_amount: z.string().default("0")
+          .describe("Total tax amount as decimal string."),
+        discount_amount: z.string().default("0")
+          .describe("Total discount amount as decimal string."),
+        notes: z.string().optional()
+          .describe("Invoice notes."),
+        line_items: z.array(z.object({
+          description: z.string()
+            .describe("Line item description or product name."),
+          quantity: z.string().default("1")
+            .describe("Quantity as decimal string."),
+          unit_price: z.string()
+            .describe("Price per unit as decimal string."),
+          tax_percent: z.string().default("0")
+            .describe("Tax rate percentage, e.g. '18'."),
+          discount_percent: z.string().default("0")
+            .describe("Discount percentage."),
+          item_name: z.string().optional()
+            .describe("If provided, links to an existing inventory item by name."),
+        })).optional()
+          .describe("Line items. Optional — if omitted, a single line item using total_amount is created."),
+      })).min(1).max(1000)
+        .describe("Array of invoice records. Max 1000 per call."),
+    },
+    wrapTool(async (input) => {
+      const result = await client.import.importInvoices({
+        source: input.source,
+        autoCreatePayments: input.auto_create_payments,
+        defaultPaymentMode: input.default_payment_mode,
+        invoices: input.invoices.map((inv) => ({
+          invoiceNumber: inv.invoice_number,
+          invoiceDate: inv.invoice_date,
+          dueDate: inv.due_date,
+          partyName: inv.party_name,
+          type: inv.type,
+          status: inv.status,
+          totalAmount: inv.total_amount,
+          amountPaid: inv.amount_paid,
+          subtotal: inv.subtotal,
+          taxAmount: inv.tax_amount,
+          discountAmount: inv.discount_amount,
+          notes: inv.notes,
+          lineItems: inv.line_items?.map((li) => ({
+            description: li.description,
+            quantity: li.quantity,
+            unitPrice: li.unit_price,
+            taxPercent: li.tax_percent,
+            discountPercent: li.discount_percent,
+            itemName: li.item_name,
+          })) ?? [],
+        })),
+      });
+      return {
+        content: [{
+          type: "text" as const,
+          text: JSON.stringify(result, null, 2),
+        }],
+      };
+    })
+  );
+
+  server.tool(
+    "import_payments",
+    [
+      "Batch import historical payment records. Requires admin role.",
+      "Parties referenced by party_name must already exist.",
+      "Invoices referenced by invoice_numbers must already exist (import invoices first).",
+      "Use this to import payment history after invoices are already imported.",
+      "Returns: created, skipped, total, and any errors encountered.",
+    ].join(" "),
+    {
+      source: z.string().default("excel")
+        .describe("Source system name for audit trail."),
+      paid_invoice_numbers: z.array(z.string()).default([])
+        .describe("List of invoice numbers that were fully paid in the source system. Used for auto-allocation fallback."),
+      payments: z.array(z.object({
+        party_name: z.string().min(1)
+          .describe("Party name — must match an existing party (case-insensitive)."),
+        amount: z.string()
+          .describe("Payment amount as decimal string."),
+        mode: z.enum(["cash", "bank", "upi", "cheque", "other"]).default("cash")
+          .describe("Payment mode."),
+        payment_date: z.string().optional()
+          .describe("Payment date (YYYY-MM-DD or DD/MM/YYYY)."),
+        payment_number: z.string().optional()
+          .describe("Original payment number from source system."),
+        reference_number: z.string().optional()
+          .describe("Transaction reference, cheque number, UTR, etc."),
+        notes: z.string().optional()
+          .describe("Notes about this payment."),
+        invoice_numbers: z.array(z.string()).optional()
+          .describe("Explicit invoice numbers to allocate this payment against."),
+      })).min(1).max(5000)
+        .describe("Array of payment records. Max 5000 per call."),
+    },
+    wrapTool(async (input) => {
+      const result = await client.import.importPayments({
+        source: input.source,
+        paidInvoiceNumbers: input.paid_invoice_numbers,
+        payments: input.payments.map((p) => ({
+          partyName: p.party_name,
+          amount: p.amount,
+          mode: p.mode,
+          paymentDate: p.payment_date,
+          paymentNumber: p.payment_number,
+          referenceNumber: p.reference_number,
+          notes: p.notes,
+          invoiceNumbers: p.invoice_numbers,
+        })),
+      });
+      return {
+        content: [{
+          type: "text" as const,
+          text: JSON.stringify(result, null, 2),
+        }],
+      };
+    })
+  );
+}