lambda-erp 0.3.4__tar.gz → 0.5.0__tar.gz

{lambda_erp-0.3.4/frontend → lambda_erp-0.5.0}/LICENSE

@@ -1,3 +1,4 @@
+Copyright 2026 TORUS INVESTMENTS AG
 
                                  Apache License
                            Version 2.0, January 2004

{lambda_erp-0.3.4 → lambda_erp-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lambda-erp
-Version: 0.3.4
+Version: 0.5.0
 Summary: Core ERP logic - accounting, sales, purchasing, inventory
 Author: TORUS INVESTMENTS AG
 License-Expression: Apache-2.0
@@ -159,6 +159,7 @@ The result is booked in one step — chart of accounts, sensible default account
 - Custom analytics drafts via chat (persisted, shareable, editable)
 - Server-side aggregation tool for in-chat factual answers across large datasets
 - PDF / image attachment → add invoices, create quotations, etc. all directly by adding them in the chat
+- **Programmatic API** — drive the ERP from external systems with per-user, role-capped Bearer keys: a [chat API](docs/chat-api.md) (converse with the agent) and a [REST API](docs/rest-api.md) (documents, masters, reports — the same endpoints the web app uses, so a connector or sync job can create and submit documents directly). Both off by default; an admin enables each independently and issues keys.
 - Auth with admin/manager/viewer roles plus a public demo mode
 - Full test suite that exercises every cycle against an in-memory SQLite
 

{lambda_erp-0.3.4 → lambda_erp-0.5.0}/README.md

@@ -132,6 +132,7 @@ The result is booked in one step — chart of accounts, sensible default account
 - Custom analytics drafts via chat (persisted, shareable, editable)
 - Server-side aggregation tool for in-chat factual answers across large datasets
 - PDF / image attachment → add invoices, create quotations, etc. all directly by adding them in the chat
+- **Programmatic API** — drive the ERP from external systems with per-user, role-capped Bearer keys: a [chat API](docs/chat-api.md) (converse with the agent) and a [REST API](docs/rest-api.md) (documents, masters, reports — the same endpoints the web app uses, so a connector or sync job can create and submit documents directly). Both off by default; an admin enables each independently and issues keys.
 - Auth with admin/manager/viewer roles plus a public demo mode
 - Full test suite that exercises every cycle against an in-memory SQLite
 

{lambda_erp-0.3.4 → lambda_erp-0.5.0}/api/auth.py

@@ -198,20 +198,48 @@ ASSIGNABLE_ROLES = {"admin", "manager", "viewer"}
 
 
 def get_current_user(request: Request) -> dict:
-    """FastAPI dependency: extract and validate JWT from cookie.
-    Falls back to public_manager if one exists and no cookie is set."""
-    token = request.cookies.get(COOKIE_NAME)
+    """FastAPI dependency: resolve the caller for every cookie-gated REST route.
+
+    Resolution order:
+      1. Session cookie (the web app) — a valid JWT wins.
+      2. `Authorization: Bearer <api-key>` — a programmatic caller, gated by the
+         `rest_api_enabled` Settings flag (off by default). The key acts AS its
+         owner with the owner's live role (capped at the key's role — see
+         `_lookup_api_key`), so a document it creates is attributed to the real
+         user and every `require_role` check behaves as if that user logged in.
+         This is the same key type the chat API uses; the two surfaces are
+         gated by independent flags.
+      3. Public manager (demo mode) when no credential is presented.
+
+    A malformed or invalid Bearer credential is a *failed* auth attempt, not a
+    fall-through — it raises 401 rather than silently downgrading to demo
+    access. `_lookup_api_key` / `_bearer_token` / `_setting_enabled` are defined
+    lower in this module and resolved at call time (late binding)."""
+    db = get_db()
 
+    token = request.cookies.get(COOKIE_NAME)
     if token:
         user_name = decode_token(token)
         if user_name:
-            db = get_db()
             user = db.get_value("User", user_name, ["name", "email", "full_name", "role", "enabled"])
             if user and user.get("enabled"):
                 return dict(user)
 
+    bearer = _bearer_token(request)
+    if bearer is not None:
+        if not _setting_enabled(db, "rest_api_enabled"):
+            raise HTTPException(status_code=401, detail="REST API key access is disabled")
+        key, owner, effective_role = _lookup_api_key(db, bearer)
+        return {
+            "name": owner["name"],
+            "email": owner.get("email"),
+            "full_name": owner.get("full_name"),
+            "role": effective_role,
+            "enabled": owner.get("enabled"),
+            "api_key_id": key["id"],
+        }
+
     # Fall back to public manager (demo mode)
-    db = get_db()
     pub = db.sql('SELECT name, email, full_name, role, enabled FROM "User" WHERE role = \'public_manager\' AND enabled = 1')
     if pub:
         return dict(pub[0])
@@ -586,6 +614,12 @@ DEFAULTS = {
     # active. Default off — an admin turns it on and issues keys. See
     # docs/chat-api-plan.md.
     "chat_api_enabled": "0",
+    # When "1", the same Bearer API keys authenticate the regular REST API
+    # (/api/documents, /api/masters, /api/reports, …) in addition to the session
+    # cookie. Default off — an admin turns it on to let connectors/scripts drive
+    # the ERP the way the web app does. Independent of chat_api_enabled. See
+    # docs/rest-api.md.
+    "rest_api_enabled": "0",
 }
 
 
@@ -655,27 +689,32 @@ def _role_rank(role: str) -> int:
     return ROLE_HIERARCHY.get(role, 0)
 
 
-def get_api_caller(request: Request) -> dict:
-    """FastAPI dependency for the programmatic chat API.
-
-    Gated by the `chat_api_enabled` Settings flag — when off the whole surface
-    404s (never advertised on instances that don't use it). Otherwise validates
-    the `Authorization: Bearer <token>` header against a non-revoked Api Key.
+def _bearer_token(request: Request) -> str | None:
+    """The token from an `Authorization: Bearer <token>` header.
 
-    Keys are per-user credentials: the effective role is resolved LIVE as
-    min(key's role cap, owner's current role), and a disabled or deleted owner
-    kills every one of their keys immediately. `name` is the key's
-    session_owner (``api:<username>``) — all of one user's keys share a session
-    space, separate from their interactive web chats.
+    Returns None when the header is absent or not a Bearer scheme (no auth
+    attempt — the caller may still have a cookie). Returns "" for a bare
+    `Bearer ` with no token — a malformed *attempt* that callers treat as a
+    401, distinct from None.
     """
-    db = get_db()
-    if not _setting_enabled(db, "chat_api_enabled"):
-        raise HTTPException(status_code=404, detail="Not Found")
-
     header = request.headers.get("authorization", "")
     if not header.lower().startswith("bearer "):
-        raise HTTPException(status_code=401, detail="Missing or malformed Authorization header")
-    token = header[7:].strip()
+        return None
+    return header[7:].strip()
+
+
+def _lookup_api_key(db, token: str) -> tuple[dict, dict, str]:
+    """Validate a Bearer API token → (key, owner, effective_role).
+
+    Raises 401 on any failure (empty/unknown/revoked token, or a disabled/
+    deleted owner). Bumps `last_used_at`. Shared by the chat API and the REST
+    API so both resolve a key identically — they differ only in the Settings
+    flag that gates them and the caller identity they build from the result.
+
+    The effective role is resolved LIVE as min(key's role cap, owner's current
+    role): a key can never out-rank its owner, and lowering an owner's role (or
+    disabling them) instantly constrains every one of their keys.
+    """
     if not token:
         raise HTTPException(status_code=401, detail="Empty bearer token")
 
@@ -687,15 +726,37 @@ def get_api_caller(request: Request) -> dict:
         raise HTTPException(status_code=401, detail="Invalid API key")
     key = dict(rows[0])
 
-    owner = db.get_value("User", key["owner"], ["name", "full_name", "role", "enabled"])
+    owner = db.get_value("User", key["owner"], ["name", "email", "full_name", "role", "enabled"])
     if not owner or not owner.get("enabled"):
         raise HTTPException(status_code=401, detail="Invalid API key")
+    owner = dict(owner)
     effective_role = (
         key["role"] if _role_rank(key["role"]) <= _role_rank(owner["role"]) else owner["role"]
     )
 
     db.sql('UPDATE "Api Key" SET last_used_at = ? WHERE id = ?', [now(), key["id"]])
     db.conn.commit()
+    return key, owner, effective_role
+
+
+def get_api_caller(request: Request) -> dict:
+    """FastAPI dependency for the programmatic chat API (POST /api/v1/chat).
+
+    Gated by the `chat_api_enabled` Settings flag — when off the whole surface
+    404s (never advertised on instances that don't use it). Otherwise validates
+    the Bearer key via `_lookup_api_key`. The caller's `name` is the key's
+    session_owner (``api:<username>``) — all of one user's keys share a chat
+    session space, separate from their interactive web chats. (The REST API, by
+    contrast, has the key act as the real user — see `get_current_user`.)
+    """
+    db = get_db()
+    if not _setting_enabled(db, "chat_api_enabled"):
+        raise HTTPException(status_code=404, detail="Not Found")
+
+    token = _bearer_token(request)
+    if token is None:
+        raise HTTPException(status_code=401, detail="Missing or malformed Authorization header")
+    key, owner, effective_role = _lookup_api_key(db, token)
 
     return {
         "name": key["session_owner"],

{lambda_erp-0.3.4 → lambda_erp-0.5.0}/api/chat.py

@@ -10,6 +10,7 @@ Supports multiple chat sessions, each with their own history and auto-generated
 
 import asyncio
 import base64
+import copy
 import difflib
 import io
 import json
@@ -1163,6 +1164,44 @@ TOOLS = [
     },
 ]
 
+
+def _extra_document_slugs():
+    """Doctype slugs registered beyond the core list (via register_doctype)."""
+    return sorted(s for s in services.SLUG_TO_DOCTYPE if s not in DOCUMENT_SLUGS)
+
+
+def _extra_master_types():
+    """Master types registered beyond the core list (via register_master)."""
+    return sorted(m for m in services.MASTER_TABLES if m not in MASTER_TYPES)
+
+
+def build_tools():
+    """TOOLS with the doctype/master enums widened from the live registries.
+
+    Plugins register doctypes and masters at startup — after this module is
+    imported — so the static TOOLS constant can't know about them. The tool
+    handlers already resolve through the live registries; the enums in the
+    schemas were the only thing shutting registered types out of chat. Built
+    per request (cheap next to the LLM call), which also makes plugin load
+    order irrelevant. Only enums that exactly match the core lists are
+    widened, so any differently-constrained doctype/master param (e.g. a
+    curated subset) is left alone.
+    """
+    extra_docs = _extra_document_slugs()
+    extra_masters = _extra_master_types()
+    if not extra_docs and not extra_masters:
+        return TOOLS
+    tools = copy.deepcopy(TOOLS)
+    for tool in tools:
+        props = tool["function"].get("parameters", {}).get("properties", {})
+        for schema in props.values():
+            if schema.get("enum") == DOCUMENT_SLUGS:
+                schema["enum"] = DOCUMENT_SLUGS + extra_docs
+            elif schema.get("enum") == MASTER_TYPES:
+                schema["enum"] = MASTER_TYPES + extra_masters
+    return tools
+
+
 # ---------------------------------------------------------------------------
 # Tool handlers — dispatch to existing service functions
 # ---------------------------------------------------------------------------
@@ -1845,6 +1884,21 @@ def build_system_prompt(user_info: dict | None = None, channel: str = "web"):
     analytics_context = _prompt_analytics_context()
     uom_context = _prompt_uom_context()
 
+    # Deployment-registered types (register_doctype / register_master). Folded
+    # into the type lists below so the assistant knows they exist and can act
+    # on them from day one — the tool schemas widen the same way (build_tools).
+    extra_docs = _extra_document_slugs()
+    extra_masters = _extra_master_types()
+    extension_doctypes_line = (
+        f"\n- **Extensions (deployment-specific):** {', '.join(extra_docs)}" if extra_docs else ""
+    )
+    master_types_line = ", ".join(MASTER_TYPES + extra_masters)
+    extension_master_keys = "".join(
+        f"\n- **{services.MASTER_TABLES[m][0]}** (master_type `{m}`): key = `name`, "
+        f"display = `{services.MASTER_TABLES[m][1]}`"
+        for m in extra_masters
+    )
+
     # 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
     # reply is relayed to an EXTERNAL app (lambda-web / the Lambda app) that is not
@@ -1952,7 +2006,7 @@ When a user asks you to do something they don't have permission for, explain wha
 - **Buying:** purchase-order, purchase-invoice
 - **Accounting:** payment-entry, journal-entry, budget, subscription, bank-transaction
 - **Stock:** stock-entry, delivery-note, purchase-receipt
-- **Settings:** pricing-rule
+- **Settings:** pricing-rule{extension_doctypes_line}
 
 ## Document Workflow & What Each Document Does
 
@@ -2076,7 +2130,7 @@ For purchased goods, prefer Purchase Receipt when receiving separately from bill
 - Cancelled documents cannot be re-submitted or modified.
 
 ## Master Data Types
-customer, supplier, item, warehouse, account, company, cost-center
+{master_types_line}
 
 ## Master Data Deletion
 Master records CAN be deleted — use the `delete_master` tool (ADMIN role only). It is reference-protected: an unreferenced record (e.g. a mistakenly created or duplicate one) is permanently deleted; a record referenced by any document, GL entry, or stock data is NOT deleted but automatically disabled/archived instead, and the result names the blocking reference — relay that reason to the user. When the user merely wants a record out of the way (not destroyed), prefer `update_master` with `{{"disabled": 1}}`. Non-admin users: explain that deletion needs an admin and offer to disable instead.
@@ -2153,7 +2207,7 @@ Every master record has a primary key (the `name` column) and a human-readable d
 - **Item:** key = `item_code` (e.g. `SVC-005`), display = `item_name` (e.g. "Project Management")
 - **Customer:** key = `name` (e.g. `CUST-007`), display = `customer_name` (e.g. "Redstone Automotive")
 - **Supplier:** key = `name` (e.g. `SUPP-003`), display = `supplier_name`
-- **Warehouse / Company / Account / Cost Center:** key = `name`
+- **Warehouse / Company / Account / Cost Center:** key = `name`{extension_master_keys}
 
 When you fill in `item_code`, `customer`, `supplier`, `warehouse`, `company`, etc. in a document or child-table row, you MUST use the **primary key**, never the display name. `"item_code": "Project Management"` is ALWAYS wrong — it's a name, not a code.
 
@@ -2646,7 +2700,7 @@ async def run_thinking_loop(
                     openai_client.chat.completions.create,
                     model=model_name,
                     messages=messages,
-                    tools=TOOLS,
+                    tools=build_tools(),
                     tool_choice="auto",
                     max_completion_tokens=max_completion,
                     # gpt-5.6-terra rejects function tools on /v1/chat/completions

{lambda_erp-0.3.4 → lambda_erp-0.5.0}/api/main.py

@@ -11,6 +11,7 @@ from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import FileResponse
 from fastapi.staticfiles import StaticFiles
 
+from lambda_erp import get_app_version
 from lambda_erp.database import setup
 
 from api.errors import register_exception_handlers
@@ -70,7 +71,7 @@ async def lifespan(app: FastAPI):
 
 app = FastAPI(
     title="Lambda ERP",
-    version="0.1.0",
+    version=get_app_version(),
     lifespan=lifespan,
 )
 
@@ -105,7 +106,7 @@ app.include_router(chat_api.router, prefix="/api")
 
 @app.get("/api/health")
 def health():
-    return {"status": "ok"}
+    return {"status": "ok", "version": get_app_version()}
 
 
 @app.websocket("/ws/chat")

{lambda_erp-0.3.4 → lambda_erp-0.5.0}/api/routers/masters.py

@@ -5,7 +5,10 @@ import re
 from fastapi import APIRouter, Depends, HTTPException, Query
 from lambda_erp.database import get_db
 from lambda_erp.utils import _dict
-from api.services import MASTER_TABLES
+# The per-type registries live in api.services so `register_master` can extend
+# them; imported here (not moved) so existing `from api.routers.masters import
+# MASTER_IDENTITY_ALIAS`-style imports keep working.
+from api.services import MASTER_TABLES, MASTER_NAME_PREFIXES, MASTER_IDENTITY_ALIAS
 from api.auth import require_role, require_non_public_manager
 
 router = APIRouter(prefix="/masters", tags=["masters"])
@@ -14,22 +17,6 @@ _viewer = Depends(require_role("viewer"))
 _manager = Depends(require_non_public_manager)
 _admin = Depends(require_role("admin"))
 
-MASTER_NAME_PREFIXES = {
-    "customer": "CUST",
-    "supplier": "SUPP",
-    "item": "ITEM",
-    "warehouse": "WH",
-}
-
-# An Item's code is stored in the primary-key column `name`, but every
-# transaction line and report references it as
-# `item_code`. Accept that intuitive alias on the master API so callers
-# (LLM tools, REST clients) can set and read the code under the name they
-# already use everywhere else, instead of silently falling back to ITEM-NNN.
-MASTER_IDENTITY_ALIAS = {
-    "item": "item_code",
-}
-
 
 def _echo_identity_alias(master_type: str, row):
     """Mirror the master's `name` back under its intuitive alias (item_code)."""

{lambda_erp-0.3.4 → lambda_erp-0.5.0}/api/services.py

@@ -70,6 +70,25 @@ MASTER_TABLES = {
     "cost-center": ("Cost Center", "cost_center_name"),
 }
 
+# Auto-naming prefixes: masters created without an explicit `name` get a
+# generated PREFIX-NNN id (see masters.create_master_record). Types without an
+# entry require an explicit name (or derive it, like company).
+MASTER_NAME_PREFIXES = {
+    "customer": "CUST",
+    "supplier": "SUPP",
+    "item": "ITEM",
+    "warehouse": "WH",
+}
+
+# An Item's code is stored in the primary-key column `name`, but every
+# transaction line and report references it as `item_code`. Accept that
+# intuitive alias on the master API so callers (LLM tools, REST clients) can
+# set and read the code under the name they already use everywhere else,
+# instead of silently falling back to ITEM-NNN.
+MASTER_IDENTITY_ALIAS = {
+    "item": "item_code",
+}
+
 # Slug <-> doctype name mapping
 SLUG_TO_DOCTYPE = {}
 DOCTYPE_TO_SLUG = {}
@@ -95,6 +114,32 @@ def register_doctype(doctype: str, cls, slug: str | None = None) -> None:
     DOCTYPE_TO_SLUG[doctype] = slug
 
 
+def register_master(slug: str, table: str, name_field: str, *,
+                    name_prefix: str | None = None,
+                    identity_alias: str | None = None) -> None:
+    """Register (or override) a master type — the master-side counterpart of
+    `register_doctype`.
+
+    A plugin calls this at startup and the master becomes a first-class type
+    everywhere `MASTER_TABLES` is consulted: the REST CRUD surface
+    (`/api/masters/{slug}`) and the chat tools (search_masters,
+    get_master_fields, create/update/delete_master — their schemas and the
+    system prompt are built from the live registry per request). Fields are
+    never declared: they're introspected from the table at call time, so every
+    text column of `table` is immediately searchable.
+
+    `name_field` is the human display column (e.g. "company_name").
+    `name_prefix` enables auto-generated ids (prefix "LEAD" -> LEAD-001) when a
+    record is created without an explicit `name`. `identity_alias` lets callers
+    address the `name` PK under a friendlier key, like item's `item_code`.
+    """
+    MASTER_TABLES[slug] = (table, name_field)
+    if name_prefix:
+        MASTER_NAME_PREFIXES[slug] = name_prefix
+    if identity_alias:
+        MASTER_IDENTITY_ALIAS[slug] = identity_alias
+
+
 def get_document_class(doctype_slug: str):
     """Get document class from URL slug."""
     doctype = SLUG_TO_DOCTYPE.get(doctype_slug)

{lambda_erp-0.3.4 → lambda_erp-0.5.0}/frontend/src/api/client.ts

@@ -447,6 +447,7 @@ export const api = {
   getPublicManagerStatus: () => request<{ active: boolean; user?: any }>("/auth/public-manager"),
   createPublicManager: () => request<any>("/auth/public-manager", { method: "POST" }),
   removePublicManager: () => request<any>("/auth/public-manager", { method: "DELETE" }),
+  getHealth: () => request<{ status: string; version: string }>("/health"),
   getSettings: () => request<Record<string, string>>("/auth/settings"),
   updateSettings: (data: Record<string, string>) =>
     request<Record<string, string>>("/auth/settings", { method: "PUT", body: JSON.stringify(data) }),

lambda_erp-0.5.0/lambda_erp/__init__.py

@@ -0,0 +1,33 @@
+"""Lambda ERP - Core ERP logic packaged as a standalone library."""
+
+
+def get_app_version() -> str:
+    """Runtime version of the ERP core.
+
+    The single human-edited source is the packaging version in `pyproject.toml`,
+    which the release process bumps. A wheel/pip install doesn't ship
+    `pyproject.toml`, so there we read the installed package metadata (populated
+    from that same version at build time). A source checkout (incl. editable
+    dev) reads `pyproject.toml` directly, so it's correct without a reinstall.
+    Falls back to "dev" when neither is available.
+    """
+    import re
+    from pathlib import Path
+
+    pyproject = Path(__file__).resolve().parent.parent / "pyproject.toml"
+    if pyproject.is_file():
+        match = re.search(
+            r'^version\s*=\s*"([^"]+)"', pyproject.read_text(encoding="utf-8"), re.MULTILINE
+        )
+        if match:
+            return match.group(1)
+
+    try:
+        from importlib.metadata import version
+
+        return version("lambda-erp")
+    except Exception:
+        return "dev"
+
+
+__version__ = get_app_version()

{lambda_erp-0.3.4 → lambda_erp-0.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lambda-erp"
-version = "0.3.4"
+version = "0.5.0"
 description = "Core ERP logic - accounting, sales, purchasing, inventory"
 readme = "README.md"
 license = "Apache-2.0"

lambda_erp-0.3.4/lambda_erp/__init__.py

@@ -1,3 +0,0 @@
-"""Lambda ERP - Core ERP logic packaged as a standalone library."""
-
-__version__ = "0.1.0"