@open-nav/mcp 0.1.0

package/LICENSE

@@ -0,0 +1,29 @@
+MIT License
+
+Copyright (c) 2026 open-nav contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+This repository vendors XML schemas, sample documents and validation message
+catalogues published by the Hungarian Tax and Customs Administration
+(Nemzeti Adó- és Vámhivatal) under the MIT license. Those files live under
+`schemas/` and `conformance/`, retain NAV's copyright, and are covered by
+`schemas/NAV-LICENCE.md`. See `schemas/README.md` for provenance.

package/README.md

@@ -0,0 +1,91 @@
+# @open-nav/mcp
+
+An MCP server that gives an AI agent the NAV **Online Számla** invoice
+service: validate invoice data, look up a rejection, render an invoice,
+report to NAV, and read back what was reported.
+
+## Setup
+
+```sh
+claude mcp add open-nav -- npx -y @open-nav/mcp
+```
+
+Or in `.mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "open-nav": {
+      "command": "npx",
+      "args": ["-y", "@open-nav/mcp"],
+      "env": {
+        "NAV_ENVIRONMENT": "test",
+        "NAV_LOGIN": "...",
+        "NAV_PASSWORD": "...",
+        "NAV_SIGN_KEY": "...",
+        "NAV_EXCHANGE_KEY": "...",
+        "NAV_TAX_NUMBER": "12345678",
+        "NAV_SOFTWARE_ID": "..."
+      }
+    }
+  }
+}
+```
+
+Same variables as the CLI, so one configuration serves both.
+`NAV_TAX_NUMBER` is the **8 digit** core number, not the 11 digit form.
+
+## Tools
+
+Four work with no credentials at all:
+
+| Tool                | What it does                                                                             |
+| ------------------- | ---------------------------------------------------------------------------------------- |
+| `validate_invoice`  | Check invoice data against the schema and the business rules, with NAV's own fault codes |
+| `lookup_fault_code` | Explain a NAV fault code in NAV's words, in `hu`, `en` or `de`                           |
+| `render_invoice`    | Render a printable invoice, with the phrases the VAT Act requires                        |
+| `export_invoices`   | Build the data export required by decree 23/2014. (VI. 30.) NGM                          |
+
+Five more appear once credentials are configured:
+
+| Tool                 | What it does                                           |
+| -------------------- | ------------------------------------------------------ |
+| `query_taxpayer`     | The authoritative check on a Hungarian tax number      |
+| `submit_invoices`    | Report invoice data; validates locally first           |
+| `transaction_status` | The verdict on a submission, optionally waiting for it |
+| `list_invoices`      | Invoices issued by you or to you, in a date range      |
+| `get_invoice`        | One invoice in full, as reported                       |
+
+## Decisions that matter for an agent
+
+**Tools that cannot work are not offered.** Without credentials the NAV tools
+are not registered at all, so an agent is never handed a tool that is
+guaranteed to fail, and never has to discover that by calling it.
+
+**A validation failure is a result, not an error.** The fault list _is_ the
+answer, and returning it as an error would hide it behind an exception. Real
+errors — a document that is not an invoice, a NAV rejection — do come back as
+errors, carrying the fault code so the agent can act on it.
+
+**`submit_invoices` validates before sending** and refuses a document with
+errors. A rejection costs a round trip and consumes the request id, and an
+agent that retries blindly would burn both.
+
+**Credentials never travel as tool arguments.** A tool argument passes through
+the agent's context and its transcript; an environment variable does not.
+
+**Everything is structured content**, not prose to be re-parsed.
+
+## Trying it without credentials
+
+```sh
+npx @open-nav/mock-server            # prints fake credentials
+```
+
+Point `NAV_BASE_URL` at the mock and the whole tool set works, including
+submission, against a service that verifies signatures the way NAV does. That
+is how this package's own tests exercise it.
+
+## Licence
+
+MIT. Not affiliated with NAV.

package/dist/bin.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=bin.d.ts.map

