wizards 0.1.9

package/apps/runtime/dist/engenty/csv-import/import-sources.js

@@ -0,0 +1,87 @@
+/**
+ * Module-declared import sources: CSV upload (always) plus connections that can
+ * produce tabular rows for a domain (secrets / contacts / team).
+ */
+/** File-capable connectors shared by secrets / contacts / team. */
+export const FILE_CONNECTION_IMPORT_SOURCES = [
+    {
+        kind: "connection",
+        connectorId: "google-drive",
+        domains: ["secrets", "contacts", "team"],
+        requiresCapability: "files",
+        fetchMode: "pick_file",
+    },
+    {
+        kind: "connection",
+        connectorId: "microsoft-onedrive",
+        domains: ["secrets", "contacts", "team"],
+        requiresCapability: "files",
+        fetchMode: "pick_file",
+    },
+    {
+        kind: "connection",
+        connectorId: "local-files",
+        domains: ["secrets", "contacts", "team"],
+        requiresCapability: "files",
+        fetchMode: "pick_file",
+    },
+    {
+        kind: "connection",
+        connectorId: "s3",
+        domains: ["secrets", "contacts", "team"],
+        requiresCapability: "files",
+        fetchMode: "pick_file",
+    },
+];
+/** Typed CRM / people connectors (contacts domain only). */
+export const TYPED_CONNECTION_IMPORT_SOURCES = [
+    {
+        kind: "connection",
+        connectorId: "google-contacts",
+        domains: ["contacts"],
+        requiresCapability: "action",
+        fetchMode: "list_records",
+        listActionId: "list_contacts",
+    },
+    {
+        kind: "connection",
+        connectorId: "hubspot",
+        domains: ["contacts"],
+        requiresCapability: "action",
+        fetchMode: "list_records",
+        listActionId: "list_contacts",
+    },
+];
+export const ALL_CONNECTION_IMPORT_SOURCES = [
+    ...FILE_CONNECTION_IMPORT_SOURCES,
+    ...TYPED_CONNECTION_IMPORT_SOURCES,
+];
+/** Sources registered for a module domain (file + typed). */
+export function connectionImportSourcesForDomain(domain, extras = []) {
+    const base = domain === "contacts"
+        ? ALL_CONNECTION_IMPORT_SOURCES
+        : FILE_CONNECTION_IMPORT_SOURCES;
+    const merged = [...base, ...extras];
+    const byId = new Map();
+    for (const source of merged) {
+        if (source.domains.includes(domain)) {
+            byId.set(source.connectorId, source);
+        }
+    }
+    return [...byId.values()];
+}
+/** MIME / extension filter for importable connection files. */
+export function isImportableConnectionFile(entry) {
+    if (entry.kind !== "file") {
+        return false;
+    }
+    const mime = (entry.mimeType ?? "").toLowerCase();
+    if (mime === "text/csv" ||
+        mime === "text/tab-separated-values" ||
+        mime === "text/plain" ||
+        mime === "application/vnd.google-apps.spreadsheet") {
+        return true;
+    }
+    const lower = entry.name.toLowerCase();
+    return (lower.endsWith(".csv") || lower.endsWith(".tsv") || lower.endsWith(".txt"));
+}

package/apps/runtime/dist/engenty/csv-import/parse-csv.js

