lambda-erp 0.8.34__tar.gz → 1.0.0__tar.gz

{lambda_erp-0.8.34 → lambda_erp-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lambda-erp
-Version: 0.8.34
+Version: 1.0.0
 Summary: Core ERP logic - accounting, sales, purchasing, inventory
 Author: TORUS INVESTMENTS AG
 License-Expression: Apache-2.0

{lambda_erp-0.8.34 → lambda_erp-1.0.0}/api/chat.py

@@ -504,6 +504,16 @@ TOOLS = [
             },
         },
     },
+    {
+        "type": "function",
+        "function": {
+            "name": "generate_document_pdf",
+            "description": "Generate and validate the actual PDF before offering or sending it. Returns a downloadable file snapshot only after successful rendering and content checks. Read get_document_fields.pdf for support and output requirements. Relay errors; never invent a PDF URL or claim a file is attached without this tool succeeding.",
+            "parameters": {"type": "object", "properties": {
+                "doctype": {"type": "string", "enum": DOCUMENT_SLUGS},
+                "name": {"type": "string"}}, "required": ["doctype", "name"]},
+        },
+    },
     {
         "type": "function",
         "function": {
@@ -1479,6 +1489,15 @@ def _handle_list_documents(args):
     return rows
 
 
+def _handle_generate_document_pdf(args, user=None):
+    from api.pdf_exports import create_pdf_export
+    from api.pdf_contract import PDFError
+    try:
+        return create_pdf_export(args.get('doctype'), args.get('name'), user)
+    except PDFError as exc:
+        return {'error': str(exc), 'code': exc.code, 'fields': exc.fields}
+
+
 def _handle_get_document_fields(args):
     return services.document_field_metadata(args["doctype"])
 
@@ -2240,6 +2259,7 @@ def _handle_apply_company_setup(args):
 TOOL_HANDLERS = {
     "list_documents": _handle_list_documents,
     "get_document_fields": _handle_get_document_fields,
+    "generate_document_pdf": _handle_generate_document_pdf,
     "get_document": _handle_get_document,
     "create_document": _handle_create_document,
     "update_document": _handle_update_document,
@@ -2409,6 +2429,11 @@ def build_system_prompt(user_info: dict | None = None, channel: str = "web"):
                 + ", ".join(f"`{field}`" for field in meta["fields"])
             )
     chat_doctype_section = _chat_doctype_section()
+    from api.pdf_profiles import pdf_metadata
+    chat_doctype_section += "\n## PDF output contracts\n" + "\n".join(
+        f"- {services.DOCTYPE_TO_SLUG[dt]}: {json.dumps(pdf_metadata(dt), ensure_ascii=False)}"
+        for dt in services.DOCUMENT_CLASSES
+    )
 
     # Channel-aware link guidance. On the "web" channel the reader is a browser
     # inside the ERP, so web-relative links are clickable. On the "api" channel the
@@ -2422,7 +2447,7 @@ def build_system_prompt(user_info: dict | None = None, channel: str = "web"):
         markdown_links_section = """## Referring to records
 Your reply is relayed to an external application (the user's Lambda assistant / app), NOT the ERP web interface. Links into the ERP web UI are NOT clickable there, so refer to every record by its human identifier in plain text — e.g. "Quotation **QTN-2298**", "Sales Invoice **SINV-0012**". Do not paste `/app/...`, `/masters/...`, or `/reports/...` URLs; they do not work outside the ERP."""
         document_links_section = """## Delivering document PDFs
-When the user wants a document as a file (an invoice, quotation, delivery note, etc.), include exactly one canonical PDF reference in the form `/api/documents/{doctype-slug}/{name}/pdf` — e.g. `/api/documents/sales-invoice/SINV-0001/pdf`. The platform detects this reference, fetches the PDF, and delivers it to the user as a downloadable attachment. So phrase it as the file being provided ("I've attached the PDF of QTN-2298"), NOT as a link to click. Do not include `/app/...` view links or `/masters/...` links — name the record instead."""
+Call generate_document_pdf for every requested file. Only a successful result means a file is generated and available for attachment. The platform attaches that exact validated file. Do not invent PDF URLs or claim generation after an error. Name the document in prose; no /app or /masters view links on this channel."""
     else:
         markdown_links_section = """## Always use markdown links
 Every URL you mention in chat MUST be written as a markdown link `[label](url)` — never a bare URL on its own. The chat UI only turns `[label](url)` into a proper clickable link. A bare `/reports/analytics?report_id=...` still works (a fallback linkifier catches it), but markdown form is the expected shape.
@@ -2436,14 +2461,14 @@ When referencing records, always use clickable markdown links so the user can op
 
 **Documents** (quotations, invoices, orders, deliveries, receipts, payments, journal entries, stock entries):
 - **View/edit link:** `/app/{doctype-slug}/{name}` — e.g. [SINV-0001](/app/sales-invoice/SINV-0001)
-- **PDF link:** `/api/documents/{doctype-slug}/{name}/pdf` — e.g. [Download PDF](/api/documents/sales-invoice/SINV-0001/pdf)
+- **PDF files:** call generate_document_pdf. Only link the returned download_url after successful generation; never construct PDF links yourself.
 The doctype slug is the lowercase, hyphenated form: sales-invoice, purchase-order, delivery-note, etc.
 
 **Master records** (customer, supplier, item, warehouse, company):
 - **View/edit link:** `/masters/{master-type}/{name}` — e.g. [SUPP-001](/masters/supplier/SUPP-001), [CUST-003](/masters/customer/CUST-003), [ITEM-001](/masters/item/ITEM-001)
 - NEVER use `/app/...` for masters — that path is only for transactional documents.
 
-Always include the view link after creating, submitting, converting, or updating a record. Include the PDF link when the user asks for a printable version or when sharing an invoice/quotation."""
+Always include the view link after creating, submitting, converting, or updating a record. Call generate_document_pdf when a printable file is requested. Only confirm and link a successfully generated file."""
 
     if user_role == "admin":
         role_desc = "You have **admin** access — full permissions to create, edit, submit, cancel documents, manage master data, run reports, and manage users."
@@ -2583,7 +2608,7 @@ Shape — note it does NOT use `items`:
 - Parent fields: `title` (e.g. "Offerte"), `customer`, `company`, `proposal_date`, `partner_name`, `partner_email`, `cover_letter` (the intro/greeting letter text).
 - Child table `quotations[]` — one row per offer to include, in display order. Each row has: `quotation` (the name of an existing Quotation), optional `position_title` and `position_blurb` (default from the quotation), and `is_recommended` (0 or 1 — set 1 on the offer you recommend, which draws an "Empfehlung" badge).
 
-To build one: ensure each offer already exists as its own Quotation (create them first if needed), then call create_document with doctype "proposal" and a data object whose `quotations` array references those quotations by name. Do NOT submit it; link the user to the PDF at `/api/documents/proposal/<name>/pdf` (and the editor at `/app/proposal/<name>`).
+To build one: ensure each offer already exists as its own Quotation (create them first if needed), then call create_document with doctype "proposal" and a data object whose `quotations` array references those quotations by name. Do NOT submit it; call generate_document_pdf with doctype proposal and link the returned download_url (and the editor at `/app/proposal/<name>`).
 
 ### Recurring offer lines (quotation line `frequency`)
 A **Quotation** line item carries an optional `frequency` that controls how it is billed and totalled on the offer:
@@ -3468,6 +3493,7 @@ async def run_thinking_loop(
     # immediately affects resource-aware handlers as well as the shared policy.
     principal_ref = [user_info]
     tool_handlers = dict(TOOL_HANDLERS)
+    tool_handlers["generate_document_pdf"] = lambda args: _handle_generate_document_pdf(args, principal_ref[0])
     # delete_master needs the caller's role (admin-only) — scoped here rather
     # than in TOOL_HANDLERS, whose handlers are called with (args) only.
     tool_handlers["delete_master"] = lambda args: _handle_delete_master(args, principal_ref[0])
@@ -3720,6 +3746,10 @@ async def run_thinking_loop(
                 and result.get("id")
             ):
                 event_payload["report_id"] = result["id"]
+            if fn_name == "generate_document_pdf":
+                event_payload["document_request"] = {key: fn_args.get(key) for key in ("doctype", "name")}
+            if success and fn_name == "generate_document_pdf" and isinstance(result, dict) and result.get("artifact_id"):
+                event_payload["document"] = result
             if session_id:
                 _save_tool_trace(session_id, "tool_result", {**event_payload, "result": result})
             await on_event(event_payload)
@@ -3912,8 +3942,15 @@ async def run_session_turn(
 
     messages.extend(conversation)
 
+    generated_files = []
+
+    async def pdf_events(event):
+        if event.get('type') == 'tool_result' and event.get('tool') == 'generate_document_pdf' and event.get('success') and event.get('document'):
+            generated_files.append(event['document'])
+        await on_event(event)
+
     await run_thinking_loop(
-        messages, on_event,
+        messages, pdf_events,
         session_id=session_id,
         user_info=user_info,
         client_ip=client_ip,
@@ -3923,6 +3960,20 @@ async def run_session_turn(
     for msg in reversed(messages):
         if msg.get("role") == "assistant" and msg.get("content"):
             assistant_content = msg["content"]
+            allowed_urls = {d[key] for d in generated_files for key in ('download_url', 'pdf_url')}
+            pdf_pattern = r"/api/(?:v1/)?documents/[^\s`<>)]*/pdf(?:\?[^\s`<>)]*)?"
+            ungenerated = []
+            def verified_link(match):
+                if match.group(0) in allowed_urls:
+                    return match.group(0)
+                ungenerated.append(match.group(0))
+                return '[PDF not generated]'
+            assistant_content = re.sub(pdf_pattern, verified_link, assistant_content)
+            if ungenerated:
+                event = {'type': 'tool_result', 'tool': 'generate_document_pdf', 'success': False,
+                         'error': 'The reply referenced a PDF that was not generated. Generate the file before offering it.', 'warnings': [], 'document_request': {'doctype': None, 'name': None}}
+                await on_event(event)
+                _save_tool_trace(session_id, 'tool_result', event)
             save_chat_message(session_id, "assistant", assistant_content)
             if on_assistant_message:
                 await on_assistant_message(session_id, assistant_content)

{lambda_erp-0.8.34 → lambda_erp-1.0.0}/api/errors.py

@@ -76,6 +76,10 @@ async def _integrity_handler(request: Request, exc: Exception):
 
 
 def register_exception_handlers(app: FastAPI):
+    from api.pdf_contract import PDFError
+    async def pdf_error_handler(request, exc):
+        return JSONResponse(status_code=422, content={"detail": {"code": exc.code, "message": str(exc), "fields": exc.fields}})
+    app.add_exception_handler(PDFError, pdf_error_handler)
 
     @app.exception_handler(ValueError)
     async def value_error(request: Request, exc: ValueError):

{lambda_erp-0.8.34 → lambda_erp-1.0.0}/api/main.py

@@ -61,6 +61,9 @@ async def lifespan(app: FastAPI):
     from api.services import apply_plugin_schema
     apply_plugin_schema()
 
+    from api.pdf_profiles import validate_pdf_registry
+    validate_pdf_registry()
+
     # Ensure the demo spend log table exists before any LLM call happens.
     from api.demo_limits import init_schema as init_demo_spend_schema
     init_demo_spend_schema()

{lambda_erp-0.8.34 → lambda_erp-1.0.0}/api/pdf.py

@@ -2,10 +2,12 @@
 
 import io
 import os
+from dataclasses import dataclass
 from jinja2 import Environment, FileSystemLoader, ChoiceLoader
 from weasyprint import HTML
 from lambda_erp.database import get_db
-from api.services import load_document
+from api.services import load_document, get_document_class
+from api.pdf_contract import prepare, validate_rendered_pdf, PDFError
 from api.remarks_md import render_remarks
 from lambda_erp.controllers.taxes_and_totals import split_by_frequency
 
@@ -51,8 +53,8 @@ def register_pdf_context(fn) -> None:
     assembled context (doc, company_info, party_info, currency, items, …) and
     may return a dict of EXTRA keys to merge in — e.g. a computed Swiss QR-bill
     image for invoices. Lets a deployment add per-document content the template
-    can't compute itself. Exceptions are swallowed so a buggy provider can't
-    break PDF generation.
+    can't compute itself. Return None when inapplicable. Exceptions fail the
+    export so required content cannot silently disappear.
     """
     _pdf_context_providers.append(fn)
 
@@ -60,6 +62,7 @@ def register_pdf_context(fn) -> None:
 DOC_CONFIG = {
     "Quotation":        ("Quotation",        "customer", "customer_name", "Customer", "Customer"),
     "Sales Order":      ("Sales Order",      "customer", "customer_name", "Customer", "Customer"),
+    "POS Invoice":      ("POS Invoice",      "customer", "customer_name", "Customer", "Customer"),
     "Sales Invoice":    ("Sales Invoice",    "customer", "customer_name", "Customer", "Customer"),
     "Purchase Order":   ("Purchase Order",   "supplier", "supplier_name", "Supplier", "Supplier"),
     "Purchase Invoice": ("Purchase Invoice", "supplier", "supplier_name", "Supplier", "Supplier"),
@@ -79,17 +82,43 @@ def _get_dict(row):
     return dict(row) if row else {}
 
 
+@dataclass(frozen=True)
+class RenderedPDF:
+    data: bytes
+    modified: str | None
+    status: str
+    warnings: list
+
+
 def generate_pdf(doctype_slug: str, name: str) -> bytes:
-    """Generate a PDF for a document and return raw bytes."""
-    # The Proposal (Sammelofferte) has a wholly different shape — several
-    # quotations rendered as lettered positions + an appended appendix — so it
-    # gets its own render path rather than the single-document template below.
-    if doctype_slug == "proposal":
-        return generate_proposal_pdf(name)
+    return render_document_pdf(doctype_slug, name).data
+
 
+def render_document_pdf(doctype_slug: str, name: str) -> RenderedPDF:
+    """Single validated renderer used by UI, REST, MCP and generated files."""
+    doctype, cls = get_document_class(doctype_slug)
+    if not cls:
+        raise PDFError(f'Unknown PDF document type: {doctype_slug}', code='pdf_unsupported')
     doc = load_document(doctype_slug, name)
-    db = get_db()
+    contract = prepare(doctype, doc)
+    kind = contract['profile'].kind
+    try:
+        if kind == 'proposal':
+            result = _render_proposal_pdf(name, doc, contract)
+        elif kind == 'commercial':
+            result = _render_commercial_pdf(doctype_slug, name, doc, contract)
+        else:
+            result = _render_record_pdf(doctype, name, doc, contract)
+    except PDFError:
+        raise
+    except Exception as exc:
+        raise PDFError(f'PDF rendering failed for {doctype} {name}: {exc}', code='pdf_render_failed') from exc
+    validate_rendered_pdf(result, contract['tokens'])
+    return RenderedPDF(result, doc.get('modified'), contract['status'], contract['warnings'])
 
+
+def _render_commercial_pdf(doctype_slug, name, doc, contract):
+    db = get_db()
     # Resolve doctype display name
     doctype = doctype_slug.replace("-", " ").title()
     # Fix multi-word: "Sales Invoice" not "Sales-Invoice"
@@ -100,14 +129,13 @@ def generate_pdf(doctype_slug: str, name: str) -> bytes:
 
     config = DOC_CONFIG.get(doctype)
     if not config:
-        # Fallback for unknown types
-        config = (doctype, None, None, None, "Party")
+        raise PDFError(f'No commercial PDF mapping for {doctype}', code='pdf_unsupported')
 
     title, party_field, party_name_field, party_doctype, party_label = config
 
     # Credit note / debit note titles
     if doc.get("is_return"):
-        if doctype == "Sales Invoice":
+        if doctype in {"Sales Invoice", "POS Invoice"}:
             title = "Credit Note"
         elif doctype == "Purchase Invoice":
             title = "Debit Note"
@@ -146,7 +174,7 @@ def generate_pdf(doctype_slug: str, name: str) -> bytes:
             company_name = company_info.get("company_name") or company_id
 
     # Currency
-    currency = doc.get("currency", "USD") or "USD"
+    currency = doc["currency"]
 
     # Meta fields (varies by doc type)
     meta_fields = []
@@ -200,6 +228,8 @@ def generate_pdf(doctype_slug: str, name: str) -> bytes:
     base_url = template.filename or os.path.join(TEMPLATE_DIR, "document.html")
     context = dict(
         doc=doc,
+        pdf_status=contract["status"],
+        pdf_warnings=contract["warnings"],
         title=title,
         company_name=company_name,
         company_info=company_info,
@@ -227,14 +257,14 @@ def generate_pdf(doctype_slug: str, name: str) -> bytes:
     )
 
     # Let deployment plugins augment the context (e.g. a Swiss QR-bill image for
-    # invoices). A provider that raises must not break PDF generation.
+    # invoices). Provider errors must fail the export.
     for provider in _pdf_context_providers:
         try:
             extra = provider(doctype, name, context)
             if extra:
                 context.update(extra)
-        except Exception:
-            pass
+        except Exception as exc:
+            raise PDFError('PDF context provider failed', code='pdf_context_failed') from exc
 
     html_str = template.render(**context)
 
@@ -242,35 +272,30 @@ def generate_pdf(doctype_slug: str, name: str) -> bytes:
 
 
 def _append_pdf(base_pdf: bytes, extra_pdf: bytes) -> bytes:
-    """Concatenate `extra_pdf` after `base_pdf`. Used to staple the uploaded
-    appendix onto the rendered offers. A corrupt/unreadable appendix must not
-    sink the whole proposal, so on any failure we return the base unchanged."""
-    try:
-        from pypdf import PdfReader, PdfWriter
-    except Exception:
-        return base_pdf
+    """A supplied appendix is required output; corruption must be reported."""
+    from pypdf import PdfReader, PdfWriter
     try:
         writer = PdfWriter()
         for src in (base_pdf, extra_pdf):
             reader = PdfReader(io.BytesIO(src))
+            if not reader.pages:
+                raise ValueError('Empty appendix')
             for page in reader.pages:
                 writer.add_page(page)
         out = io.BytesIO()
         writer.write(out)
         return out.getvalue()
-    except Exception:
-        return base_pdf
+    except Exception as exc:
+        raise PDFError('Proposal appendix is not a readable PDF', code='pdf_invalid_appendix') from exc
 
 
 def generate_proposal_pdf(name: str) -> bytes:
-    """Render a Proposal (Sammelofferte): a cover letter plus each referenced
-    Quotation as a lettered position (A, B, C…), then append the uploaded
-    appendix PDF if there is one. Never mutates the quotations."""
-    from lambda_erp.selling.proposal import Proposal
-    Proposal.load(name).validate_for_output()
-    proposal = load_document("proposal", name)
-    db = get_db()
+    # Keep the public extension import; all paths use the shared contract.
+    return generate_pdf('proposal', name)
+
 
+def _render_proposal_pdf(name, proposal, contract):
+    db = get_db()
     # Customer (party) — looked up live so a corrected name/address shows.
     party_name = proposal.get("customer_name") or proposal.get("customer") or ""
     party_info = {}
@@ -303,7 +328,16 @@ def generate_proposal_pdf(name: str) -> bytes:
     rows = sorted(proposal.get("quotations", []) or [], key=lambda r: r.get("idx") or 0)
     for i, row in enumerate(rows):
         qname = row.get("quotation")
+        if not qname:
+            raise PDFError('Proposal PDF requires a Quotation in every row')
         quote = load_document("quotation", qname)
+        if quote.get('company') != proposal.get('company') or quote.get('customer') != proposal.get('customer'):
+            raise PDFError('Proposal PDF: quotation company and customer must match')
+        quote_contract = prepare('Quotation', quote)
+        # Each included offer must be rendered completely. Its state is printed
+        # alongside its number, including historical cancelled/voided offers.
+        contract['tokens'].extend(quote_contract['tokens'])
+        contract['warnings'].extend(quote_contract['warnings'])
         items = quote.get("items", []) or []
         # Refresh each line's item_name from the master, consistent with the
         # single-document path.
@@ -317,11 +351,16 @@ def generate_proposal_pdf(name: str) -> bytes:
         positions.append({
             "letter": chr(ord("A") + i),
             "quotation": qname,
+            "pdf_status": quote_contract["status"],
             "title": row.get("position_title") or default_title or qname,
             "blurb": row.get("position_blurb") or quote.get("remarks") or "",
             "is_recommended": bool(row.get("is_recommended")),
-            "currency": quote.get("currency", "USD") or "USD",
-            "grand_total": quote.get("grand_total") or 0,
+            "currency": quote["currency"],
+            "net_total": quote["net_total"],
+            "grand_total": quote["grand_total"],
+            "total_taxes_and_charges": quote["total_taxes_and_charges"],
+            "taxes": quote.get("taxes") or [],
+            "recurring_summary": split_by_frequency(quote)[1],
             "items": items,
         })
 
@@ -333,6 +372,8 @@ def generate_proposal_pdf(name: str) -> bytes:
     base_url = template.filename or os.path.join(TEMPLATE_DIR, "proposal.html")
     context = dict(
         proposal=proposal,
+        pdf_status=contract["status"],
+        pdf_warnings=contract["warnings"],
         title=proposal.get("title") or "Offerte",
         company_name=company_name,
         company_info=company_info,
@@ -348,8 +389,8 @@ def generate_proposal_pdf(name: str) -> bytes:
             extra = provider("Proposal", name, context)
             if extra:
                 context.update(extra)
-        except Exception:
-            pass
+        except Exception as exc:
+            raise PDFError('PDF context provider failed', code='pdf_context_failed') from exc
 
     html_str = template.render(**context)
     pdf_bytes = HTML(string=html_str, base_url=base_url).write_pdf()
@@ -364,3 +405,31 @@ def generate_proposal_pdf(name: str) -> bytes:
             pdf_bytes = _append_pdf(pdf_bytes, bytes(data))
 
     return pdf_bytes
+
+
+# Shared record layouts use strict contexts; a misspelled field must fail rather
+# than quietly disappear. Deployment overrides can extend these same blocks.
+def _render_record_pdf(doctype, name, doc, contract):
+    from jinja2 import StrictUndefined
+    template = _jinja_env.overlay(undefined=StrictUndefined).get_template('record.html')
+    company = contract['company']
+    page_size_row = get_db().sql('SELECT value FROM "Settings" WHERE key = ?', ['pdf_page_size'])
+    context = dict(
+        title=contract['profile'].title, name=name, pdf_status=contract['status'],
+        pdf_warnings=contract['warnings'], print_fields=contract['fields'],
+        print_tables=contract['tables'], print_labels={}, print_title=contract['profile'].title,
+        company_info=company, company_name=company.get('company_name') or doc.get('company') or '',
+        company_currency=contract['company_currency'] if doctype in {'Journal Entry', 'Budget', 'Subscription', 'Pricing Rule'} else '',
+        party_name=contract['party_name'],
+        page_size=page_size_row[0]['value'] if page_size_row else 'A4',
+    )
+    for provider in _pdf_context_providers:
+        # A registered provider may be optional, but required providers must
+        # propagate failures (for example a mandatory payment part).
+        try:
+            extra = provider(doctype, name, context)
+            if extra:
+                context.update(extra)
+        except Exception as exc:
+            raise PDFError('PDF context provider failed', code='pdf_context_failed') from exc
+    return HTML(string=template.render(**context), base_url=template.filename).write_pdf()