package/dist/bin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bin.d.ts","sourceRoot":"","sources":["../src/bin.ts"],"names":[],"mappings":""}

package/dist/bin.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { createNavMcpServer } from './server.js';
+import { resolveConfig } from './config.js';
+const config = resolveConfig();
+if (config.missing.length > 0) {
+    // stderr, never stdout: stdout carries the MCP protocol.
+    process.stderr.write(`open-nav MCP: running with the offline tools only.\n` +
+        `Set ${config.missing.join(', ')} to enable the tools that talk to NAV.\n`);
+}
+const server = createNavMcpServer({
+    ...(config.credentials ? { credentials: config.credentials } : {}),
+    ...(config.software ? { software: config.software } : {}),
+    environment: config.environment,
+    ...(config.baseUrl ? { baseUrl: config.baseUrl } : {}),
+});
+await server.connect(new StdioServerTransport());
+//# sourceMappingURL=bin.js.map

package/dist/bin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bin.js","sourceRoot":"","sources":["../src/bin.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,2CAA2C,CAAC;AACjF,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAE5C,MAAM,MAAM,GAAG,aAAa,EAAE,CAAC;AAE/B,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;IAC9B,yDAAyD;IACzD,OAAO,CAAC,MAAM,CAAC,KAAK,CAClB,sDAAsD;QACpD,OAAO,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,0CAA0C,CAC7E,CAAC;AACJ,CAAC;AAED,MAAM,MAAM,GAAG,kBAAkB,CAAC;IAChC,GAAG,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;IAClE,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;IACzD,WAAW,EAAE,MAAM,CAAC,WAAW;IAC/B,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;CACvD,CAAC,CAAC;AAEH,MAAM,MAAM,CAAC,OAAO,CAAC,IAAI,oBAAoB,EAAE,CAAC,CAAC"}

package/dist/config.d.ts

@@ -0,0 +1,20 @@
+import type { SoftwareType } from '@open-nav/core';
+import type { NavCredentials } from '@open-nav/client';
+/**
+ * Configuration from the environment, using the same variables as the CLI so
+ * one `.env` serves both.
+ *
+ * Credentials are never taken as tool arguments. A tool argument travels
+ * through the agent's context and its transcript; an environment variable does
+ * not.
+ */
+export interface ResolvedConfig {
+    credentials?: NavCredentials;
+    software?: SoftwareType;
+    environment: 'test' | 'production';
+    baseUrl?: string;
+    /** Which required variables are absent, if any. */
+    missing: string[];
+}
+export declare function resolveConfig(env?: Record<string, string | undefined>): ResolvedConfig;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAGvD;;;;;;;GAOG;AACH,MAAM,WAAW,cAAc;IAC7B,WAAW,CAAC,EAAE,cAAc,CAAC;IAC7B,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB,WAAW,EAAE,MAAM,GAAG,YAAY,CAAC;IACnC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,mDAAmD;IACnD,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAWD,wBAAgB,aAAa,CAC3B,GAAG,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAe,GACpD,cAAc,CAsChB"}

package/dist/config.js

