buchpilot-mcp 0.1.1

package/dist/backends/types.d.ts

@@ -0,0 +1,120 @@
+export interface Contact {
+    id: string;
+    type: "person" | "company";
+    name: string;
+    firstName?: string;
+    email?: string;
+    role: "customer" | "vendor" | "both";
+    backend: string;
+    raw: Record<string, unknown>;
+}
+export interface ContactInput {
+    type: "person" | "company";
+    name: string;
+    firstName?: string;
+    email?: string;
+    role?: "customer" | "vendor" | "both";
+}
+export interface ContactFilter {
+    name?: string;
+    email?: string;
+    role?: "customer" | "vendor";
+    limit?: number;
+}
+export interface LineItem {
+    name: string;
+    quantity: number;
+    unitPrice: number;
+    taxRate: number;
+}
+export interface Invoice {
+    id: string;
+    number: string;
+    contactId: string;
+    date: string;
+    dueDate: string;
+    status: "draft" | "open" | "paid" | "overdue";
+    totalNet: number;
+    totalGross: number;
+    currency: string;
+    lineItems: LineItem[];
+    backend: string;
+    raw: Record<string, unknown>;
+}
+export interface InvoiceInput {
+    contactId: string;
+    date: string;
+    lineItems: LineItem[];
+    title?: string;
+    introduction?: string;
+    remark?: string;
+    currency?: string;
+    finalize?: boolean;
+}
+export interface InvoiceFilter {
+    status?: "draft" | "open" | "paid" | "overdue";
+    contactId?: string;
+    limit?: number;
+}
+export interface Voucher {
+    id: string;
+    type: string;
+    date: string;
+    totalGross: number;
+    taxRate: number;
+    backend: string;
+    raw: Record<string, unknown>;
+}
+export interface VoucherInput {
+    type: "purchaseinvoice" | "purchasecreditnote" | "any";
+    date: string;
+    totalGross: number;
+    taxRate: number;
+    contactId?: string;
+    remark?: string;
+}
+export interface VoucherFilter {
+    type?: "purchaseinvoice" | "purchasecreditnote" | "any";
+    limit?: number;
+}
+export interface Quotation {
+    id: string;
+    contactId: string;
+    date: string;
+    expirationDate?: string;
+    totalNet: number;
+    totalGross: number;
+    lineItems: LineItem[];
+    backend: string;
+    raw: Record<string, unknown>;
+}
+export interface QuotationInput {
+    contactId: string;
+    date: string;
+    lineItems: LineItem[];
+    expirationDate?: string;
+    title?: string;
+    introduction?: string;
+    remark?: string;
+    finalize?: boolean;
+}
+export interface IAccountingBackend {
+    name: string;
+    createContact(input: ContactInput): Promise<Contact>;
+    getContact(id: string): Promise<Contact>;
+    listContacts(filter?: ContactFilter): Promise<Contact[]>;
+    updateContact(id: string, input: Partial<ContactInput>): Promise<Contact>;
+    createInvoice(input: InvoiceInput): Promise<Invoice>;
+    getInvoice(id: string): Promise<Invoice>;
+    listInvoices(filter?: InvoiceFilter): Promise<Invoice[]>;
+    getInvoicePdf(id: string): Promise<{
+        data: Buffer;
+        filename: string;
+    }>;
+    updateInvoice(id: string, input: Partial<InvoiceInput>): Promise<Invoice>;
+    createVoucher(input: VoucherInput): Promise<Voucher>;
+    getVoucher(id: string): Promise<Voucher>;
+    listVouchers(filter?: VoucherFilter): Promise<Voucher[]>;
+    createQuotation(input: QuotationInput): Promise<Quotation>;
+    getQuotation(id: string): Promise<Quotation>;
+}

package/dist/backends/types.js

@@ -0,0 +1,2 @@
+// === Gemeinsame Entity-Typen ===
+export {};

package/dist/config.d.ts

