@kevludwig/eve-lexware-office 0.1.0

package/dist/extension/tools/create_customer.d.ts

@@ -0,0 +1,44 @@
+declare const _default: import("eve/tools").ToolDefinition<{
+    company_name?: string | undefined;
+    first_name?: string | undefined;
+    last_name?: string | undefined;
+    street: string;
+    zip: string;
+    city: string;
+    country_code?: string | undefined;
+    email?: string | undefined;
+    phone?: string | undefined;
+}, {
+    contactId: string;
+    note: string;
+    customerNumber?: undefined;
+    name?: undefined;
+} | {
+    contactId: string;
+    customerNumber: number | undefined;
+    name: string;
+    note: string | undefined;
+}> & {
+    execute(input: {
+        company_name?: string | undefined;
+        first_name?: string | undefined;
+        last_name?: string | undefined;
+        street: string;
+        zip: string;
+        city: string;
+        country_code?: string | undefined;
+        email?: string | undefined;
+        phone?: string | undefined;
+    }, ctx: import("eve/tools").ToolContext): Promise<{
+        contactId: string;
+        note: string;
+        customerNumber?: undefined;
+        name?: undefined;
+    } | {
+        contactId: string;
+        customerNumber: number | undefined;
+        name: string;
+        note: string | undefined;
+    }>;
+};
+export default _default;

package/dist/extension/tools/create_customer.mjs

@@ -0,0 +1,107 @@
+import { fileURLToPath as __eveFileURLToPath } from "node:url";
+import { dirname as __eveDirname } from "node:path";
+import { createRequire as __eveCreateRequire } from "node:module";
+const __filename = __eveFileURLToPath(import.meta.url);
+__eveDirname(__filename);
+__eveCreateRequire(import.meta.url);
+import { approverPolicy, client } from "../lib/runtime.mjs";
+import { saveWarnings } from "../lib/findings.mjs";
+import { readJournal, writeJournal } from "../lib/journal.mjs";
+import { rememberShownContacts, shownContactsOf } from "../lib/state.mjs";
+import { z } from "zod";
+import { createCustomer, describeError, findContactsByName } from "@kevludwig/lexware-office";
+import { defineTool } from "eve/tools";
+const inputSchema = z.object({
+	company_name: z.string().trim().min(1).max(255).optional().describe("Firmenname inkl. Rechtsform — entweder dieser oder last_name"),
+	first_name: z.string().trim().max(100).optional().describe("Vorname (nur bei Privatperson)"),
+	last_name: z.string().trim().min(1).max(100).optional().describe("Nachname (nur bei Privatperson) — entweder dieser oder company_name"),
+	street: z.string().trim().min(1).max(200).describe("Straße und Hausnummer"),
+	zip: z.string().trim().min(1).max(10).describe("Postleitzahl"),
+	city: z.string().trim().min(1).max(100).describe("Ort"),
+	country_code: z.string().trim().length(2).optional().describe("ISO-Ländercode, Standard DE"),
+	email: z.string().trim().email().max(200).optional().describe("E-Mail-Adresse (optional)"),
+	phone: z.string().trim().max(50).optional().describe("Telefonnummer (optional)")
+}).strict().refine((input) => Boolean(input.company_name) !== Boolean(input.last_name), { message: "Genau eines von company_name und last_name angeben." });
+const nameOf = (input) => input.company_name?.trim() || input.last_name?.trim() || "";
+const label = (contact) => `${contact.name}${contact.number ? ` (Nr. ${contact.number})` : ""}`;
+var create_customer_default = defineTool({
+	description: "Legt einen neuen Kunden in Lexware Office an. Pflicht sind Name (Firma oder Person) UND die Rechnungsadresse (Straße, PLZ, Ort) — fehlt die Adresse, frage sie zuerst beim Nutzer ab. E-Mail und Telefon sind optional. Prüfe vorher mit dem Lese-Tool (/contacts?name=…), ob der Kunde schon existiert. Legt erst nach Freigabe an.",
+	inputSchema,
+	approval: {
+		request: async (ctx) => {
+			const name = nameOf(ctx.toolInput ?? {});
+			if (!name) return "user-approval";
+			const findings = [];
+			try {
+				const similar = await findContactsByName(client(), name, {
+					size: 5,
+					signal: ctx.abortSignal
+				});
+				if (similar.length > 0) findings.push({
+					kind: "note",
+					title: "⚠ Ähnliche Kontakte",
+					value: similar.map(label).join(", ")
+				});
+				rememberShownContacts(ctx.callId, similar.map((contact) => contact.id));
+			} catch (error) {
+				findings.push({
+					kind: "note",
+					title: "⚠ Suche fehlgeschlagen",
+					value: `Ähnliche Kontakte ungeprüft: ${describeError(error)}`
+				});
+			}
+			saveWarnings(ctx.callId, findings);
+			return "user-approval";
+		},
+		response: approverPolicy
+	},
+	async execute(input, ctx) {
+		const journal = await readJournal("customer", ctx.callId);
+		if (journal?.resourceId) return {
+			contactId: journal.resourceId,
+			note: "Wiederaufnahme: Der Kunde war bereits angelegt — nichts doppelt erstellt."
+		};
+		const shown = shownContactsOf(ctx.callId);
+		try {
+			const unseen = (await findContactsByName(client(), nameOf(input), {
+				size: 5,
+				signal: ctx.abortSignal
+			})).filter((contact) => !shown.has(contact.id));
+			if (unseen.length > 0) throw new Error(`Abgebrochen: Inzwischen gibt es einen ähnlichen Kontakt, den die Karte nicht zeigte: ${unseen.map(label).join(", ")}. Nichts angelegt. Rufe das Tool erneut auf, wenn trotzdem ein neuer Kunde entstehen soll.`);
+		} catch (error) {
+			if (error instanceof Error && error.message.startsWith("Abgebrochen")) throw error;
+		}
+		await writeJournal("customer", ctx.callId, { status: "pending" });
+		let created;
+		try {
+			created = await createCustomer(client(), {
+				...input.company_name ? { company: { name: input.company_name } } : {},
+				...input.last_name ? { person: {
+					...input.first_name ? { firstName: input.first_name } : {},
+					lastName: input.last_name
+				} } : {},
+				billingAddress: {
+					street: input.street,
+					zip: input.zip,
+					city: input.city,
+					countryCode: input.country_code
+				},
+				email: input.email,
+				phone: input.phone
+			}, ctx.abortSignal);
+		} catch (error) {
+			throw new Error(`Kunde nicht angelegt: ${describeError(error)}`);
+		}
+		await writeJournal("customer", ctx.callId, {
+			status: "created",
+			resourceId: created.id
+		});
+		return {
+			contactId: created.id,
+			customerNumber: created.customerNumber,
+			name: created.name,
+			note: created.customerNumber === void 0 ? "Angelegt; die Kundennummer ließ sich nicht zurücklesen." : void 0
+		};
+	}
+});
+export { create_customer_default as default };