@@ -0,0 +1,45 @@
+import { VERSION } from './version.js';
+const REQUIRED = [
+    'NAV_LOGIN',
+    'NAV_PASSWORD',
+    'NAV_SIGN_KEY',
+    'NAV_EXCHANGE_KEY',
+    'NAV_TAX_NUMBER',
+    'NAV_SOFTWARE_ID',
+];
+export function resolveConfig(env = process.env) {
+    const missing = REQUIRED.filter((name) => !env[name]);
+    const environment = env['NAV_ENVIRONMENT'] === 'production' ? 'production' : 'test';
+    if (missing.length > 0) {
+        return {
+            environment,
+            missing,
+            ...(env['NAV_BASE_URL'] ? { baseUrl: env['NAV_BASE_URL'] } : {}),
+        };
+    }
+    const operation = env['NAV_SOFTWARE_OPERATION'] === 'ONLINE_SERVICE' ? 'ONLINE_SERVICE' : 'LOCAL_SOFTWARE';
+    return {
+        credentials: {
+            login: env['NAV_LOGIN'],
+            password: env['NAV_PASSWORD'],
+            signKey: env['NAV_SIGN_KEY'],
+            exchangeKey: env['NAV_EXCHANGE_KEY'],
+            taxNumber: env['NAV_TAX_NUMBER'],
+        },
+        software: {
+            softwareId: env['NAV_SOFTWARE_ID'],
+            softwareName: env['NAV_SOFTWARE_NAME'] ?? 'open-nav',
+            softwareOperation: operation,
+            softwareMainVersion: env['NAV_SOFTWARE_VERSION'] ?? VERSION,
+            softwareDevName: env['NAV_SOFTWARE_DEV_NAME'] ?? 'open-nav',
+            softwareDevContact: env['NAV_SOFTWARE_DEV_CONTACT'] ?? 'unknown',
+            ...(env['NAV_SOFTWARE_DEV_TAX_NUMBER']
+                ? { softwareDevTaxNumber: env['NAV_SOFTWARE_DEV_TAX_NUMBER'] }
+                : {}),
+        },
+        environment,
+        ...(env['NAV_BASE_URL'] ? { baseUrl: env['NAV_BASE_URL'] } : {}),
+        missing: [],
+    };
+}
+//# sourceMappingURL=config.js.map

package/dist/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAmBvC,MAAM,QAAQ,GAAG;IACf,WAAW;IACX,cAAc;IACd,cAAc;IACd,kBAAkB;IAClB,gBAAgB;IAChB,iBAAiB;CACT,CAAC;AAEX,MAAM,UAAU,aAAa,CAC3B,MAA0C,OAAO,CAAC,GAAG;IAErD,MAAM,OAAO,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;IACtD,MAAM,WAAW,GAAG,GAAG,CAAC,iBAAiB,CAAC,KAAK,YAAY,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,MAAM,CAAC;IAEpF,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACvB,OAAO;YACL,WAAW;YACX,OAAO;YACP,GAAG,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,GAAG,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SACjE,CAAC;IACJ,CAAC;IAED,MAAM,SAAS,GACb,GAAG,CAAC,wBAAwB,CAAC,KAAK,gBAAgB,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,gBAAgB,CAAC;IAE3F,OAAO;QACL,WAAW,EAAE;YACX,KAAK,EAAE,GAAG,CAAC,WAAW,CAAE;YACxB,QAAQ,EAAE,GAAG,CAAC,cAAc,CAAE;YAC9B,OAAO,EAAE,GAAG,CAAC,cAAc,CAAE;YAC7B,WAAW,EAAE,GAAG,CAAC,kBAAkB,CAAE;YACrC,SAAS,EAAE,GAAG,CAAC,gBAAgB,CAAE;SAClC;QACD,QAAQ,EAAE;YACR,UAAU,EAAE,GAAG,CAAC,iBAAiB,CAAE;YACnC,YAAY,EAAE,GAAG,CAAC,mBAAmB,CAAC,IAAI,UAAU;YACpD,iBAAiB,EAAE,SAAS;YAC5B,mBAAmB,EAAE,GAAG,CAAC,sBAAsB,CAAC,IAAI,OAAO;YAC3D,eAAe,EAAE,GAAG,CAAC,uBAAuB,CAAC,IAAI,UAAU;YAC3D,kBAAkB,EAAE,GAAG,CAAC,0BAA0B,CAAC,IAAI,SAAS;YAChE,GAAG,CAAC,GAAG,CAAC,6BAA6B,CAAC;gBACpC,CAAC,CAAC,EAAE,oBAAoB,EAAE,GAAG,CAAC,6BAA6B,CAAC,EAAE;gBAC9D,CAAC,CAAC,EAAE,CAAC;SACR;QACD,WAAW;QACX,GAAG,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,GAAG,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAChE,OAAO,EAAE,EAAE;KACZ,CAAC;AACJ,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './server.js';
+export * from './config.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC"}

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from './server.js';
+export * from './config.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC"}