@@ -0,0 +1,129 @@
+export function parseCSV(csvContent) {
+    const delimiter = detectDelimiter(csvContent);
+    const rows = parseCSVRows(csvContent, delimiter);
+    if (rows.length === 0) {
+        throw new Error("CSV file is empty");
+    }
+    const headers = rows[0];
+    const dataRows = rows.slice(1);
+    return { headers, rows: dataRows, totalRows: dataRows.length };
+}
+function pushField(row, field, quoted) {
+    // Quoted fields keep interior whitespace; unquoted fields are trimmed.
+    row.push(quoted ? field : field.trim());
+}
+/** Parse delimited text into a raw matrix (no header/data split). */
+export function parseCSVRows(csvContent, delimiter) {
+    const rows = [];
+    let currentRow = [];
+    let currentField = "";
+    let inQuotes = false;
+    let fieldWasQuoted = false;
+    let i = 0;
+    while (i < csvContent.length) {
+        const char = csvContent[i];
+        const nextChar = csvContent[i + 1];
+        if (char === '"') {
+            if (inQuotes && nextChar === '"') {
+                currentField += '"';
+                i += 2;
+                continue;
+            }
+            inQuotes = !inQuotes;
+            fieldWasQuoted = true;
+            // Delimiter quotes are not part of the cell value (RFC 4180 / Sheets TSV).
+            i++;
+            continue;
+        }
+        if (char === delimiter && !inQuotes) {
+            pushField(currentRow, currentField, fieldWasQuoted);
+            currentField = "";
+            fieldWasQuoted = false;
+            i++;
+            continue;
+        }
+        if ((char === "\n" || (char === "\r" && nextChar === "\n")) && !inQuotes) {
+            if (char === "\r" && nextChar === "\n") {
+                i += 2;
+            }
+            else {
+                i++;
+            }
+            pushField(currentRow, currentField, fieldWasQuoted);
+            if (currentRow.length > 0 &&
+                currentRow.some((f) => f.trim().length > 0)) {
+                rows.push(currentRow);
+            }
+            currentRow = [];
+            currentField = "";
+            fieldWasQuoted = false;
+            continue;
+        }
+        currentField += char;
+        i++;
+    }
+    if (currentField.length > 0 || currentRow.length > 0) {
+        pushField(currentRow, currentField, fieldWasQuoted);
+        if (currentRow.length > 0 && currentRow.some((f) => f.trim().length > 0)) {
+            rows.push(currentRow);
+        }
+    }
+    return rows;
+}
+export function detectDelimiter(csvContent) {
+    let firstRow = "";
+    let inQuotes = false;
+    for (let i = 0; i < csvContent.length; i++) {
+        const char = csvContent[i];
+        const nextChar = csvContent[i + 1];
+        if (char === '"') {
+            if (inQuotes && nextChar === '"') {
+                firstRow += char;
+                i++;
+                continue;
+            }
+            inQuotes = !inQuotes;
+            firstRow += char;
+            continue;
+        }
+        if ((char === "\n" || (char === "\r" && nextChar === "\n")) && !inQuotes) {
+            break;
+        }
+        firstRow += char;
+    }
+    let commaCount = 0;
+    let semicolonCount = 0;
+    let tabCount = 0;
+    inQuotes = false;
+    for (let i = 0; i < firstRow.length; i++) {
+        const char = firstRow[i];
+        const nextChar = firstRow[i + 1];
+        if (char === '"') {
+            if (inQuotes && nextChar === '"') {
+                i++;
+            }
+            else {
+                inQuotes = !inQuotes;
+            }
+            continue;
+        }
+        if (!inQuotes) {
+            if (char === ",") {
+                commaCount++;
+            }
+            if (char === ";") {
+                semicolonCount++;
+            }
+            if (char === "\t") {
+                tabCount++;
+            }
+        }
+    }
+    if (semicolonCount > commaCount && semicolonCount > tabCount) {
+        return ";";
+    }
+    if (tabCount > commaCount) {
+        return "\t";
+    }
+    return ",";
+}

package/apps/runtime/dist/engenty/csv-import/serialize-csv.js

@@ -0,0 +1,20 @@
+/** Escape a single CSV/TSV field for the given delimiter. */
+export function escapeDelimitedField(value, delimiter) {
+    if (value.includes(delimiter) ||
+        value.includes('"') ||
+        value.includes("\n") ||
+        value.includes("\r")) {
+        return `"${value.replace(/"/g, '""')}"`;
+    }
+    return value;
+}
+/** Serialize a header + data matrix to delimited text (LF endings). */
+export function serializeDelimitedMatrix(headers, rows, delimiter) {
+    const lines = [
+        headers.map((h) => escapeDelimitedField(h, delimiter)).join(delimiter),
+        ...rows.map((row) => headers
+            .map((_, index) => escapeDelimitedField(row[index] ?? "", delimiter))
+            .join(delimiter)),
+    ];
+    return `${lines.join("\n")}\n`;
+}

package/apps/runtime/dist/engenty/csv-import/types.js

@@ -0,0 +1 @@
+export {};

package/apps/runtime/dist/engenty/csv-import/xlsx-workbook.js