package/dist/extension/tools/create_invoice.d.ts

@@ -0,0 +1,28 @@
+declare const _default: import("eve/tools").ToolDefinition<{
+    customer_number?: number | undefined;
+    contact_id?: string | undefined;
+    items: {
+        name: string;
+        quantity: number;
+        unit: string;
+        net_price: number;
+        tax_rate: 0 | 7 | 19;
+    }[];
+    source_document_id?: string | undefined;
+    source_document_type?: "order-confirmation" | "quotation" | undefined;
+}, Record<string, unknown>> & {
+    execute(input: {
+        customer_number?: number | undefined;
+        contact_id?: string | undefined;
+        items: {
+            name: string;
+            quantity: number;
+            unit: string;
+            net_price: number;
+            tax_rate: 0 | 7 | 19;
+        }[];
+        source_document_id?: string | undefined;
+        source_document_type?: "order-confirmation" | "quotation" | undefined;
+    }, ctx: import("eve/tools").ToolContext): Promise<Record<string, unknown>>;
+};
+export default _default;

package/dist/extension/tools/create_invoice.mjs

@@ -0,0 +1,28 @@
+import { fileURLToPath as __eveFileURLToPath } from "node:url";
+import { dirname as __eveDirname } from "node:path";
+import { createRequire as __eveCreateRequire } from "node:module";
+const __filename = __eveFileURLToPath(import.meta.url);
+__eveDirname(__filename);
+__eveCreateRequire(import.meta.url);
+import { approverPolicy } from "../lib/runtime.mjs";
+import { customerFields, executeSalesDocument, lineItemSchema, salesApproval } from "../lib/sales.mjs";
+import { z } from "zod";
+import { defineTool } from "eve/tools";
+const inputSchema = z.object({
+	...customerFields,
+	items: z.array(lineItemSchema).min(1).max(300).describe("Alle Positionen der Rechnung"),
+	source_document_id: z.string().uuid().optional().describe("UUID des Angebots bzw. der AB, aus der diese Rechnung hervorgeht"),
+	source_document_type: z.enum(["quotation", "order-confirmation"]).optional().describe("Art des Bezugsbelegs zu source_document_id")
+}).strict().refine((input) => input.customer_number === void 0 !== (input.contact_id === void 0), { message: "Genau eines von customer_number und contact_id angeben." }).refine((input) => !input.source_document_id || input.source_document_type, { message: "source_document_type zu source_document_id angeben." });
+var create_invoice_default = defineTool({
+	description: "Erstellt eine Ausgangsrechnung als Entwurf in Lexware Office — festgeschrieben und versendet wird dort, nie hier. Kunde per Kundennummer oder contact_id, dazu die Positionen; source_document_id, wenn die Rechnung aus einem Angebot oder einer AB hervorgeht. Legt erst nach Freigabe an und prüft vorher auf Dubletten.",
+	inputSchema,
+	approval: {
+		request: salesApproval("invoice"),
+		response: approverPolicy
+	},
+	async execute(input, ctx) {
+		return executeSalesDocument("invoice", input, ctx);
+	}
+});
+export { create_invoice_default as default };