package/dist/server.d.ts

@@ -0,0 +1,30 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { type SoftwareType } from '@open-nav/core';
+import { NavClient, type NavCredentials } from '@open-nav/client';
+/**
+ * MCP server for the Online Számla invoice service.
+ *
+ * Shaped for an agent rather than for a person. Three things follow from
+ * that:
+ *
+ * - Tools that need no credentials are always registered, so an agent can
+ *   validate and render invoices before anyone has a technical user.
+ * - Tools that reach NAV are registered only when credentials are present,
+ *   so an agent is never offered a tool that cannot work, and never has to
+ *   discover that by calling it.
+ * - Every result is structured content, not prose, and a validation failure
+ *   is a normal result rather than an error: the fault list *is* the answer.
+ */
+export interface NavMcpOptions {
+    /** Credentials. Omit to run with the offline tools only. */
+    credentials?: NavCredentials;
+    software?: SoftwareType;
+    environment?: 'test' | 'production';
+    baseUrl?: string;
+    /** Injected for tests. */
+    createClient?: (options: {
+        credentials: NavCredentials;
+    }) => NavClient;
+}
+export declare function createNavMcpServer(options?: NavMcpOptions): McpServer;
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEpE,OAAO,EASL,KAAK,YAAY,EAClB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,SAAS,EAAsB,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAItF;;;;;;;;;;;;;GAaG;AAEH,MAAM,WAAW,aAAa;IAC5B,4DAA4D;IAC5D,WAAW,CAAC,EAAE,cAAc,CAAC;IAC7B,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,GAAG,YAAY,CAAC;IACpC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,0BAA0B;IAC1B,YAAY,CAAC,EAAE,CAAC,OAAO,EAAE;QAAE,WAAW,EAAE,cAAc,CAAA;KAAE,KAAK,SAAS,CAAC;CACxE;AAiDD,wBAAgB,kBAAkB,CAAC,OAAO,GAAE,aAAkB,GAAG,SAAS,CAWzE"}

package/dist/server.js

