@humanagencyp/erp-mcp 0.1.0

package/dist/index.js

@@ -0,0 +1,787 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  ListToolsRequestSchema,
+  CallToolRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/db.ts
+import { existsSync, mkdirSync, copyFileSync, statSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var SCHEMA = `
+CREATE TABLE IF NOT EXISTS items (
+  id TEXT PRIMARY KEY,
+  sku TEXT NOT NULL UNIQUE,
+  name TEXT NOT NULL,
+  unit TEXT NOT NULL DEFAULT 'pcs',
+  list_price REAL NOT NULL,
+  currency TEXT NOT NULL DEFAULT 'EUR',
+  stock INTEGER NOT NULL DEFAULT 0
+);
+
+CREATE TABLE IF NOT EXISTS customers (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  email TEXT,
+  country TEXT,
+  currency TEXT NOT NULL DEFAULT 'EUR',
+  credit_limit REAL NOT NULL DEFAULT 0,
+  open_balance REAL NOT NULL DEFAULT 0,
+  payment_terms TEXT
+);
+
+CREATE TABLE IF NOT EXISTS quotes (
+  id TEXT PRIMARY KEY,
+  number TEXT NOT NULL UNIQUE,
+  customer_id TEXT NOT NULL REFERENCES customers(id),
+  status TEXT CHECK(status IN ('draft','sent','converted','cancelled')) NOT NULL DEFAULT 'draft',
+  currency TEXT NOT NULL,
+  discount_pct REAL NOT NULL DEFAULT 0,
+  net_total REAL NOT NULL DEFAULT 0,
+  valid_until TEXT,
+  notes TEXT,
+  created_at TEXT DEFAULT (datetime('now')),
+  updated_at TEXT DEFAULT (datetime('now')),
+  sent_at TEXT,
+  receipt_id TEXT
+);
+
+CREATE TABLE IF NOT EXISTS quote_lines (
+  id TEXT PRIMARY KEY,
+  quote_id TEXT NOT NULL REFERENCES quotes(id) ON DELETE CASCADE,
+  item_id TEXT NOT NULL REFERENCES items(id),
+  qty INTEGER NOT NULL,
+  list_price REAL NOT NULL,
+  line_total REAL NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS orders (
+  id TEXT PRIMARY KEY,
+  number TEXT NOT NULL UNIQUE,
+  quote_id TEXT NOT NULL REFERENCES quotes(id),
+  customer_id TEXT NOT NULL REFERENCES customers(id),
+  status TEXT CHECK(status IN ('confirmed')) NOT NULL DEFAULT 'confirmed',
+  net_total REAL NOT NULL,
+  currency TEXT NOT NULL,
+  requested_delivery TEXT,
+  created_at TEXT DEFAULT (datetime('now')),
+  updated_at TEXT DEFAULT (datetime('now')),
+  receipt_id TEXT
+);
+`;
+var RECEIPT_ID_TABLES = ["quotes", "orders"];
+var SEED_ITEMS = [
+  // id, sku, name, unit, list_price, stock
+  ["item-1", "WIDGET-100", "Widget 100", "pcs", 25, 500],
+  ["item-2", "WIDGET-200", "Widget 200 Pro", "pcs", 45, 300],
+  ["item-3", "GEAR-A1", "Precision Gear A1", "pcs", 120, 80],
+  ["item-4", "GEAR-B2", "Precision Gear B2", "pcs", 150, 60],
+  ["item-5", "PANEL-S", "Control Panel S", "pcs", 89.5, 150],
+  ["item-6", "PANEL-L", "Control Panel L", "pcs", 149.5, 90],
+  ["item-7", "CABLE-5M", "Cable 5m", "pcs", 12, 1e3],
+  ["item-8", "SERVICE-KIT", "Maintenance Kit", "set", 340, 20]
+];
+var SEED_CUSTOMERS = [
+  // id, name, email, country, credit_limit, open_balance, payment_terms
+  ["cust-1", "Nordkap Manufacturing GmbH", "ap@nordkap.example", "DE", 5e4, 12e3, "NET30"],
+  ["cust-2", "Alpine Components AG", "finance@alpinecomp.example", "AT", 2e4, 4e3, "NET30"],
+  ["cust-3", "Baltic Retail Group", "accounts@balticretail.example", "LV", 8e3, 7500, "NET14"],
+  ["cust-4", "Meridian Industrial Ltd", "payables@meridianind.example", "IE", 1e5, 0, "NET60"],
+  ["cust-5", "Solstice Equipment Co", "finance@solsticeeq.example", "NL", 5e3, 4800, "NET7"]
+];
+function seedSqlite(db) {
+  const { count } = db.prepare("SELECT COUNT(*) as count FROM items").get();
+  if (count > 0) return;
+  const insertItem = db.prepare(
+    `INSERT INTO items (id, sku, name, unit, list_price, currency, stock) VALUES (?, ?, ?, ?, ?, 'EUR', ?)`
+  );
+  for (const [id, sku, name, unit, listPrice, stock] of SEED_ITEMS) {
+    insertItem.run(id, sku, name, unit, listPrice, stock);
+  }
+  const insertCustomer = db.prepare(
+    `INSERT INTO customers (id, name, email, country, currency, credit_limit, open_balance, payment_terms) VALUES (?, ?, ?, ?, 'EUR', ?, ?, ?)`
+  );
+  for (const [id, name, email, country, creditLimit, openBalance, terms] of SEED_CUSTOMERS) {
+    insertCustomer.run(id, name, email, country, creditLimit, openBalance, terms);
+  }
+}
+async function createSqliteDb(dbPath) {
+  const { default: Database } = await import("better-sqlite3");
+  const db = new Database(dbPath);
+  db.pragma("foreign_keys = ON");
+  db.exec(SCHEMA);
+  seedSqlite(db);
+  for (const table of RECEIPT_ID_TABLES) {
+    const cols = db.prepare(`PRAGMA table_info(${table})`).all();
+    if (!cols.some((c) => c.name === "receipt_id")) {
+      db.exec(`ALTER TABLE ${table} ADD COLUMN receipt_id TEXT`);
+    }
+  }
+  return {
+    async run(sql, params = []) {
+      db.prepare(sql).run(...params);
+    },
+    async get(sql, params = []) {
+      return db.prepare(sql).get(...params);
+    },
+    async all(sql, params = []) {
+      return db.prepare(sql).all(...params);
+    },
+    async close() {
+      db.close();
+    }
+  };
+}
+async function createPostgresDb(connectionString) {
+  const { default: pg } = await import("pg");
+  const pool = new pg.Pool({ connectionString });
+  function adaptSql(sql) {
+    let i = 0;
+    return sql.replace(/\?/g, () => `$${++i}`);
+  }
+  const pgSchema = SCHEMA.replace(/datetime\('now'\)/g, "NOW()");
+  const client = await pool.connect();
+  try {
+    await client.query(pgSchema);
+    for (const table of RECEIPT_ID_TABLES) {
+      await client.query(`ALTER TABLE ${table} ADD COLUMN IF NOT EXISTS receipt_id TEXT`);
+    }
+    const { rows } = await client.query("SELECT COUNT(*)::int as count FROM items");
+    if (rows[0].count === 0) {
+      for (const [id, sku, name, unit, listPrice, stock] of SEED_ITEMS) {
+        await client.query(
+          `INSERT INTO items (id, sku, name, unit, list_price, currency, stock) VALUES ($1, $2, $3, $4, $5, 'EUR', $6)`,
+          [id, sku, name, unit, listPrice, stock]
+        );
+      }
+      for (const [id, name, email, country, creditLimit, openBalance, terms] of SEED_CUSTOMERS) {
+        await client.query(
+          `INSERT INTO customers (id, name, email, country, currency, credit_limit, open_balance, payment_terms) VALUES ($1, $2, $3, $4, 'EUR', $5, $6, $7)`,
+          [id, name, email, country, creditLimit, openBalance, terms]
+        );
+      }
+    }
+  } finally {
+    client.release();
+  }
+  return {
+    async run(sql, params = []) {
+      await pool.query(adaptSql(sql), params);
+    },
+    async get(sql, params = []) {
+      const result = await pool.query(adaptSql(sql), params);
+      return result.rows[0];
+    },
+    async all(sql, params = []) {
+      const result = await pool.query(adaptSql(sql), params);
+      return result.rows;
+    },
+    async close() {
+      await pool.end();
+    }
+  };
+}
+function maybeBackupSqlite(dbPath) {
+  const backupPath = dbPath.replace(/\.db$/, ".backup.db");
+  if (!existsSync(dbPath)) return;
+  const shouldBackup = !existsSync(backupPath) || Date.now() - statSync(backupPath).mtimeMs > 24 * 60 * 60 * 1e3;
+  if (shouldBackup) {
+    try {
+      copyFileSync(dbPath, backupPath);
+      console.error(`[erp-mcp] backup written to ${backupPath}`);
+    } catch (err) {
+      console.error(`[erp-mcp] backup failed: ${err}`);
+    }
+  }
+}
+async function createDb() {
+  const databaseUrl = process.env.DATABASE_URL ?? "";
+  if (databaseUrl.startsWith("postgres://") || databaseUrl.startsWith("postgresql://")) {
+    console.error("[erp-mcp] using Postgres");
+    return createPostgresDb(databaseUrl);
+  }
+  const hapDir = process.env.HAP_DATA_DIR ?? join(homedir(), ".hap");
+  if (!existsSync(hapDir)) {
+    mkdirSync(hapDir, { recursive: true });
+  }
+  const dbPath = databaseUrl || join(hapDir, "erp.db");
+  maybeBackupSqlite(dbPath);
+  console.error(`[erp-mcp] using SQLite at ${dbPath}`);
+  return createSqliteDb(dbPath);
+}
+
+// src/tools/items.ts
+async function list_items(db, args) {
+  const { query, limit = 50 } = args;
+  const conditions = [];
+  const params = [];
+  if (query) {
+    conditions.push("(sku LIKE ? OR name LIKE ?)");
+    const like = `%${query}%`;
+    params.push(like, like);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  params.push(limit);
+  return db.all(`SELECT * FROM items ${where} ORDER BY sku LIMIT ?`, params);
+}
+async function get_item(db, args) {
+  const { id } = args;
+  const row = await db.get("SELECT * FROM items WHERE id = ?", [id]);
+  if (!row) throw new Error(`Unknown item id: ${id}`);
+  return row;
+}
+
+// src/money.ts
+var VALUE_TOLERANCE = 0.01;
+function roundToCents(n) {
+  return Math.round(n * 100) / 100;
+}
+function computeNetTotal(lines, discountPct) {
+  const gross = lines.reduce((sum, l) => sum + l.qty * l.list_price, 0);
+  return roundToCents(gross * (1 - discountPct / 100));
+}
+function valuesMatch(a, b) {
+  return Math.abs(a - b) <= VALUE_TOLERANCE;
+}
+var RefusalError = class extends Error {
+};
+function refuse(field, declared, expected, extra) {
+  const suffix = extra ? ` ${extra}` : "";
+  throw new RefusalError(
+    `Refused: ${field} mismatch \u2014 declared ${JSON.stringify(declared)}, expected ${JSON.stringify(expected)}.${suffix}`
+  );
+}
+
+// src/tools/customers.ts
+function withAvailableCredit(row) {
+  return { ...row, available_credit: roundToCents(row.credit_limit - row.open_balance) };
+}
+async function find_customers(db, args) {
+  const { query, limit = 50 } = args;
+  const conditions = [];
+  const params = [];
+  if (query) {
+    conditions.push("(name LIKE ? OR email LIKE ?)");
+    const like = `%${query}%`;
+    params.push(like, like);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  params.push(limit);
+  const rows = await db.all(`SELECT * FROM customers ${where} ORDER BY name LIMIT ?`, params);
+  return rows.map(withAvailableCredit);
+}
+async function get_customer(db, args) {
+  const { id } = args;
+  const row = await db.get("SELECT * FROM customers WHERE id = ?", [id]);
+  if (!row) throw new Error(`Unknown customer id: ${id}`);
+  return withAvailableCredit(row);
+}
+async function requireCustomer(db, id) {
+  const row = await db.get("SELECT * FROM customers WHERE id = ?", [id]);
+  if (!row) throw new Error(`Unknown customer id: ${id}`);
+  return row;
+}
+
+// src/tools/quotes.ts
+import { v4 as uuidv4 } from "uuid";
+async function priceLines(db, lines) {
+  if (!Array.isArray(lines) || lines.length === 0) {
+    throw new Error("lines must be a non-empty array of { item_id, qty }");
+  }
+  const priced = [];
+  for (const line of lines) {
+    const { item_id, qty } = line ?? {};
+    if (!item_id) {
+      throw new Error("Every line requires an item_id");
+    }
+    if (!Number.isInteger(qty) || qty <= 0) {
+      throw new Error(`Invalid qty for item ${item_id}: ${JSON.stringify(qty)} (must be a positive integer)`);
+    }
+    const item = await db.get("SELECT * FROM items WHERE id = ?", [item_id]);
+    if (!item) {
+      throw new Error(`Unknown item id: ${item_id}`);
+    }
+    priced.push({
+      item_id,
+      qty,
+      list_price: item.list_price,
+      line_total: Math.round(item.list_price * qty * 100) / 100
+    });
+  }
+  return priced;
+}
+function validateDiscountPct(discount_pct) {
+  if (typeof discount_pct !== "number" || !Number.isFinite(discount_pct) || discount_pct < 0 || discount_pct > 100) {
+    refuse("discount_pct", discount_pct, "a number between 0 and 100");
+  }
+  return discount_pct;
+}
+async function nextNumber(db, table, prefix) {
+  const { count } = await db.get(`SELECT COUNT(*) as count FROM ${table}`) ?? { count: 0 };
+  return `${prefix}-${String(count + 1).padStart(4, "0")}`;
+}
+async function requireQuote(db, id) {
+  const row = await db.get("SELECT * FROM quotes WHERE id = ?", [id]);
+  if (!row) throw new Error(`Unknown quote id: ${id}`);
+  return row;
+}
+async function loadQuoteLines(db, quoteId) {
+  return db.all("SELECT * FROM quote_lines WHERE quote_id = ? ORDER BY rowid", [quoteId]);
+}
+async function quoteWithLines(db, id) {
+  const quote = await requireQuote(db, id);
+  const lines = await loadQuoteLines(db, id);
+  return { ...quote, lines };
+}
+async function create_quote(db, args) {
+  const { customer_id, lines, discount_pct, value, currency, valid_until, notes, receipt_id } = args;
+  const customer = await requireCustomer(db, customer_id);
+  const priced = await priceLines(db, lines);
+  const discountPct = validateDiscountPct(discount_pct);
+  if (currency !== customer.currency) {
+    refuse("currency", currency, customer.currency, `Customer ${customer.name} (${customer.id}) is billed in ${customer.currency}.`);
+  }
+  const netTotal = computeNetTotal(priced, discountPct);
+  if (!valuesMatch(value, netTotal)) {
+    refuse("value", value, netTotal, "Recomputed from the quote lines and the declared discount.");
+  }
+  const id = uuidv4();
+  const number = await nextNumber(db, "quotes", "Q");
+  await db.run(
+    `INSERT INTO quotes (id, number, customer_id, status, currency, discount_pct, net_total, valid_until, notes, receipt_id)
+     VALUES (?, ?, ?, 'draft', ?, ?, ?, ?, ?, ?)`,
+    [id, number, customer_id, currency, discountPct, netTotal, valid_until ?? null, notes ?? null, receipt_id ?? null]
+  );
+  for (const line of priced) {
+    await db.run(
+      `INSERT INTO quote_lines (id, quote_id, item_id, qty, list_price, line_total) VALUES (?, ?, ?, ?, ?, ?)`,
+      [uuidv4(), id, line.item_id, line.qty, line.list_price, line.line_total]
+    );
+  }
+  return quoteWithLines(db, id);
+}
+async function update_quote(db, args) {
+  const { id, lines, discount_pct, value, currency, valid_until, notes, receipt_id } = args;
+  const quote = await requireQuote(db, id);
+  if (quote.status !== "draft") {
+    throw new Error(`Quote ${quote.number} (${id}) is ${quote.status}; only draft quotes can be updated`);
+  }
+  const priced = lines !== void 0 ? await priceLines(db, lines) : await loadQuoteLines(db, id);
+  const discountPct = validateDiscountPct(discount_pct);
+  if (currency !== quote.currency) {
+    refuse("currency", currency, quote.currency, `Quote ${quote.number} was created in ${quote.currency}; currency cannot change on update.`);
+  }
+  const netTotal = computeNetTotal(priced, discountPct);
+  if (!valuesMatch(value, netTotal)) {
+    refuse("value", value, netTotal, "Recomputed from the quote lines and the declared discount.");
+  }
+  if (lines !== void 0) {
+    await db.run("DELETE FROM quote_lines WHERE quote_id = ?", [id]);
+    for (const line of priced) {
+      await db.run(
+        `INSERT INTO quote_lines (id, quote_id, item_id, qty, list_price, line_total) VALUES (?, ?, ?, ?, ?, ?)`,
+        [uuidv4(), id, line.item_id, line.qty, line.list_price, line.line_total]
+      );
+    }
+  }
+  await db.run(
+    `UPDATE quotes SET discount_pct = ?, net_total = ?, valid_until = ?, notes = ?, receipt_id = ?, updated_at = datetime('now') WHERE id = ?`,
+    [discountPct, netTotal, valid_until ?? quote.valid_until ?? null, notes ?? quote.notes ?? null, receipt_id ?? quote.receipt_id ?? null, id]
+  );
+  return quoteWithLines(db, id);
+}
+async function send_quote(db, args) {
+  const { id, value, discount_pct, currency, receipt_id } = args;
+  const quote = await requireQuote(db, id);
+  if (quote.status !== "draft") {
+    throw new Error(`Quote ${quote.number} (${id}) is ${quote.status}; only draft quotes can be sent`);
+  }
+  if (currency !== quote.currency) {
+    refuse("currency", currency, quote.currency, `Quote ${quote.number} is in ${quote.currency}.`);
+  }
+  if (discount_pct !== quote.discount_pct) {
+    refuse("discount_pct", discount_pct, quote.discount_pct, `Quote ${quote.number}'s discount cannot change at send time \u2014 edit the draft first.`);
+  }
+  const lines = await loadQuoteLines(db, id);
+  const netTotal = computeNetTotal(lines, quote.discount_pct);
+  if (!valuesMatch(value, netTotal)) {
+    refuse("value", value, netTotal, "Recomputed from the quote's lines and stored discount.");
+  }
+  await db.run(
+    `UPDATE quotes SET status = 'sent', sent_at = datetime('now'), receipt_id = ?, updated_at = datetime('now') WHERE id = ?`,
+    [receipt_id ?? quote.receipt_id ?? null, id]
+  );
+  return quoteWithLines(db, id);
+}
+async function list_quotes(db, args) {
+  const { status, customer_id, limit = 50 } = args;
+  const conditions = [];
+  const params = [];
+  if (status) {
+    conditions.push("status = ?");
+    params.push(status);
+  }
+  if (customer_id) {
+    conditions.push("customer_id = ?");
+    params.push(customer_id);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  params.push(limit);
+  return db.all(`SELECT * FROM quotes ${where} ORDER BY created_at DESC LIMIT ?`, params);
+}
+async function get_quote(db, args) {
+  const { id } = args;
+  return quoteWithLines(db, id);
+}
+
+// src/tools/orders.ts
+import { v4 as uuidv42 } from "uuid";
+async function nextOrderNumber(db) {
+  const { count } = await db.get("SELECT COUNT(*) as count FROM orders") ?? { count: 0 };
+  return `O-${String(count + 1).padStart(4, "0")}`;
+}
+async function orderWithLines(db, id) {
+  const order = await db.get("SELECT * FROM orders WHERE id = ?", [id]);
+  if (!order) throw new Error(`Unknown order id: ${id}`);
+  const lines = await loadQuoteLines(db, order.quote_id);
+  return { ...order, lines };
+}
+async function convert_quote_to_order(db, args) {
+  const { id, value, discount_pct, currency, requested_delivery, receipt_id } = args;
+  const quote = await requireQuote(db, id);
+  if (quote.status !== "sent") {
+    throw new Error(
+      `Quote ${quote.number} (${id}) is ${quote.status}; only sent quotes can be converted to an order` + (quote.status === "converted" ? " (it already was)" : "")
+    );
+  }
+  if (currency !== quote.currency) {
+    refuse("currency", currency, quote.currency, `Quote ${quote.number} is in ${quote.currency}.`);
+  }
+  if (discount_pct !== quote.discount_pct) {
+    refuse("discount_pct", discount_pct, quote.discount_pct, `Quote ${quote.number}'s discount cannot change at conversion time.`);
+  }
+  const lines = await loadQuoteLines(db, id);
+  const netTotal = computeNetTotal(lines, quote.discount_pct);
+  if (!valuesMatch(value, netTotal)) {
+    refuse("value", value, netTotal, "Recomputed from the quote's lines and stored discount.");
+  }
+  const customer = await requireCustomer(db, quote.customer_id);
+  const projectedBalance = roundToCents(customer.open_balance + netTotal);
+  if (projectedBalance > customer.credit_limit) {
+    throw new Error(
+      `Refused: credit limit exceeded for ${customer.name} (${customer.id}) \u2014 open balance ${customer.open_balance} + order value ${netTotal} = ${projectedBalance}, credit limit is ${customer.credit_limit}.`
+    );
+  }
+  const items = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    if (!items.has(line.item_id)) {
+      const item2 = await db.get("SELECT * FROM items WHERE id = ?", [line.item_id]);
+      if (!item2) throw new Error(`Unknown item id: ${line.item_id}`);
+      items.set(line.item_id, item2);
+    }
+    const item = items.get(line.item_id);
+    if (item.stock < line.qty) {
+      throw new Error(
+        `Refused: insufficient stock for ${item.sku} (${item.name}) \u2014 requested ${line.qty}, available ${item.stock}.`
+      );
+    }
+  }
+  for (const line of lines) {
+    await db.run("UPDATE items SET stock = stock - ? WHERE id = ?", [line.qty, line.item_id]);
+  }
+  const orderId = uuidv42();
+  const number = await nextOrderNumber(db);
+  await db.run(
+    `INSERT INTO orders (id, number, quote_id, customer_id, status, net_total, currency, requested_delivery, receipt_id)
+     VALUES (?, ?, ?, ?, 'confirmed', ?, ?, ?, ?)`,
+    [orderId, number, id, quote.customer_id, netTotal, currency, requested_delivery ?? null, receipt_id ?? null]
+  );
+  await db.run(`UPDATE quotes SET status = 'converted', updated_at = datetime('now') WHERE id = ?`, [id]);
+  return orderWithLines(db, orderId);
+}
+async function list_orders(db, args) {
+  const { customer_id, limit = 50 } = args;
+  const conditions = [];
+  const params = [];
+  if (customer_id) {
+    conditions.push("customer_id = ?");
+    params.push(customer_id);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  params.push(limit);
+  return db.all(`SELECT * FROM orders ${where} ORDER BY created_at DESC LIMIT ?`, params);
+}
+async function get_order(db, args) {
+  const { id } = args;
+  return orderWithLines(db, id);
+}
+
+// src/index.ts
+var RECEIPT_FIELD = {
+  type: "string",
+  description: "Suveren authorizing receipt id. Injected by the gateway \u2014 agents do not set this."
+};
+var LINE_SCHEMA = {
+  type: "object",
+  properties: {
+    item_id: { type: "string", description: "Item ID" },
+    qty: { type: "number", description: "Quantity (positive integer)" }
+  },
+  required: ["item_id", "qty"]
+};
+var TOOL_DEFINITIONS = [
+  // --- Reads ---
+  {
+    name: "list_items",
+    description: "List/search catalog items (sku, name, unit, list price, stock)",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Text search across sku and name" },
+        limit: { type: "number", description: "Maximum results to return (default: 50)" }
+      },
+      required: []
+    }
+  },
+  {
+    name: "get_item",
+    description: "Get a single item, including stock and list price",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "Item ID" }
+      },
+      required: ["id"]
+    }
+  },
+  {
+    name: "find_customers",
+    description: "Search customers by name or email",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Text search across name and email" },
+        limit: { type: "number", description: "Maximum results to return (default: 50)" }
+      },
+      required: []
+    }
+  },
+  {
+    name: "get_customer",
+    description: "Get a single customer, including credit limit, open balance, and available credit",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "Customer ID" }
+      },
+      required: ["id"]
+    }
+  },
+  {
+    name: "list_quotes",
+    description: "List quotes, optionally filtered by status or customer",
+    inputSchema: {
+      type: "object",
+      properties: {
+        status: { type: "string", enum: ["draft", "sent", "converted", "cancelled"], description: "Filter by status" },
+        customer_id: { type: "string", description: "Filter by customer ID" },
+        limit: { type: "number", description: "Maximum results to return (default: 50)" }
+      },
+      required: []
+    }
+  },
+  {
+    name: "get_quote",
+    description: "Get a single quote with its lines",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "Quote ID" }
+      },
+      required: ["id"]
+    }
+  },
+  {
+    name: "list_orders",
+    description: "List orders, optionally filtered by customer",
+    inputSchema: {
+      type: "object",
+      properties: {
+        customer_id: { type: "string", description: "Filter by customer ID" },
+        limit: { type: "number", description: "Maximum results to return (default: 50)" }
+      },
+      required: []
+    }
+  },
+  {
+    name: "get_order",
+    description: "Get a single order with its lines",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "Order ID" }
+      },
+      required: ["id"]
+    }
+  },
+  // --- Changes ---
+  {
+    name: "create_quote",
+    description: "Create a draft quote for a customer. The connector recomputes the net total from the lines and the discount and refuses the call if the declared value, discount, or currency does not match.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        customer_id: { type: "string", description: "Customer ID" },
+        lines: { type: "array", items: LINE_SCHEMA, description: "Quote lines" },
+        discount_pct: { type: "number", description: "Document discount against list price, in percent (0-100)" },
+        value: { type: "number", description: "Net document total \u2014 must equal sum(qty*list_price)*(1-discount_pct/100)" },
+        currency: { type: "string", description: "Document currency \u2014 must match the customer's currency" },
+        valid_until: { type: "string", description: "ISO 8601 date the quote is valid until (optional)" },
+        notes: { type: "string", description: "Free-form notes (optional)" },
+        receipt_id: RECEIPT_FIELD
+      },
+      required: ["customer_id", "lines", "discount_pct", "value", "currency"]
+    }
+  },
+  {
+    name: "update_quote",
+    description: "Update a draft quote (lines, discount, valid_until, notes). Only draft quotes can be updated. The connector recomputes the net total and refuses the call if the declared value, discount, or currency does not match.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "Quote ID" },
+        lines: { type: "array", items: LINE_SCHEMA, description: "Replacement quote lines (optional \u2014 omit to keep existing lines)" },
+        discount_pct: { type: "number", description: "Document discount against list price, in percent (0-100)" },
+        value: { type: "number", description: "Net document total \u2014 must equal sum(qty*list_price)*(1-discount_pct/100)" },
+        currency: { type: "string", description: "Document currency \u2014 must match the quote's currency" },
+        valid_until: { type: "string", description: "ISO 8601 date the quote is valid until (optional)" },
+        notes: { type: "string", description: "Free-form notes (optional)" },
+        receipt_id: RECEIPT_FIELD
+      },
+      required: ["id", "discount_pct", "value", "currency"]
+    }
+  },
+  {
+    name: "send_quote",
+    description: "Send a draft quote to the customer (draft -> sent). Simulated: marks the quote sent and records sent_at. The declared value, discount, and currency must match the quote as stored.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "Quote ID" },
+        value: { type: "number", description: "Net document total \u2014 must match the quote's stored net total" },
+        discount_pct: { type: "number", description: "Must match the quote's stored discount \u2014 cannot change at send time" },
+        currency: { type: "string", description: "Must match the quote's stored currency" },
+        receipt_id: RECEIPT_FIELD
+      },
+      required: ["id", "value", "discount_pct", "currency"]
+    }
+  },
+  {
+    name: "convert_quote_to_order",
+    description: "Convert a sent quote into a confirmed order (sent -> order). Reserves stock for every line and refuses if the customer's credit limit would be exceeded or any line lacks sufficient stock.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "Quote ID" },
+        value: { type: "number", description: "Net document total \u2014 must match the quote's stored net total" },
+        discount_pct: { type: "number", description: "Must match the quote's stored discount \u2014 cannot change at conversion time" },
+        currency: { type: "string", description: "Must match the quote's stored currency" },
+        requested_delivery: { type: "string", description: "Requested delivery date (ISO 8601, optional)" },
+        receipt_id: RECEIPT_FIELD
+      },
+      required: ["id", "value", "discount_pct", "currency"]
+    }
+  }
+];
+async function main() {
+  const db = await createDb();
+  const server = new Server(
+    { name: "erp", version: "0.1.0" },
+    { capabilities: { tools: {} } }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return { tools: TOOL_DEFINITIONS };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    const safeArgs = args ?? {};
+    try {
+      let result;
+      switch (name) {
+        case "list_items":
+          result = await list_items(db, safeArgs);
+          break;
+        case "get_item":
+          result = await get_item(db, safeArgs);
+          break;
+        case "find_customers":
+          result = await find_customers(db, safeArgs);
+          break;
+        case "get_customer":
+          result = await get_customer(db, safeArgs);
+          break;
+        case "list_quotes":
+          result = await list_quotes(db, safeArgs);
+          break;
+        case "get_quote":
+          result = await get_quote(db, safeArgs);
+          break;
+        case "list_orders":
+          result = await list_orders(db, safeArgs);
+          break;
+        case "get_order":
+          result = await get_order(db, safeArgs);
+          break;
+        case "create_quote":
+          result = await create_quote(db, safeArgs);
+          break;
+        case "update_quote":
+          result = await update_quote(db, safeArgs);
+          break;
+        case "send_quote":
+          result = await send_quote(db, safeArgs);
+          break;
+        case "convert_quote_to_order":
+          result = await convert_quote_to_order(db, safeArgs);
+          break;
+        default:
+          throw new Error(`Unknown tool: ${name}`);
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(`[erp-mcp] tool error (${name}):`, message);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ error: message }, null, 2)
+          }
+        ],
+        isError: true
+      };
+    }
+  });
+  process.on("SIGINT", async () => {
+    await db.close();
+    process.exit(0);
+  });
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("[erp-mcp] server started");
+}
+main().catch((err) => {
+  console.error("[erp-mcp] fatal:", err);
+  process.exit(1);
+});