@@ -0,0 +1,24 @@
+import { z } from "zod";
+declare const ConfigSchema: z.ZodObject<{
+    backends: z.ZodRecord<z.ZodString, z.ZodObject<{
+        api_key: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        api_key: string;
+    }, {
+        api_key: string;
+    }>>;
+    default_backend: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    backends: Record<string, {
+        api_key: string;
+    }>;
+    default_backend: string;
+}, {
+    backends: Record<string, {
+        api_key: string;
+    }>;
+    default_backend: string;
+}>;
+export type BuchPilotConfig = z.infer<typeof ConfigSchema>;
+export declare function loadConfig(): BuchPilotConfig;
+export {};

package/dist/config.js

@@ -0,0 +1,44 @@
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { z } from "zod";
+import { ErrorCode, createError } from "./errors.js";
+const BackendConfigSchema = z.object({
+    api_key: z.string().min(1, "API key must not be empty"),
+});
+const ConfigSchema = z.object({
+    backends: z.record(z.string(), BackendConfigSchema),
+    default_backend: z.string(),
+});
+export function loadConfig() {
+    const configPaths = [
+        process.env.BUCHPILOT_CONFIG,
+        join(homedir(), ".buchpilot.json"),
+        join(process.cwd(), ".buchpilot.json"),
+    ].filter(Boolean);
+    for (const configPath of configPaths) {
+        if (existsSync(configPath)) {
+            try {
+                const raw = readFileSync(configPath, "utf-8");
+                const parsed = JSON.parse(raw);
+                const validated = ConfigSchema.parse(parsed);
+                if (!validated.backends[validated.default_backend]) {
+                    throw createError(ErrorCode.BACKEND_NOT_CONFIGURED, `Default backend "${validated.default_backend}" is not configured in backends`);
+                }
+                return validated;
+            }
+            catch (err) {
+                if (err && typeof err === "object" && "code" in err) {
+                    throw err;
+                }
+                throw createError(ErrorCode.CONFIG_MISSING, `Invalid config at ${configPath}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+    }
+    throw createError(ErrorCode.CONFIG_MISSING, "No .buchpilot.json found. Create one at ~/.buchpilot.json or ./.buchpilot.json with your API keys.", {
+        example: {
+            backends: { lexoffice: { api_key: "YOUR_KEY" } },
+            default_backend: "lexoffice",
+        },
+    });
+}

package/dist/errors.d.ts

@@ -0,0 +1,18 @@
+export declare enum ErrorCode {
+    AUTH_FAILED = "AUTH_FAILED",
+    RATE_LIMITED = "RATE_LIMITED",
+    NOT_FOUND = "NOT_FOUND",
+    VALIDATION_ERROR = "VALIDATION_ERROR",
+    BACKEND_ERROR = "BACKEND_ERROR",
+    SYNC_CONFLICT = "SYNC_CONFLICT",
+    CONFIG_MISSING = "CONFIG_MISSING",
+    BACKEND_NOT_CONFIGURED = "BACKEND_NOT_CONFIGURED"
+}
+export interface BuchPilotError {
+    code: ErrorCode;
+    message: string;
+    details?: Record<string, unknown>;
+    retry_after_ms?: number;
+}
+export declare function createError(code: ErrorCode, message: string, details?: Record<string, unknown>): BuchPilotError;
+export declare function isRetryable(error: BuchPilotError): boolean;

package/dist/errors.js

@@ -0,0 +1,22 @@
+export var ErrorCode;
+(function (ErrorCode) {
+    ErrorCode["AUTH_FAILED"] = "AUTH_FAILED";
+    ErrorCode["RATE_LIMITED"] = "RATE_LIMITED";
+    ErrorCode["NOT_FOUND"] = "NOT_FOUND";
+    ErrorCode["VALIDATION_ERROR"] = "VALIDATION_ERROR";
+    ErrorCode["BACKEND_ERROR"] = "BACKEND_ERROR";
+    ErrorCode["SYNC_CONFLICT"] = "SYNC_CONFLICT";
+    ErrorCode["CONFIG_MISSING"] = "CONFIG_MISSING";
+    ErrorCode["BACKEND_NOT_CONFIGURED"] = "BACKEND_NOT_CONFIGURED";
+})(ErrorCode || (ErrorCode = {}));
+export function createError(code, message, details) {
+    return {
+        code,
+        message,
+        ...(details && { details }),
+        ...(code === ErrorCode.RATE_LIMITED && { retry_after_ms: 500 }),
+    };
+}
+export function isRetryable(error) {
+    return error.code === ErrorCode.RATE_LIMITED || error.code === ErrorCode.BACKEND_ERROR;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { loadConfig } from "./config.js";
+import { ErrorCode, createError } from "./errors.js";
+import { LexofficeBackend } from "./backends/lexoffice.js";
+import { registerContactTools } from "./tools/contacts.js";
+import { registerInvoiceTools } from "./tools/invoices.js";
+import { registerVoucherTools } from "./tools/vouchers.js";
+import { registerQuotationTools } from "./tools/quotations.js";
+import { registerSyncTools } from "./tools/sync.js";
+// === Backend Registry ===
+const backends = new Map();
+function getBackend(name) {
+    const config = loadConfig();
+    const backendName = name || config.default_backend;
+    // Lazy-initialize backends
+    if (!backends.has(backendName)) {
+        const backendConfig = config.backends[backendName];
+        if (!backendConfig) {
+            throw createError(ErrorCode.BACKEND_NOT_CONFIGURED, `Backend "${backendName}" is not configured. Available: ${Object.keys(config.backends).join(", ")}`);
+        }
+        switch (backendName) {
+            case "lexoffice":
+                backends.set(backendName, new LexofficeBackend(backendConfig.api_key));
+                break;
+            default:
+                throw createError(ErrorCode.BACKEND_NOT_CONFIGURED, `Unknown backend type: "${backendName}". Supported: lexoffice`);
+        }
+    }
+    return backends.get(backendName);
+}
+// === MCP Server ===
+const server = new McpServer({
+    name: "buchpilot",
+    version: "0.1.1",
+});
+// Register all tools
+registerContactTools(server, getBackend);
+registerInvoiceTools(server, getBackend);
+registerVoucherTools(server, getBackend);
+registerQuotationTools(server, getBackend);
+registerSyncTools(server, getBackend);
+// === Start ===
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("BuchPilot MCP Server running (stdio)");
+}
+main().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});

package/dist/tools/contacts.d.ts

@@ -0,0 +1,75 @@
+import { z } from "zod";
+import type { IAccountingBackend } from "../backends/types.js";
+export declare const contactSchemas: {
+    create_contact: z.ZodObject<{
+        type: z.ZodEnum<["person", "company"]>;
+        name: z.ZodString;
+        firstName: z.ZodOptional<z.ZodString>;
+        email: z.ZodOptional<z.ZodString>;
+        role: z.ZodDefault<z.ZodEnum<["customer", "vendor", "both"]>>;
+        backend: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "person" | "company";
+        name: string;
+        role: "customer" | "vendor" | "both";
+        firstName?: string | undefined;
+        email?: string | undefined;
+        backend?: string | undefined;
+    }, {
+        type: "person" | "company";
+        name: string;
+        firstName?: string | undefined;
+        email?: string | undefined;
+        role?: "customer" | "vendor" | "both" | undefined;
+        backend?: string | undefined;
+    }>;
+    get_contact: z.ZodObject<{
+        id: z.ZodString;
+        backend: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        backend?: string | undefined;
+    }, {
+        id: string;
+        backend?: string | undefined;
+    }>;
+    list_contacts: z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        email: z.ZodOptional<z.ZodString>;
+        role: z.ZodOptional<z.ZodEnum<["customer", "vendor"]>>;
+        limit: z.ZodDefault<z.ZodNumber>;
+        backend: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        limit: number;
+        email?: string | undefined;
+        name?: string | undefined;
+        role?: "customer" | "vendor" | undefined;
+        backend?: string | undefined;
+    }, {
+        email?: string | undefined;
+        name?: string | undefined;
+        role?: "customer" | "vendor" | undefined;
+        backend?: string | undefined;
+        limit?: number | undefined;
+    }>;
+    update_contact: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        firstName: z.ZodOptional<z.ZodString>;
+        email: z.ZodOptional<z.ZodString>;
+        backend: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        firstName?: string | undefined;
+        email?: string | undefined;
+        name?: string | undefined;
+        backend?: string | undefined;
+    }, {
+        id: string;
+        firstName?: string | undefined;
+        email?: string | undefined;
+        name?: string | undefined;
+        backend?: string | undefined;
+    }>;
+};
+export declare function registerContactTools(server: any, getBackend: (name?: string) => IAccountingBackend): void;

package/dist/tools/contacts.js

@@ -0,0 +1,63 @@
+import { z } from "zod";
+export const contactSchemas = {
+    create_contact: z.object({
+        type: z.enum(["person", "company"]).describe("Kontakttyp: Person oder Firma"),
+        name: z.string().describe("Nachname (Person) oder Firmenname (Firma)"),
+        firstName: z.string().optional().describe("Vorname (nur bei Person)"),
+        email: z.string().optional().describe("E-Mail-Adresse"),
+        role: z.enum(["customer", "vendor", "both"]).default("customer").describe("Rolle: Kunde, Lieferant, oder beides"),
+        backend: z.string().optional().describe("Backend (z.B. 'lexoffice'). Leer = default"),
+    }),
+    get_contact: z.object({
+        id: z.string().describe("Kontakt-ID"),
+        backend: z.string().optional(),
+    }),
+    list_contacts: z.object({
+        name: z.string().optional().describe("Nach Name filtern"),
+        email: z.string().optional().describe("Nach E-Mail filtern"),
+        role: z.enum(["customer", "vendor"]).optional().describe("Nach Rolle filtern"),
+        limit: z.number().default(25).describe("Maximale Anzahl"),
+        backend: z.string().optional(),
+    }),
+    update_contact: z.object({
+        id: z.string().describe("Kontakt-ID"),
+        name: z.string().optional().describe("Neuer Name"),
+        firstName: z.string().optional().describe("Neuer Vorname"),
+        email: z.string().optional().describe("Neue E-Mail"),
+        backend: z.string().optional(),
+    }),
+};
+export function registerContactTools(server, getBackend) {
+    server.tool("create_contact", "Erstellt einen neuen Kontakt (Person oder Firma) im Buchhaltungssystem. Creates a new contact (person or company).", contactSchemas.create_contact.shape, async (args) => {
+        const backend = getBackend(args.backend);
+        const result = await backend.createContact({
+            type: args.type,
+            name: args.name,
+            firstName: args.firstName,
+            email: args.email,
+            role: args.role,
+        });
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    });
+    server.tool("get_contact", "Ruft einen Kontakt per ID ab. Gets a contact by ID.", contactSchemas.get_contact.shape, async (args) => {
+        const backend = getBackend(args.backend);
+        const result = await backend.getContact(args.id);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    });
+    server.tool("list_contacts", "Listet Kontakte auf mit optionalen Filtern. Lists contacts with optional filters.", contactSchemas.list_contacts.shape, async (args) => {
+        const backend = getBackend(args.backend);
+        const result = await backend.listContacts({
+            name: args.name,
+            email: args.email,
+            role: args.role,
+            limit: args.limit,
+        });
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    });
+    server.tool("update_contact", "Aktualisiert einen bestehenden Kontakt. Updates an existing contact.", contactSchemas.update_contact.shape, async (args) => {
+        const backend = getBackend(args.backend);
+        const { id, backend: _, ...updateFields } = args;
+        const result = await backend.updateContact(id, updateFields);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    });
+}

package/dist/tools/invoices.d.ts

@@ -0,0 +1,116 @@
+import { z } from "zod";
+import type { IAccountingBackend } from "../backends/types.js";
+export declare const invoiceSchemas: {
+    create_invoice: z.ZodObject<{
+        contactId: z.ZodString;
+        date: z.ZodString;
+        lineItems: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            quantity: z.ZodDefault<z.ZodNumber>;
+            unitPrice: z.ZodNumber;
+            taxRate: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            quantity: number;
+            unitPrice: number;
+            taxRate: number;
+        }, {
+            name: string;
+            unitPrice: number;
+            quantity?: number | undefined;
+            taxRate?: number | undefined;
+        }>, "many">;
+        title: z.ZodOptional<z.ZodString>;
+        introduction: z.ZodOptional<z.ZodString>;
+        remark: z.ZodOptional<z.ZodString>;
+        currency: z.ZodDefault<z.ZodString>;
+        finalize: z.ZodDefault<z.ZodBoolean>;
+        backend: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        date: string;
+        lineItems: {
+            name: string;
+            quantity: number;
+            unitPrice: number;
+            taxRate: number;
+        }[];
+        finalize: boolean;
+        contactId: string;
+        currency: string;
+        title?: string | undefined;
+        introduction?: string | undefined;
+        remark?: string | undefined;
+        backend?: string | undefined;
+    }, {
+        date: string;
+        lineItems: {
+            name: string;
+            unitPrice: number;
+            quantity?: number | undefined;
+            taxRate?: number | undefined;
+        }[];
+        contactId: string;
+        title?: string | undefined;
+        introduction?: string | undefined;
+        remark?: string | undefined;
+        finalize?: boolean | undefined;
+        currency?: string | undefined;
+        backend?: string | undefined;
+    }>;
+    get_invoice: z.ZodObject<{
+        id: z.ZodString;
+        backend: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        backend?: string | undefined;
+    }, {
+        id: string;
+        backend?: string | undefined;
+    }>;
+    list_invoices: z.ZodObject<{
+        status: z.ZodOptional<z.ZodEnum<["draft", "open", "paid", "overdue"]>>;
+        contactId: z.ZodOptional<z.ZodString>;
+        limit: z.ZodDefault<z.ZodNumber>;
+        backend: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        limit: number;
+        status?: "draft" | "open" | "paid" | "overdue" | undefined;
+        contactId?: string | undefined;
+        backend?: string | undefined;
+    }, {
+        status?: "draft" | "open" | "paid" | "overdue" | undefined;
+        contactId?: string | undefined;
+        backend?: string | undefined;
+        limit?: number | undefined;
+    }>;
+    get_invoice_pdf: z.ZodObject<{
+        id: z.ZodString;
+        backend: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        backend?: string | undefined;
+    }, {
+        id: string;
+        backend?: string | undefined;
+    }>;
+    update_invoice: z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+        introduction: z.ZodOptional<z.ZodString>;
+        remark: z.ZodOptional<z.ZodString>;
+        backend: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        title?: string | undefined;
+        introduction?: string | undefined;
+        remark?: string | undefined;
+        backend?: string | undefined;
+    }, {
+        id: string;
+        title?: string | undefined;
+        introduction?: string | undefined;
+        remark?: string | undefined;
+        backend?: string | undefined;
+    }>;
+};
+export declare function registerInvoiceTools(server: any, getBackend: (name?: string) => IAccountingBackend): void;

package/dist/tools/invoices.js

@@ -0,0 +1,92 @@
+import { z } from "zod";
+const lineItemSchema = z.object({
+    name: z.string().describe("Positionsname"),
+    quantity: z.number().default(1).describe("Menge"),
+    unitPrice: z.number().describe("Einzelpreis netto"),
+    taxRate: z.number().default(19).describe("Steuersatz in Prozent"),
+});
+export const invoiceSchemas = {
+    create_invoice: z.object({
+        contactId: z.string().describe("Kontakt-ID des Rechnungsempfaengers"),
+        date: z.string().describe("Rechnungsdatum (ISO 8601, z.B. 2026-03-18)"),
+        lineItems: z.array(lineItemSchema).min(1).describe("Rechnungspositionen"),
+        title: z.string().optional().describe("Rechnungstitel"),
+        introduction: z.string().optional().describe("Einleitungstext"),
+        remark: z.string().optional().describe("Schlusstext"),
+        currency: z.string().default("EUR").describe("Waehrung"),
+        finalize: z.boolean().default(false).describe("Rechnung direkt finalisieren (nicht mehr editierbar)"),
+        backend: z.string().optional(),
+    }),
+    get_invoice: z.object({
+        id: z.string().describe("Rechnungs-ID"),
+        backend: z.string().optional(),
+    }),
+    list_invoices: z.object({
+        status: z.enum(["draft", "open", "paid", "overdue"]).optional().describe("Nach Status filtern"),
+        contactId: z.string().optional().describe("Nach Kontakt filtern"),
+        limit: z.number().default(25).describe("Maximale Anzahl"),
+        backend: z.string().optional(),
+    }),
+    get_invoice_pdf: z.object({
+        id: z.string().describe("Rechnungs-ID"),
+        backend: z.string().optional(),
+    }),
+    update_invoice: z.object({
+        id: z.string().describe("Rechnungs-ID"),
+        title: z.string().optional(),
+        introduction: z.string().optional(),
+        remark: z.string().optional(),
+        backend: z.string().optional(),
+    }),
+};
+export function registerInvoiceTools(server, getBackend) {
+    server.tool("create_invoice", "Erstellt eine neue Rechnung mit Positionen. Creates a new invoice with line items.", invoiceSchemas.create_invoice.shape, async (args) => {
+        const backend = getBackend(args.backend);
+        const result = await backend.createInvoice({
+            contactId: args.contactId,
+            date: args.date,
+            lineItems: args.lineItems,
+            title: args.title,
+            introduction: args.introduction,
+            remark: args.remark,
+            currency: args.currency,
+            finalize: args.finalize,
+        });
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    });
+    server.tool("get_invoice", "Ruft eine Rechnung per ID ab. Gets an invoice by ID.", invoiceSchemas.get_invoice.shape, async (args) => {
+        const backend = getBackend(args.backend);
+        const result = await backend.getInvoice(args.id);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    });
+    server.tool("list_invoices", "Listet Rechnungen auf. Kann nach Status filtern (draft, open, paid, overdue). Lists invoices with optional status filter.", invoiceSchemas.list_invoices.shape, async (args) => {
+        const backend = getBackend(args.backend);
+        const result = await backend.listInvoices({
+            status: args.status,
+            contactId: args.contactId,
+            limit: args.limit,
+        });
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    });
+    server.tool("get_invoice_pdf", "Laedt eine Rechnung als PDF herunter (Base64-kodiert). Downloads an invoice as PDF (base64-encoded).", invoiceSchemas.get_invoice_pdf.shape, async (args) => {
+        const backend = getBackend(args.backend);
+        const { data, filename } = await backend.getInvoicePdf(args.id);
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        filename,
+                        size_bytes: data.length,
+                        base64: data.toString("base64"),
+                        hint: "PDF ist base64-kodiert. Zum Speichern: Buffer.from(base64, 'base64') oder als data-URI verwenden.",
+                    }, null, 2),
+                }],
+        };
+    });
+    server.tool("update_invoice", "Aktualisiert eine bestehende Rechnung (nur Entwuerfe). Updates a draft invoice.", invoiceSchemas.update_invoice.shape, async (args) => {
+        const backend = getBackend(args.backend);
+        const { id, backend: _, ...updateFields } = args;
+        const result = await backend.updateInvoice(id, updateFields);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    });
+}

package/dist/tools/quotations.d.ts

@@ -0,0 +1,2 @@
+import type { IAccountingBackend } from "../backends/types.js";
+export declare function registerQuotationTools(server: any, getBackend: (name?: string) => IAccountingBackend): void;