@@ -0,0 +1,159 @@
+/**
+ * Read limits, per sheet.
+ *
+ * Parsing is not the cost — unzipping the file is, and that is paid whatever we
+ * do with it. These exist so one pathological sheet cannot hold a million
+ * strings in memory. When a limit bites, the sheet says so; it never trims in
+ * silence.
+ */
+export const XLSX_MAX_ROWS = 10_000;
+export const XLSX_MAX_COLUMNS = 256;
+/** True when the sheet holds more than was read. */
+export function isXlsxSheetTruncated(sheet) {
+    return (sheet.sourceRowCount > sheet.matrix.rows.length ||
+        sheet.sourceColumnCount > sheet.matrix.columns.length);
+}
+/** 0-based index → spreadsheet column letters: 0 → `A`, 26 → `AA`. */
+export function columnLetter(index) {
+    let remaining = index;
+    let letters = "";
+    do {
+        letters = String.fromCharCode(65 + (remaining % 26)) + letters;
+        remaining = Math.floor(remaining / 26) - 1;
+    } while (remaining >= 0);
+    return letters;
+}
+/** Excel stores naive datetimes; exceljs hands them back as UTC instants. */
+function formatDate(value) {
+    if (Number.isNaN(value.getTime())) {
+        return "";
+    }
+    const date = value.toISOString().slice(0, 10);
+    const time = value.toISOString().slice(11, 16);
+    return time === "00:00" ? date : `${date} ${time}`;
+}
+function isDate(value) {
+    return value instanceof Date;
+}
+/**
+ * One property off a value that may not be an object.
+ *
+ * A plain reader rather than a type guard: exceljs models a cell as a union of
+ * a dozen shapes, and narrowing that union one key at a time fights the
+ * compiler for no benefit — every branch below wants the same "is this key
+ * here, and what is in it" question answered.
+ */
+function prop(value, key) {
+    return typeof value === "object" && value !== null
+        ? value[key]
+        : undefined;
+}
+/**
+ * A cell as the text Excel would show in it.
+ *
+ * The formula case is the one with a decision in it: a workbook carries the
+ * last computed result alongside the formula, and that cached value is what
+ * Excel displays. When a file was written by a tool that never calculated, the
+ * result is missing — then the formula itself is shown, because a blank cell
+ * would claim the sheet is empty where it is merely uncomputed.
+ */
+export function xlsxCellText(value) {
+    if (value === null || value === undefined) {
+        return "";
+    }
+    if (typeof value === "string") {
+        return value;
+    }
+    // Excel shows booleans uppercase, and so does anything reading its CSV.
+    if (typeof value === "boolean") {
+        return value ? "TRUE" : "FALSE";
+    }
+    if (typeof value === "number") {
+        return String(value);
+    }
+    if (isDate(value)) {
+        return formatDate(value);
+    }
+    const error = prop(value, "error");
+    if (error !== undefined) {
+        return String(error);
+    }
+    const richText = prop(value, "richText");
+    if (Array.isArray(richText)) {
+        return richText.map((run) => String(prop(run, "text") ?? "")).join("");
+    }
+    const formula = prop(value, "formula") ?? prop(value, "sharedFormula");
+    if (formula !== undefined) {
+        const result = prop(value, "result");
+        if (result !== undefined && result !== null) {
+            return xlsxCellText(result);
+        }
+        return `=${String(formula)}`;
+    }
+    // A hyperlink renders as its label; the target is not text the sheet shows.
+    const text = prop(value, "text");
+    if (text !== undefined) {
+        return String(text);
+    }
+    const hyperlink = prop(value, "hyperlink");
+    if (hyperlink !== undefined) {
+        return String(hyperlink);
+    }
+    return String(value);
+}
+/**
+ * exceljs ships as CommonJS, so the namespace hides under `default` in some
+ * builds and is the module object itself in others.
+ */
+function unwrap(mod) {
+    const candidate = prop(mod, "default") ?? mod;
+    return (prop(candidate, "Workbook")
+        ? candidate
+        : mod);
+}
+function readSheet(worksheet, mergeType) {
+    // `rowCount` and `columnCount` are computed getters that walk every row —
+    // reading either one inside the scan turns a 5ms pass into a 60s one.
+    const sourceRowCount = worksheet.rowCount;
+    const sourceColumnCount = worksheet.columnCount;
+    const height = Math.min(sourceRowCount, XLSX_MAX_ROWS);
+    const width = Math.min(sourceColumnCount, XLSX_MAX_COLUMNS);
+    const rows = [];
+    for (let rowIndex = 1; rowIndex <= height; rowIndex++) {
+        const line = new Array(width).fill("");
+        worksheet.getRow(rowIndex).eachCell({ includeEmpty: true }, (cell, col) => {
+            if (col > width) {
+                return;
+            }
+            // A merged range repeats the master's value in every cell it covers.
+            // Written out as-is, one banner becomes three; only the master keeps it.
+            line[col - 1] = cell.type === mergeType ? "" : xlsxCellText(cell.value);
+        });
+        rows.push(line);
+    }
+    return {
+        hidden: worksheet.state !== "visible",
+        matrix: {
+            columns: Array.from({ length: width }, (_, index) => columnLetter(index)),
+            // A worksheet has no delimiter. It gets one only because the matrix is
+            // also what "copy as text" serializes through.
+            delimiter: ",",
+            raggedRows: 0,
+            rows,
+        },
+        name: worksheet.name,
+        sourceColumnCount,
+        sourceRowCount,
+    };
+}
+/** Bytes → sheets. Rejects with exceljs's own error when the file is not xlsx. */
+export async function readXlsxWorkbook(data) {
+    const excel = unwrap(await import("exceljs"));
+    const workbook = new excel.Workbook();
+    const buffer = data instanceof Uint8Array
+        ? data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength)
+        : data;
+    await workbook.xlsx.load(buffer);
+    const mergeType = excel.ValueType.Merge;
+    return { sheets: workbook.worksheets.map((ws) => readSheet(ws, mergeType)) };
+}