package/dist/extension/tools/create_order_confirmation.d.ts

@@ -0,0 +1,28 @@
+declare const _default: import("eve/tools").ToolDefinition<{
+    customer_number?: number | undefined;
+    contact_id?: string | undefined;
+    items: {
+        name: string;
+        quantity: number;
+        unit: string;
+        net_price: number;
+        tax_rate: 0 | 7 | 19;
+    }[];
+    title?: string | undefined;
+    quotation_id?: string | undefined;
+}, Record<string, unknown>> & {
+    execute(input: {
+        customer_number?: number | undefined;
+        contact_id?: string | undefined;
+        items: {
+            name: string;
+            quantity: number;
+            unit: string;
+            net_price: number;
+            tax_rate: 0 | 7 | 19;
+        }[];
+        title?: string | undefined;
+        quotation_id?: string | undefined;
+    }, ctx: import("eve/tools").ToolContext): Promise<Record<string, unknown>>;
+};
+export default _default;

package/dist/extension/tools/create_order_confirmation.mjs

@@ -0,0 +1,33 @@
+import { fileURLToPath as __eveFileURLToPath } from "node:url";
+import { dirname as __eveDirname } from "node:path";
+import { createRequire as __eveCreateRequire } from "node:module";
+const __filename = __eveFileURLToPath(import.meta.url);
+__eveDirname(__filename);
+__eveCreateRequire(import.meta.url);
+import { approverPolicy } from "../lib/runtime.mjs";
+import { customerFields, executeSalesDocument, lineItemSchema, salesApproval, titleSchema } from "../lib/sales.mjs";
+import { z } from "zod";
+import { defineTool } from "eve/tools";
+const inputSchema = z.object({
+	...customerFields,
+	items: z.array(lineItemSchema).min(1).max(300).describe("Alle Positionen der AB — beim Ableiten aus einem Angebot dessen Positionen (per Lese-Tool /quotations/{id}), plus gewünschte Änderungen"),
+	title: titleSchema("der AB"),
+	quotation_id: z.string().uuid().optional().describe("UUID des Angebots, aus dem diese AB hervorgeht. Dann prüft das Tool Kunde und Positionssumme gegen das Angebot.")
+}).strict().refine((input) => input.customer_number === void 0 !== (input.contact_id === void 0), { message: "Genau eines von customer_number und contact_id angeben." });
+const withSource = (input) => input.quotation_id && !input.source_document_id ? {
+	...input,
+	source_document_id: input.quotation_id,
+	source_document_type: "quotation"
+} : input;
+var create_order_confirmation_default = defineTool({
+	description: "Erstellt eine Auftragsbestätigung (AB) in Lexware Office und schreibt sie direkt fest (sie erhält eine AB-Nummer; kein Entwurf). Geht die AB aus einem Angebot hervor, dessen quotation_id mitgeben — das Angebot vorher über /voucherlist (voucherType 'quotation') suchen und lesen; bei mehreren passenden den Nutzer wählen lassen. Legt erst nach Freigabe an.",
+	inputSchema,
+	approval: {
+		request: salesApproval("order-confirmation", withSource),
+		response: approverPolicy
+	},
+	async execute(input, ctx) {
+		return executeSalesDocument("order-confirmation", withSource(input), ctx);
+	}
+});
+export { create_order_confirmation_default as default };

