kassza 0.11.0 → 0.13.0

package/dist/server-C6PoNkdD.cjs

@@ -0,0 +1,1557 @@
+const require_create_once = require("./create-once-DgMtKKcG.cjs");
+const require_errors = require("./errors-DxeuTslP.cjs");
+const require_client = require("./client-C-PdfL_P.cjs");
+const require_dates = require("./dates-CPgBodkP.cjs");
+const require_vat = require("./vat-g35srbNG.cjs");
+const require_money = require("./money-BxytJW6f.cjs");
+const require_issue = require("./issue-AGRohSm7.cjs");
+const require_crypto = require("./crypto-Dpn4FHQ6.cjs");
+const require_nav = require("./nav-BEwcX7-N.cjs");
+//#region src/mcp/protocol.ts
+const MCP_MODERN_VERSIONS = ["2026-07-28"];
+const MCP_LEGACY_VERSIONS = [
+	"2025-11-25",
+	"2025-06-18",
+	"2025-03-26",
+	"2024-11-05"
+];
+const MCP_SUPPORTED_VERSIONS = [...MCP_MODERN_VERSIONS, ...MCP_LEGACY_VERSIONS];
+const META_PROTOCOL_VERSION = "io.modelcontextprotocol/protocolVersion";
+const META_CLIENT_CAPABILITIES = "io.modelcontextprotocol/clientCapabilities";
+const META_SERVER_INFO = "io.modelcontextprotocol/serverInfo";
+const JSON_RPC_PARSE_ERROR = -32700;
+const JSON_RPC_INVALID_REQUEST = -32600;
+const JSON_RPC_METHOD_NOT_FOUND = -32601;
+const JSON_RPC_INVALID_PARAMS = -32602;
+const JSON_RPC_INTERNAL_ERROR = -32603;
+const MCP_UNSUPPORTED_PROTOCOL_VERSION = -32022;
+var McpProtocolError = class extends Error {
+	name = "McpProtocolError";
+	code;
+	id;
+	data;
+	constructor(code, message, options = {}) {
+		super(message);
+		this.code = code;
+		this.id = options.id ?? null;
+		this.data = options.data;
+	}
+};
+function isJsonObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isValidId(value) {
+	return typeof value === "string" || typeof value === "number" && Number.isFinite(value);
+}
+function readableId(value) {
+	return isValidId(value) ? value : null;
+}
+function failure(id, code, message, data) {
+	return {
+		jsonrpc: "2.0",
+		id,
+		error: data === void 0 ? {
+			code,
+			message
+		} : {
+			code,
+			message,
+			data
+		}
+	};
+}
+function success(id, result) {
+	return {
+		jsonrpc: "2.0",
+		id,
+		result
+	};
+}
+function parseMcpMessage(value) {
+	if (!isJsonObject(value) || value.jsonrpc !== "2.0") throw new McpProtocolError(JSON_RPC_INVALID_REQUEST, "Érvénytelen JSON-RPC 2.0 üzenet.", { id: isJsonObject(value) ? readableId(value.id) : null });
+	if (typeof value.method !== "string") {
+		if ("result" in value || "error" in value) return { kind: "ignored" };
+		throw new McpProtocolError(JSON_RPC_INVALID_REQUEST, "Hiányzik a method mező.", { id: readableId(value.id) });
+	}
+	if (!("id" in value)) return {
+		kind: "notification",
+		method: value.method
+	};
+	if (!isValidId(value.id)) throw new McpProtocolError(JSON_RPC_INVALID_REQUEST, "A kérés azonosítója (id) csak szöveg vagy szám lehet, null nem.");
+	if (value.params !== void 0 && !isJsonObject(value.params)) throw new McpProtocolError(JSON_RPC_INVALID_PARAMS, "A params mezőnek objektumnak kell lennie.", { id: value.id });
+	return {
+		kind: "request",
+		id: value.id,
+		method: value.method,
+		params: value.params ?? {}
+	};
+}
+function protocolFailure(error) {
+	return failure(error.id, error.code, error.message, error.data);
+}
+//#endregion
+//#region src/mcp/arguments.ts
+var ToolInputError = class extends Error {
+	name = "ToolInputError";
+};
+const DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+const NUMERIC_TEXT = /^-?\d+(?:[.,]\d+)?$/;
+function field(path, key) {
+	return path === "" ? key : `${path}.${key}`;
+}
+function objectArg(value, path) {
+	if (!isJsonObject(value)) throw new ToolInputError(`A(z) ${path} mezőnek objektumnak kell lennie.`);
+	return value;
+}
+function assertKnownKeys(value, allowed, path) {
+	const unknown = Object.keys(value).filter((key) => !allowed.includes(key));
+	if (unknown.length === 0) return;
+	throw new ToolInputError(`Ismeretlen mező ${path === "" ? "a bemenetben" : `a(z) ${path} objektumban`}: ${unknown.join(", ")}. Megengedett mezők: ${allowed.join(", ")}.`);
+}
+function optionalString(value, key, path) {
+	const raw = value[key];
+	if (raw === void 0 || raw === null) return void 0;
+	if (typeof raw !== "string") throw new ToolInputError(`A(z) ${field(path, key)} mezőnek szövegnek kell lennie.`);
+	const trimmed = raw.trim();
+	return trimmed === "" ? void 0 : trimmed;
+}
+function requiredString(value, key, path) {
+	const result = optionalString(value, key, path);
+	if (result === void 0) throw new ToolInputError(`A(z) ${field(path, key)} mező kötelező, és nem lehet üres.`);
+	return result;
+}
+function optionalNumber(value, key, path) {
+	const raw = value[key];
+	if (raw === void 0 || raw === null) return void 0;
+	if (typeof raw !== "number" || !Number.isFinite(raw)) throw new ToolInputError(`A(z) ${field(path, key)} mezőnek véges számnak kell lennie.`);
+	return raw;
+}
+function optionalInteger(value, key, path) {
+	const result = optionalNumber(value, key, path);
+	if (result !== void 0 && !Number.isInteger(result)) throw new ToolInputError(`A(z) ${field(path, key)} mezőnek egész számnak kell lennie.`);
+	return result;
+}
+function optionalBoolean(value, key, path) {
+	const raw = value[key];
+	if (raw === void 0 || raw === null) return void 0;
+	if (typeof raw !== "boolean") throw new ToolInputError(`A(z) ${field(path, key)} mezőnek true vagy false értéknek kell lennie.`);
+	return raw;
+}
+function optionalDate(value, key, path) {
+	const result = optionalString(value, key, path);
+	if (result !== void 0 && !DATE_PATTERN.test(result)) throw new ToolInputError(`A(z) ${field(path, key)} mezőt ÉÉÉÉ-HH-NN formában add meg (például 2026-10-02).`);
+	return result;
+}
+function optionalEnum(value, key, path, allowed) {
+	const raw = optionalString(value, key, path);
+	if (raw === void 0) return void 0;
+	const match = allowed.find((candidate) => candidate === raw);
+	if (match === void 0) throw new ToolInputError(`A(z) ${field(path, key)} értéke nem megengedett: ${raw}. Lehetséges értékek: ${allowed.join(", ")}.`);
+	return match;
+}
+function optionalArray(value, key, path) {
+	const raw = value[key];
+	if (raw === void 0 || raw === null) return void 0;
+	if (!Array.isArray(raw)) throw new ToolInputError(`A(z) ${field(path, key)} mezőnek tömbnek kell lennie.`);
+	return raw;
+}
+function requiredArray(value, key, path, limits) {
+	const result = optionalArray(value, key, path) ?? [];
+	if (result.length < limits.min || result.length > limits.max) throw new ToolInputError(`A(z) ${field(path, key)} tömbben ${limits.min} és ${limits.max} közötti számú elem lehet, kapott: ${result.length}.`);
+	return result;
+}
+function numericFromText(value) {
+	if (typeof value !== "string" || !NUMERIC_TEXT.test(value.trim())) return value;
+	return Number(value.trim().replace(",", "."));
+}
+function vatFailure(value, path) {
+	return new ToolInputError(`Ismeretlen áfakulcs a(z) ${path} mezőben: ${JSON.stringify(value)}. Add meg számként (például 27, 18, 5 vagy 0) vagy kódként (például "AAM", "TAM", "EUT", "EUKT", "F.AFA", "K.AFA").`);
+}
+function invoiceVat(value, path) {
+	const candidate = numericFromText(value);
+	if (require_vat.isVatRate(candidate)) return candidate;
+	throw vatFailure(value, path);
+}
+function receiptVat(value, path) {
+	const candidate = numericFromText(value);
+	if (require_vat.isVatRate(candidate)) return candidate;
+	const code = require_issue.RECEIPT_ONLY_VAT_CODES.find((entry) => entry === candidate);
+	if (code !== void 0) return code;
+	throw vatFailure(value, path);
+}
+//#endregion
+//#region src/mcp/confirmation.ts
+const DEFAULT_CONFIRMATION_TTL_MS = 9e5;
+const SECRET_BYTES = 32;
+const SIGNATURE_LENGTH = 32;
+const IDEMPOTENCY_KEY_LENGTH = 20;
+const TOKEN_PATTERN = /^([0-9a-z]+)\.([0-9a-f]+)$/;
+function canonicalize(value) {
+	if (Array.isArray(value)) return value.map(canonicalize);
+	if (typeof value !== "object" || value === null) return value;
+	return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([key, entry]) => [key, canonicalize(entry)]));
+}
+function canonicalJson(value) {
+	return JSON.stringify(canonicalize(value)) ?? "null";
+}
+async function idempotencyKey(action, day, payload) {
+	return (await require_crypto.digestHex("SHA-256", `${action}\n${day}\n${canonicalJson(payload)}`)).slice(0, IDEMPOTENCY_KEY_LENGTH).toUpperCase();
+}
+function randomSecret() {
+	return crypto.getRandomValues(new Uint8Array(SECRET_BYTES));
+}
+function resolveTtl(ttlMs) {
+	if (ttlMs === void 0) return DEFAULT_CONFIRMATION_TTL_MS;
+	if (!Number.isInteger(ttlMs) || ttlMs <= 0) throw new TypeError(`A confirmationTtlMs pozitív egész szám legyen, kapott: ${ttlMs}`);
+	return ttlMs;
+}
+function createConfirmations(options) {
+	const secret = options.secret ?? randomSecret();
+	const ttlMs = resolveTtl(options.ttlMs);
+	const sign = async (action, expiresAt, payload) => {
+		return (await require_crypto.hmacHex("SHA-256", secret, `${action}\n${expiresAt}\n${canonicalJson(payload)}`)).slice(0, SIGNATURE_LENGTH);
+	};
+	return {
+		async issue(action, payload) {
+			const expiresAt = options.now().getTime() + ttlMs;
+			const signature = await sign(action, expiresAt, payload);
+			return {
+				token: `${expiresAt.toString(36)}.${signature}`,
+				expiresAt: new Date(expiresAt).toISOString()
+			};
+		},
+		async verify(action, payload, token, previewTool) {
+			const again = `Hívd meg újra a ${previewTool} eszközt pontosan ezekkel az adatokkal, mutasd meg az előnézetet a felhasználónak, és a jóváhagyása után az új kóddal próbáld újra.`;
+			if (typeof token !== "string" || token.trim() === "") throw new ToolInputError(`Hiányzik a megerősítő kód (confirmation). ${again}`);
+			const match = TOKEN_PATTERN.exec(token.trim());
+			const expiresAt = match?.[1] === void 0 ? NaN : Number.parseInt(match[1], 36);
+			if (!match?.[2] || !Number.isSafeInteger(expiresAt)) throw new ToolInputError(`A megerősítő kód formátuma érvénytelen. ${again}`);
+			if (options.now().getTime() > expiresAt) throw new ToolInputError(`A megerősítő kód lejárt. ${again}`);
+			const expected = await sign(action, expiresAt, payload);
+			if (!require_crypto.timingSafeEqual(expected, match[2])) throw new ToolInputError(`A megerősítő kód nem ehhez a kéréshez tartozik (az adatok eltérnek az előnézettől). ${again}`);
+		}
+	};
+}
+//#endregion
+//#region src/core/version.ts
+const KASSZA_VERSION = "0.12.0";
+//#endregion
+//#region src/mcp/tool-kit.ts
+const LOCAL_READ = {
+	readOnlyHint: true,
+	destructiveHint: false,
+	idempotentHint: true,
+	openWorldHint: false
+};
+const REMOTE_READ = {
+	readOnlyHint: true,
+	destructiveHint: false,
+	idempotentHint: true,
+	openWorldHint: true
+};
+const REMOTE_CREATE = {
+	readOnlyHint: false,
+	destructiveHint: false,
+	idempotentHint: true,
+	openWorldHint: true
+};
+const REMOTE_REVERSE = {
+	readOnlyHint: false,
+	destructiveHint: true,
+	idempotentHint: true,
+	openWorldHint: true
+};
+const amountFormat = new Intl.NumberFormat("hu-HU", { maximumFractionDigits: 2 });
+function money(value, currency) {
+	return `${amountFormat.format(value)} ${currency}`;
+}
+function plainJson(value) {
+	return JSON.parse(JSON.stringify(value, (_key, entry) => entry instanceof Uint8Array ? void 0 : entry));
+}
+function lines(...parts) {
+	return parts.filter((part) => typeof part === "string" && part !== "").join("\n");
+}
+function splitConfirmation(args) {
+	const { confirmation, ...payload } = args;
+	return {
+		payload,
+		confirmation
+	};
+}
+//#endregion
+//#region src/mcp/inputs.ts
+const MCP_INVOICE_TYPES = ["invoice", "proforma"];
+const BUYER_KEYS = [
+	"name",
+	"zip",
+	"city",
+	"address",
+	"country",
+	"email",
+	"taxNumber",
+	"euTaxNumber"
+];
+const ITEM_KEYS = [
+	"name",
+	"quantity",
+	"unit",
+	"netUnitPrice",
+	"grossUnitPrice",
+	"vat",
+	"comment"
+];
+const PAYMENT_KEYS = [
+	"method",
+	"amount",
+	"description"
+];
+const INVOICE_INPUT_KEYS = [
+	"type",
+	"buyer",
+	"items",
+	"paymentMethod",
+	"currency",
+	"exchangeRate",
+	"exchangeBank",
+	"language",
+	"issueDate",
+	"fulfillmentDate",
+	"dueDate",
+	"comment",
+	"orderNumber",
+	"externalId",
+	"prefix",
+	"paid",
+	"eInvoice",
+	"sendEmail"
+];
+const RECEIPT_INPUT_KEYS = [
+	"items",
+	"payments",
+	"paymentMethod",
+	"currency",
+	"exchangeRate",
+	"exchangeBank",
+	"comment",
+	"orderNumber",
+	"prefix"
+];
+function unitPriceOf(item, path) {
+	const net = optionalNumber(item, "netUnitPrice", path);
+	const gross = optionalNumber(item, "grossUnitPrice", path);
+	const quantity = optionalNumber(item, "quantity", path);
+	if (net === void 0 === (gross === void 0)) throw new ToolInputError(`A(z) ${path} tételnél pontosan az egyiket add meg: netUnitPrice (nettó egységár) vagy grossUnitPrice (bruttó egységár).`);
+	return {
+		...net === void 0 ? {} : { netUnitPrice: net },
+		...gross === void 0 ? {} : { grossUnitPrice: gross },
+		...quantity === void 0 ? {} : { quantity }
+	};
+}
+function itemObject(value, index) {
+	const path = `items[${index}]`;
+	const item = objectArg(value, path);
+	assertKnownKeys(item, ITEM_KEYS, path);
+	return {
+		item,
+		path
+	};
+}
+function invoiceItemOf(value, index) {
+	const { item, path } = itemObject(value, index);
+	return {
+		name: requiredString(item, "name", path),
+		unit: optionalString(item, "unit", path),
+		comment: optionalString(item, "comment", path),
+		vat: invoiceVat(item.vat, `${path}.vat`),
+		...unitPriceOf(item, path)
+	};
+}
+function receiptItemOf(value, index) {
+	const { item, path } = itemObject(value, index);
+	return {
+		name: requiredString(item, "name", path),
+		unit: optionalString(item, "unit", path),
+		comment: optionalString(item, "comment", path),
+		vat: receiptVat(item.vat, `${path}.vat`),
+		...unitPriceOf(item, path)
+	};
+}
+function buyerOf(value, sendEmail) {
+	const buyer = objectArg(value, "buyer");
+	assertKnownKeys(buyer, BUYER_KEYS, "buyer");
+	return {
+		name: requiredString(buyer, "name", "buyer"),
+		zip: requiredString(buyer, "zip", "buyer"),
+		city: requiredString(buyer, "city", "buyer"),
+		address: requiredString(buyer, "address", "buyer"),
+		country: optionalString(buyer, "country", "buyer"),
+		email: optionalString(buyer, "email", "buyer"),
+		taxNumber: optionalString(buyer, "taxNumber", "buyer"),
+		euTaxNumber: optionalString(buyer, "euTaxNumber", "buyer"),
+		sendEmail
+	};
+}
+function paymentOf(value, index) {
+	const path = `payments[${index}]`;
+	const payment = objectArg(value, path);
+	assertKnownKeys(payment, PAYMENT_KEYS, path);
+	const amount = optionalNumber(payment, "amount", path);
+	if (amount === void 0) throw new ToolInputError(`A(z) ${path}.amount mező kötelező.`);
+	return {
+		method: requiredString(payment, "method", path),
+		amount,
+		description: optionalString(payment, "description", path)
+	};
+}
+function invoiceInputOf(args, extraKeys = []) {
+	assertKnownKeys(args, [...INVOICE_INPUT_KEYS, ...extraKeys], "");
+	return {
+		type: optionalEnum(args, "type", "", MCP_INVOICE_TYPES),
+		buyer: buyerOf(args.buyer, optionalBoolean(args, "sendEmail", "") ?? false),
+		items: requiredArray(args, "items", "", {
+			min: 1,
+			max: 100
+		}).map(invoiceItemOf),
+		paymentMethod: optionalString(args, "paymentMethod", ""),
+		currency: optionalString(args, "currency", ""),
+		exchangeRate: optionalNumber(args, "exchangeRate", ""),
+		exchangeBank: optionalString(args, "exchangeBank", ""),
+		language: optionalEnum(args, "language", "", require_create_once.INVOICE_LANGUAGES),
+		issueDate: optionalDate(args, "issueDate", ""),
+		fulfillmentDate: optionalDate(args, "fulfillmentDate", ""),
+		dueDate: optionalDate(args, "dueDate", ""),
+		comment: optionalString(args, "comment", ""),
+		orderNumber: optionalString(args, "orderNumber", ""),
+		externalId: optionalString(args, "externalId", ""),
+		prefix: optionalString(args, "prefix", ""),
+		paid: optionalBoolean(args, "paid", ""),
+		eInvoice: optionalBoolean(args, "eInvoice", ""),
+		downloadPdf: false
+	};
+}
+function receiptInputOf(args, extraKeys = []) {
+	assertKnownKeys(args, [...RECEIPT_INPUT_KEYS, ...extraKeys], "");
+	return {
+		items: requiredArray(args, "items", "", {
+			min: 1,
+			max: 100
+		}).map(receiptItemOf),
+		payments: optionalArray(args, "payments", "")?.map(paymentOf),
+		paymentMethod: optionalString(args, "paymentMethod", ""),
+		currency: optionalString(args, "currency", ""),
+		exchangeRate: optionalNumber(args, "exchangeRate", ""),
+		exchangeBank: optionalString(args, "exchangeBank", ""),
+		comment: optionalString(args, "comment", ""),
+		orderNumber: optionalString(args, "orderNumber", ""),
+		prefix: optionalString(args, "prefix", ""),
+		downloadPdf: false
+	};
+}
+//#endregion
+//#region src/mcp/schemas.ts
+const TEXT = {
+	type: "string",
+	minLength: 1
+};
+const DATE = {
+	type: "string",
+	pattern: "^\\d{4}-\\d{2}-\\d{2}$",
+	description: "Dátum ÉÉÉÉ-HH-NN formában (Europe/Budapest szerint)."
+};
+const VAT = {
+	description: "Áfakulcs: szám (például 27, 18, 5, 0) vagy kód (például \"AAM\" alanyi adómentes, \"TAM\" tárgyi adómentes, \"EUT\", \"EUKT\", \"F.AFA\", \"K.AFA\"). Nyugtán \"ÁKK\", \"MAA\", \"EU\" és \"EUK\" is lehet.",
+	anyOf: [{ type: "number" }, {
+		type: "string",
+		minLength: 1
+	}]
+};
+const ITEMS = {
+	type: "array",
+	items: {
+		type: "object",
+		properties: {
+			name: {
+				...TEXT,
+				description: "A tétel megnevezése."
+			},
+			quantity: {
+				type: "number",
+				description: "Mennyiség, alapértelmezés: 1."
+			},
+			unit: {
+				...TEXT,
+				description: "Mennyiségi egység, például db, óra."
+			},
+			netUnitPrice: {
+				type: "number",
+				description: "Nettó egységár. A netUnitPrice és a grossUnitPrice közül pontosan egyet adj meg."
+			},
+			grossUnitPrice: {
+				type: "number",
+				description: "Bruttó egységár. A netUnitPrice és a grossUnitPrice közül pontosan egyet adj meg."
+			},
+			vat: VAT,
+			comment: {
+				...TEXT,
+				description: "Megjegyzés a tételhez."
+			}
+		},
+		required: ["name", "vat"],
+		additionalProperties: false
+	},
+	minItems: 1,
+	maxItems: 100
+};
+const BUYER = {
+	type: "object",
+	properties: {
+		name: {
+			...TEXT,
+			description: "A vevő neve."
+		},
+		zip: {
+			...TEXT,
+			description: "Irányítószám."
+		},
+		city: {
+			...TEXT,
+			description: "Település."
+		},
+		address: {
+			...TEXT,
+			description: "Utca, házszám."
+		},
+		country: {
+			...TEXT,
+			description: "Ország, ha nem Magyarország."
+		},
+		email: {
+			...TEXT,
+			description: "A vevő e-mail címe."
+		},
+		taxNumber: {
+			...TEXT,
+			description: "Magyar adószám, például 12345676-2-42."
+		},
+		euTaxNumber: {
+			...TEXT,
+			description: "Közösségi adószám, például HU12345676."
+		}
+	},
+	required: [
+		"name",
+		"zip",
+		"city",
+		"address"
+	],
+	additionalProperties: false
+};
+const COMMON_DOCUMENT_PROPERTIES = {
+	paymentMethod: {
+		...TEXT,
+		description: "Fizetési mód, például átutalás, készpénz, bankkártya."
+	},
+	currency: {
+		...TEXT,
+		description: "Pénznem, alapértelmezés: HUF."
+	},
+	exchangeRate: {
+		type: "number",
+		description: "Árfolyam devizás bizonylathoz."
+	},
+	exchangeBank: {
+		...TEXT,
+		description: "Az árfolyamot jegyző bank, például MNB."
+	},
+	comment: {
+		...TEXT,
+		description: "Megjegyzés a bizonylaton."
+	},
+	orderNumber: {
+		...TEXT,
+		description: "Rendelésszám (a bizonylaton megjelenik)."
+	},
+	prefix: {
+		...TEXT,
+		description: "A Számlázz.hu fiókban rögzített előtag."
+	}
+};
+function objectSchema(properties, required = []) {
+	return {
+		type: "object",
+		properties,
+		required: [...required],
+		additionalProperties: false
+	};
+}
+const INVOICE_PROPERTIES = {
+	type: {
+		type: "string",
+		enum: [...MCP_INVOICE_TYPES],
+		description: "invoice (számla, alapértelmezés) vagy proforma (díjbekérő)."
+	},
+	buyer: BUYER,
+	items: ITEMS,
+	...COMMON_DOCUMENT_PROPERTIES,
+	language: {
+		type: "string",
+		enum: [...require_create_once.INVOICE_LANGUAGES],
+		description: "A számla nyelve."
+	},
+	issueDate: {
+		...DATE,
+		description: "Kelt, alapértelmezés: ma."
+	},
+	fulfillmentDate: {
+		...DATE,
+		description: "Teljesítés dátuma, alapértelmezés: ma."
+	},
+	dueDate: {
+		...DATE,
+		description: "Fizetési határidő."
+	},
+	externalId: {
+		...TEXT,
+		description: "Saját külső azonosító. Ha megadod, ugyanezzel csak egy számla készül; ha nem, a kassza képez egyet."
+	},
+	paid: {
+		type: "boolean",
+		description: "A számla már ki van fizetve."
+	},
+	eInvoice: {
+		type: "boolean",
+		description: "Elektronikus számla."
+	},
+	sendEmail: {
+		type: "boolean",
+		description: "A Számlázz.hu e-mailben elküldi-e a vevőnek. Alapértelmezés: false."
+	}
+};
+const RECEIPT_PROPERTIES = {
+	items: ITEMS,
+	payments: {
+		type: "array",
+		description: "Kifizetések fizetőeszközönként; az összegük a nyugta bruttó végösszege.",
+		items: objectSchema({
+			method: {
+				...TEXT,
+				description: "Fizetőeszköz, például készpénz, bankkártya."
+			},
+			amount: { type: "number" },
+			description: TEXT
+		}, ["method", "amount"])
+	},
+	...COMMON_DOCUMENT_PROPERTIES
+};
+const CONFIRMATION_PROPERTY = {
+	...TEXT,
+	description: "Az előnézeti eszköz által adott megerősítő kód. Csak azután add meg, hogy a felhasználó jóváhagyta az előnézetet."
+};
+const TEXT_PROPERTY = TEXT;
+const INVOICE_SCHEMA = objectSchema(INVOICE_PROPERTIES, ["buyer", "items"]);
+const CREATE_INVOICE_SCHEMA = objectSchema({
+	...INVOICE_PROPERTIES,
+	confirmation: CONFIRMATION_PROPERTY
+}, [
+	"buyer",
+	"items",
+	"confirmation"
+]);
+const RECEIPT_SCHEMA = objectSchema(RECEIPT_PROPERTIES, ["items"]);
+const CREATE_RECEIPT_SCHEMA = objectSchema({
+	...RECEIPT_PROPERTIES,
+	confirmation: CONFIRMATION_PROPERTY
+}, ["items", "confirmation"]);
+//#endregion
+//#region src/mcp/tools-invoice.ts
+const PREVIEW_INVOICE = "preview_invoice";
+const CREATE_INVOICE = "create_invoice";
+function documentLabel(resolved) {
+	return resolved.type === "proforma" ? "Díjbekérő" : "Számla";
+}
+function resolve(input, context) {
+	return require_create_once.resolveInvoice(context.defaults.invoice ?? {}, input, context.now());
+}
+function previewData(input, resolved) {
+	const totals = require_money.summarizeItems(resolved.items.map((item) => item.amounts));
+	return {
+		document: resolved.type,
+		buyer: input.buyer,
+		issueDate: resolved.issueDate,
+		fulfillmentDate: resolved.fulfillmentDate,
+		dueDate: resolved.dueDate,
+		paymentMethod: resolved.paymentMethod,
+		currency: resolved.currency,
+		exchangeRate: resolved.exchangeRate,
+		exchangeBank: resolved.exchangeBank,
+		language: resolved.language,
+		prefix: resolved.prefix,
+		eInvoice: resolved.eInvoice,
+		sendEmail: resolved.sendEmail,
+		orderNumber: input.orderNumber,
+		comment: input.comment,
+		items: resolved.items.map((item) => ({
+			name: item.input.name,
+			quantity: item.amounts.quantity,
+			unit: item.unit,
+			netUnitPrice: item.amounts.netUnitPrice,
+			vat: item.amounts.vat,
+			netAmount: item.amounts.netAmount,
+			vatAmount: item.amounts.vatAmount,
+			grossAmount: item.amounts.grossAmount
+		})),
+		totals: {
+			netAmount: totals.netAmount,
+			vatAmount: totals.vatAmount,
+			grossAmount: totals.grossAmount
+		}
+	};
+}
+async function previewInvoice(args, context) {
+	const input = invoiceInputOf(args);
+	const resolved = resolve(input, context);
+	const data = previewData(input, resolved);
+	const totals = require_money.summarizeItems(resolved.items.map((item) => item.amounts));
+	const confirmation = await context.confirmations.issue(CREATE_INVOICE, args);
+	return {
+		summary: lines(`${documentLabel(resolved)} előnézete (még NEM készült el): ${input.buyer.name}, nettó ${money(totals.netAmount, resolved.currency)}, bruttó ${money(totals.grossAmount, resolved.currency)}.`, `Kelt: ${resolved.issueDate}, teljesítés: ${resolved.fulfillmentDate}, fizetési határidő: ${resolved.dueDate}, fizetési mód: ${resolved.paymentMethod}.`, resolved.sendEmail ? "A Számlázz.hu e-mailben elküldi a vevőnek." : "A vevő nem kap e-mailt a Számlázz.hu-tól.", `Mutasd meg az előnézetet a felhasználónak. Ha jóváhagyja, hívd meg a ${CREATE_INVOICE} eszközt pontosan ugyanezekkel az adatokkal, a confirmation mezőben ezzel a kóddal: ${confirmation.token} (lejár: ${confirmation.expiresAt}).`),
+		data: {
+			...data,
+			confirmation: confirmation.token,
+			confirmationExpiresAt: confirmation.expiresAt
+		}
+	};
+}
+function existingOutput(details, externalId, created) {
+	const currency = details.header.currency ?? "HUF";
+	return {
+		summary: created ? `Kiállítva: ${details.header.number} (bruttó ${money(details.totals.grossAmount, currency)}). A válasz elveszett, de a kassza visszakereste.` : `Ezzel a külső azonosítóval (${externalId}) már létezik bizonylat: ${details.header.number} (bruttó ${money(details.totals.grossAmount, currency)}). Nem állítottam ki újra. Ha valóban még egy ugyanilyen kell, adj meg eltérő externalId értéket.`,
+		data: {
+			created,
+			number: details.header.number,
+			externalId,
+			netTotal: details.totals.netAmount,
+			grossTotal: details.totals.grossAmount,
+			currency
+		}
+	};
+}
+async function createInvoice(args, context) {
+	const { payload, confirmation } = splitConfirmation(args);
+	await context.confirmations.verify(CREATE_INVOICE, payload, confirmation, PREVIEW_INVOICE);
+	const input = invoiceInputOf(payload);
+	const resolved = resolve(input, context);
+	const externalId = input.externalId ?? `MCP-${await idempotencyKey("create_invoice", resolved.issueDate, payload)}`;
+	const kassza = context.client();
+	const lookup = () => kassza.invoices.find({ externalId }, { includePdf: false });
+	const existing = await lookup();
+	if (existing) return existingOutput(existing, externalId, false);
+	try {
+		const created = await kassza.invoices.create({
+			...input,
+			externalId,
+			issueDate: resolved.issueDate,
+			fulfillmentDate: resolved.fulfillmentDate,
+			dueDate: resolved.dueDate
+		});
+		return {
+			summary: `${documentLabel(resolved)} kiállítva: ${created.number} (bruttó ${money(created.grossTotal, resolved.currency)}).`,
+			data: {
+				created: true,
+				number: created.number,
+				externalId,
+				netTotal: created.netTotal,
+				grossTotal: created.grossTotal,
+				outstanding: created.outstanding,
+				currency: resolved.currency
+			}
+		};
+	} catch (error) {
+		if (!require_issue.isUncertainOutcome(error)) throw error;
+		const recovered = await require_issue.recoverAfterFailure(lookup, context.recoveryDelayMs, void 0);
+		if (!recovered) throw error;
+		return existingOutput(recovered, externalId, error.category !== "duplicate");
+	}
+}
+const INVOICE_TOOLS = [{
+	name: PREVIEW_INVOICE,
+	title: "Számla előnézete",
+	description: "Kiszámolja egy számla vagy díjbekérő tételeit és végösszegét a Számlázz.hu hívása nélkül, és ad egy megerősítő kódot a create_invoice eszközhöz. Semmit nem állít ki.",
+	inputSchema: INVOICE_SCHEMA,
+	annotations: LOCAL_READ,
+	write: false,
+	run: previewInvoice
+}, {
+	name: CREATE_INVOICE,
+	title: "Számla kiállítása",
+	description: "Kiállítja a számlát vagy díjbekérőt a Számlázz.hu-n. Csak a preview_invoice által adott megerősítő kóddal működik, és csak akkor hívd, ha a felhasználó jóváhagyta az előnézetet. Ugyanazzal a kéréssel naponta csak egy bizonylat készül.",
+	inputSchema: CREATE_INVOICE_SCHEMA,
+	annotations: REMOTE_CREATE,
+	write: true,
+	run: createInvoice
+}];
+const INVOICE_TYPE_LABELS = {
+	invoice: "Számla",
+	proforma: "Díjbekérő",
+	advance: "Előlegszámla",
+	final: "Végszámla",
+	corrective: "Helyesbítő számla",
+	reversal: "Sztornó számla",
+	deliveryNote: "Szállítólevél"
+};
+function exactlyOne(values) {
+	const present = Object.entries(values).filter(([, value]) => value !== void 0);
+	if (present.length !== 1) throw new ToolInputError(`Pontosan egyet adj meg ezek közül: ${Object.keys(values).join(", ")}.`);
+	return present[0]?.[0] ?? "";
+}
+async function getInvoice(args, context) {
+	assertKnownKeys(args, [
+		"invoiceNumber",
+		"orderNumber",
+		"externalId"
+	], "");
+	const invoiceNumber = optionalString(args, "invoiceNumber", "");
+	const orderNumber = optionalString(args, "orderNumber", "");
+	const externalId = optionalString(args, "externalId", "");
+	const kind = exactlyOne({
+		invoiceNumber,
+		orderNumber,
+		externalId
+	});
+	const reference = kind === "invoiceNumber" ? invoiceNumber ?? "" : kind === "orderNumber" ? { orderNumber: orderNumber ?? "" } : { externalId: externalId ?? "" };
+	const details = await context.client().invoices.find(reference, { includePdf: false });
+	if (!details) return {
+		summary: "Nincs ilyen számla a Számlázz.hu fiókban.",
+		data: { found: false }
+	};
+	const { header } = details;
+	const currency = header.currency ?? "HUF";
+	return {
+		summary: lines(`${INVOICE_TYPE_LABELS[header.type] ?? "Bizonylat"} ${header.number}: ${details.buyer.name}, bruttó ${money(details.totals.grossAmount, currency)}, kelt: ${header.issueDate}.`, header.reversed === true && "A számlát sztornózták.", header.test === true && "Tesztfiókban készült."),
+		data: {
+			found: true,
+			invoice: plainJson(details)
+		}
+	};
+}
+async function getReceipt(args, context) {
+	assertKnownKeys(args, ["receiptNumber", "orderNumber"], "");
+	const receiptNumber = optionalString(args, "receiptNumber", "");
+	const orderNumber = optionalString(args, "orderNumber", "");
+	const kind = exactlyOne({
+		receiptNumber,
+		orderNumber
+	});
+	const receipt = await context.client().receipts.find(kind === "receiptNumber" ? {
+		receiptNumber: receiptNumber ?? "",
+		downloadPdf: false
+	} : {
+		orderNumber: orderNumber ?? "",
+		downloadPdf: false
+	});
+	if (!receipt) return {
+		summary: "Nincs ilyen nyugta a Számlázz.hu fiókban.",
+		data: { found: false }
+	};
+	return {
+		summary: lines(`${receipt.type === "reversal" ? "Sztornónyugta" : "Nyugta"} ${receipt.number}: bruttó ${money(receipt.totals.grossAmount, receipt.currency)}, kelt: ${receipt.issueDate}.`, receipt.isReversed && "A nyugtát sztornózták.", receipt.isTest && "Tesztfiókban készült."),
+		data: {
+			found: true,
+			receipt: plainJson(receipt)
+		}
+	};
+}
+async function queryTaxpayer(args, context) {
+	assertKnownKeys(args, ["taxNumber"], "");
+	const taxNumber = requiredString(args, "taxNumber", "");
+	const info = await context.client().taxpayer.query(taxNumber);
+	return {
+		summary: info.valid ? lines(`${info.name ?? "Ismeretlen név"}${info.taxNumber?.formatted ? ` (${info.taxNumber.formatted})` : ""}: a NAV szerint érvényes adószám.`, info.address && `Székhely: ${info.address.formatted}.`) : "A NAV szerint ez az adószám nem érvényes, vagy nem tartozik működő adóalanyhoz.",
+		data: plainJson(info)
+	};
+}
+function receiptNumbersOf(args) {
+	const listed = optionalArray(args, "receiptNumbers", "");
+	const series = optionalString(args, "series", "");
+	const from = optionalInteger(args, "from", "");
+	const to = optionalInteger(args, "to", "");
+	if (listed !== void 0) {
+		if (series !== void 0 || from !== void 0 || to !== void 0) throw new ToolInputError("A receiptNumbers mellett ne adj meg series, from vagy to mezőt.");
+		const numbers = listed.map((value, index) => {
+			if (typeof value !== "string" || value.trim() === "") throw new ToolInputError(`A(z) receiptNumbers[${index}] nem érvényes nyugtaszám.`);
+			return value.trim();
+		});
+		return [...new Set(numbers)];
+	}
+	if (series === void 0 || from === void 0 || to === void 0) throw new ToolInputError("Add meg a nyugtaszámokat (receiptNumbers), vagy a sorozatot és a tartományt (series, from, to), például series: \"NYGT-2026\", from: 1, to: 120.");
+	if (from < 1 || to < from) throw new ToolInputError("A from legalább 1 legyen, és nem lehet nagyobb a to értékénél.");
+	return Array.from({ length: to - from + 1 }, (_, index) => `${series}-${from + index}`);
+}
+async function navDailySummary(args, context) {
+	assertKnownKeys(args, [
+		"receiptNumbers",
+		"series",
+		"from",
+		"to",
+		"includeTest"
+	], "");
+	const numbers = receiptNumbersOf(args);
+	if (numbers.length === 0 || numbers.length > 200) throw new ToolInputError(`Egyszerre 1 és 200 közötti számú nyugta összesíthető, kért: ${numbers.length}.`);
+	const includeTest = optionalBoolean(args, "includeTest", "") ?? false;
+	const kassza = context.client();
+	const receipts = [];
+	const missing = [];
+	for (const receiptNumber of numbers) {
+		const receipt = await kassza.receipts.find({
+			receiptNumber,
+			downloadPdf: false
+		});
+		if (receipt) receipts.push(receipt);
+		else missing.push(receiptNumber);
+	}
+	const reports = require_nav.navDailyReports(receipts, { includeTest });
+	const skippedTest = includeTest ? 0 : receipts.filter((receipt) => receipt.isTest).length;
+	return {
+		summary: lines(reports.length === 0 ? "Nincs összesíthető nyugta." : reports.map((report) => require_nav.describeNavReport(report)).join("\n\n"), missing.length > 0 && `Nem található nyugták: ${missing.join(", ")}.`, skippedTest > 0 && `${skippedTest} tesztfiókos nyugtát kihagytam (az includeTest: true beveszi őket).`),
+		data: {
+			reports: plainJson({ reports }).reports,
+			missing,
+			receiptCount: receipts.length
+		}
+	};
+}
+const LOOKUP_TOOLS = [
+	{
+		name: "get_invoice",
+		title: "Számla lekérdezése",
+		description: "Lekér egy számlát (díjbekérőt, sztornót) a Számlázz.hu-ról számlaszám, rendelésszám vagy külső azonosító alapján.",
+		inputSchema: objectSchema({
+			invoiceNumber: TEXT_PROPERTY,
+			orderNumber: TEXT_PROPERTY,
+			externalId: TEXT_PROPERTY
+		}),
+		annotations: REMOTE_READ,
+		write: false,
+		run: getInvoice
+	},
+	{
+		name: "get_receipt",
+		title: "Nyugta lekérdezése",
+		description: "Lekér egy nyugtát a Számlázz.hu-ról nyugtaszám vagy rendelésszám alapján.",
+		inputSchema: objectSchema({
+			receiptNumber: TEXT_PROPERTY,
+			orderNumber: TEXT_PROPERTY
+		}),
+		annotations: REMOTE_READ,
+		write: false,
+		run: getReceipt
+	},
+	{
+		name: "query_taxpayer",
+		title: "Adószám ellenőrzése",
+		description: "A NAV adatai alapján (a Számlázz.hu-n keresztül) ellenőrzi az adószámot, és visszaadja a cég nevét és székhelyét.",
+		inputSchema: objectSchema({ taxNumber: {
+			...TEXT_PROPERTY,
+			description: "8 jegyű törzsszám vagy 11 jegyű adószám, például 12345676-2-42."
+		} }, ["taxNumber"]),
+		annotations: REMOTE_READ,
+		write: false,
+		run: queryTaxpayer
+	},
+	{
+		name: "nav_daily_summary",
+		title: "Napi NAV nyugta-összesítő",
+		description: `Lekéri a megadott nyugtákat, és elkészíti belőlük a NAV felé teendő napi, áfakategóriánkénti összesítőt (kezdő sorszám, értékesítés, módosító bizonylatok). Egyszerre legfeljebb 200 nyugta.`,
+		inputSchema: objectSchema({
+			receiptNumbers: {
+				type: "array",
+				items: TEXT_PROPERTY,
+				minItems: 1,
+				maxItems: 200
+			},
+			series: {
+				...TEXT_PROPERTY,
+				description: "Sorozat, például NYGT-2026."
+			},
+			from: {
+				type: "integer",
+				minimum: 1
+			},
+			to: {
+				type: "integer",
+				minimum: 1
+			},
+			includeTest: {
+				type: "boolean",
+				description: "A tesztfiókos nyugtákat is összesíti."
+			}
+		}),
+		annotations: REMOTE_READ,
+		write: false,
+		run: navDailySummary
+	}
+];
+//#endregion
+//#region src/mcp/tools-receipt.ts
+const PREVIEW_RECEIPT = "preview_receipt";
+const CREATE_RECEIPT = "create_receipt";
+const DUPLICATE_CALL_ID = 338;
+function previewOf(input, context) {
+	const defaults = context.defaults.receipt ?? {};
+	require_issue.buildCreateReceiptXml([], defaults, input);
+	const currency = input.currency ?? defaults.currency ?? "HUF";
+	const items = require_issue.calculateReceiptItems(input.items, currency);
+	const totals = require_money.summarizeItems(items.map((item) => item.amounts));
+	return {
+		currency,
+		grossAmount: totals.grossAmount,
+		data: {
+			document: "receipt",
+			prefix: input.prefix ?? defaults.prefix,
+			paymentMethod: input.paymentMethod ?? defaults.paymentMethod,
+			currency,
+			exchangeRate: input.exchangeRate ?? defaults.exchangeRate,
+			orderNumber: input.orderNumber,
+			comment: input.comment,
+			items: items.map((item) => ({
+				name: item.input.name,
+				quantity: item.amounts.quantity,
+				unit: item.input.unit ?? defaults.unit ?? "db",
+				netUnitPrice: item.amounts.netUnitPrice,
+				vat: item.vat,
+				netAmount: item.amounts.netAmount,
+				vatAmount: item.amounts.vatAmount,
+				grossAmount: item.amounts.grossAmount
+			})),
+			payments: input.payments ?? [],
+			totals: {
+				netAmount: totals.netAmount,
+				vatAmount: totals.vatAmount,
+				grossAmount: totals.grossAmount
+			}
+		}
+	};
+}
+async function previewReceipt(args, context) {
+	const preview = previewOf(receiptInputOf(args), context);
+	const confirmation = await context.confirmations.issue(CREATE_RECEIPT, args);
+	return {
+		summary: lines(`Nyugta előnézete (még NEM készült el): bruttó ${money(preview.grossAmount, preview.currency)}.`, `Mutasd meg az előnézetet a felhasználónak. Ha jóváhagyja, hívd meg a ${CREATE_RECEIPT} eszközt pontosan ugyanezekkel az adatokkal, a confirmation mezőben ezzel a kóddal: ${confirmation.token} (lejár: ${confirmation.expiresAt}).`),
+		data: {
+			...preview.data,
+			confirmation: confirmation.token,
+			confirmationExpiresAt: confirmation.expiresAt
+		}
+	};
+}
+function receiptOutput(receipt, created) {
+	const total = money(receipt.totals.grossAmount, receipt.currency);
+	return {
+		summary: created ? `Nyugta kiállítva: ${receipt.number} (bruttó ${total}).` : `Ehhez a rendelésszámhoz már létezik nyugta: ${receipt.number} (bruttó ${total}). Nem állítottam ki újra.`,
+		data: {
+			created,
+			number: receipt.number,
+			type: receipt.type,
+			orderNumber: receipt.orderNumber,
+			callId: receipt.callId,
+			issueDate: receipt.issueDate,
+			grossTotal: receipt.totals.grossAmount,
+			currency: receipt.currency
+		}
+	};
+}
+function duplicateCallIdError(error, callId) {
+	return new require_errors.SzamlazzError(`Ezekkel az adatokkal ma már készült nyugta ezen az eszközön keresztül (hívásazonosító: ${callId}), ezért nem készült új.`, {
+		category: "duplicate",
+		code: error.code,
+		action: error.action,
+		hint: "A Számla Agent hívásazonosító alapján nem tud nyugtát lekérdezni: a nyugtát a Számlázz.hu felületén találod. Ha valóban még egy ugyanilyen nyugta kell, adj meg rendelésszámot (orderNumber), vagy változtass az adatokon.",
+		cause: error
+	});
+}
+async function createReceipt(args, context) {
+	const { payload, confirmation } = splitConfirmation(args);
+	await context.confirmations.verify(CREATE_RECEIPT, payload, confirmation, PREVIEW_RECEIPT);
+	const input = receiptInputOf(payload);
+	previewOf(input, context);
+	const day = require_dates.toBudapestDate(context.now());
+	const callId = `MCP-${await idempotencyKey(CREATE_RECEIPT, day, payload)}`;
+	const kassza = context.client();
+	if (input.orderNumber !== void 0) {
+		const result = await kassza.receipts.createOnce({
+			...input,
+			callId
+		}, { recoveryDelayMs: context.recoveryDelayMs });
+		return receiptOutput(result.receipt, result.created);
+	}
+	try {
+		return receiptOutput(await kassza.receipts.create({
+			...input,
+			callId
+		}), true);
+	} catch (error) {
+		if (require_errors.isSzamlazzError(error) && error.code === DUPLICATE_CALL_ID) throw duplicateCallIdError(error, callId);
+		throw error;
+	}
+}
+const RECEIPT_TOOLS = [{
+	name: PREVIEW_RECEIPT,
+	title: "Nyugta előnézete",
+	description: "Kiszámolja egy nyugta tételeit és végösszegét a Számlázz.hu hívása nélkül, ellenőrzi a forintos kerekítési szabályokat, és ad egy megerősítő kódot a create_receipt eszközhöz. Semmit nem állít ki.",
+	inputSchema: RECEIPT_SCHEMA,
+	annotations: LOCAL_READ,
+	write: false,
+	run: previewReceipt
+}, {
+	name: CREATE_RECEIPT,
+	title: "Nyugta kiállítása",
+	description: "Kiállítja a nyugtát a Számlázz.hu-n. Csak a preview_receipt által adott megerősítő kóddal működik, és csak akkor hívd, ha a felhasználó jóváhagyta az előnézetet. Rendelésszámmal egy rendeléshez csak egy nyugta készül.",
+	inputSchema: CREATE_RECEIPT_SCHEMA,
+	annotations: REMOTE_CREATE,
+	write: true,
+	run: createReceipt
+}];
+//#endregion
+//#region src/mcp/tools-reversal.ts
+const PREVIEW_REVERSAL = "preview_reversal";
+const REVERSE_INVOICE = "reverse_invoice";
+const REVERSE_RECEIPT = "reverse_receipt";
+const DOCUMENT_KINDS = ["invoice", "receipt"];
+const ALREADY_REVERSED_MESSAGE = "már sztornózták";
+function assertReversibleInvoice(details) {
+	const { number, type } = details.header;
+	if (type === "reversal") throw new ToolInputError(`A(z) ${number} sztornó számla, nem sztornózható.`);
+	if (type === "proforma") throw new ToolInputError(`A(z) ${number} díjbekérő, nem sztornózható. Díjbekérőt a Számlázz.hu felületén vagy a kassza deleteProforma függvényével lehet törölni.`);
+	if (type === "deliveryNote") throw new ToolInputError(`A(z) ${number} szállítólevél, nem sztornózható.`);
+}
+function assertReversibleReceipt(receipt) {
+	if (receipt.type === "reversal") throw new ToolInputError(`A(z) ${receipt.number} sztornónyugta, nem sztornózható.`);
+}
+async function previewInvoiceReversal(number, context) {
+	const details = await context.client().invoices.get(number, { includePdf: false });
+	assertReversibleInvoice(details);
+	if (details.header.reversed === true) throw new ToolInputError(`A(z) ${number} számlát már sztornózták.`);
+	const confirmation = await context.confirmations.issue(REVERSE_INVOICE, { invoiceNumber: number });
+	const currency = details.header.currency ?? "HUF";
+	return {
+		summary: lines(`Sztornó előnézete (még NEM készült el): a(z) ${number} számla sztornózása. Vevő: ${details.buyer.name}, bruttó ${money(details.totals.grossAmount, currency)}, kelt: ${details.header.issueDate}.`, `Mutasd meg a felhasználónak. Ha jóváhagyja, hívd meg a ${REVERSE_INVOICE} eszközt az invoiceNumber mezőben a számlaszámmal, a confirmation mezőben ezzel a kóddal: ${confirmation.token} (lejár: ${confirmation.expiresAt}).`),
+		data: {
+			document: "invoice",
+			number,
+			buyer: details.buyer.name,
+			issueDate: details.header.issueDate,
+			grossTotal: details.totals.grossAmount,
+			currency,
+			confirmation: confirmation.token,
+			confirmationExpiresAt: confirmation.expiresAt
+		}
+	};
+}
+async function previewReceiptReversal(number, context) {
+	const receipt = await context.client().receipts.get({
+		receiptNumber: number,
+		downloadPdf: false
+	});
+	assertReversibleReceipt(receipt);
+	if (receipt.isReversed) throw new ToolInputError(`A(z) ${number} nyugtát már sztornózták.`);
+	const confirmation = await context.confirmations.issue(REVERSE_RECEIPT, { receiptNumber: number });
+	return {
+		summary: lines(`Sztornó előnézete (még NEM készült el): a(z) ${number} nyugta sztornózása, bruttó ${money(receipt.totals.grossAmount, receipt.currency)}, kelt: ${receipt.issueDate}.`, `Mutasd meg a felhasználónak. Ha jóváhagyja, hívd meg a ${REVERSE_RECEIPT} eszközt a receiptNumber mezőben a nyugtaszámmal, a confirmation mezőben ezzel a kóddal: ${confirmation.token} (lejár: ${confirmation.expiresAt}).`),
+		data: {
+			document: "receipt",
+			number,
+			issueDate: receipt.issueDate,
+			grossTotal: receipt.totals.grossAmount,
+			currency: receipt.currency,
+			confirmation: confirmation.token,
+			confirmationExpiresAt: confirmation.expiresAt
+		}
+	};
+}
+async function previewReversal(args, context) {
+	assertKnownKeys(args, ["document", "number"], "");
+	const document = optionalEnum(args, "document", "", DOCUMENT_KINDS);
+	if (document === void 0) throw new ToolInputError("A document mező kötelező: invoice (számla) vagy receipt (nyugta).");
+	const number = requiredString(args, "number", "");
+	return document === "invoice" ? previewInvoiceReversal(number, context) : previewReceiptReversal(number, context);
+}
+function reversalOutput(document, reversedNumber, number, created) {
+	const label = document === "invoice" ? "számla" : "nyugta";
+	return {
+		summary: created ? `A(z) ${reversedNumber} ${label} sztornózva${number === void 0 ? "" : `, sztornó: ${number}`}.` : `A(z) ${reversedNumber} ${label} már sztornózva volt${number === void 0 ? "" : ` (sztornó: ${number})`}, nem sztornóztam újra.`,
+		data: {
+			created,
+			document,
+			reversedNumber,
+			number
+		}
+	};
+}
+async function reverseInvoice(args, context) {
+	assertKnownKeys(args, ["invoiceNumber", "confirmation"], "");
+	const invoiceNumber = requiredString(args, "invoiceNumber", "");
+	await context.confirmations.verify(REVERSE_INVOICE, { invoiceNumber }, args.confirmation, PREVIEW_REVERSAL);
+	const kassza = context.client();
+	const externalId = `${invoiceNumber}/SS`;
+	const lookup = () => kassza.invoices.find({ externalId }, { includePdf: false });
+	const existing = await lookup();
+	if (existing) return reversalOutput("invoice", invoiceNumber, existing.header.number, false);
+	const original = await kassza.invoices.get(invoiceNumber, { includePdf: false });
+	assertReversibleInvoice(original);
+	if (original.header.reversed === true) return reversalOutput("invoice", invoiceNumber, void 0, false);
+	try {
+		return reversalOutput("invoice", invoiceNumber, (await kassza.invoices.reverse({
+			invoiceNumber,
+			externalId,
+			downloadPdf: false
+		})).number, true);
+	} catch (error) {
+		if (!require_issue.isUncertainOutcome(error)) throw error;
+		const recovered = await require_issue.recoverAfterFailure(lookup, context.recoveryDelayMs, void 0);
+		if (!recovered) throw error;
+		return reversalOutput("invoice", invoiceNumber, recovered.header.number, error.category !== "duplicate");
+	}
+}
+async function reverseReceipt(args, context) {
+	assertKnownKeys(args, ["receiptNumber", "confirmation"], "");
+	const receiptNumber = requiredString(args, "receiptNumber", "");
+	await context.confirmations.verify(REVERSE_RECEIPT, { receiptNumber }, args.confirmation, PREVIEW_REVERSAL);
+	const kassza = context.client();
+	const original = await kassza.receipts.get({
+		receiptNumber,
+		downloadPdf: false
+	});
+	assertReversibleReceipt(original);
+	if (original.isReversed) return reversalOutput("receipt", receiptNumber, void 0, false);
+	try {
+		return reversalOutput("receipt", receiptNumber, (await kassza.receipts.reverse({
+			receiptNumber,
+			callId: `${receiptNumber}/SN`,
+			downloadPdf: false
+		})).number, true);
+	} catch (error) {
+		if (!require_issue.isUncertainOutcome(error)) throw error;
+		if (!(await kassza.receipts.get({
+			receiptNumber,
+			downloadPdf: false
+		})).isReversed) throw error;
+		return reversalOutput("receipt", receiptNumber, void 0, !(error.category === "duplicate" || error.message.includes(ALREADY_REVERSED_MESSAGE)));
+	}
+}
+const REVERSAL_TOOLS = [
+	{
+		name: PREVIEW_REVERSAL,
+		title: "Sztornó előnézete",
+		description: "Lekéri a sztornózandó számlát vagy nyugtát, ellenőrzi, hogy sztornózható-e, és ad egy megerősítő kódot a reverse_invoice vagy reverse_receipt eszközhöz. Semmit nem sztornóz.",
+		inputSchema: objectSchema({
+			document: {
+				type: "string",
+				enum: [...DOCUMENT_KINDS],
+				description: "invoice (számla) vagy receipt (nyugta)."
+			},
+			number: {
+				...TEXT_PROPERTY,
+				description: "A számla- vagy nyugtaszám."
+			}
+		}, ["document", "number"]),
+		annotations: REMOTE_READ,
+		write: false,
+		run: previewReversal
+	},
+	{
+		name: REVERSE_INVOICE,
+		title: "Számla sztornózása",
+		description: "Sztornó számlát állít ki a megadott számlához. Csak a preview_reversal által adott megerősítő kóddal működik, és csak a felhasználó jóváhagyása után hívd. Egy számlát csak egyszer sztornóz.",
+		inputSchema: objectSchema({
+			invoiceNumber: TEXT_PROPERTY,
+			confirmation: CONFIRMATION_PROPERTY
+		}, ["invoiceNumber", "confirmation"]),
+		annotations: REMOTE_REVERSE,
+		write: true,
+		run: reverseInvoice
+	},
+	{
+		name: REVERSE_RECEIPT,
+		title: "Nyugta sztornózása",
+		description: "Sztornónyugtát állít ki a megadott nyugtához. Csak a preview_reversal által adott megerősítő kóddal működik, és csak a felhasználó jóváhagyása után hívd. Egy nyugtát csak egyszer sztornóz.",
+		inputSchema: objectSchema({
+			receiptNumber: TEXT_PROPERTY,
+			confirmation: CONFIRMATION_PROPERTY
+		}, ["receiptNumber", "confirmation"]),
+		annotations: REMOTE_REVERSE,
+		write: true,
+		run: reverseReceipt
+	}
+];
+//#endregion
+//#region src/mcp/tools.ts
+const KASSZA_MCP_TOOLS = [
+	...INVOICE_TOOLS,
+	...RECEIPT_TOOLS,
+	...REVERSAL_TOOLS,
+	...LOOKUP_TOOLS
+];
+//#endregion
+//#region src/mcp/server.ts
+const SERVER_INFO = {
+	name: "kassza",
+	title: "kassza: Számlázz.hu számlák és nyugták",
+	version: KASSZA_VERSION
+};
+const LIST_TTL_MS = 36e5;
+const INSTRUCTIONS = [
+	"A kassza a Számlázz.hu Számla Agenten keresztül állít ki és kérdez le számlákat és nyugtákat.",
+	"Kiállítás vagy sztornó előtt mindig hívd meg a megfelelő előnézeti eszközt (preview_invoice, preview_receipt, preview_reversal), mutasd meg az eredményt a felhasználónak, és csak a kifejezett jóváhagyása után hívd az író eszközt a kapott confirmation kóddal.",
+	"Az író eszközök csak akkor érhetők el, ha a szervert KASSZA_MCP_ALLOW_WRITE=1 beállítással indították. Próbához Számlázz.hu tesztfiókot ajánlunk."
+].join(" ");
+const WRITE_DISABLED_MESSAGE = "Az írási eszközök ki vannak kapcsolva. A kiállításhoz és a sztornóhoz indítsd a szervert a KASSZA_MCP_ALLOW_WRITE=1 környezeti változóval (vagy a kassza mcp --allow-write kapcsolóval).";
+function describeError(error) {
+	if (error instanceof ToolInputError) return error.message;
+	if (require_errors.isSzamlazzError(error)) return error.hint ? `${error.message}\nTipp: ${error.hint}` : error.message;
+	if (error instanceof Error) return `Váratlan hiba: ${error.message}`;
+	return "Váratlan hiba történt.";
+}
+function modernVersionOf(params) {
+	const meta = params._meta;
+	if (!isJsonObject(meta) || !("io.modelcontextprotocol/protocolVersion" in meta)) return void 0;
+	const version = meta[META_PROTOCOL_VERSION];
+	if (typeof version !== "string" || version.trim() === "") throw new McpProtocolError(JSON_RPC_INVALID_PARAMS, `A _meta["${META_PROTOCOL_VERSION}"] mezőnek nem üres szövegnek kell lennie.`);
+	if (!MCP_MODERN_VERSIONS.includes(version)) throw new McpProtocolError(MCP_UNSUPPORTED_PROTOCOL_VERSION, "Unsupported protocol version", { data: {
+		supported: [...MCP_SUPPORTED_VERSIONS],
+		requested: version
+	} });
+	if (!isJsonObject(meta["io.modelcontextprotocol/clientCapabilities"])) throw new McpProtocolError(JSON_RPC_INVALID_PARAMS, `Hiányzik a kötelező _meta["${META_CLIENT_CAPABILITIES}"] mező.`);
+	return version;
+}
+function toolDefinition(tool) {
+	return {
+		name: tool.name,
+		title: tool.title,
+		description: tool.description,
+		inputSchema: tool.inputSchema,
+		annotations: {
+			title: tool.title,
+			...tool.annotations
+		}
+	};
+}
+function createKasszaMcpServer(options = {}) {
+	const allowWrite = options.allowWrite === true;
+	const now = options.now ?? (() => /* @__PURE__ */ new Date());
+	const recoveryDelayMs = require_issue.resolveRecoveryDelay(options.recoveryDelayMs ?? 1e3);
+	const confirmations = createConfirmations({
+		secret: options.confirmationSecret,
+		ttlMs: options.confirmationTtlMs,
+		now
+	});
+	let client;
+	const context = {
+		client: () => {
+			client ??= require_client.createKassza(options);
+			return client;
+		},
+		defaults: options.defaults ?? {},
+		confirmations,
+		now,
+		recoveryDelayMs
+	};
+	const visibleTools = KASSZA_MCP_TOOLS.filter((tool) => allowWrite || !tool.write);
+	const listTools = (params) => {
+		if (params.cursor !== void 0) throw new McpProtocolError(JSON_RPC_INVALID_PARAMS, "Érvénytelen cursor: az eszközlista egyetlen oldalból áll.");
+		return { tools: visibleTools.map(toolDefinition) };
+	};
+	const callTool = async (params) => {
+		const name = params.name;
+		if (typeof name !== "string") throw new McpProtocolError(JSON_RPC_INVALID_PARAMS, "Hiányzik az eszköz neve (name).");
+		const tool = KASSZA_MCP_TOOLS.find((candidate) => candidate.name === name);
+		if (!tool) throw new McpProtocolError(JSON_RPC_INVALID_PARAMS, `Ismeretlen eszköz: ${name}`);
+		const args = params.arguments ?? {};
+		if (!isJsonObject(args)) throw new McpProtocolError(JSON_RPC_INVALID_PARAMS, "Az arguments mezőnek objektumnak kell lennie.");
+		if (tool.write && !allowWrite) return {
+			content: [{
+				type: "text",
+				text: WRITE_DISABLED_MESSAGE
+			}],
+			isError: true
+		};
+		try {
+			const output = await tool.run(args, context);
+			const data = plainJson(output.data);
+			return {
+				content: [{
+					type: "text",
+					text: output.summary
+				}, {
+					type: "text",
+					text: JSON.stringify(data, null, 2)
+				}],
+				structuredContent: data,
+				isError: false
+			};
+		} catch (error) {
+			return {
+				content: [{
+					type: "text",
+					text: describeError(error)
+				}],
+				isError: true
+			};
+		}
+	};
+	const modern = async (request) => {
+		const meta = { [META_SERVER_INFO]: SERVER_INFO };
+		switch (request.method) {
+			case "server/discover": return {
+				resultType: "complete",
+				supportedVersions: [...MCP_SUPPORTED_VERSIONS],
+				capabilities: { tools: {} },
+				instructions: INSTRUCTIONS,
+				ttlMs: LIST_TTL_MS,
+				cacheScope: "private",
+				_meta: meta
+			};
+			case "tools/list": return {
+				resultType: "complete",
+				...listTools(request.params),
+				ttlMs: LIST_TTL_MS,
+				cacheScope: "private",
+				_meta: meta
+			};
+			case "tools/call": return {
+				resultType: "complete",
+				...await callTool(request.params),
+				_meta: meta
+			};
+			default: throw new McpProtocolError(JSON_RPC_METHOD_NOT_FOUND, `Ismeretlen metódus: ${request.method}`);
+		}
+	};
+	const initialize = (request, session) => {
+		const requested = request.params.protocolVersion;
+		if (typeof requested !== "string") throw new McpProtocolError(JSON_RPC_INVALID_PARAMS, "Hiányzik a protocolVersion mező.");
+		const version = MCP_LEGACY_VERSIONS.includes(requested) ? requested : MCP_LEGACY_VERSIONS[0] ?? requested;
+		session.legacyVersion = version;
+		return {
+			protocolVersion: version,
+			capabilities: { tools: { listChanged: false } },
+			serverInfo: SERVER_INFO,
+			instructions: INSTRUCTIONS
+		};
+	};
+	const legacy = async (request, session) => {
+		if (request.method === "ping") return {};
+		if (session.legacyVersion === void 0) throw new McpProtocolError(JSON_RPC_INVALID_PARAMS, `Hiányzik a kötelező _meta["${META_PROTOCOL_VERSION}"] mező. 2026-07-28 előtti protokollnál előbb initialize kérést kell küldeni.`);
+		if (request.method === "tools/list") return listTools(request.params);
+		if (request.method === "tools/call") return callTool(request.params);
+		throw new McpProtocolError(JSON_RPC_METHOD_NOT_FOUND, `Ismeretlen metódus: ${request.method}`);
+	};
+	const respond = async (request, session) => {
+		try {
+			if (request.method === "initialize") return success(request.id, initialize(request, session));
+			const result = modernVersionOf(request.params) === void 0 ? await legacy(request, session) : await modern(request);
+			return success(request.id, result);
+		} catch (error) {
+			if (error instanceof McpProtocolError) return failure(request.id, error.code, error.message, error.data);
+			return failure(request.id, JSON_RPC_INTERNAL_ERROR, "Belső hiba a kassza MCP szerverben.");
+		}
+	};
+	const handleSingle = async (message, session) => {
+		try {
+			const parsed = parseMcpMessage(message);
+			if (parsed.kind !== "request") return void 0;
+			return await respond(parsed, session);
+		} catch (error) {
+			if (error instanceof McpProtocolError) return protocolFailure(error);
+			return failure(null, JSON_RPC_INTERNAL_ERROR, "Belső hiba a kassza MCP szerverben.");
+		}
+	};
+	return {
+		tools: KASSZA_MCP_TOOLS.map((tool) => ({
+			name: tool.name,
+			title: tool.title,
+			write: tool.write
+		})),
+		connect() {
+			const session = { legacyVersion: void 0 };
+			const handle = async (message) => {
+				if (!Array.isArray(message)) return handleSingle(message, session);
+				if (message.length === 0) return failure(null, JSON_RPC_INVALID_REQUEST, "Az üres batch érvénytelen.");
+				const responses = [];
+				for (const entry of message) {
+					const response = await handleSingle(entry, session);
+					if (response) responses.push(response);
+				}
+				return responses.length === 0 ? void 0 : responses;
+			};
+			return {
+				handle,
+				async handleLine(line) {
+					const trimmed = line.trim();
+					if (trimmed === "") return void 0;
+					let message;
+					try {
+						message = JSON.parse(trimmed);
+					} catch {
+						return JSON.stringify(failure(null, JSON_RPC_PARSE_ERROR, "Érvénytelen JSON."));
+					}
+					const response = await handle(message);
+					return response === void 0 ? void 0 : JSON.stringify(response);
+				}
+			};
+		}
+	};
+}
+//#endregion
+Object.defineProperty(exports, "DEFAULT_CONFIRMATION_TTL_MS", {
+	enumerable: true,
+	get: function() {
+		return DEFAULT_CONFIRMATION_TTL_MS;
+	}
+});
+Object.defineProperty(exports, "KASSZA_VERSION", {
+	enumerable: true,
+	get: function() {
+		return KASSZA_VERSION;
+	}
+});
+Object.defineProperty(exports, "MCP_LEGACY_VERSIONS", {
+	enumerable: true,
+	get: function() {
+		return MCP_LEGACY_VERSIONS;
+	}
+});
+Object.defineProperty(exports, "MCP_MODERN_VERSIONS", {
+	enumerable: true,
+	get: function() {
+		return MCP_MODERN_VERSIONS;
+	}
+});
+Object.defineProperty(exports, "MCP_SUPPORTED_VERSIONS", {
+	enumerable: true,
+	get: function() {
+		return MCP_SUPPORTED_VERSIONS;
+	}
+});
+Object.defineProperty(exports, "ToolInputError", {
+	enumerable: true,
+	get: function() {
+		return ToolInputError;
+	}
+});
+Object.defineProperty(exports, "canonicalJson", {
+	enumerable: true,
+	get: function() {
+		return canonicalJson;
+	}
+});
+Object.defineProperty(exports, "createConfirmations", {
+	enumerable: true,
+	get: function() {
+		return createConfirmations;
+	}
+});
+Object.defineProperty(exports, "createKasszaMcpServer", {
+	enumerable: true,
+	get: function() {
+		return createKasszaMcpServer;
+	}
+});