package/apps/runtime/dist/engenty/doc-converter/interface.js

@@ -0,0 +1,9 @@
+/**
+ * Document Converter — Provider interface.
+ *
+ * Following the banking provider architecture:
+ * - Abstract interface defines the contract
+ * - Concrete providers implement for specific services
+ * - Facade class selects the right provider
+ */
+export {};

package/apps/runtime/dist/engenty/doc-converter/page-break.js

@@ -0,0 +1,92 @@
+/** Empty HTML sentinel between page bodies. Must be explicitly closed (not `/>`). */
+export const PAGE_BREAK_TAG = "page-break";
+function escapeAttr(value) {
+    return value.replaceAll("&", "&").replaceAll('"', """);
+}
+/** `<page-break number="12" total="240"></page-break>` */
+export function formatPageBreak(attrs) {
+    const parts = [`number="${attrs.number}"`];
+    if (typeof attrs.total === "number" && attrs.total > 0) {
+        parts.push(`total="${attrs.total}"`);
+    }
+    const printed = attrs.printed?.trim();
+    if (printed) {
+        parts.push(`printed="${escapeAttr(printed)}"`);
+    }
+    return `<${PAGE_BREAK_TAG} ${parts.join(" ")}></${PAGE_BREAK_TAG}>`;
+}
+export function joinPagesWithBreaks(pages, total) {
+    const resolvedTotal = total && total > 0 ? total : pages.length;
+    const parts = [];
+    for (const page of pages) {
+        const markdown = page.markdown.trim();
+        if (!markdown) {
+            continue;
+        }
+        parts.push(formatPageBreak({
+            number: page.number,
+            total: resolvedTotal,
+            printed: page.printed,
+        }));
+        parts.push(markdown);
+    }
+    return parts.join("\n\n").trim();
+}
+/** Join per-page parser output, falling back to a concatenated blob. */
+export function markdownFromPagedParseResult(input) {
+    const slices = input.pages.map((page, index) => ({
+        number: page.number ?? index + 1,
+        markdown: (page.markdown ?? page.text ?? "").trim(),
+        ...(page.printed?.trim() ? { printed: page.printed.trim() } : {}),
+    }));
+    const joined = joinPagesWithBreaks(slices, input.total ?? (input.pages.length > 0 ? input.pages.length : undefined));
+    return joined || (input.fallback ?? "").trim();
+}
+const PAGE_BREAK_RE = /<page-break\b([^>]*)><\/page-break>/gi;
+function parseAttrs(raw) {
+    const attrs = {};
+    const re = /([a-zA-Z_:][\w:.-]*)\s*=\s*"([^"]*)"/g;
+    for (const match of raw.matchAll(re)) {
+        const name = match[1];
+        const value = match[2];
+        if (name && value != null) {
+            attrs[name] = value;
+        }
+    }
+    return attrs;
+}
+/** Split sidecar markdown on page-break sentinels. Untagged text is one page. */
+export function splitMarkdownByPageBreaks(markdown) {
+    const source = markdown.trim();
+    if (!source) {
+        return [];
+    }
+    const matches = [...source.matchAll(PAGE_BREAK_RE)];
+    if (matches.length === 0) {
+        return [{ markdown: source, number: 1 }];
+    }
+    const pages = [];
+    for (let index = 0; index < matches.length; index++) {
+        const match = matches[index];
+        if (!match || match.index == null) {
+            continue;
+        }
+        const start = match.index + match[0].length;
+        const end = matches[index + 1]?.index ?? source.length;
+        const body = source.slice(start, end).trim();
+        if (!body) {
+            continue;
+        }
+        const attrs = parseAttrs(match[1] ?? "");
+        const number = Number.parseInt(attrs.number ?? "", 10);
+        const total = Number.parseInt(attrs.total ?? "", 10);
+        const printed = attrs.printed?.trim();
+        pages.push({
+            markdown: body,
+            number: Number.isFinite(number) && number > 0 ? number : index + 1,
+            ...(printed ? { printed } : {}),
+            ...(Number.isFinite(total) && total > 0 ? { total } : {}),
+        });
+    }
+    return pages;
+}

package/apps/runtime/dist/engenty/doc-converter/providers/local/index.js

@@ -0,0 +1,72 @@
+/**
+ * Local provider — Uses pdf-parse for PDFs and mammoth for DOCX.
+ *
+ * No external API calls needed. Good as fallback.
+ */
+import { htmlToMarkdown } from "../../../shims/web-ingest.js";
+import { markdownFromPagedParseResult } from "../../page-break.js";
+const SUPPORTED_TYPES = [
+    "application/pdf",
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    "application/msword",
+    "text/plain",
+    "text/markdown",
+];
+export class LocalProvider {
+    id = "local";
+    name = "Local (pdf-parse + mammoth)";
+    supportedTypes = SUPPORTED_TYPES;
+    canConvert(mimeType) {
+        return SUPPORTED_TYPES.includes(mimeType);
+    }
+    async convert(data, filename, mimeType, _options) {
+        let markdown = "";
+        const metadata = {};
+        if (mimeType === "application/pdf") {
+            const { PDFParse } = await import("pdf-parse");
+            const buffer = Buffer.from(data);
+            const parser = new PDFParse({ data: buffer });
+            try {
+                const textResult = await parser.getText({ pageJoiner: "" });
+                const infoResult = await parser.getInfo();
+                markdown = markdownFromPagedParseResult({
+                    fallback: textResult.text,
+                    pages: textResult.pages.map((page) => ({
+                        number: page.num,
+                        text: page.text,
+                    })),
+                    total: textResult.total,
+                });
+                metadata.page_count = textResult.total;
+                const info = infoResult.info;
+                metadata.title = info?.Title;
+                metadata.author = info?.Author;
+            }
+            finally {
+                await parser.destroy();
+            }
+        }
+        else if (mimeType ===
+            "application/vnd.openxmlformats-officedocument.wordprocessingml.document" ||
+            mimeType === "application/msword") {
+            const mammoth = await import("mammoth");
+            const buffer = Buffer.from(data);
+            const result = await mammoth.convertToHtml({ buffer });
+            // Simple HTML to markdown conversion (basic)
+            markdown = htmlToMarkdown(result.value);
+        }
+        else if (mimeType === "text/plain" || mimeType === "text/markdown") {
+            markdown = new TextDecoder().decode(data);
+        }
+        metadata.word_count = markdown.split(/\s+/).filter(Boolean).length;
+        return {
+            markdown,
+            metadata,
+            source: {
+                filename,
+                mime_type: mimeType,
+                size_bytes: data.byteLength,
+            },
+        };
+    }
+}

package/apps/runtime/dist/engenty/document-scanner/schemas/classifier.js

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import { documentTypeSchema } from "./shared.js";
+/**
+ * Document classifier schema — lightweight extraction for routing.
+ * Determines document type + metadata before full extraction.
+ */
+export const classifierSchema = z.object({
+    document_type: documentTypeSchema.describe("Classify this document: 'invoice' (bill requesting payment), 'receipt' (proof of payment), or 'other' (non-financial)."),
+    title: z
+        .string()
+        .nullable()
+        .describe("A descriptive, meaningful title for this document. Include key identifying information like document number, company names, dates. Examples: 'Invoice INV-2024-001 from Acme Corp', 'Receipt from Starbucks 2024-03-15'. Do NOT use generic names."),
+    summary: z
+        .string()
+        .nullable()
+        .describe("A brief, one-sentence summary of the document's main purpose or content."),
+    tags: z
+        .array(z.string())
+        .max(5)
+        .nullable()
+        .describe("Up to 5 relevant keywords for classifying and searching (e.g., 'Invoice', 'Acme Corp', 'Consulting')."),
+    date: z
+        .string()
+        .nullable()
+        .describe("The most relevant date in ISO 8601 format (YYYY-MM-DD) — issue date, purchase date, etc."),
+    language: z
+        .string()
+        .nullable()
+        .describe("The language of the document (e.g., 'english', 'german', 'french')"),
+});

package/apps/runtime/dist/engenty/document-scanner/schemas/index.js

@@ -0,0 +1,4 @@
+export { classifierSchema } from "./classifier.js";
+export { invoiceSchema, } from "./invoice.js";
+export { receiptSchema, } from "./receipt.js";
+export { documentTypeSchema, lineItemSchema, taxTypeSchema, } from "./shared.js";

package/apps/runtime/dist/engenty/document-scanner/schemas/invoice.js

@@ -0,0 +1,73 @@
+import { z } from "zod";
+import { documentTypeDescription, documentTypeSchema, lineItemSchema, taxTypeSchema, } from "./shared.js";
+/**
+ * Incoming invoice extraction schema.
+ * Uses Zod `.describe()` annotations as LLM instructions.
+ * Designed for multi-modal OCR extraction via Mistral/Gemini.
+ */
+export const invoiceSchema = z.object({
+    document_type: documentTypeSchema.describe(documentTypeDescription),
+    invoice_number: z
+        .string()
+        .nullable()
+        .describe("Unique identifier for the invoice (e.g., RE-2024-001)"),
+    invoice_date: z
+        .string()
+        .nullable()
+        .describe("Date of invoice in ISO 8601 format (YYYY-MM-DD)"),
+    due_date: z
+        .string()
+        .nullable()
+        .describe("Payment due date in ISO 8601 format (YYYY-MM-DD)"),
+    total_amount: z
+        .number()
+        .nullable()
+        .describe("Total amount for the invoice in EUR. Null if document_type is 'other'."),
+    subtotal_amount: z.number().nullable().describe("Subtotal amount before tax"),
+    tax_amount: z.number().nullable().describe("Tax amount for the invoice"),
+    tax_rate: z
+        .number()
+        .nullable()
+        .optional()
+        .describe("Tax rate as a percentage value (e.g., 20 for 20%)"),
+    tax_type: taxTypeSchema
+        .nullable()
+        .describe("The type of tax applied: VAT, Sales Tax, GST, etc. Infer from country/context if not specified."),
+    vendor_name: z
+        .string()
+        .nullable()
+        .describe("The legal registered business name of the company issuing the invoice. Look for names with entity types like 'Inc.', 'Ltd', 'GmbH', 'e.U.', etc. Prioritize the name issuing the invoice, not subsidiaries."),
+    vendor_address: z
+        .string()
+        .nullable()
+        .describe("Complete address of the vendor"),
+    vendor_email: z.string().nullable().describe("Email of the vendor/seller"),
+    vendor_website: z
+        .string()
+        .nullable()
+        .describe("Root domain of the vendor (e.g., 'example.com'). Infer from email if not explicit."),
+    vendor_vat_id: z
+        .string()
+        .nullable()
+        .describe("VAT ID of the vendor (e.g., ATU12345678, DE123456789). Look for UID, USt-IdNr., or similar."),
+    customer_name: z
+        .string()
+        .nullable()
+        .describe("Name of the customer/buyer (the recipient of this invoice)"),
+    customer_address: z
+        .string()
+        .nullable()
+        .describe("Complete address of the customer"),
+    line_items: z
+        .array(lineItemSchema)
+        .describe("Array of items/services listed in the invoice"),
+    payment_instructions: z
+        .string()
+        .nullable()
+        .describe("Payment terms, bank details, or instructions (IBAN, BIC, etc.)"),
+    notes: z.string().nullable().describe("Additional notes or comments"),
+    language: z
+        .string()
+        .nullable()
+        .describe("The language of the document (e.g., 'english', 'german', 'french')"),
+});