package/dist/extension/tools/create_purchase_invoice.d.ts

@@ -0,0 +1,76 @@
+declare const _default: import("eve/tools").ToolDefinition<{
+    supplier_name: string;
+    voucher_number: string;
+    voucher_date: string;
+    due_date?: string | undefined;
+    currency: string;
+    bank_statement_eur_amount?: number | undefined;
+    total_gross_amount: number;
+    tax_groups: {
+        gross_amount: number;
+        tax_rate_percent: number;
+        category?: string | undefined;
+    }[];
+    category?: string | undefined;
+    contact_id?: string | undefined;
+    remark?: string | undefined;
+    attachment_path?: string | undefined;
+}, {
+    voucherId: string;
+    url: string;
+    supplier: string;
+    contact: string;
+    voucherNumber: string;
+    voucherDate: string;
+    status: "unchecked";
+    gross: number;
+    tax: number;
+    net: number;
+    currency: string;
+    conversion: string | null;
+    declaredGross: number;
+    difference: number;
+    category: string;
+    attachment: string;
+    preflightNotes: string[];
+    note: string;
+}> & {
+    execute(input: {
+        supplier_name: string;
+        voucher_number: string;
+        voucher_date: string;
+        due_date?: string | undefined;
+        currency: string;
+        bank_statement_eur_amount?: number | undefined;
+        total_gross_amount: number;
+        tax_groups: {
+            gross_amount: number;
+            tax_rate_percent: number;
+            category?: string | undefined;
+        }[];
+        category?: string | undefined;
+        contact_id?: string | undefined;
+        remark?: string | undefined;
+        attachment_path?: string | undefined;
+    }, ctx: import("eve/tools").ToolContext): Promise<{
+        voucherId: string;
+        url: string;
+        supplier: string;
+        contact: string;
+        voucherNumber: string;
+        voucherDate: string;
+        status: "unchecked";
+        gross: number;
+        tax: number;
+        net: number;
+        currency: string;
+        conversion: string | null;
+        declaredGross: number;
+        difference: number;
+        category: string;
+        attachment: string;
+        preflightNotes: string[];
+        note: string;
+    }>;
+};
+export default _default;

package/dist/extension/tools/create_purchase_invoice.mjs

