@hisaabo/mcp 0.1.0

package/dist/index.js

@@ -0,0 +1,2681 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/client.ts
+import superjson from "superjson";
+var HisaaboApiError = class extends Error {
+  constructor(hisaaboError) {
+    super(formatHisaaboError(hisaaboError));
+    this.hisaaboError = hisaaboError;
+    this.name = "HisaaboApiError";
+  }
+};
+function formatHisaaboError(err) {
+  switch (err.code) {
+    case "unauthorized":
+      return `Authentication required: ${err.message}. Check that HISAABO_TOKEN is set and not expired.`;
+    case "forbidden":
+      return `Permission denied: ${err.message}`;
+    case "not_found":
+      return `Not found: ${err.resource}`;
+    case "validation_failed":
+      return `Validation failed:
+` + Object.entries(err.fields).map(([field, msgs]) => `  ${field}: ${msgs.join(", ")}`).join("\n");
+    case "api_error":
+      return `API error: ${err.message}`;
+  }
+}
+function normalizeTrpcError(raw) {
+  if (!raw || typeof raw !== "object") {
+    return { code: "api_error", message: "Unknown error from API" };
+  }
+  const err = raw;
+  const code = err["code"];
+  const message = err["message"] ?? "Unknown error";
+  if (code === "UNAUTHORIZED") return { code: "unauthorized", message };
+  if (code === "FORBIDDEN") return { code: "forbidden", message };
+  if (code === "NOT_FOUND") return { code: "not_found", resource: message };
+  if (code === "BAD_REQUEST") {
+    const data = err["data"];
+    const zodError = data?.["zodError"];
+    if (zodError?.fieldErrors) {
+      return { code: "validation_failed", fields: zodError.fieldErrors };
+    }
+    return { code: "validation_failed", fields: { _: [message] } };
+  }
+  return { code: "api_error", message };
+}
+var HisaaboClient = class {
+  constructor(config2) {
+    this.config = config2;
+    this.apiUrl = config2.apiUrl;
+  }
+  /** Base API URL, exposed for tools that need to construct URLs (e.g. PDF download). */
+  apiUrl;
+  buildHeaders() {
+    return {
+      "Authorization": `Bearer ${this.config.token}`,
+      "x-business-id": this.config.businessId,
+      "x-tenant-id": this.config.tenantId,
+      "x-client-type": "mcp"
+    };
+  }
+  async unwrap(res) {
+    const body = await res.json();
+    if (typeof body !== "object" || body === null) {
+      throw new HisaaboApiError({ code: "api_error", message: "Unexpected response format from API" });
+    }
+    const envelope = body;
+    if (!res.ok || "error" in envelope) {
+      throw new HisaaboApiError(normalizeTrpcError(envelope["error"] ?? { code: "api_error", message: `HTTP ${res.status}` }));
+    }
+    const result = envelope["result"];
+    if (!result) {
+      throw new HisaaboApiError({ code: "api_error", message: "Missing result in API response" });
+    }
+    const data = result["data"];
+    return superjson.deserialize(data);
+  }
+  /**
+   * Call a tRPC query procedure.
+   * Queries use GET with SuperJSON-serialized input as a URL param.
+   */
+  async query(path, input) {
+    const url = new URL(`${this.config.apiUrl}/api/trpc/${path}`);
+    if (input !== void 0) {
+      url.searchParams.set("input", JSON.stringify(superjson.serialize(input)));
+    }
+    const res = await fetch(url.toString(), { headers: this.buildHeaders() });
+    return this.unwrap(res);
+  }
+  /**
+   * Call a tRPC mutation procedure.
+   * Mutations use POST with SuperJSON-serialized body.
+   */
+  async mutate(path, input) {
+    const res = await fetch(`${this.config.apiUrl}/api/trpc/${path}`, {
+      method: "POST",
+      headers: { ...this.buildHeaders(), "Content-Type": "application/json" },
+      body: JSON.stringify(superjson.serialize(input))
+    });
+    return this.unwrap(res);
+  }
+  // ── Namespaced procedure accessors ──────────────────────────────────────
+  get invoice() {
+    const c = this;
+    return {
+      list(input) {
+        return c.query("invoice.list", input);
+      },
+      create(input) {
+        return c.mutate("invoice.create", input);
+      },
+      get(id) {
+        return c.query("invoice.get", { id });
+      },
+      updateStatus(id, status) {
+        return c.mutate("invoice.updateStatus", { id, status });
+      },
+      delete(id) {
+        return c.mutate("invoice.delete", { id });
+      }
+    };
+  }
+  get party() {
+    const c = this;
+    return {
+      list(input) {
+        return c.query("party.list", input);
+      },
+      create(input) {
+        return c.mutate("party.create", input);
+      },
+      get(id) {
+        return c.query("party.get", { id });
+      },
+      ledger(partyId, input) {
+        return c.query("party.ledger", { partyId, ...input });
+      },
+      update(id, data) {
+        return c.mutate("party.update", { id, data });
+      },
+      delete(id) {
+        return c.mutate("party.delete", { id });
+      }
+    };
+  }
+  get item() {
+    const c = this;
+    return {
+      list(input) {
+        return c.query("item.list", input);
+      },
+      create(input) {
+        return c.mutate("item.create", input);
+      },
+      get(id) {
+        return c.query("item.get", { id });
+      },
+      adjustStock(input) {
+        return c.mutate("item.adjustStock", input);
+      },
+      update(id, data) {
+        return c.mutate("item.update", { id, data });
+      },
+      delete(id) {
+        return c.mutate("item.delete", { id });
+      },
+      categories() {
+        return c.query("item.categories");
+      }
+    };
+  }
+  get payment() {
+    const c = this;
+    return {
+      list(input) {
+        return c.query("payment.list", input);
+      },
+      create(input) {
+        return c.mutate("payment.create", input);
+      },
+      getById(id) {
+        return c.query("payment.getById", { id });
+      },
+      update(input) {
+        return c.mutate("payment.update", input);
+      },
+      delete(id) {
+        return c.mutate("payment.delete", { id });
+      }
+    };
+  }
+  get expense() {
+    const c = this;
+    return {
+      list(input) {
+        return c.query("expense.list", input);
+      },
+      create(input) {
+        return c.mutate("expense.create", input);
+      },
+      update(id, data) {
+        return c.mutate("expense.update", { id, data });
+      },
+      delete(id) {
+        return c.mutate("expense.delete", { id });
+      },
+      categories() {
+        return c.query("expense.categories");
+      }
+    };
+  }
+  get dashboard() {
+    const c = this;
+    return {
+      summary(input) {
+        return c.query("dashboard.summary", input);
+      }
+    };
+  }
+  get business() {
+    const c = this;
+    return {
+      get() {
+        return c.query("business.get");
+      },
+      list() {
+        return c.query("business.list");
+      }
+    };
+  }
+  get gst() {
+    const c = this;
+    return {
+      gstr1(input) {
+        return c.query("gst.gstr1", input);
+      },
+      gstr3b(input) {
+        return c.query("gst.gstr3b", input);
+      },
+      gstr1CSV(input) {
+        return c.query("gst.gstr1CSV", input);
+      }
+    };
+  }
+  get shipment() {
+    const c = this;
+    return {
+      list(input) {
+        return c.query("shipment.list", input);
+      },
+      get(id) {
+        return c.query("shipment.getById", { id });
+      },
+      create(input) {
+        return c.mutate("shipment.create", input);
+      },
+      update(input) {
+        return c.mutate("shipment.update", input);
+      },
+      delete(id) {
+        return c.mutate("shipment.delete", { id });
+      }
+    };
+  }
+  get bankAccount() {
+    const c = this;
+    return {
+      list() {
+        return c.query("bankAccount.list");
+      },
+      get(id) {
+        return c.query("bankAccount.getById", { id });
+      },
+      create(input) {
+        return c.mutate("bankAccount.create", input);
+      },
+      update(id, data) {
+        return c.mutate("bankAccount.update", { id, data });
+      },
+      delete(id) {
+        return c.mutate("bankAccount.delete", { id });
+      },
+      transfer(input) {
+        return c.mutate("bankAccount.transfer", input);
+      },
+      listTransactions(input) {
+        return c.query("bankAccount.listTransactions", input);
+      },
+      summary() {
+        return c.query("bankAccount.summary");
+      }
+    };
+  }
+  get reports() {
+    const c = this;
+    return {
+      daybook(input) {
+        return c.query("reports.daybook", input);
+      },
+      outstanding(input) {
+        return c.query("reports.outstanding", input);
+      },
+      taxSummary(input) {
+        return c.query("reports.taxSummary", input);
+      },
+      itemSales(input) {
+        return c.query("reports.itemSales", input);
+      },
+      stockSummary(input) {
+        return c.query("reports.stockSummary", input);
+      },
+      partyStatement(input) {
+        return c.query("reports.partyStatement", input);
+      },
+      paymentSummary(input) {
+        return c.query("reports.paymentSummary", input);
+      }
+    };
+  }
+  get store() {
+    const c = this;
+    return {
+      getSettings() {
+        return c.query("store.getSettings");
+      },
+      updateSettings(input) {
+        return c.mutate("store.updateSettings", input);
+      },
+      listOrders(input) {
+        return c.query("store.listOrders", input);
+      },
+      getOrder(id) {
+        return c.query("store.getOrder", { id });
+      },
+      updateOrderStatus(input) {
+        return c.mutate("store.updateOrderStatus", input);
+      }
+    };
+  }
+  get target() {
+    const c = this;
+    return {
+      list(input) {
+        return c.query("target.list", input);
+      },
+      create(input) {
+        return c.mutate("target.create", input);
+      },
+      getProgress(id) {
+        return c.query("target.getProgress", { id });
+      },
+      update(input) {
+        return c.mutate("target.update", input);
+      },
+      delete(id) {
+        return c.mutate("target.delete", { id });
+      },
+      myTargets() {
+        return c.query("target.myTargets");
+      }
+    };
+  }
+  get import() {
+    const c = this;
+    return {
+      importParties(input) {
+        return c.mutate("import.importParties", input);
+      },
+      importItems(input) {
+        return c.mutate("import.importItems", input);
+      },
+      importInvoices(input) {
+        return c.mutate("import.importInvoices", input);
+      },
+      importPayments(input) {
+        return c.mutate("import.importPayments", input);
+      }
+    };
+  }
+};
+
+// src/tools/invoice.ts
+import { z } from "zod";
+
+// src/lib/errors.ts
+function wrapTool(handler) {
+  return async (input) => {
+    try {
+      return await handler(input);
+    } catch (err) {
+      const hisaaboErr = toHisaaboError(err);
+      return {
+        isError: true,
+        content: [
+          {
+            type: "text",
+            text: formatHisaaboError(hisaaboErr)
+          }
+        ]
+      };
+    }
+  };
+}
+function toHisaaboError(err) {
+  if (err instanceof HisaaboApiError) {
+    return err.hisaaboError;
+  }
+  const message = err instanceof Error ? err.message : "An unexpected error occurred. Check server logs.";
+  return { code: "api_error", message };
+}
+
+// src/lib/pagination.ts
+var envCap = parseInt(process.env.HISAABO_MCP_PAGE_SIZE ?? "25", 10);
+var MAX_PAGE_SIZE = Math.min(Math.max(isNaN(envCap) ? 25 : envCap, 1), 50);
+function withPaginationMeta(result) {
+  return {
+    ...result,
+    hasMore: result.total > result.page * result.limit
+  };
+}
+
+// src/tools/invoice.ts
+var INVOICE_STATUS = ["draft", "unfulfilled", "sent", "paid", "partial", "overdue", "cancelled"];
+var DOCUMENT_TYPE = ["invoice", "quotation", "credit_note", "debit_note", "delivery_challan", "proforma", "sales_return", "purchase_return"];
+function registerInvoiceTools(server2, client2) {
+  server2.tool(
+    "invoice_list",
+    [
+      "List invoices for the active business. Returns up to 25 invoices per page with pagination metadata.",
+      "Use `page` to fetch subsequent pages when `hasMore` is true in the response.",
+      "Example: to find all unpaid invoices from a customer, set status='sent' or status='partial' and party_id=<uuid>.",
+      "To find overdue invoices across all customers, set status='overdue'."
+    ].join(" "),
+    {
+      type: z.enum(["sale", "purchase"]).optional().describe("sale = customer invoices, purchase = supplier bills. Omit to return both."),
+      document_type: z.enum(DOCUMENT_TYPE).optional().describe("Filter by document type (default: invoice). Use 'quotation' for quotes, 'credit_note' for credits."),
+      status: z.enum(INVOICE_STATUS).optional().describe("Filter by status. Common values: 'sent' (awaiting payment), 'paid', 'overdue', 'draft'."),
+      party_id: z.string().uuid().optional().describe("UUID of a specific customer or supplier to filter by."),
+      from_date: z.string().datetime().optional().describe("Start of invoice date range (ISO 8601, e.g. '2024-04-01T00:00:00Z')."),
+      to_date: z.string().datetime().optional().describe("End of invoice date range (ISO 8601)."),
+      search: z.string().max(200).optional().describe("Search by invoice number or party name (partial match)."),
+      sort_by: z.enum(["date", "amount", "number"]).optional().describe("Sort field. Defaults to date descending."),
+      sort_dir: z.enum(["asc", "desc"]).optional().describe("Sort direction. Defaults to desc."),
+      page: z.number().int().min(1).default(1).describe("Page number (1-indexed). Use with hasMore in the response to paginate.")
+    },
+    wrapTool(async (input) => {
+      const result = await client2.invoice.list({
+        type: input.type,
+        documentType: input.document_type,
+        status: input.status,
+        partyId: input.party_id,
+        fromDate: input.from_date,
+        toDate: input.to_date,
+        search: input.search,
+        sortBy: input.sort_by,
+        sortDir: input.sort_dir,
+        page: input.page,
+        limit: MAX_PAGE_SIZE
+      });
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(withPaginationMeta(result), null, 2)
+        }]
+      };
+    })
+  );
+  server2.tool(
+    "invoice_create",
+    [
+      "Create a new invoice or bill for the active business. Returns the created invoice with its assigned invoice number.",
+      "For sale invoices (customer billing), set type='sale'. For purchase bills (supplier invoices), set type='purchase'.",
+      "Each line item requires a description, quantity (decimal string), and unit_price (decimal string, no currency symbol).",
+      "Monetary values are always decimal strings, e.g. '1500.00' not 1500.",
+      "If a line item corresponds to an inventory item, set item_id to link it and update stock automatically.",
+      "Example: { party_id: 'uuid', type: 'sale', line_items: [{ description: 'Web Design', quantity: '1.00', unit_price: '15000.00', tax_percent: '18.00' }] }"
+    ].join(" "),
+    {
+      party_id: z.string().uuid().describe("UUID of the customer (for sales) or supplier (for purchases). Use party_list to find UUIDs."),
+      type: z.enum(["sale", "purchase"]).describe("'sale' for customer invoices (money coming in), 'purchase' for supplier bills (money going out)."),
+      document_type: z.enum(DOCUMENT_TYPE).optional().describe("Document type (default: 'invoice'). Use 'quotation' to create a quote instead of an invoice."),
+      line_items: z.array(z.object({
+        description: z.string().min(1).max(500).describe("Product or service name/description."),
+        quantity: z.string().regex(/^\d+(\.\d{1,3})?$/).describe("Quantity as decimal string, e.g. '1.000', '7.500', '100'."),
+        unit_price: z.string().regex(/^\d+(\.\d{1,2})?$/).describe("Price per unit as decimal string, e.g. '250.00', '15000.00'."),
+        tax_percent: z.string().regex(/^\d+(\.\d{1,2})?$/).default("0").describe("GST/tax rate percentage as decimal string: '0', '5.00', '12.00', '18.00', '28.00'."),
+        discount_percent: z.string().regex(/^\d+(\.\d{1,2})?$/).default("0").describe("Line-level discount percentage, e.g. '10.00' for 10% off."),
+        item_id: z.string().uuid().optional().describe("Link to an inventory item UUID to auto-fill price and update stock (optional).")
+      })).min(1).describe("At least one line item is required."),
+      invoice_date: z.string().datetime().optional().describe("Invoice date (ISO 8601). Defaults to today if omitted."),
+      due_date: z.string().datetime().optional().describe("Payment due date (ISO 8601). Set to enforce credit terms."),
+      notes: z.string().max(2e3).optional().describe("Notes visible on the printed invoice, e.g. bank account details or thank-you message."),
+      terms_and_conditions: z.string().max(2e3).optional().describe("Terms and conditions text printed on the invoice."),
+      invoice_discount: z.string().regex(/^\d+(\.\d{1,2})?$/).optional().describe("Invoice-level discount. Interpretation depends on invoice_discount_type."),
+      invoice_discount_type: z.enum(["amount", "percent"]).optional().describe("Whether invoice_discount is a flat amount or percentage (default: 'amount')."),
+      round_off: z.string().regex(/^-?\d+(\.\d{1,2})?$/).optional().describe("Round-off adjustment for the total, e.g. '0.50' or '-0.25' (typically small). Default '0'."),
+      reference_document_id: z.string().uuid().optional().describe("UUID of a source document (e.g. quotation UUID when converting quote to invoice).")
+    },
+    wrapTool(async (input) => {
+      const invoice = await client2.invoice.create({
+        partyId: input.party_id,
+        type: input.type,
+        documentType: input.document_type,
+        invoiceDate: input.invoice_date,
+        dueDate: input.due_date,
+        notes: input.notes,
+        termsAndConditions: input.terms_and_conditions,
+        invoiceDiscount: input.invoice_discount,
+        invoiceDiscountType: input.invoice_discount_type,
+        roundOff: input.round_off,
+        referenceDocumentId: input.reference_document_id,
+        lineItems: input.line_items.map((li) => ({
+          description: li.description,
+          quantity: li.quantity,
+          unitPrice: li.unit_price,
+          taxPercent: li.tax_percent,
+          discountPercent: li.discount_percent,
+          itemId: li.item_id
+        }))
+      });
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(invoice, null, 2)
+        }]
+      };
+    })
+  );
+  server2.tool(
+    "invoice_get",
+    [
+      "Get the full details of a single invoice, including all line items, payment history, and outstanding balance.",
+      "Use this after invoice_list to get complete details. The 'balanceDue' field shows how much is still owed.",
+      "Payments already applied to this invoice appear in the response."
+    ].join(" "),
+    {
+      invoice_id: z.string().uuid().describe("Invoice UUID from invoice_list or invoice_create.")
+    },
+    wrapTool(async (input) => {
+      const invoice = await client2.invoice.get(input.invoice_id);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(invoice, null, 2)
+        }]
+      };
+    })
+  );
+  server2.tool(
+    "invoice_update_status",
+    [
+      "Change the status of an invoice.",
+      "Typical workflow: create (draft) \u2192 mark sent \u2192 payment received (handled by payment_create, which auto-updates status to 'paid' or 'partial').",
+      "Use this tool to manually set status to 'sent' (invoice delivered), 'cancelled' (void the invoice), or 'overdue' (mark past due).",
+      "Note: 'paid' and 'partial' status is normally set automatically when payments are recorded \u2014 prefer payment_create over forcing 'paid' here."
+    ].join(" "),
+    {
+      invoice_id: z.string().uuid().describe("Invoice UUID."),
+      status: z.enum(INVOICE_STATUS).describe("New status. 'sent' = delivered to customer. 'cancelled' = voided. 'draft' = revert to draft.")
+    },
+    wrapTool(async (input) => {
+      const result = await client2.invoice.updateStatus(input.invoice_id, input.status);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(result, null, 2)
+        }]
+      };
+    })
+  );
+  server2.tool(
+    "invoice_delete",
+    [
+      "Soft-delete an invoice (marks it as cancelled and hides it from lists).",
+      "Admins can delete any invoice. Seller managers can only delete unpaid invoices created within the last 2 hours.",
+      "Paid invoices cannot be deleted \u2014 void them by recording a credit note instead.",
+      "This is a soft delete \u2014 the invoice is not physically removed from the database."
+    ].join(" "),
+    {
+      invoice_id: z.string().uuid().describe("Invoice UUID to delete.")
+    },
+    wrapTool(async (input) => {
+      const result = await client2.invoice.delete(input.invoice_id);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(result, null, 2)
+        }]
+      };
+    })
+  );
+  server2.tool(
+    "invoice_pdf_url",
+    [
+      "Get the URL to download or view an invoice as a PDF.",
+      "The URL requires the HISAABO_TOKEN for authentication (pass as a Bearer token).",
+      "Use format='a4' for standard invoices and format='thermal' for 80mm receipt printing.",
+      "The URL is valid for as long as the session token is valid."
+    ].join(" "),
+    {
+      invoice_id: z.string().uuid().describe("Invoice UUID."),
+      format: z.enum(["a4", "thermal"]).default("a4").describe("'a4' for standard A4 invoice PDF, 'thermal' for 80mm thermal receipt.")
+    },
+    wrapTool(async (input) => {
+      const url = `${client2.apiUrl}/api/invoice/${input.invoice_id}/pdf?format=${input.format}`;
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            url,
+            note: "Fetch this URL with the Authorization: Bearer <HISAABO_TOKEN> header to download the PDF.",
+            format: input.format
+          }, null, 2)
+        }]
+      };
+    })
+  );
+}
+
+// src/tools/party.ts
+import { z as z2 } from "zod";
+function registerPartyTools(server2, client2) {
+  server2.tool(
+    "party_list",
+    [
+      "List customers and suppliers (parties) for the active business.",
+      "The 'balance' field in each result shows the outstanding amount: positive = they owe you (receivable), negative = you owe them (payable).",
+      "Use filter='outstanding' to find parties with unpaid balances. Use filter='overdue' for parties with overdue invoices.",
+      "Use this tool to find party UUIDs before calling invoice_create or payment_create."
+    ].join(" "),
+    {
+      type: z2.enum(["customer", "supplier"]).optional().describe("'customer' for buyers, 'supplier' for vendors. Omit to return both."),
+      filter: z2.enum(["all", "customer", "supplier", "outstanding", "overdue"]).optional().describe("'outstanding' = parties with unpaid balance, 'overdue' = parties with overdue invoices."),
+      search: z2.string().max(200).optional().describe("Search by party name, phone, email, or GSTIN (partial match)."),
+      category: z2.string().max(100).optional().describe("Filter by party category tag."),
+      sort_by: z2.enum(["name", "balance"]).optional().describe("Sort by name (alphabetical) or balance (largest first)."),
+      sort_dir: z2.enum(["asc", "desc"]).optional().describe("Sort direction."),
+      page: z2.number().int().min(1).default(1).describe("Page number for pagination.")
+    },
+    wrapTool(async (input) => {
+      const result = await client2.party.list({
+        type: input.type,
+        filter: input.filter,
+        search: input.search,
+        category: input.category,
+        sortBy: input.sort_by,
+        sortDir: input.sort_dir,
+        page: input.page,
+        limit: MAX_PAGE_SIZE
+      });
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(withPaginationMeta(result), null, 2)
+        }]
+      };
+    })
+  );
+  server2.tool(
+    "party_create",
+    [
+      "Create a new customer or supplier party.",
+      "Minimum required: type ('customer' or 'supplier') and name.",
+      "For GST-registered parties, provide gstin (format: 22AAAAA0000A1Z5). For unregistered, omit it.",
+      "opening_balance sets their starting account balance: positive = they owe you, negative = you owe them."
+    ].join(" "),
+    {
+      type: z2.enum(["customer", "supplier"]).describe("'customer' for buyers/clients, 'supplier' for vendors/sellers."),
+      name: z2.string().min(1).max(200).describe("Full name of the customer or business."),
+      phone: z2.string().max(15).optional().describe("Phone number (digits only, no country code prefix required)."),
+      email: z2.string().email().optional().describe("Email address for sending invoices."),
+      gstin: z2.string().regex(/^[0-9]{2}[A-Z]{5}[0-9]{4}[A-Z]{1}[1-9A-Z]{1}Z[0-9A-Z]{1}$/).optional().describe("GST Identification Number (15 characters), e.g. '22AAAAA0000A1Z5'. Omit if unregistered."),
+      pan: z2.string().optional().describe("PAN (Permanent Account Number), 10 characters."),
+      billing_address: z2.string().max(500).optional().describe("Full billing address."),
+      city: z2.string().max(100).optional(),
+      state: z2.string().max(100).optional(),
+      pincode: z2.string().max(10).optional(),
+      opening_balance: z2.string().regex(/^-?\d+(\.\d{1,2})?$/).optional().describe("Starting balance as decimal string. Positive = they owe you, negative = you owe them. Default '0'."),
+      category: z2.string().max(100).optional().describe("Category tag for grouping parties, e.g. 'retail', 'wholesale', 'government'."),
+      credit_period_days: z2.number().int().min(0).max(365).optional().describe("Number of days before payment is due (e.g. 30 for net-30 terms)."),
+      credit_limit: z2.string().regex(/^\d+(\.\d{1,2})?$/).optional().describe("Maximum credit amount as decimal string.")
+    },
+    wrapTool(async (input) => {
+      const party = await client2.party.create({
+        type: input.type,
+        name: input.name,
+        phone: input.phone,
+        email: input.email,
+        gstin: input.gstin,
+        pan: input.pan,
+        billingAddress: input.billing_address,
+        city: input.city,
+        state: input.state,
+        pincode: input.pincode,
+        openingBalance: input.opening_balance,
+        category: input.category,
+        creditPeriodDays: input.credit_period_days,
+        creditLimit: input.credit_limit
+      });
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(party, null, 2)
+        }]
+      };
+    })
+  );
+  server2.tool(
+    "party_get",
+    [
+      "Get full details of a single customer or supplier, including their current outstanding balance.",
+      "'balance' shows net amount: positive = they owe you, negative = you owe them.",
+      "Use this to answer questions like 'What does Acme Corp owe us?' or 'What is our balance with Supplier X?'"
+    ].join(" "),
+    {
+      party_id: z2.string().uuid().describe("Party UUID from party_list.")
+    },
+    wrapTool(async (input) => {
+      const party = await client2.party.get(input.party_id);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(party, null, 2)
+        }]
+      };
+    })
+  );
+  server2.tool(
+    "party_update",
+    [
+      "Update an existing customer or supplier's details.",
+      "Only provide fields you want to change \u2014 all other fields remain unchanged.",
+      "Note: 'type' (customer/supplier) cannot be changed after creation."
+    ].join(" "),
+    {
+      party_id: z2.string().uuid().describe("Party UUID to update."),
+      name: z2.string().min(1).max(200).optional().describe("Updated name."),
+      phone: z2.string().max(15).optional().describe("Updated phone number."),
+      email: z2.string().email().optional().describe("Updated email address."),
+      gstin: z2.string().regex(/^[0-9]{2}[A-Z]{5}[0-9]{4}[A-Z]{1}[1-9A-Z]{1}Z[0-9A-Z]{1}$/).optional().describe("Updated GSTIN (15 characters)."),
+      billing_address: z2.string().max(500).optional().describe("Updated billing address."),
+      shipping_address: z2.string().max(500).optional().describe("Updated shipping address."),
+      city: z2.string().max(100).optional().describe("Updated city."),
+      state: z2.string().max(100).optional().describe("Updated state."),
+      pincode: z2.string().max(10).optional().describe("Updated PIN code."),
+      category: z2.string().max(100).optional().describe("Updated category tag."),
+      credit_period_days: z2.number().int().min(0).max(365).optional().describe("Updated credit period in days."),
+      credit_limit: z2.string().regex(/^\d+(\.\d{1,2})?$/).optional().describe("Updated credit limit as decimal string."),
+      contact_person_name: z2.string().max(200).optional().describe("Updated contact person name.")
+    },
+    wrapTool(async (input) => {
+      const { party_id, ...fields } = input;
+      const party = await client2.party.update(party_id, {
+        name: fields.name,
+        phone: fields.phone,
+        email: fields.email,
+        gstin: fields.gstin,
+        billingAddress: fields.billing_address,
+        shippingAddress: fields.shipping_address,
+        city: fields.city,
+        state: fields.state,
+        pincode: fields.pincode,
+        category: fields.category,
+        creditPeriodDays: fields.credit_period_days,
+        creditLimit: fields.credit_limit,
+        contactPersonName: fields.contact_person_name
+      });
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(party, null, 2)
+        }]
+      };
+    })
+  );
+  server2.tool(
+    "party_delete",
+    [
+      "Permanently delete a customer or supplier. Requires admin role.",
+      "Warning: this is a hard delete. Associated invoices and payments are not deleted, but the party reference will be broken.",
+      "Consider deactivating or archiving instead \u2014 only delete if the party was created in error."
+    ].join(" "),
+    {
+      party_id: z2.string().uuid().describe("Party UUID to delete.")
+    },
+    wrapTool(async (input) => {
+      const result = await client2.party.delete(input.party_id);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(result, null, 2)
+        }]
+      };
+    })
+  );
+  server2.tool(
+    "party_ledger",
+    [
+      "Get the full transaction ledger (account statement) for a customer or supplier.",
+      "Shows all invoices, payments, and credit notes in chronological order with running balance.",
+      "Use this to answer 'Show me all transactions with Customer X' or 'What is the payment history for this supplier?'",
+      "The closing_balance field is the current net balance for the party."
+    ].join(" "),
+    {
+      party_id: z2.string().uuid().describe("Party UUID."),
+      from_date: z2.string().datetime().optional().describe("Start date for ledger entries (ISO 8601). Omit for all-time."),
+      to_date: z2.string().datetime().optional().describe("End date for ledger entries (ISO 8601)."),
+      page: z2.number().int().min(1).default(1).describe("Page number for pagination.")
+    },
+    wrapTool(async (input) => {
+      const ledger = await client2.party.ledger(input.party_id, {
+        fromDate: input.from_date,
+        toDate: input.to_date,
+        page: input.page,
+        limit: MAX_PAGE_SIZE
+      });
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(ledger, null, 2)
+        }]
+      };
+    })
+  );
+}
+
+// src/tools/item.ts
+import { z as z3 } from "zod";
+function registerItemTools(server2, client2) {
+  server2.tool(
+    "item_list",
+    [
+      "List inventory items and services for the active business.",
+      "The 'stockQuantity' field shows current stock. Items with stock below 'lowStockAlert' are low-stock.",
+      "Use low_stock=true to find items that need restocking.",
+      "Use this to find item UUIDs before creating invoices (linking item_id speeds up invoice creation and updates stock)."
+    ].join(" "),
+    {
+      search: z3.string().max(200).optional().describe("Search by item name, SKU, or HSN code."),
+      category: z3.string().max(100).optional().describe("Filter by category."),
+      item_type: z3.enum(["product", "service"]).optional().describe("'product' for physical goods with stock, 'service' for billable services (no stock tracking)."),
+      low_stock: z3.boolean().optional().describe("If true, return only items where current stock is below the low-stock alert threshold."),
+      page: z3.number().int().min(1).default(1).describe("Page number for pagination.")
+    },
+    wrapTool(async (input) => {
+      const result = await client2.item.list({
+        search: input.search,
+        category: input.category,
+        itemType: input.item_type,
+        lowStock: input.low_stock,
+        page: input.page,
+        limit: MAX_PAGE_SIZE
+      });
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(withPaginationMeta(result), null, 2)
+        }]
+      };
+    })
+  );
+  server2.tool(
+    "item_create",
+    [
+      "Create a new inventory item or service.",
+      "For physical products, set item_type='product' and provide initial stock_quantity.",
+      "For billable services (consulting, installation, etc.), set item_type='service' \u2014 stock is not tracked.",
+      "Monetary values (sale_price, purchase_price) are decimal strings without currency symbols: '250.00' not '\u20B9250'.",
+      "Setting low_stock_alert triggers warnings when stock falls below that level."
+    ].join(" "),
+    {
+      name: z3.string().min(1).max(200).describe("Item name as it should appear on invoices."),
+      item_type: z3.enum(["product", "service"]).default("product").describe("'product' for physical goods, 'service' for services (no stock)."),
+      unit: z3.enum(["pcs", "kg", "g", "l", "ml", "m", "cm", "ft", "in", "box", "dozen", "pair", "set", "pkt", "bun", "pouch", "jar", "btl", "bag", "ton", "pack", "pet", "person", "other"]).optional().describe("Unit of measurement. Default 'pcs'. Use 'kg' for weight, 'l' for liquids, etc."),
+      sale_price: z3.string().regex(/^\d+(\.\d{1,2})?$/).optional().describe("Default selling price per unit as decimal string, e.g. '250.00'."),
+      purchase_price: z3.string().regex(/^\d+(\.\d{1,2})?$/).optional().describe("Default purchase/cost price per unit as decimal string."),
+      tax_percent: z3.string().regex(/^\d+(\.\d{1,2})?$/).optional().describe("Default GST/tax rate percentage, e.g. '18.00'. Default '0'."),
+      stock_quantity: z3.string().regex(/^-?\d+(\.\d{1,3})?$/).optional().describe("Opening stock quantity as decimal string, e.g. '100.000'. Default '0'."),
+      low_stock_alert: z3.string().regex(/^\d+(\.\d{1,3})?$/).optional().describe("Alert threshold: warn when stock falls below this quantity."),
+      hsn: z3.string().max(20).optional().describe("HSN (Harmonized System of Nomenclature) code for GST compliance."),
+      sku: z3.string().max(50).optional().describe("SKU (Stock Keeping Unit) \u2014 your internal product code."),
+      description: z3.string().max(1e3).optional().describe("Internal description (not shown on invoices)."),
+      category: z3.string().max(100).optional().describe("Category for grouping, e.g. 'Electronics', 'Raw Materials'.")
+    },
+    wrapTool(async (input) => {
+      const item = await client2.item.create({
+        name: input.name,
+        itemType: input.item_type,
+        unit: input.unit,
+        salePrice: input.sale_price,
+        purchasePrice: input.purchase_price,
+        taxPercent: input.tax_percent,
+        stockQuantity: input.stock_quantity,
+        lowStockAlert: input.low_stock_alert,
+        hsn: input.hsn,
+        sku: input.sku,
+        description: input.description,
+        category: input.category
+      });
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(item, null, 2)
+        }]
+      };
+    })
+  );
+  server2.tool(
+    "item_get",
+    [
+      "Get full details of a single inventory item, including current stock quantity and variant information.",
+      "Use this to check current stock levels or get the full item spec before creating invoices."
+    ].join(" "),
+    {
+      item_id: z3.string().uuid().describe("Item UUID from item_list.")
+    },
+    wrapTool(async (input) => {
+      const item = await client2.item.get(input.item_id);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(item, null, 2)
+        }]
+      };
+    })
+  );
+  server2.tool(
+    "item_update",
+    [
+      "Update an existing inventory item's details, pricing, or stock settings.",
+      "Only provide fields you want to change \u2014 all other fields remain unchanged.",
+      "Changing sale_price or purchase_price updates the default price for future invoices but does not retroactively change past invoice line items."
+    ].join(" "),
+    {
+      item_id: z3.string().uuid().describe("Item UUID to update."),
+      name: z3.string().min(1).max(200).optional().describe("Updated item name."),
+      sale_price: z3.string().regex(/^\d+(\.\d{1,2})?$/).optional().describe("Updated selling price per unit as decimal string."),
+      purchase_price: z3.string().regex(/^\d+(\.\d{1,2})?$/).optional().describe("Updated purchase/cost price per unit as decimal string."),
+      tax_percent: z3.string().regex(/^\d+(\.\d{1,2})?$/).optional().describe("Updated GST/tax rate percentage, e.g. '18.00'."),
+      low_stock_alert: z3.string().regex(/^\d+(\.\d{1,3})?$/).optional().describe("Updated low-stock alert threshold."),
+      hsn: z3.string().max(20).optional().describe("Updated HSN code."),
+      sku: z3.string().max(50).optional().describe("Updated SKU."),
+      description: z3.string().max(1e3).optional().describe("Updated internal description."),
+      category: z3.string().max(100).optional().describe("Updated category.")
+    },
+    wrapTool(async (input) => {
+      const { item_id, ...fields } = input;
+      const item = await client2.item.update(item_id, {
+        name: fields.name,
+        salePrice: fields.sale_price,
+        purchasePrice: fields.purchase_price,
+        taxPercent: fields.tax_percent,
+        lowStockAlert: fields.low_stock_alert,
+        hsn: fields.hsn,
+        sku: fields.sku,
+        description: fields.description,
+        category: fields.category
+      });
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(item, null, 2)
+        }]
+      };
+    })
+  );
+  server2.tool(
+    "item_delete",
+    [
+      "Permanently delete an inventory item. Requires admin role.",
+      "Warning: this is a hard delete \u2014 it removes the item record and its variants.",
+      "Existing invoice line items that reference this item are not deleted (they retain the data at time of invoicing).",
+      "Only delete if the item was created in error. For discontinued items, consider just setting them inactive."
+    ].join(" "),
+    {
+      item_id: z3.string().uuid().describe("Item UUID to delete.")
+    },
+    wrapTool(async (input) => {
+      const result = await client2.item.delete(input.item_id);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(result, null, 2)
+        }]
+      };
+    })
+  );
+  server2.tool(
+    "item_categories",
+    [
+      "Get a list of all distinct item categories used in the business.",
+      "Use this to discover valid category names before filtering item_list by category or creating items."
+    ].join(" "),
+    {},
+    wrapTool(async (_input) => {
+      const categories = await client2.item.categories();
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(categories, null, 2)
+        }]
+      };
+    })
+  );
+  server2.tool(
+    "item_adjust_stock",
+    [
+      "Record a manual stock adjustment for an inventory item.",
+      "Use a positive adjustment to add stock (e.g. '+50' for stock received) and a negative adjustment to remove stock (e.g. '-5' for damaged goods).",
+      "Every adjustment is recorded in the audit log \u2014 always provide a reason.",
+      "Example: to record receiving 100 units from a supplier, set adjustment='+100' and reason='Stock received from Supplier X'."
+    ].join(" "),
+    {
+      item_id: z3.string().uuid().describe("Item UUID from item_list."),
+      adjustment: z3.string().regex(/^[+-]?\d+(\.\d{1,3})?$/).describe("Signed quantity change as decimal string. '+50' or '50' to add, '-10' to subtract."),
+      reason: z3.string().max(500).optional().describe("Reason for the adjustment, e.g. 'Stock received from supplier', 'Damaged goods write-off'.")
+    },
+    wrapTool(async (input) => {
+      const result = await client2.item.adjustStock({
+        itemId: input.item_id,
+        adjustment: input.adjustment,
+        reason: input.reason
+      });
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(result, null, 2)
+        }]
+      };
+    })
+  );
+}
+
+// src/tools/payment.ts
+import { z as z4 } from "zod";
+var PAYMENT_MODES = ["cash", "bank", "upi", "cheque", "other"];
+function registerPaymentTools(server2, client2) {
+  server2.tool(
+    "payment_create",
+    [
+      "Record a payment received from a customer or made to a supplier.",
+      "If the payment is for a specific invoice, set invoice_id \u2014 the invoice status will update automatically to 'paid' or 'partial'.",
+      "If the payment is not tied to a specific invoice (advance payment or bulk payment), omit invoice_id \u2014 it applies to the party's account balance.",
+      "To split a payment across multiple invoices, use the allocations array instead of invoice_id.",
+      "Example: customer paid invoice INV-001 by UPI: { party_id: '<uuid>', amount: '5000.00', mode: 'upi', invoice_id: '<uuid>' }"
+    ].join(" "),
+    {
+      party_id: z4.string().uuid().describe("UUID of the customer (payment received) or supplier (payment made)."),
+      amount: z4.string().regex(/^\d+(\.\d{1,2})?$/).describe("Payment amount as decimal string, e.g. '5000.00'."),
+      mode: z4.enum(PAYMENT_MODES).describe("Payment method: 'cash', 'bank' (bank transfer/NEFT/RTGS), 'upi', 'cheque', or 'other'."),
+      invoice_id: z4.string().uuid().optional().describe("Link this payment to a specific invoice UUID. The invoice status updates automatically. Omit for advance payments."),
+      discount: z4.string().regex(/^\d+(\.\d{1,2})?$/).optional().describe("Discount or write-off amount applied alongside this payment, e.g. '100.00'. Default '0'."),
+      reference_number: z4.string().max(100).optional().describe("Transaction reference, UTR number, cheque number, or any payment identifier."),
+      payment_date: z4.string().datetime().optional().describe("Date the payment was received/made (ISO 8601). Defaults to today."),
+      notes: z4.string().max(500).optional().describe("Internal notes about this payment."),
+      bank_account_id: z4.string().uuid().optional().describe("Bank/cash account UUID to record this transaction against (for cash flow tracking)."),
+      allocations: z4.array(z4.object({
+        invoice_id: z4.string().uuid().describe("Invoice UUID to allocate part of this payment to."),
+        amount: z4.string().regex(/^\d+(\.\d{1,2})?$/).describe("Amount to allocate to this invoice.")
+      })).optional().describe("Allocate a single payment across multiple invoices. Use instead of invoice_id when splitting a payment.")
+    },
+    wrapTool(async (input) => {
+      const payment = await client2.payment.create({
+        partyId: input.party_id,
+        amount: input.amount,
+        mode: input.mode,
+        invoiceId: input.invoice_id,
+        discount: input.discount,
+        referenceNumber: input.reference_number,
+        paymentDate: input.payment_date,
+        notes: input.notes,
+        bankAccountId: input.bank_account_id,
+        allocations: input.allocations?.map((a) => ({
+          invoiceId: a.invoice_id,
+          amount: a.amount
+        }))
+      });
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(payment, null, 2)
+        }]
+      };
+    })
+  );
+  server2.tool(
+    "payment_get",
+    [
+      "Get full details of a single payment, including the invoices it was applied to.",
+      "The 'linkedInvoices' field shows which invoices received allocations from this payment."
+    ].join(" "),
+    {
+      payment_id: z4.string().uuid().describe("Payment UUID from payment_list.")
+    },
+    wrapTool(async (input) => {
+      const payment = await client2.payment.getById(input.payment_id);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(payment, null, 2)
+        }]
+      };
+    })
+  );
+  server2.tool(
+    "payment_update",
+    [
+      "Update an existing payment record. This reverses the old allocation and re-applies the new one.",
+      "The linked invoice's amountPaid and status are recalculated automatically.",
+      "Only provide fields you want to change.",
+      "Warning: updating a payment recalculates invoice statuses \u2014 ensure the new amount/allocation is correct."
+    ].join(" "),
+    {
+      payment_id: z4.string().uuid().describe("Payment UUID to update."),
+      amount: z4.string().regex(/^\d+(\.\d{1,2})?$/).optional().describe("New payment amount as decimal string."),
+      mode: z4.enum(PAYMENT_MODES).optional().describe("Updated payment mode."),
+      discount: z4.string().regex(/^\d+(\.\d{1,2})?$/).optional().describe("Updated discount/write-off amount."),
+      reference_number: z4.string().max(100).optional().nullable().describe("Updated transaction reference number."),
+      payment_date: z4.string().datetime().optional().describe("Updated payment date (ISO 8601)."),
+      notes: z4.string().max(500).optional().nullable().describe("Updated internal notes."),
+      bank_account_id: z4.string().uuid().optional().nullable().describe("Updated bank account UUID. Null to unlink from any account."),
+      allocations: z4.array(z4.object({
+        invoice_id: z4.string().uuid().describe("Invoice UUID to allocate part of this payment to."),
+        amount: z4.string().regex(/^\d+(\.\d{1,2})?$/).describe("Amount to allocate.")
+      })).optional().describe("Updated invoice allocations. Replaces all existing allocations.")
+    },
+    wrapTool(async (input) => {
+      const payment = await client2.payment.update({
+        id: input.payment_id,
+        amount: input.amount,
+        mode: input.mode,
+        discount: input.discount,
+        referenceNumber: input.reference_number,
+        paymentDate: input.payment_date,
+        notes: input.notes,
+        bankAccountId: input.bank_account_id,
+        allocations: input.allocations?.map((a) => ({
+          invoiceId: a.invoice_id,
+          amount: a.amount
+        }))
+      });
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(payment, null, 2)
+        }]
+      };
+    })
+  );
+  server2.tool(
+    "payment_delete",
+    [
+      "Soft-delete a payment record. Requires admin role.",
+      "Deleting a payment reverses the invoice allocation: the linked invoice's amountPaid is reduced and its status is recalculated.",
+      "The bank account balance is also reversed if the payment was recorded against an account."
+    ].join(" "),
+    {
+      payment_id: z4.string().uuid().describe("Payment UUID to delete.")
+    },
+    wrapTool(async (input) => {
+      const result = await client2.payment.delete(input.payment_id);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(result, null, 2)
+        }]
+      };
+    })
+  );
+  server2.tool(
+    "payment_list",
+    [
+      "List payments for the active business, filtered by party, invoice, or date range.",
+      "Use party_id to see all payments from/to a specific customer or supplier.",
+      "Use invoice_id to see all payments applied to a specific invoice."
+    ].join(" "),
+    {
+      party_id: z4.string().uuid().optional().describe("Filter by customer or supplier UUID."),
+      invoice_id: z4.string().uuid().optional().describe("Filter payments linked to a specific invoice."),
+      from_date: z4.string().datetime().optional().describe("Start date (ISO 8601)."),
+      to_date: z4.string().datetime().optional().describe("End date (ISO 8601)."),
+      search: z4.string().max(200).optional().describe("Search by payment number, party name, or reference number."),
+      page: z4.number().int().min(1).default(1).describe("Page number for pagination.")
+    },
+    wrapTool(async (input) => {
+      const result = await client2.payment.list({
+        partyId: input.party_id,
+        invoiceId: input.invoice_id,
+        fromDate: input.from_date,
+        toDate: input.to_date,
+        search: input.search,
+        page: input.page,
+        limit: MAX_PAGE_SIZE
+      });
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(withPaginationMeta(result), null, 2)
+        }]
+      };
+    })
+  );
+}
+
+// src/tools/expense.ts
+import { z as z5 } from "zod";
+var PAYMENT_MODES2 = ["cash", "bank", "upi", "cheque", "other"];
+function registerExpenseTools(server2, client2) {
+  server2.tool(
+    "expense_create",
+    [
+      "Record a business expense (operating cost, overhead, etc.).",
+      "Category is a free-form label \u2014 use consistent names like 'Rent', 'Utilities', 'Salaries', 'Travel'.",
+      "Expenses appear in the dashboard summary's 'totalExpenses' and affect the P&L."
+    ].join(" "),
+    {
+      category: z5.string().min(1).max(100).describe("Expense category, e.g. 'Rent', 'Electricity', 'Office Supplies', 'Travel'."),
+      amount: z5.string().regex(/^\d+(\.\d{1,2})?$/).describe("Expense amount as decimal string, e.g. '12000.00'."),
+      mode: z5.enum(PAYMENT_MODES2).describe("Payment method used: 'cash', 'bank', 'upi', 'cheque', or 'other'."),
+      description: z5.string().max(500).optional().describe("Additional details, e.g. 'Office rent for March 2024'."),
+      expense_date: z5.string().datetime().optional().describe("Date of the expense (ISO 8601). Defaults to today."),
+      reference_number: z5.string().max(100).optional().describe("Bill number, receipt number, or transaction ID.")
+    },
+    wrapTool(async (input) => {
+      const expense = await client2.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",
+          text: JSON.stringify(expense, null, 2)
+        }]
+      };
+    })
+  );
+  server2.tool(
+    "expense_update",
+    [
+      "Update an existing expense record.",
+      "Only provide fields you want to change \u2014 all other fields remain unchanged."
+    ].join(" "),
+    {
+      expense_id: z5.string().uuid().describe("Expense UUID to update."),
+      category: z5.string().min(1).max(100).optional().describe("Updated expense category."),
+      amount: z5.string().regex(/^\d+(\.\d{1,2})?$/).optional().describe("Updated expense amount as decimal string."),
+      mode: z5.enum(PAYMENT_MODES2).optional().describe("Updated payment method."),
+      description: z5.string().max(500).optional().describe("Updated description."),
+      expense_date: z5.string().datetime().optional().describe("Updated expense date (ISO 8601)."),
+      reference_number: z5.string().max(100).optional().describe("Updated bill number or receipt number.")
+    },
+    wrapTool(async (input) => {
+      const expense = await client2.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",
+          text: JSON.stringify(expense, null, 2)
+        }]
+      };
+    })
+  );
+  server2.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: z5.string().uuid().describe("Expense UUID to delete.")
+    },
+    wrapTool(async (input) => {
+      const result = await client2.expense.delete(input.expense_id);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(result, null, 2)
+        }]
+      };
+    })
+  );
+  server2.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 client2.expense.categories();
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(categories, null, 2)
+        }]
+      };
+    })
+  );
+  server2.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: z5.string().max(100).optional().describe("Filter by expense category (exact match)."),
+      from_date: z5.string().datetime().optional().describe("Start date (ISO 8601)."),
+      to_date: z5.string().datetime().optional().describe("End date (ISO 8601)."),
+      search: z5.string().max(200).optional().describe("Search by description or reference number."),
+      page: z5.number().int().min(1).default(1).describe("Page number for pagination.")
+    },
+    wrapTool(async (input) => {
+      const result = await client2.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",
+          text: JSON.stringify(withPaginationMeta(result), null, 2)
+        }]
+      };
+    })
+  );
+}
+
+// src/tools/dashboard.ts
+import { z as z6 } from "zod";
+function resolvePeriod(period) {
+  const now = /* @__PURE__ */ new Date();
+  if (!period || period === "this-fy") {
+    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() };
+  }
+  return {};
+}
+function registerDashboardTools(server2, client2) {
+  server2.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\u2013March 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: z6.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: z6.string().datetime().optional().describe("Custom start date (ISO 8601). Only used when period='custom'."),
+      to_date: z6.string().datetime().optional().describe("Custom end date (ISO 8601). Only used when period='custom'.")
+    },
+    wrapTool(async (input) => {
+      let dateRange;
+      if (input.period === "custom") {
+        dateRange = {
+          fromDate: input.from_date,
+          toDate: input.to_date
+        };
+      } else {
+        dateRange = resolvePeriod(input.period);
+      }
+      const summary = await client2.dashboard.summary(
+        Object.keys(dateRange).length > 0 ? dateRange : void 0
+      );
+      return {
+        content: [{
+          type: "text",
+          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
+          )
+        }]
+      };
+    })
+  );
+}
+
+// src/tools/gst.ts
+import { z as z7 } from "zod";
+var CURRENT_YEAR = (/* @__PURE__ */ new Date()).getFullYear();
+function registerGstTools(server2, client2) {
+  server2.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\u201312 (1 = January, 3 = March, etc.)."
+    ].join(" "),
+    {
+      month: z7.number().int().min(1).max(12).describe("Month number (1 = January, 12 = December)."),
+      year: z7.number().int().min(2020).max(CURRENT_YEAR + 1).describe(`Year, e.g. ${CURRENT_YEAR}.`)
+    },
+    wrapTool(async (input) => {
+      const result = await client2.gst.gstr1CSV({ month: input.month, year: input.year });
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(result, null, 2)
+        }]
+      };
+    })
+  );
+  server2.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 \u2014 use this to answer 'What is our GST liability for March 2024?' or 'How much ITC can we claim this month?'",
+      "Month is 1\u201312 (1 = January, 3 = March, etc.).",
+      "Example: { report_type: 'gstr3b', month: 3, year: 2024 } for March 2024 GSTR3B."
+    ].join(" "),
+    {
+      report_type: z7.enum(["gstr1", "gstr3b"]).describe("'gstr1' for outward supplies (sales) report. 'gstr3b' for monthly summary return."),
+      month: z7.number().int().min(1).max(12).describe("Month number (1 = January, 12 = December)."),
+      year: z7.number().int().min(2020).max(CURRENT_YEAR + 1).describe(`Year, e.g. ${CURRENT_YEAR}.`)
+    },
+    wrapTool(async (input) => {
+      const report = input.report_type === "gstr1" ? await client2.gst.gstr1({ month: input.month, year: input.year }) : await client2.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",
+          text: JSON.stringify(
+            {
+              ...report,
+              _meta: {
+                reportType: input.report_type.toUpperCase(),
+                period: `${monthName} ${input.year}`
+              }
+            },
+            null,
+            2
+          )
+        }]
+      };
+    })
+  );
+}
+
+// src/tools/shipment.ts
+import { z as z8 } from "zod";
+var SHIPMENT_STATUSES = ["pending", "shipped", "in_transit", "delivered", "returned"];
+function registerShipmentTools(server2, client2) {
+  server2.tool(
+    "shipment_list",
+    [
+      "List shipments for the active business with optional filters.",
+      "Use status='pending' to find shipments not yet dispatched, or status='in_transit' for active deliveries.",
+      "Filter by invoice_id to see all shipments for a specific invoice, or by party_id for a specific customer."
+    ].join(" "),
+    {
+      status: z8.enum(SHIPMENT_STATUSES).optional().describe("Filter by shipment status: 'pending', 'shipped', 'in_transit', 'delivered', or 'returned'."),
+      invoice_id: z8.string().uuid().optional().describe("Filter shipments linked to a specific invoice UUID."),
+      party_id: z8.string().uuid().optional().describe("Filter shipments for a specific customer/party UUID."),
+      page: z8.number().int().min(1).default(1).describe("Page number for pagination.")
+    },
+    wrapTool(async (input) => {
+      const result = await client2.shipment.list({
+        status: input.status,
+        invoiceId: input.invoice_id,
+        partyId: input.party_id,
+        page: input.page,
+        limit: MAX_PAGE_SIZE
+      });
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(withPaginationMeta(result), null, 2)
+        }]
+      };
+    })
+  );
+  server2.tool(
+    "shipment_get",
+    [
+      "Get full details of a single shipment, including tracking info, carrier, address, and delivery dates.",
+      "If the carrier is one of the 7 pre-configured Indian carriers (Delhivery, BlueDart, DTDC, Ecom Express, India Post, Shadowfax, Xpressbees), a tracking URL is auto-generated."
+    ].join(" "),
+    {
+      shipment_id: z8.string().uuid().describe("Shipment UUID from shipment_list.")
+    },
+    wrapTool(async (input) => {
+      const shipment = await client2.shipment.get(input.shipment_id);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(shipment, null, 2)
+        }]
+      };
+    })
+  );
+  server2.tool(
+    "shipment_create",
+    [
+      "Create a new shipment record for an invoice or party.",
+      "For known carriers (Delhivery, BlueDart, DTDC, Ecom Express, India Post, Shadowfax, Xpressbees), providing carrier + tracking_number auto-generates the tracking URL.",
+      "For custom carriers, provide tracking_url manually.",
+      "Cost is the shipping cost charged; weight is the parcel weight in kg."
+    ].join(" "),
+    {
+      invoice_id: z8.string().uuid().optional().describe("Link this shipment to an invoice UUID. Use shipment_list to avoid duplicates."),
+      party_id: z8.string().uuid().optional().describe("Customer/party UUID for this shipment."),
+      carrier: z8.string().max(100).optional().describe("Carrier name, e.g. 'Delhivery', 'BlueDart', 'DTDC'. Known carriers get auto-tracking URLs."),
+      mode: z8.string().max(50).optional().describe("Delivery mode, e.g. 'surface', 'air', 'express'. Matches business custom shipping methods."),
+      tracking_number: z8.string().max(200).optional().describe("AWB/tracking number from the carrier. Required for auto-generating tracking URL."),
+      tracking_url: z8.string().max(500).optional().describe("Manual tracking URL if carrier is not in the pre-configured list."),
+      cost: z8.string().regex(/^\d+(\.\d{1,2})?$/).optional().describe("Shipping cost as decimal string, e.g. '250.00'. Default '0'."),
+      weight: z8.string().regex(/^\d+(\.\d{1,3})?$/).optional().describe("Parcel weight in kg as decimal string, e.g. '2.500'."),
+      shipping_address: z8.string().optional().describe("Delivery address (street/flat/block)."),
+      shipping_city: z8.string().optional().describe("Delivery city."),
+      shipping_pincode: z8.string().optional().describe("Delivery PIN code."),
+      status: z8.enum(SHIPMENT_STATUSES).optional().describe("Initial status. Default 'pending'. Set 'shipped' if already dispatched."),
+      shipment_date: z8.string().datetime().optional().describe("Date the parcel was dispatched (ISO 8601). Defaults to today."),
+      estimated_delivery: z8.string().datetime().optional().describe("Expected delivery date (ISO 8601)."),
+      notes: z8.string().optional().describe("Internal notes about this shipment.")
+    },
+    wrapTool(async (input) => {
+      const shipment = await client2.shipment.create({
+        invoiceId: input.invoice_id,
+        partyId: input.party_id,
+        carrier: input.carrier,
+        mode: input.mode,
+        trackingNumber: input.tracking_number,
+        trackingUrl: input.tracking_url,
+        cost: input.cost,
+        weight: input.weight,
+        shippingAddress: input.shipping_address,
+        shippingCity: input.shipping_city,
+        shippingPincode: input.shipping_pincode,
+        status: input.status,
+        shipmentDate: input.shipment_date,
+        estimatedDelivery: input.estimated_delivery,
+        notes: input.notes
+      });
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(shipment, null, 2)
+        }]
+      };
+    })
+  );
+  server2.tool(
+    "shipment_update",
+    [
+      "Update a shipment's status, tracking information, or delivery dates.",
+      "Use this to mark a shipment as shipped (set status='shipped'), in transit, or delivered.",
+      "Setting status='delivered' automatically records the actual delivery date if not provided.",
+      "Update tracking_number to trigger re-generation of the carrier tracking URL."
+    ].join(" "),
+    {
+      shipment_id: z8.string().uuid().describe("Shipment UUID to update."),
+      carrier: z8.string().max(100).optional().describe("Updated carrier name."),
+      mode: z8.string().max(50).optional().describe("Updated delivery mode."),
+      tracking_number: z8.string().max(200).optional().describe("Updated tracking/AWB number. Re-generates tracking URL for known carriers."),
+      tracking_url: z8.string().max(500).optional().describe("Manual tracking URL override."),
+      cost: z8.string().regex(/^\d+(\.\d{1,2})?$/).optional().describe("Updated shipping cost as decimal string."),
+      weight: z8.string().regex(/^\d+(\.\d{1,3})?$/).optional().describe("Updated parcel weight in kg."),
+      status: z8.enum(SHIPMENT_STATUSES).optional().describe("New status. 'shipped' = dispatched. 'in_transit' = en route. 'delivered' = received. 'returned' = sent back."),
+      shipment_date: z8.string().datetime().optional().describe("Updated dispatch date (ISO 8601)."),
+      estimated_delivery: z8.string().datetime().optional().describe("Updated estimated delivery date (ISO 8601)."),
+      actual_delivery: z8.string().datetime().optional().describe("Actual delivery date (ISO 8601). Auto-set when status becomes 'delivered' if omitted."),
+      notes: z8.string().optional().describe("Updated notes.")
+    },
+    wrapTool(async (input) => {
+      const shipment = await client2.shipment.update({
+        id: input.shipment_id,
+        carrier: input.carrier,
+        mode: input.mode,
+        trackingNumber: input.tracking_number,
+        trackingUrl: input.tracking_url,
+        cost: input.cost,
+        weight: input.weight,
+        status: input.status,
+        shipmentDate: input.shipment_date,
+        estimatedDelivery: input.estimated_delivery,
+        actualDelivery: input.actual_delivery,
+        notes: input.notes
+      });
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(shipment, null, 2)
+        }]
+      };
+    })
+  );
+  server2.tool(
+    "shipment_delete",
+    [
+      "Delete a shipment record. This is a hard delete \u2014 the shipment record is permanently removed.",
+      "Requires admin role. Use with caution; prefer updating status to 'returned' instead of deleting."
+    ].join(" "),
+    {
+      shipment_id: z8.string().uuid().describe("Shipment UUID to delete.")
+    },
+    wrapTool(async (input) => {
+      const result = await client2.shipment.delete(input.shipment_id);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(result, null, 2)
+        }]
+      };
+    })
+  );
+}
+
+// src/tools/bankAccount.ts
+import { z as z9 } from "zod";
+var ACCOUNT_TYPES = ["savings", "current", "cash", "credit", "other"];
+function registerBankAccountTools(server2, client2) {
+  server2.tool(
+    "bank_account_list",
+    [
+      "List all bank and cash accounts for the active business, including current balances.",
+      "Use this to find account UUIDs before recording payments or transfers.",
+      "The 'currentBalance' field reflects the running balance after all recorded transactions.",
+      "The default account (isDefault=true) is used automatically when no account is specified in payment_create."
+    ].join(" "),
+    {},
+    wrapTool(async (_input) => {
+      const accounts = await client2.bankAccount.list();
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(accounts, null, 2)
+        }]
+      };
+    })
+  );
+  server2.tool(
+    "bank_account_get",
+    [
+      "Get details of a single bank account including its 20 most recent transactions.",
+      "Use this to check an account's running balance and recent activity."
+    ].join(" "),
+    {
+      account_id: z9.string().uuid().describe("Bank account UUID from bank_account_list.")
+    },
+    wrapTool(async (input) => {
+      const account = await client2.bankAccount.get(input.account_id);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(account, null, 2)
+        }]
+      };
+    })
+  );
+  server2.tool(
+    "bank_account_create",
+    [
+      "Create a new bank account or cash account for the business.",
+      "Use account_type='cash' for a physical cash register/petty cash account.",
+      "Use account_type='savings' or 'current' for bank accounts.",
+      "opening_balance sets the starting balance (e.g. the balance when you started using Hisaabo).",
+      "Set is_default=true to make this the default account for payment recording."
+    ].join(" "),
+    {
+      account_name: z9.string().min(1).max(200).describe("Display name, e.g. 'HDFC Current Account' or 'Petty Cash'."),
+      account_type: z9.enum(ACCOUNT_TYPES).describe("'savings', 'current', 'cash' (petty cash/physical cash), 'credit', or 'other'."),
+      account_number: z9.string().max(34).optional().describe("Bank account number (not required for cash accounts)."),
+      ifsc: z9.string().max(11).optional().describe("IFSC code, e.g. 'HDFC0001234'. Required for bank transfers."),
+      bank_name: z9.string().max(200).optional().describe("Bank name, e.g. 'HDFC Bank', 'State Bank of India'."),
+      opening_balance: z9.string().regex(/^-?\d+(\.\d{1,2})?$/).optional().describe("Opening balance as decimal string. Default '0'. Use the current account balance when onboarding."),
+      is_default: z9.boolean().optional().describe("If true, this becomes the default account. Any previous default is cleared.")
+    },
+    wrapTool(async (input) => {
+      const account = await client2.bankAccount.create({
+        accountName: input.account_name,
+        accountType: input.account_type,
+        accountNumber: input.account_number,
+        ifsc: input.ifsc,
+        bankName: input.bank_name,
+        openingBalance: input.opening_balance,
+        isDefault: input.is_default
+      });
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(account, null, 2)
+        }]
+      };
+    })
+  );
+  server2.tool(
+    "bank_account_transfer",
+    [
+      "Transfer funds between two of the business's bank/cash accounts.",
+      "Creates a withdrawal transaction on the source account and a deposit on the destination.",
+      "Use this to record moving cash to the bank, or inter-account transfers.",
+      "Example: transfer from 'Petty Cash' to 'HDFC Current Account' to replenish cash."
+    ].join(" "),
+    {
+      from_account_id: z9.string().uuid().describe("UUID of the source account (funds leave this account)."),
+      to_account_id: z9.string().uuid().describe("UUID of the destination account (funds arrive here). Must differ from from_account_id."),
+      amount: z9.string().regex(/^\d+(\.\d{1,2})?$/).describe("Transfer amount as decimal string, e.g. '5000.00'."),
+      description: z9.string().max(500).optional().describe("Description of the transfer, e.g. 'Monthly cash deposit to bank'."),
+      transaction_date: z9.string().datetime().optional().describe("Date of the transfer (ISO 8601). Defaults to today.")
+    },
+    wrapTool(async (input) => {
+      const result = await client2.bankAccount.transfer({
+        fromAccountId: input.from_account_id,
+        toAccountId: input.to_account_id,
+        amount: input.amount,
+        description: input.description,
+        transactionDate: input.transaction_date
+      });
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(result, null, 2)
+        }]
+      };
+    })
+  );
+  server2.tool(
+    "bank_account_transactions",
+    [
+      "List transactions for a specific bank or cash account with date and type filters.",
+      "Each transaction includes a 'balanceAfter' field showing the running balance.",
+      "Use type='deposit' to see only incoming funds, 'withdrawal' for outgoing, 'transfer' for inter-account moves."
+    ].join(" "),
+    {
+      account_id: z9.string().uuid().describe("Bank account UUID from bank_account_list."),
+      from_date: z9.string().datetime().optional().describe("Start date (ISO 8601)."),
+      to_date: z9.string().datetime().optional().describe("End date (ISO 8601)."),
+      type: z9.enum(["deposit", "withdrawal", "transfer"]).optional().describe("Filter by transaction type."),
+      page: z9.number().int().min(1).default(1).describe("Page number for pagination.")
+    },
+    wrapTool(async (input) => {
+      const result = await client2.bankAccount.listTransactions({
+        bankAccountId: input.account_id,
+        fromDate: input.from_date,
+        toDate: input.to_date,
+        type: input.type,
+        page: input.page,
+        limit: MAX_PAGE_SIZE
+      });
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(withPaginationMeta(result), null, 2)
+        }]
+      };
+    })
+  );
+  server2.tool(
+    "bank_account_summary",
+    [
+      "Get a summary of total funds across all bank and cash accounts.",
+      "Returns totalBalance (all accounts), cashInHand (cash-type accounts only), bankBalance (non-cash accounts), and account count.",
+      "Use this to quickly answer 'How much money do we have in total?' or 'What is our cash in hand?'"
+    ].join(" "),
+    {},
+    wrapTool(async (_input) => {
+      const summary = await client2.bankAccount.summary();
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(summary, null, 2)
+        }]
+      };
+    })
+  );
+}
+
+// src/tools/reports.ts
+import { z as z10 } from "zod";
+var CURRENT_YEAR2 = (/* @__PURE__ */ new Date()).getFullYear();
+function registerReportTools(server2, client2) {
+  server2.tool(
+    "report_daybook",
+    [
+      "Get the daybook (daily transaction log) for a date range.",
+      "Returns all invoices, payments, and expenses in chronological order with debit/credit columns.",
+      "Use type_filter to narrow to only invoices, payments, or expenses.",
+      "The summary shows totals: sales invoiced, purchases invoiced, payments received, payments made, expenses, and net cash movement.",
+      "Dates are plain date strings (YYYY-MM-DD), not ISO datetime."
+    ].join(" "),
+    {
+      from_date: z10.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("Start date in YYYY-MM-DD format, e.g. '2024-04-01'."),
+      to_date: z10.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("End date in YYYY-MM-DD format, e.g. '2024-04-30'."),
+      type_filter: z10.enum(["all", "invoices", "payments", "expenses"]).default("all").describe("'all' = everything, 'invoices' = only invoice entries, 'payments' = only payment entries, 'expenses' = only expense entries.")
+    },
+    wrapTool(async (input) => {
+      const result = await client2.reports.daybook({
+        fromDate: input.from_date,
+        toDate: input.to_date,
+        typeFilter: input.type_filter
+      });
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(result, null, 2)
+        }]
+      };
+    })
+  );
+  server2.tool(
+    "report_outstanding",
+    [
+      "Get outstanding receivables (what customers owe you) and/or payables (what you owe suppliers).",
+      "Results are grouped by party with aging buckets: current (0-30 days), 31-60 days, 61-90 days, 90+ days.",
+      "Use type='receivable' for unpaid customer invoices, 'payable' for unpaid supplier bills, 'both' for all.",
+      "as_of_date lets you see outstanding amounts as of a specific past date."
+    ].join(" "),
+    {
+      type: z10.enum(["receivable", "payable", "both"]).default("receivable").describe("'receivable' = unpaid customer invoices, 'payable' = unpaid supplier bills, 'both' = all outstanding."),
+      as_of_date: z10.string().datetime().optional().describe("Calculate outstanding as of this date (ISO 8601). Defaults to today.")
+    },
+    wrapTool(async (input) => {
+      const result = await client2.reports.outstanding({
+        type: input.type,
+        asOfDate: input.as_of_date
+      });
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(result, null, 2)
+        }]
+      };
+    })
+  );
+  server2.tool(
+    "report_tax_summary",
+    [
+      "Get a tax summary (GST collected/paid) for a date range, broken down by tax rate.",
+      "Use this to answer 'How much GST did we collect this month?' or 'What is our total ITC (input tax credit)?'",
+      "Results are grouped by tax rate (0%, 5%, 12%, 18%, 28%) showing taxable amount and tax amount.",
+      "type='sales' = output tax (collected from customers), 'purchases' = input tax (ITC from suppliers)."
+    ].join(" "),
+    {
+      from_date: z10.string().datetime().describe("Start date (ISO 8601)."),
+      to_date: z10.string().datetime().describe("End date (ISO 8601)."),
+      type: z10.enum(["sales", "purchases", "both"]).default("both").describe("'sales' = tax on outward supplies, 'purchases' = input tax credit, 'both' = combined.")
+    },
+    wrapTool(async (input) => {
+      const result = await client2.reports.taxSummary({
+        fromDate: input.from_date,
+        toDate: input.to_date,
+        type: input.type
+      });
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(result, null, 2)
+        }]
+      };
+    })
+  );
+  server2.tool(
+    "report_item_sales",
+    [
+      "Get item-wise sales analysis for a date range.",
+      "Returns revenue, quantity sold, invoice count, and margin for each item.",
+      "Use sort_by to rank items by revenue (default), quantity, number of invoices, or profit margin.",
+      "Use compare_to_previous=true to include comparison with the equivalent prior period.",
+      "Use this to answer 'What were our top-selling products this quarter?' or 'Which items have the best margins?'"
+    ].join(" "),
+    {
+      from_date: z10.string().datetime().describe("Start date (ISO 8601)."),
+      to_date: z10.string().datetime().describe("End date (ISO 8601)."),
+      category: z10.string().max(100).optional().describe("Filter by item category."),
+      item_type: z10.enum(["product", "service"]).optional().describe("'product' for physical goods, 'service' for services."),
+      sort_by: z10.enum(["revenue", "quantity", "invoices", "margin"]).default("revenue").describe("Sort by: 'revenue' (total sales amount), 'quantity' (units sold), 'invoices' (order count), 'margin' (profit)."),
+      compare_to_previous: z10.boolean().default(false).describe("If true, include comparison data from the previous equivalent period.")
+    },
+    wrapTool(async (input) => {
+      const result = await client2.reports.itemSales({
+        fromDate: input.from_date,
+        toDate: input.to_date,
+        category: input.category,
+        itemType: input.item_type,
+        sortBy: input.sort_by,
+        compareToPrevious: input.compare_to_previous
+      });
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(result, null, 2)
+        }]
+      };
+    })
+  );
+  server2.tool(
+    "report_stock_summary",
+    [
+      "Get current stock levels and values for all inventory items.",
+      "Returns quantity on hand, sale value, and purchase value for each product.",
+      "Use category to filter by product category.",
+      "Set show_zero_stock=true to include items with zero stock (useful for identifying out-of-stock items).",
+      "Use this to answer 'What is the total value of our inventory?' or 'Which products are out of stock?'"
+    ].join(" "),
+    {
+      category: z10.string().max(100).optional().describe("Filter by item category."),
+      show_zero_stock: z10.boolean().default(false).describe("If true, include items with zero stock. Default false (only items with stock > 0).")
+    },
+    wrapTool(async (input) => {
+      const result = await client2.reports.stockSummary({
+        category: input.category,
+        showZeroStock: input.show_zero_stock
+      });
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(result, null, 2)
+        }]
+      };
+    })
+  );
+  server2.tool(
+    "report_party_statement",
+    [
+      "Get a party (customer or supplier) account statement showing all transactions and running balance.",
+      "Returns invoices, payments, credit notes, and other entries in chronological order.",
+      "Use this to answer 'Show me the complete transaction history with Customer X' or 'What is the account statement for this supplier?'",
+      "Note: for a quick balance only, use party_get instead."
+    ].join(" "),
+    {
+      party_id: z10.string().uuid().describe("Party UUID from party_list or party_get."),
+      from_date: z10.string().datetime().optional().describe("Start date for the statement (ISO 8601). Omit for full history."),
+      to_date: z10.string().datetime().optional().describe("End date for the statement (ISO 8601).")
+    },
+    wrapTool(async (input) => {
+      const result = await client2.reports.partyStatement({
+        partyId: input.party_id,
+        fromDate: input.from_date,
+        toDate: input.to_date
+      });
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(result, null, 2)
+        }]
+      };
+    })
+  );
+  server2.tool(
+    "report_payment_summary",
+    [
+      "Get a payment summary showing trends by payment mode (cash, UPI, bank, cheque) over a date range.",
+      "Use type='received' for incoming payments from customers, 'made' for payments to suppliers, 'both' for all.",
+      "Filter by bank_account_id to see payments for a specific account.",
+      "Use this to answer 'How much did we receive via UPI this month?' or 'What were our total bank deposits?'"
+    ].join(" "),
+    {
+      from_date: z10.string().datetime().describe("Start date (ISO 8601)."),
+      to_date: z10.string().datetime().describe("End date (ISO 8601)."),
+      type: z10.enum(["received", "made", "both"]).default("both").describe("'received' = payments from customers, 'made' = payments to suppliers, 'both' = all."),
+      bank_account_id: z10.string().uuid().optional().describe("Filter to payments recorded against a specific bank/cash account.")
+    },
+    wrapTool(async (input) => {
+      const result = await client2.reports.paymentSummary({
+        fromDate: input.from_date,
+        toDate: input.to_date,
+        type: input.type,
+        bankAccountId: input.bank_account_id
+      });
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(result, null, 2)
+        }]
+      };
+    })
+  );
+}
+
+// src/tools/store.ts
+import { z as z11 } from "zod";
+var ORDER_STATUSES = ["pending", "confirmed", "preparing", "ready", "delivered", "cancelled"];
+function registerStoreTools(server2, client2) {
+  server2.tool(
+    "store_settings",
+    [
+      "Get the current online store configuration for the active business.",
+      "Returns whether the store is enabled, the store URL slug, tagline, accent color, minimum order amount, and order prefix.",
+      "If storeEnabled=false, the public store is not accessible.",
+      "The store URL is: https://<storeSlug>.hisaabo.in (when enabled)."
+    ].join(" "),
+    {},
+    wrapTool(async (_input) => {
+      const settings = await client2.store.getSettings();
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(settings, null, 2)
+        }]
+      };
+    })
+  );
+  server2.tool(
+    "store_update_settings",
+    [
+      "Update the online store configuration.",
+      "Enable/disable the store, change the URL slug, tagline, accent color, minimum order amount, etc.",
+      "store_slug must be unique across all businesses and match the pattern: lowercase letters, numbers, and hyphens.",
+      "Setting store_enabled=true activates the public storefront."
+    ].join(" "),
+    {
+      store_enabled: z11.boolean().optional().describe("Enable (true) or disable (false) the public storefront."),
+      store_slug: z11.string().min(3).max(50).regex(/^[a-z0-9][a-z0-9-]*[a-z0-9]$/).optional().nullable().describe("URL slug for the store, e.g. 'acme-traders'. Must be lowercase alphanumeric with hyphens."),
+      store_tagline: z11.string().max(200).optional().nullable().describe("Short tagline shown on the store homepage, e.g. 'Fresh groceries delivered daily'."),
+      store_accent_color: z11.string().regex(/^#[0-9a-fA-F]{6}$/).optional().nullable().describe("Brand accent color as hex code, e.g. '#FF5722'."),
+      store_min_order_amount: z11.string().regex(/^\d+(\.\d{1,2})?$/).optional().nullable().describe("Minimum order value as decimal string, e.g. '200.00'. Null to remove minimum."),
+      store_delivery_note: z11.string().max(500).optional().nullable().describe("Note shown at checkout about delivery, e.g. 'Delivery within 2 hours in city limits'."),
+      store_whatsapp_number: z11.string().max(15).optional().nullable().describe("WhatsApp number for order notifications (digits only)."),
+      store_allow_negative_stock: z11.boolean().optional().describe("If true, orders can be placed even when stock is zero or negative."),
+      store_order_prefix: z11.string().min(1).max(10).optional().describe("Prefix for store order numbers, e.g. 'ORD'. Default 'ORD'.")
+    },
+    wrapTool(async (input) => {
+      const settings = await client2.store.updateSettings({
+        storeEnabled: input.store_enabled,
+        storeSlug: input.store_slug,
+        storeTagline: input.store_tagline,
+        storeAccentColor: input.store_accent_color,
+        storeMinOrderAmount: input.store_min_order_amount,
+        storeDeliveryNote: input.store_delivery_note,
+        storeWhatsappNumber: input.store_whatsapp_number,
+        storeAllowNegativeStock: input.store_allow_negative_stock,
+        storeOrderPrefix: input.store_order_prefix
+      });
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(settings, null, 2)
+        }]
+      };
+    })
+  );
+  server2.tool(
+    "store_orders",
+    [
+      "List customer orders placed through the online store.",
+      "Orders progress through statuses: pending \u2192 confirmed \u2192 preparing \u2192 ready \u2192 delivered.",
+      "Use status='pending' to find new orders requiring attention.",
+      "Search by customer name, phone number, or order number."
+    ].join(" "),
+    {
+      status: z11.enum(ORDER_STATUSES).optional().describe("Filter by order status. 'pending' = new orders awaiting confirmation."),
+      from_date: z11.string().datetime().optional().describe("Filter orders placed on or after this date (ISO 8601)."),
+      to_date: z11.string().datetime().optional().describe("Filter orders placed on or before this date (ISO 8601)."),
+      search: z11.string().max(200).optional().describe("Search by customer name, phone number, or order number."),
+      page: z11.number().int().min(1).default(1).describe("Page number for pagination.")
+    },
+    wrapTool(async (input) => {
+      const result = await client2.store.listOrders({
+        status: input.status,
+        fromDate: input.from_date,
+        toDate: input.to_date,
+        search: input.search,
+        page: input.page,
+        limit: MAX_PAGE_SIZE
+      });
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(withPaginationMeta(result), null, 2)
+        }]
+      };
+    })
+  );
+  server2.tool(
+    "store_order_get",
+    [
+      "Get full details of a single store order, including line items and linked invoice.",
+      "If the order has been confirmed, it will have a linked invoice (invoiceId) in the response."
+    ].join(" "),
+    {
+      order_id: z11.string().uuid().describe("Store order UUID from store_orders.")
+    },
+    wrapTool(async (input) => {
+      const order = await client2.store.getOrder(input.order_id);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(order, null, 2)
+        }]
+      };
+    })
+  );
+  server2.tool(
+    "store_order_update",
+    [
+      "Update a confirmed store order's status to 'preparing', 'ready', or 'delivered'.",
+      "Orders must be confirmed first (status='confirmed') before they can be updated.",
+      "Use 'preparing' when the order is being packed, 'ready' when ready for pickup/delivery, 'delivered' when handed to customer.",
+      "To confirm a pending order or cancel an order, use the Hisaabo web app \u2014 those actions also update the linked invoice."
+    ].join(" "),
+    {
+      order_id: z11.string().uuid().describe("Store order UUID."),
+      status: z11.enum(["preparing", "ready", "delivered"]).describe("New status: 'preparing' (being packed), 'ready' (ready to deliver), 'delivered' (handed to customer).")
+    },
+    wrapTool(async (input) => {
+      const result = await client2.store.updateOrderStatus({
+        orderId: input.order_id,
+        status: input.status
+      });
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(result, null, 2)
+        }]
+      };
+    })
+  );
+}
+
+// src/tools/target.ts
+import { z as z12 } from "zod";
+var TARGET_TYPES = ["order_count", "order_value", "item_quantity"];
+var PERIOD_TYPES = ["daily", "weekly", "monthly", "quarterly", "custom"];
+function registerTargetTools(server2, client2) {
+  server2.tool(
+    "target_list",
+    [
+      "List sales targets for the active business (admin/viewer view).",
+      "Filter by user, period type, or active targets only.",
+      "Set with_progress=true to include real-time progress (current vs target, percentage, on-track status).",
+      "Use user_id to see targets for a specific seller."
+    ].join(" "),
+    {
+      user_id: z12.string().uuid().optional().describe("Filter targets assigned to a specific user UUID."),
+      period_type: z12.enum(PERIOD_TYPES).optional().describe("Filter by period: 'daily', 'weekly', 'monthly', 'quarterly', or 'custom'."),
+      active: z12.boolean().optional().describe("If true, return only targets whose period includes today (active targets)."),
+      with_progress: z12.boolean().default(false).describe("If true, compute and return real-time progress for each target. Adds latency.")
+    },
+    wrapTool(async (input) => {
+      const targets = await client2.target.list({
+        userId: input.user_id,
+        periodType: input.period_type,
+        active: input.active,
+        withProgress: input.with_progress
+      });
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(targets, null, 2)
+        }]
+      };
+    })
+  );
+  server2.tool(
+    "target_create",
+    [
+      "Create a sales target for a seller. Requires admin role.",
+      "target_type options: 'order_count' (number of invoices), 'order_value' (total revenue), 'item_quantity' (units sold of a specific item).",
+      "For 'item_quantity' targets, item_id is required.",
+      "period_start and period_end define the target window. Use period_type to categorize (daily/weekly/monthly/quarterly/custom).",
+      "Example: set a monthly revenue target of \u20B91,00,000 for a seller."
+    ].join(" "),
+    {
+      user_id: z12.string().uuid().describe("UUID of the seller this target is assigned to."),
+      target_type: z12.enum(TARGET_TYPES).describe("'order_count' = number of invoices, 'order_value' = total revenue amount, 'item_quantity' = units of a specific item sold."),
+      target_value: z12.string().regex(/^\d+(\.\d{1,2})?$/).describe("Target value as decimal string: e.g. '100000.00' for \u20B91 lakh revenue, or '50' for 50 orders."),
+      item_id: z12.string().uuid().optional().nullable().describe("Required for 'item_quantity' targets \u2014 the specific item UUID to track."),
+      period_type: z12.enum(PERIOD_TYPES).describe("Categorization: 'daily', 'weekly', 'monthly', 'quarterly', or 'custom'."),
+      period_start: z12.string().datetime().describe("Start of the target period (ISO 8601)."),
+      period_end: z12.string().datetime().describe("End of the target period (ISO 8601). Must be after period_start."),
+      notes: z12.string().max(500).optional().nullable().describe("Optional notes about this target, e.g. 'Q1 FY2025 target'.")
+    },
+    wrapTool(async (input) => {
+      const target = await client2.target.create({
+        userId: input.user_id,
+        targetType: input.target_type,
+        targetValue: input.target_value,
+        itemId: input.item_id,
+        periodType: input.period_type,
+        periodStart: input.period_start,
+        periodEnd: input.period_end,
+        notes: input.notes
+      });
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(target, null, 2)
+        }]
+      };
+    })
+  );
+  server2.tool(
+    "target_progress",
+    [
+      "Get real-time progress for a specific sales target.",
+      "Returns current achievement, target value, percentage, remaining amount, and whether the seller is on track.",
+      "Also shows timeline: days total, days elapsed, days remaining.",
+      "'onTrack' is true if current progress is >= what it should be based on time elapsed."
+    ].join(" "),
+    {
+      target_id: z12.string().uuid().describe("Target UUID from target_list.")
+    },
+    wrapTool(async (input) => {
+      const result = await client2.target.getProgress(input.target_id);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(result, null, 2)
+        }]
+      };
+    })
+  );
+  server2.tool(
+    "target_my",
+    [
+      "Get the current user's active sales targets with real-time progress.",
+      "Returns targets whose period includes today, with progress data for each.",
+      "Sellers use this to check their own performance without needing admin access."
+    ].join(" "),
+    {},
+    wrapTool(async (_input) => {
+      const targets = await client2.target.myTargets();
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(targets, null, 2)
+        }]
+      };
+    })
+  );
+}
+
+// src/tools/import.ts
+import { z as z13 } from "zod";
+function registerImportTools(server2, client2) {
+  server2.tool(
+    "import_parties",
+    [
+      "Batch import customers and/or suppliers. Requires admin role.",
+      "Duplicates (same name, case-insensitive) are automatically skipped \u2014 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: z13.string().default("excel").describe("Source system name, e.g. 'mybillbook', 'tally', 'excel'. Used for audit trail."),
+      parties: z13.array(z13.object({
+        name: z13.string().min(1).max(200).describe("Party name. Duplicate names (case-insensitive) are skipped."),
+        type: z13.enum(["customer", "supplier"]).default("customer").describe("'customer' for buyers, 'supplier' for sellers."),
+        phone: z13.string().max(15).optional().describe("Phone number."),
+        email: z13.string().optional().describe("Email address."),
+        gstin: z13.string().optional().describe("GST Identification Number (15 chars)."),
+        pan: z13.string().optional().describe("PAN number."),
+        opening_balance: z13.string().optional().describe("Opening balance as decimal string. Positive = they owe you. Default '0'."),
+        billing_address: z13.string().optional().describe("Billing address."),
+        shipping_address: z13.string().optional().describe("Shipping address (if different from billing)."),
+        city: z13.string().optional().describe("City."),
+        state: z13.string().optional().describe("State name."),
+        pincode: z13.string().optional().describe("PIN code.")
+      })).min(1).max(5e3).describe("Array of party records to import. Max 5000 per call.")
+    },
+    wrapTool(async (input) => {
+      const result = await client2.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",
+          text: JSON.stringify(result, null, 2)
+        }]
+      };
+    })
+  );
+  server2.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\u2192kg, PCS\u2192pcs, LTR\u2192l, BOX\u2192box, etc.",
+      "Stock quantity is always set to 0 on import \u2014 use import_invoices or item_adjust_stock to build stock from history."
+    ].join(" "),
+    {
+      source: z13.string().default("excel").describe("Source system name for audit trail."),
+      items: z13.array(z13.object({
+        name: z13.string().min(1).max(200).describe("Item name. Duplicates (case-insensitive) are skipped."),
+        item_type: z13.enum(["product", "service"]).default("product").describe("'product' for physical goods, 'service' for services."),
+        sale_price: z13.string().optional().describe("Default selling price as decimal string."),
+        purchase_price: z13.string().optional().describe("Default purchase price as decimal string."),
+        tax_percent: z13.string().default("0").describe("GST rate percentage, e.g. '18'. Default '0'."),
+        hsn: z13.string().optional().describe("HSN code for GST compliance."),
+        unit: z13.string().default("pcs").describe("Unit code. Common values: pcs, kg, l, box, m. Auto-mapped from MyBillBook/Tally format."),
+        sku: z13.string().optional().describe("SKU / product code."),
+        category: z13.string().optional().describe("Category name for grouping.")
+      })).min(1).max(5e3).describe("Array of item records to import. Max 5000 per call.")
+    },
+    wrapTool(async (input) => {
+      const result = await client2.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",
+          text: JSON.stringify(result, null, 2)
+        }]
+      };
+    })
+  );
+  server2.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: z13.string().default("excel").describe("Source system name for audit trail."),
+      auto_create_payments: z13.boolean().default(false).describe("If true, automatically create payment records for invoices with amountPaid > 0."),
+      default_payment_mode: z13.enum(["cash", "bank", "upi", "cheque", "other"]).default("cash").describe("Payment mode to use when auto-creating payments from paid invoices."),
+      invoices: z13.array(z13.object({
+        invoice_number: z13.string().min(1).describe("Invoice number. Duplicates are skipped."),
+        invoice_date: z13.string().describe("Invoice date (YYYY-MM-DD or DD/MM/YYYY or DD-MM-YYYY)."),
+        due_date: z13.string().optional().describe("Due date (same formats as invoice_date)."),
+        party_name: z13.string().min(1).describe("Exact party name \u2014 must match an existing party (case-insensitive)."),
+        type: z13.enum(["sale", "purchase"]).default("sale").describe("'sale' for customer invoice, 'purchase' for supplier bill."),
+        status: z13.enum(["draft", "sent", "paid", "partial", "overdue", "cancelled"]).default("sent").describe("Invoice status. Use 'paid' for fully paid historical invoices."),
+        total_amount: z13.string().describe("Total invoice amount including tax, as decimal string."),
+        amount_paid: z13.string().default("0").describe("Amount already paid. '0' for unpaid, same as total_amount for fully paid."),
+        subtotal: z13.string().default("0").describe("Pre-tax subtotal as decimal string."),
+        tax_amount: z13.string().default("0").describe("Total tax amount as decimal string."),
+        discount_amount: z13.string().default("0").describe("Total discount amount as decimal string."),
+        notes: z13.string().optional().describe("Invoice notes."),
+        line_items: z13.array(z13.object({
+          description: z13.string().describe("Line item description or product name."),
+          quantity: z13.string().default("1").describe("Quantity as decimal string."),
+          unit_price: z13.string().describe("Price per unit as decimal string."),
+          tax_percent: z13.string().default("0").describe("Tax rate percentage, e.g. '18'."),
+          discount_percent: z13.string().default("0").describe("Discount percentage."),
+          item_name: z13.string().optional().describe("If provided, links to an existing inventory item by name.")
+        })).optional().describe("Line items. Optional \u2014 if omitted, a single line item using total_amount is created.")
+      })).min(1).max(1e3).describe("Array of invoice records. Max 1000 per call.")
+    },
+    wrapTool(async (input) => {
+      const result = await client2.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",
+          text: JSON.stringify(result, null, 2)
+        }]
+      };
+    })
+  );
+  server2.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: z13.string().default("excel").describe("Source system name for audit trail."),
+      paid_invoice_numbers: z13.array(z13.string()).default([]).describe("List of invoice numbers that were fully paid in the source system. Used for auto-allocation fallback."),
+      payments: z13.array(z13.object({
+        party_name: z13.string().min(1).describe("Party name \u2014 must match an existing party (case-insensitive)."),
+        amount: z13.string().describe("Payment amount as decimal string."),
+        mode: z13.enum(["cash", "bank", "upi", "cheque", "other"]).default("cash").describe("Payment mode."),
+        payment_date: z13.string().optional().describe("Payment date (YYYY-MM-DD or DD/MM/YYYY)."),
+        payment_number: z13.string().optional().describe("Original payment number from source system."),
+        reference_number: z13.string().optional().describe("Transaction reference, cheque number, UTR, etc."),
+        notes: z13.string().optional().describe("Notes about this payment."),
+        invoice_numbers: z13.array(z13.string()).optional().describe("Explicit invoice numbers to allocate this payment against.")
+      })).min(1).max(5e3).describe("Array of payment records. Max 5000 per call.")
+    },
+    wrapTool(async (input) => {
+      const result = await client2.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",
+          text: JSON.stringify(result, null, 2)
+        }]
+      };
+    })
+  );
+}
+
+// src/resources/index.ts
+function registerResources(server2, client2) {
+  server2.resource(
+    "business_current",
+    "business://current",
+    async (_uri) => {
+      const biz = await client2.business.get();
+      return {
+        contents: [{
+          uri: "business://current",
+          text: JSON.stringify(biz, null, 2),
+          mimeType: "application/json"
+        }]
+      };
+    }
+  );
+  server2.resource(
+    "parties_customers",
+    "parties://customers",
+    async (_uri) => {
+      const result = await client2.party.list({
+        type: "customer",
+        sortBy: "name",
+        sortDir: "asc",
+        limit: 50,
+        page: 1
+      });
+      return {
+        contents: [{
+          uri: "parties://customers",
+          text: JSON.stringify(result.data, null, 2),
+          mimeType: "application/json"
+        }]
+      };
+    }
+  );
+  server2.resource(
+    "parties_suppliers",
+    "parties://suppliers",
+    async (_uri) => {
+      const result = await client2.party.list({
+        type: "supplier",
+        sortBy: "name",
+        sortDir: "asc",
+        limit: 50,
+        page: 1
+      });
+      return {
+        contents: [{
+          uri: "parties://suppliers",
+          text: JSON.stringify(result.data, null, 2),
+          mimeType: "application/json"
+        }]
+      };
+    }
+  );
+  server2.resource(
+    "items_inventory",
+    "items://inventory",
+    async (_uri) => {
+      const result = await client2.item.list({ limit: 100, page: 1 });
+      return {
+        contents: [{
+          uri: "items://inventory",
+          text: JSON.stringify(result.data, null, 2),
+          mimeType: "application/json"
+        }]
+      };
+    }
+  );
+  server2.resource(
+    "invoices_recent",
+    "invoices://recent",
+    async (_uri) => {
+      const result = await client2.invoice.list({
+        type: "sale",
+        limit: 10,
+        page: 1
+      });
+      return {
+        contents: [{
+          uri: "invoices://recent",
+          text: JSON.stringify(result.data, null, 2),
+          mimeType: "application/json"
+        }]
+      };
+    }
+  );
+  server2.resource(
+    "dashboard_summary",
+    "dashboard://summary",
+    async (_uri) => {
+      const summary = await client2.dashboard.summary();
+      return {
+        contents: [{
+          uri: "dashboard://summary",
+          text: JSON.stringify(summary, null, 2),
+          mimeType: "application/json"
+        }]
+      };
+    }
+  );
+  server2.resource(
+    "bank_accounts",
+    "bank://accounts",
+    async (_uri) => {
+      const accounts = await client2.bankAccount.list();
+      return {
+        contents: [{
+          uri: "bank://accounts",
+          text: JSON.stringify(accounts, null, 2),
+          mimeType: "application/json"
+        }]
+      };
+    }
+  );
+  server2.resource(
+    "shipments_recent",
+    "shipments://recent",
+    async (_uri) => {
+      const result = await client2.shipment.list({ page: 1, limit: 10 });
+      return {
+        contents: [{
+          uri: "shipments://recent",
+          text: JSON.stringify(result.data, null, 2),
+          mimeType: "application/json"
+        }]
+      };
+    }
+  );
+  server2.resource(
+    "targets_active",
+    "targets://active",
+    async (_uri) => {
+      const targets = await client2.target.list({ active: true, withProgress: true });
+      return {
+        contents: [{
+          uri: "targets://active",
+          text: JSON.stringify(targets, null, 2),
+          mimeType: "application/json"
+        }]
+      };
+    }
+  );
+}
+
+// src/server.ts
+function registerTools(server2, client2) {
+  registerInvoiceTools(server2, client2);
+  registerPartyTools(server2, client2);
+  registerItemTools(server2, client2);
+  registerPaymentTools(server2, client2);
+  registerExpenseTools(server2, client2);
+  registerDashboardTools(server2, client2);
+  registerGstTools(server2, client2);
+  registerReportTools(server2, client2);
+  registerShipmentTools(server2, client2);
+  registerBankAccountTools(server2, client2);
+  registerStoreTools(server2, client2);
+  registerTargetTools(server2, client2);
+  registerImportTools(server2, client2);
+  registerResources(server2, client2);
+}
+
+// src/index.ts
+function requireEnv(name) {
+  const val = process.env[name];
+  if (!val) {
+    process.stderr.write(
+      `[hisaabo-mcp] Error: Required environment variable "${name}" is not set.
+[hisaabo-mcp] Run "hisaabo whoami --json" to get all required values.
+`
+    );
+    process.exit(1);
+  }
+  return val;
+}
+var config = {
+  apiUrl: process.env.HISAABO_API_URL ?? "http://localhost:3000",
+  token: requireEnv("HISAABO_TOKEN"),
+  tenantId: requireEnv("HISAABO_TENANT_ID"),
+  businessId: requireEnv("HISAABO_BUSINESS_ID")
+};
+var client = new HisaaboClient(config);
+var server = new McpServer({
+  name: "hisaabo",
+  version: "0.1.0"
+});
+registerTools(server, client);
+var transport = new StdioServerTransport();
+await server.connect(transport);