@@ -0,0 +1,361 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { NavApiError, decodeInvoiceData, faultMessage, parseDocument, parseTaxNumber, serializeDocument, validateInvoice, } from '@open-nav/core';
+import { NavClient, waitForTransaction } from '@open-nav/client';
+import { createDataExport, renderInvoiceHtml } from '@open-nav/invoicing';
+import { VERSION } from './version.js';
+const OPERATION = z
+    .enum(['CREATE', 'MODIFY', 'STORNO'])
+    .describe('The operation the document will be submitted under');
+const LANGUAGE = z.enum(['en', 'hu', 'de']).describe("Language for NAV's own fault descriptions");
+const DIRECTION = z
+    .enum(['OUTBOUND', 'INBOUND'])
+    .describe('OUTBOUND for invoices you issued, INBOUND for invoices issued to you');
+/** Wrap a value as an MCP tool result carrying both text and structure. */
+function result(value) {
+    return {
+        content: [{ type: 'text', text: JSON.stringify(value, null, 2) }],
+        structuredContent: value,
+    };
+}
+/** An error an agent can act on, rather than a stack trace. */
+function failure(error) {
+    const detail = error instanceof NavApiError
+        ? {
+            message: error.message,
+            errorCode: error.errorCode,
+            funcCode: error.funcCode,
+            status: error.status,
+            validationMessages: error.validationMessages,
+        }
+        : { message: error.message ?? String(error) };
+    return { content: [{ type: 'text', text: JSON.stringify(detail, null, 2) }], isError: true };
+}
+function parseInvoice(xml) {
+    const parsed = parseDocument(xml, { unknownElements: 'ignore' });
+    if (parsed.root !== 'InvoiceData') {
+        throw new Error(`Expected an InvoiceData document, found ${parsed.root}`);
+    }
+    return parsed.value;
+}
+export function createNavMcpServer(options = {}) {
+    const server = new McpServer({ name: 'open-nav', version: VERSION });
+    registerOfflineTools(server);
+    if (options.credentials && options.software) {
+        registerOnlineTools(server, {
+            ...options,
+            credentials: options.credentials,
+            software: options.software,
+        });
+    }
+    return server;
+}
+/** Tools that contact nothing and need no credentials. */
+function registerOfflineTools(server) {
+    server.registerTool('validate_invoice', {
+        title: 'Validate invoice data',
+        description: 'Check NAV invoice data (InvoiceData XML) against the schema and the business rules ' +
+            'that are decidable from the document alone. Returns every finding with NAV’s own ' +
+            'fault code, so a failure here names what the service would have rejected. Needs no ' +
+            'credentials. Errors block a submission; warnings do not.',
+        inputSchema: {
+            xml: z.string().describe('The InvoiceData XML document to check'),
+            operation: OPERATION.optional(),
+            language: LANGUAGE.optional(),
+        },
+        annotations: { readOnlyHint: true, openWorldHint: false },
+    }, async ({ xml, operation, language }) => {
+        try {
+            const report = validateInvoice(parseInvoice(xml), {
+                ...(operation ? { operation } : {}),
+                ...(language ? { language } : {}),
+            });
+            // A failed validation is the answer, not an error.
+            return result({
+                valid: report.valid,
+                errorCount: report.errors.length,
+                warningCount: report.warnings.length,
+                issues: report.issues,
+            });
+        }
+        catch (error) {
+            return failure(error);
+        }
+    });
+    server.registerTool('lookup_fault_code', {
+        title: 'Look up a NAV fault code',
+        description: 'Explain a NAV validation fault code, such as INCORRECT_SUMMARY_CALCULATION_' +
+            "INVOICE_VAT_AMOUNT_SUMMARY, in NAV's own words. Use this to interpret a rejection.",
+        inputSchema: {
+            code: z.string().describe('The fault code, as NAV reported it'),
+            language: LANGUAGE.optional(),
+        },
+        annotations: { readOnlyHint: true, openWorldHint: false },
+    }, async ({ code, language }) => {
+        const normalised = code.trim().toUpperCase();
+        const message = faultMessage(normalised, language ?? 'en');
+        if (!message) {
+            return failure(new Error(`NAV defines no fault code ${normalised}`));
+        }
+        return result({ code: normalised, language: language ?? 'en', message });
+    });
+    server.registerTool('render_invoice', {
+        title: 'Render a printable invoice',
+        description: 'Render NAV invoice data as a self-contained, printable HTML invoice, with the phrases ' +
+            'the VAT Act requires derived from the data. Convert to PDF with any browser. Needs no ' +
+            'credentials.',
+        inputSchema: {
+            xml: z.string().describe('The InvoiceData XML document to render'),
+            language: z
+                .enum(['hu', 'en'])
+                .optional()
+                .describe('Document language, Hungarian by default'),
+            note: z.string().optional().describe('Extra note printed under the totals'),
+        },
+        annotations: { readOnlyHint: true, openWorldHint: false },
+    }, async ({ xml, language, note }) => {
+        try {
+            const html = renderInvoiceHtml(parseInvoice(xml), {
+                ...(language ? { language } : {}),
+                ...(note ? { note } : {}),
+            });
+            return {
+                content: [{ type: 'text', text: html }],
+                structuredContent: { html, bytes: html.length },
+            };
+        }
+        catch (error) {
+            return failure(error);
+        }
+    });
+    server.registerTool('export_invoices', {
+        title: 'Produce the tax authority data export',
+        description: 'Build the data export required of invoicing programs by decree 23/2014. (VI. 30.) NGM ' +
+            'from a set of InvoiceData documents, selected by issue date or invoice number range. ' +
+            'Returns the files rather than writing them. Needs no credentials.',
+        inputSchema: {
+            invoices: z.array(z.string()).describe('InvoiceData XML documents'),
+            issueDateFrom: z.string().optional().describe('First issue date, inclusive, as yyyy-mm-dd'),
+            issueDateTo: z.string().optional().describe('Last issue date, inclusive'),
+            invoiceNumberFrom: z.string().optional(),
+            invoiceNumberTo: z.string().optional(),
+        },
+        annotations: { readOnlyHint: true, openWorldHint: false },
+    }, async ({ invoices, ...selection }) => {
+        try {
+            const parsed = invoices.map((xml) => parseInvoice(xml));
+            const exported = createDataExport(parsed, selection);
+            return result({
+                manifest: exported.manifest,
+                files: exported.files,
+            });
+        }
+        catch (error) {
+            return failure(error);
+        }
+    });
+}
+/** Tools that talk to NAV. Registered only when credentials are configured. */
+function registerOnlineTools(server, options) {
+    const client = () => options.createClient
+        ? options.createClient({ credentials: options.credentials })
+        : new NavClient({
+            credentials: options.credentials,
+            software: options.software,
+            environment: options.environment ?? 'test',
+            ...(options.baseUrl ? { baseUrl: options.baseUrl } : {}),
+        });
+    server.registerTool('query_taxpayer', {
+        title: 'Look up a Hungarian taxpayer',
+        description: "Check whether a Hungarian tax number is valid and registered, and get the taxpayer's " +
+            'name. This is the authoritative check on a tax number; a check digit is not. Accepts ' +
+            'the 8 digit core or the 11 digit written form.',
+        inputSchema: { taxNumber: z.string().describe('8 or 11 digit Hungarian tax number') },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    }, async ({ taxNumber }) => {
+        try {
+            const { taxpayerId } = parseTaxNumber(taxNumber);
+            const response = await client().queryTaxpayer({ taxNumber: taxpayerId });
+            return result({
+                taxNumber: taxpayerId,
+                valid: response.taxpayerValidity ?? false,
+                taxpayer: response.taxpayerData ?? null,
+            });
+        }
+        catch (error) {
+            return failure(error);
+        }
+    });
+    server.registerTool('submit_invoices', {
+        title: 'Submit invoice data to NAV',
+        description: 'Report invoice data to NAV. Validates locally first and refuses to submit a document ' +
+            'with errors, because a rejection costs a round trip and consumes the request id. ' +
+            'Returns the transaction id, and the per-invoice verdict when waitForVerdict is set. ' +
+            'This reports data to the tax authority and cannot be undone except by a technical ' +
+            'annulment.',
+        inputSchema: {
+            invoices: z.array(z.string()).describe('InvoiceData XML documents to report'),
+            operation: OPERATION.optional(),
+            compress: z.boolean().optional().describe('Gzip the payloads'),
+            waitForVerdict: z
+                .boolean()
+                .optional()
+                .describe('Poll until NAV decides, and return the per-invoice outcome'),
+        },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+    }, async ({ invoices, operation, compress, waitForVerdict }) => {
+        try {
+            const parsed = invoices.map((xml) => parseInvoice(xml));
+            const effective = operation ?? 'CREATE';
+            const blocking = parsed
+                .map((invoice, index) => ({
+                index,
+                report: validateInvoice(invoice, { operation: effective }),
+            }))
+                .filter((entry) => !entry.report.valid);
+            if (blocking.length > 0) {
+                return result({
+                    submitted: false,
+                    reason: 'local validation failed',
+                    invalid: blocking.map((entry) => ({
+                        index: entry.index,
+                        errors: entry.report.errors,
+                    })),
+                });
+            }
+            const navClient = client();
+            const response = await navClient.submitInvoices(parsed.map((invoice) => ({ operation: effective, invoice })), { compress: compress ?? false });
+            if (!waitForVerdict) {
+                return result({
+                    submitted: true,
+                    transactionId: response.transactionId,
+                    count: parsed.length,
+                });
+            }
+            const outcome = await waitForTransaction(navClient, response.transactionId);
+            return result({
+                submitted: true,
+                transactionId: response.transactionId,
+                accepted: outcome.accepted.length,
+                rejected: outcome.rejected.length,
+                results: outcome.results,
+            });
+        }
+        catch (error) {
+            return failure(error);
+        }
+    });
+    server.registerTool('transaction_status', {
+        title: 'Check a submission',
+        description: 'Get the processing status of a submitted transaction. NAV validates asynchronously, ' +
+            'so a submission has no verdict until this reports one.',
+        inputSchema: {
+            transactionId: z.string(),
+            waitForVerdict: z.boolean().optional().describe('Poll until NAV decides'),
+        },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    }, async ({ transactionId, waitForVerdict }) => {
+        try {
+            const navClient = client();
+            if (waitForVerdict) {
+                const outcome = await waitForTransaction(navClient, transactionId);
+                return result({
+                    transactionId,
+                    accepted: outcome.accepted.length,
+                    rejected: outcome.rejected.length,
+                    results: outcome.results,
+                });
+            }
+            const response = await navClient.queryTransactionStatus({ transactionId });
+            return result({
+                transactionId,
+                results: response.processingResults?.processingResult ?? [],
+            });
+        }
+        catch (error) {
+            return failure(error);
+        }
+    });
+    server.registerTool('list_invoices', {
+        title: 'List invoices in a date range',
+        description: 'List invoices issued by you (OUTBOUND) or issued to you (INBOUND) in a range of issue ' +
+            'dates. Returns a summary per invoice; use get_invoice for the full data. Paged, 100 ' +
+            'per page.',
+        inputSchema: {
+            dateFrom: z.string().describe('First issue date, inclusive, as yyyy-mm-dd'),
+            dateTo: z.string().describe('Last issue date, inclusive, as yyyy-mm-dd'),
+            direction: DIRECTION.optional(),
+            page: z.number().int().min(1).optional(),
+        },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    }, async ({ dateFrom, dateTo, direction, page }) => {
+        try {
+            const response = await client().queryInvoiceDigest({
+                page: page ?? 1,
+                invoiceDirection: direction ?? 'OUTBOUND',
+                invoiceQueryParams: { mandatoryQueryParams: { invoiceIssueDate: { dateFrom, dateTo } } },
+            });
+            const digest = response.invoiceDigestResult;
+            return result({
+                page: digest.currentPage,
+                availablePages: digest.availablePage,
+                invoices: digest.invoiceDigest ?? [],
+            });
+        }
+        catch (error) {
+            return failure(error);
+        }
+    });
+    server.registerTool('get_invoice', {
+        title: 'Fetch one invoice in full',
+        description: 'Fetch the complete data of one invoice by number, as reported to NAV. Returns the ' +
+            'invoice as XML and as structured data.',
+        inputSchema: {
+            invoiceNumber: z.string(),
+            direction: DIRECTION.optional(),
+            supplierTaxNumber: z
+                .string()
+                .optional()
+                .describe('Required for an inbound invoice: who issued it'),
+        },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    }, async ({ invoiceNumber, direction, supplierTaxNumber }) => {
+        try {
+            const requested = direction ?? 'OUTBOUND';
+            if (requested === 'INBOUND' && !supplierTaxNumber) {
+                throw new Error('supplierTaxNumber is required for an inbound invoice');
+            }
+            const response = await client().queryInvoiceData({
+                invoiceNumberQuery: {
+                    invoiceNumber,
+                    invoiceDirection: requested,
+                    ...(supplierTaxNumber
+                        ? { supplierTaxNumber: parseTaxNumber(supplierTaxNumber).taxpayerId }
+                        : {}),
+                },
+            });
+            const data = response.invoiceDataResult;
+            if (!data)
+                return result({ found: false, invoiceNumber });
+            const invoice = decodeInvoiceData(data.invoiceData, {
+                compressed: data.compressedContentIndicator,
+            });
+            return result({
+                found: true,
+                invoiceNumber,
+                auditData: data.auditData,
+                xml: serializeDocument('InvoiceData', invoice, { indent: '  ' }),
+                invoice,
+            });
+        }
+        catch (error) {
+            return failure(error);
+        }
+    });
+}
+//# sourceMappingURL=server.js.map