@@ -0,0 +1,241 @@
+import { fileURLToPath as __eveFileURLToPath } from "node:url";
+import { dirname as __eveDirname } from "node:path";
+import { createRequire as __eveCreateRequire } from "node:module";
+const __filename = __eveFileURLToPath(import.meta.url);
+__eveDirname(__filename);
+__eveCreateRequire(import.meta.url);
+import { eur } from "../lib/format.mjs";
+import { approverPolicy, client, config } from "../lib/runtime.mjs";
+import { MISSING_EUR_AMOUNT_INSTRUCTION, approvedPurchaseTarget, bookedGroupsOf, invoiceCurrencyOf, isAllowedAttachmentPath, isForeignCurrency, lacksEurAmount, purchaseSignatureOf, rememberPurchaseTarget, runPurchasePreflight, totalsOf } from "../lib/purchase.mjs";
+import { describeWarning, isCorrectable, notesOf, rememberRejection, saveWarnings, wasRejected, wasShownOnCard } from "../lib/findings.mjs";
+import { readJournal, writeJournal } from "../lib/journal.mjs";
+import { z } from "zod";
+import { REVERSE_CHARGE_TAX_RATE, createVoucher, describeError, findPurchaseInvoiceByNumber, isReverseChargeCategory, round2, taxFromGross, uploadVoucherFile } from "@kevludwig/lexware-office";
+import { defineTool } from "eve/tools";
+const VOUCHER_STATUS = "unchecked";
+const TAX_TYPE = "gross";
+const ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
+const TAX_RATES = [
+	0,
+	5,
+	7,
+	16,
+	19
+];
+const taxGroupSchema = z.object({
+	gross_amount: z.number().positive().describe("Bruttobetrag dieser Steuersatz-Gruppe in Rechnungswährung, wie auf der Rechnung — nicht umgerechnet"),
+	tax_rate_percent: z.number().refine((rate) => TAX_RATES.includes(rate), { message: `Steuersatz muss einer von ${TAX_RATES.join(", ")} sein` }).describe("Steuersatz dieser Gruppe in Prozent"),
+	category: z.string().trim().min(1).max(100).optional().describe("Buchungskategorie NUR dieser Gruppe (Name oder Id) — nur für einen auf mehrere Kategorien aufgeteilten Beleg; dann bei ALLEN Gruppen setzen und das Feld category weglassen. Bei gleichem Steuersatz mehrere Gruppen mit demselben Satz anlegen.")
+}).strict();
+const inputSchema = z.object({
+	supplier_name: z.string().trim().min(1).max(255).describe("Name des Lieferanten laut Rechnungskopf"),
+	voucher_number: z.string().trim().min(1).max(100).describe("Rechnungsnummer des Lieferanten. Pflicht — daran wird eine schon erfasste Rechnung erkannt."),
+	voucher_date: z.string().regex(ISO_DATE).describe("Rechnungsdatum, yyyy-MM-dd"),
+	due_date: z.string().regex(ISO_DATE).optional().describe("Fälligkeitsdatum, yyyy-MM-dd, wenn die Rechnung eines nennt"),
+	currency: z.string().trim().regex(/^[A-Za-z]{3}$/).describe("Währung der Rechnung als ISO-Code (EUR, USD, GBP, …). Alle Beträge sind in dieser Währung."),
+	bank_statement_eur_amount: z.number().positive().optional().describe("Nur bei currency ungleich EUR, dann Pflicht: der abgebuchte EUR-Betrag laut Kontoauszug, wie der Nutzer ihn nennt. Nie selbst umrechnen."),
+	total_gross_amount: z.number().positive().describe("Rechnungsendbetrag brutto in Rechnungswährung. Die Summe der tax_groups muss ihn ergeben."),
+	tax_groups: z.array(taxGroupSchema).min(1).max(5).describe("Die Beträge nach Steuersatz gruppiert, nicht die Einzelpositionen — 48 Artikel zu 19 % sind eine Gruppe. Mehrere Gruppen bei mehreren Steuersätzen oder für eine Aufteilung auf mehrere Kategorien (dann je Kategorie eine Gruppe mit category)."),
+	category: z.string().trim().min(1).max(100).optional().describe("Buchungskategorie (Name oder Id). Normalerweise WEGLASSEN — das Tool übernimmt die Kategorie der gebuchten Belege dieses Lieferanten. Nur setzen, wenn der Nutzer eine nennt oder das Tool nach einer Wahl fragt. Der Name muss wörtlich einer Kategorie des Kontos entsprechen."),
+	contact_id: z.string().uuid().optional().describe("Kontakt-Id des Lieferanten. Normalerweise weglassen — das Tool sucht selbst. Nur setzen, wenn die Suche mehrere findet und der Nutzer einen nennt."),
+	remark: z.string().trim().max(500).optional().describe("Bemerkung am Beleg. Ohne Angabe: Lieferant und Rechnungsnummer."),
+	attachment_path: z.string().trim().max(500).optional().describe("Sandbox-Pfad des Originals, wie beim hochgeladenen Dokument angegeben (/workspace/attachments/…). Wird als Anhang hochgeladen.")
+}).strict().refine((input) => {
+	const withCategory = input.tax_groups.filter((group) => group.category).length;
+	return withCategory === 0 || withCategory === input.tax_groups.length;
+}, { message: "category je Gruppe entweder bei allen tax_groups setzen oder bei keiner." }).refine((input) => !input.category || !input.tax_groups.some((group) => group.category), { message: "Entweder das Feld category ODER category je tax_group — nicht beides." }).refine((input) => !lacksEurAmount(input), { message: MISSING_EUR_AMOUNT_INSTRUCTION }).refine((input) => isForeignCurrency(input) || input.bank_statement_eur_amount === void 0, { message: "bank_statement_eur_amount nur bei einer Rechnung in Fremdwährung setzen." });
+function mediaTypeOf(path) {
+	switch (path.slice(path.lastIndexOf(".") + 1).toLowerCase()) {
+		case "pdf": return "application/pdf";
+		case "png": return "image/png";
+		case "jpg":
+		case "jpeg": return "image/jpeg";
+		case "xml": return "application/xml";
+		default: return "application/octet-stream";
+	}
+}
+const basename = (path) => path.split("/").pop() || path;
+var create_purchase_invoice_default = defineTool({
+	description: "Erfasst eine Eingangsrechnung (Lieferantenrechnung) als Beleg in Lexware Office und hängt das Original an. Beträge nach Steuersatz gruppiert, nicht als Einzelpositionen — die Artikel stehen im Anhang. Entsteht erst nach Freigabe, unter „Belege zur Prüfung“. Vorher wird geprüft, ob die Gruppen den Endbetrag ergeben und ob die Rechnungsnummer schon erfasst ist.",
+	inputSchema,
+	approval: {
+		request: async (ctx) => {
+			const input = ctx.toolInput;
+			if (!input?.voucher_number) return "user-approval";
+			if (lacksEurAmount(input)) return {
+				type: "denied",
+				reason: MISSING_EUR_AMOUNT_INSTRUCTION
+			};
+			const fallback = config().attachments;
+			const { warnings, supplier, category, groupCategories } = await runPurchasePreflight(input, {
+				signal: ctx.abortSignal,
+				readFileSize: async (path) => {
+					const bytes = await (await ctx.getSandbox()).readBinaryFile({ path });
+					if (bytes) return bytes.byteLength;
+					if (!fallback) return null;
+					if (fallback.size) return fallback.size(path);
+					return (await fallback.read(path))?.byteLength ?? null;
+				}
+			});
+			const signature = purchaseSignatureOf(input);
+			const correctable = warnings.filter(isCorrectable);
+			if (correctable.length > 0 && !wasRejected(signature)) {
+				rememberRejection(signature);
+				const totals = correctable.some((warning) => warning.kind === "voucher-total-mismatch");
+				const deviation = correctable.some((warning) => warning.kind === "category-deviation");
+				return {
+					type: "denied",
+					reason: correctable.map((warning) => describeWarning(warning).value).join(" — ") + (totals ? ". Prüfe die Beträge erneut: Der Rechnungsendbetrag ist brutto, die tax_groups müssen ihn in Summe ergeben. Korrigiere und rufe das Tool erneut auf. Bleibt die Abweichung, rufe es unverändert erneut auf — dann entscheidet der Nutzer." : deviation ? ". Setze category nur, wenn der Nutzer diese Kategorie genannt hat — sonst weglassen oder die übliche nehmen. Ist die Abweichung gewollt, rufe das Tool unverändert erneut auf — dann entscheidet der Nutzer an der Karte." : ". Rufe das Tool danach erneut auf; ohne Kategorie-Wahl entscheidet der Nutzer an der Karte.")
+				};
+			}
+			saveWarnings(ctx.callId, warnings);
+			rememberPurchaseTarget(ctx.callId, {
+				contactId: supplier.contactId,
+				contactName: supplier.contactName,
+				categoryId: category?.id,
+				categoryName: category?.name,
+				groupCategories: groupCategories?.map((match) => ({
+					id: match?.id,
+					name: match?.name
+				}))
+			});
+			const onCaptured = config().onPurchaseCaptured;
+			if (onCaptured && input.tax_groups?.length) {
+				const totals = totalsOf(bookedGroupsOf(input));
+				try {
+					await onCaptured({
+						callId: ctx.callId,
+						voucherNumber: input.voucher_number,
+						supplierName: supplier.contactName,
+						...totals
+					});
+				} catch (error) {
+					console.warn(`[lexware] onPurchaseCaptured failed: ${String(error)}`);
+				}
+			}
+			return "user-approval";
+		},
+		response: approverPolicy
+	},
+	async execute(input, ctx) {
+		const bookedGroups = bookedGroupsOf(input);
+		const totals = totalsOf(bookedGroups);
+		const currency = invoiceCurrencyOf(input);
+		const invoiceGross = totalsOf(input.tax_groups).gross;
+		const conversion = isForeignCurrency(input) ? `${eur(invoiceGross, currency)} laut Rechnung, abgebucht ${eur(totals.gross)} laut Kontoauszug` : null;
+		const fallback = config().attachments;
+		let attachment = null;
+		let attachmentProblem = null;
+		if (input.attachment_path) {
+			if (!isAllowedAttachmentPath(input.attachment_path)) attachmentProblem = `„${input.attachment_path}" liegt nicht unter /workspace/attachments/`;
+			else {
+				let bytes = null;
+				try {
+					bytes = await (await ctx.getSandbox()).readBinaryFile({ path: input.attachment_path });
+				} catch (error) {
+					console.warn(`[lexware] Sandbox read failed: ${describeError(error)}`);
+				}
+				if (!bytes && fallback) bytes = await fallback.read(input.attachment_path, ctx.abortSignal).catch(() => null);
+				if (bytes) attachment = {
+					bytes,
+					filename: basename(input.attachment_path),
+					mediaType: mediaTypeOf(input.attachment_path)
+				};
+				else attachmentProblem = `${basename(input.attachment_path)} liegt nicht mehr in der Sandbox${fallback ? " und nicht im Archiv" : ""}`;
+			}
+		}
+		const journal = await readJournal("purchase", ctx.callId);
+		let voucher;
+		let contactNote;
+		let categoryNote;
+		if (journal?.resourceId) {
+			voucher = {
+				id: journal.resourceId,
+				url: client().voucherUrl(journal.resourceId)
+			};
+			contactNote = `${input.supplier_name} (Wiederaufnahme — Beleg existierte bereits)`;
+			categoryNote = "wie beim ersten Lauf — in Lexware Office prüfen";
+		} else {
+			let existing = null;
+			try {
+				existing = await findPurchaseInvoiceByNumber(client(), input.voucher_number, ctx.abortSignal);
+			} catch {}
+			if (existing && !wasShownOnCard(ctx.callId, existing.url)) throw new Error(`Abgebrochen: Rechnung ${input.voucher_number} ist inzwischen bereits erfasst: ${existing.url}. Nichts angelegt. Schicke die Rechnung erneut, wenn trotzdem ein zweiter Beleg entstehen soll — dann steht der Fund auf der Karte.`);
+			const target = approvedPurchaseTarget(ctx.callId);
+			if (!target) throw new Error("Abgebrochen: Die an die Freigabe gebundene Lieferanten- und Kategorienwahl fehlt — nichts angelegt. Rufe das Tool erneut auf.");
+			const categoryOf = (index) => target.groupCategories?.[index]?.id ?? target.categoryId;
+			const reverseCharge = (index, rate) => rate === 0 && isReverseChargeCategory(target.groupCategories?.[index]?.name ?? target.categoryName);
+			categoryNote = target.groupCategories ? target.groupCategories.map((entry) => entry.name ?? "keine — in Lexware Office zuordnen").join(" / ") : target.categoryName ?? "keine — in Lexware Office zuordnen";
+			const common = {
+				type: "purchaseinvoice",
+				voucherStatus: VOUCHER_STATUS,
+				taxType: TAX_TYPE,
+				voucherNumber: input.voucher_number,
+				voucherDate: input.voucher_date,
+				dueDate: input.due_date,
+				totalGrossAmount: totals.gross,
+				totalTaxAmount: totals.tax,
+				remark: input.remark ?? `Lieferantenrechnung ${input.voucher_number} — ${target.contactName}${conversion ? ` · ${conversion}` : ""}`,
+				voucherItems: bookedGroups.map((group, index) => reverseCharge(index, group.tax_rate_percent) ? {
+					amount: group.gross_amount,
+					taxAmount: 0,
+					taxRatePercent: REVERSE_CHARGE_TAX_RATE,
+					categoryId: categoryOf(index)
+				} : {
+					amount: group.gross_amount,
+					taxAmount: taxFromGross(group.gross_amount, group.tax_rate_percent),
+					taxRatePercent: group.tax_rate_percent,
+					categoryId: categoryOf(index)
+				})
+			};
+			await writeJournal("purchase", ctx.callId, { status: "pending" });
+			voucher = target.contactId ? await createVoucher(client(), {
+				...common,
+				contactId: target.contactId
+			}, ctx.abortSignal) : await createVoucher(client(), {
+				...common,
+				useCollectiveContact: true,
+				contactName: target.contactName
+			}, ctx.abortSignal);
+			await writeJournal("purchase", ctx.callId, {
+				status: "created",
+				resourceId: voucher.id
+			});
+			contactNote = target.contactId ? target.contactName : `Sammellieferant (${target.contactName})`;
+		}
+		let attachmentResult = attachmentProblem ? `ohne Original — ${attachmentProblem}. In Lexware Office am Beleg nachreichen.` : "kein Anhang";
+		if (journal?.status === "attached") attachmentResult = "bereits angehängt (Wiederaufnahme)";
+		else if (attachment) try {
+			await uploadVoucherFile(client(), voucher.id, attachment, ctx.abortSignal);
+			await writeJournal("purchase", ctx.callId, {
+				status: "attached",
+				resourceId: voucher.id
+			});
+			attachmentResult = `${attachment.filename} angehängt`;
+			if (input.attachment_path) await fallback?.release?.(input.attachment_path).catch(() => {});
+		} catch (error) {
+			attachmentResult = `${attachment.filename} konnte nicht angehängt werden: ${describeError(error)}`;
+		}
+		return {
+			voucherId: voucher.id,
+			url: voucher.url,
+			supplier: input.supplier_name,
+			contact: contactNote,
+			voucherNumber: input.voucher_number,
+			voucherDate: input.voucher_date,
+			status: VOUCHER_STATUS,
+			gross: totals.gross,
+			tax: totals.tax,
+			net: totals.net,
+			currency,
+			conversion,
+			declaredGross: input.total_gross_amount,
+			difference: round2(invoiceGross - input.total_gross_amount),
+			category: categoryNote,
+			attachment: attachmentResult,
+			preflightNotes: notesOf(ctx.callId),
+			note: `Der Beleg liegt unter „Belege zur Prüfung" und ist noch nicht gebucht. Netto ${eur(totals.net)}, USt. ${eur(totals.tax)}.`
+		};
+	}
+});
+export { create_purchase_invoice_default as default };

package/dist/extension/tools/create_quotation.d.ts

@@ -0,0 +1,28 @@
+declare const _default: import("eve/tools").ToolDefinition<{
+    customer_number?: number | undefined;
+    contact_id?: string | undefined;
+    items: {
+        name: string;
+        quantity: number;
+        unit: string;
+        net_price: number;
+        tax_rate: 0 | 7 | 19;
+    }[];
+    title?: string | undefined;
+    valid_until?: string | undefined;
+}, Record<string, unknown>> & {
+    execute(input: {
+        customer_number?: number | undefined;
+        contact_id?: string | undefined;
+        items: {
+            name: string;
+            quantity: number;
+            unit: string;
+            net_price: number;
+            tax_rate: 0 | 7 | 19;
+        }[];
+        title?: string | undefined;
+        valid_until?: string | undefined;
+    }, ctx: import("eve/tools").ToolContext): Promise<Record<string, unknown>>;
+};
+export default _default;

package/dist/extension/tools/create_quotation.mjs

@@ -0,0 +1,28 @@
+import { fileURLToPath as __eveFileURLToPath } from "node:url";
+import { dirname as __eveDirname } from "node:path";
+import { createRequire as __eveCreateRequire } from "node:module";
+const __filename = __eveFileURLToPath(import.meta.url);
+__eveDirname(__filename);
+__eveCreateRequire(import.meta.url);
+import { approverPolicy } from "../lib/runtime.mjs";
+import { customerFields, executeSalesDocument, isCalendarDate, lineItemSchema, salesApproval, titleSchema } from "../lib/sales.mjs";
+import { z } from "zod";
+import { defineTool } from "eve/tools";
+const inputSchema = z.object({
+	...customerFields,
+	items: z.array(lineItemSchema).min(1).max(300).describe("Alle Positionen des Angebots"),
+	title: titleSchema("des Angebots"),
+	valid_until: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).refine(isCalendarDate, { message: "kein gültiges Kalenderdatum" }).optional().describe(`Gültig bis, yyyy-MM-dd. Ohne Angabe 30 Tage ab heute.`)
+}).strict().refine((input) => input.customer_number === void 0 !== (input.contact_id === void 0), { message: "Genau eines von customer_number und contact_id angeben." });
+var create_quotation_default = defineTool({
+	description: "Erstellt ein Angebot in Lexware Office und schreibt es direkt fest (es erhält eine Angebotsnummer; kein Entwurf). Kunde per Kundennummer oder contact_id — existiert er noch nicht, zuerst create_customer. Legt erst nach Freigabe an und prüft vorher, ob es für diesen Kunden schon ein Angebot mit gleicher Positionssumme gibt. Versendet wird aus Lexware Office.",
+	inputSchema,
+	approval: {
+		request: salesApproval("quotation"),
+		response: approverPolicy
+	},
+	async execute(input, ctx) {
+		return executeSalesDocument("quotation", input, ctx);
+	}
+});
+export { create_quotation_default as default };