lambda-erp 1.1.9__tar.gz → 1.2.0__tar.gz

{lambda_erp-1.1.9 → lambda_erp-1.2.0}/PKG-INFO

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

{lambda_erp-1.1.9 → lambda_erp-1.2.0}/api/chat.py

@@ -473,6 +473,11 @@ DOCUMENT_SLUGS = [
 
 MASTER_TYPES = ["customer", "supplier", "item", "warehouse", "account", "company", "cost-center"]
 
+# Discovery for direct (MCP) clients, which don't get the chat system prompt.
+# The native chat already carries WORKFLOW_GUIDANCE in its prompt; offering the
+# tool there made the model re-fetch ~4k tokens of the same context most turns.
+DIRECT_CLIENT_ONLY_TOOLS = frozenset({"get_erp_context"})
+
 TOOLS = [
     {"type": "function", "function": {
         "name": "get_erp_context",
@@ -1400,7 +1405,7 @@ def _chat_doctype_section() -> str:
     )
 
 
-def build_tools(user_info: dict | None = None):
+def build_tools(user_info: dict | None = None, *, native_chat: bool = False):
     """TOOLS widened with live plugin types and registered business actions.
 
     Plugins register doctypes and masters at startup — after this module is
@@ -1410,19 +1415,20 @@ def build_tools(user_info: dict | None = None):
     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.
+    curated subset) is left alone. `native_chat` drops the direct-client-only
+    discovery tools the chat prompt already covers.
     """
     extra_docs = _extra_document_slugs()
     extra_masters = _extra_master_types()
     action_tools = services.registered_action_tools()
-    hidden_tools: set[str] = set()
+    hidden_tools: set[str] = set(DIRECT_CLIENT_ONLY_TOOLS) if native_chat else set()
     if user_info is not None:
         role = user_info.get("role")
         action_tools = [
             tool for tool in action_tools
             if tool_allowed(tool["function"]["name"], role)
         ]
-        hidden_tools = {
+        hidden_tools |= {
             tool["function"]["name"] for tool in TOOLS
             if not tool_allowed(tool["function"]["name"], role)
         }
@@ -3645,7 +3651,7 @@ async def run_thinking_loop(
                 # or the legacy API for compatible models. Returns Chat-shaped
                 # (message, usage) either way, so everything below is unchanged.
                 message, usage = await asyncio.to_thread(
-                    _orchestrator_turn, openai_client, messages, build_tools(user_info), max_completion,
+                    _orchestrator_turn, openai_client, messages, build_tools(user_info, native_chat=True), max_completion,
                 )
             except Exception as e:
                 await on_event({"type": "error", "content": f"Error calling LLM: {e}"})
@@ -3817,7 +3823,7 @@ async def run_thinking_loop(
                         "stands alone: do NOT refer to 'the results above' or to earlier messages."
                     ),
                 }],
-                build_tools(user_info),
+                build_tools(user_info, native_chat=True),
                 2048,
                 tool_choice="none",
             )

{lambda_erp-1.1.9 → lambda_erp-1.2.0}/api/main.py

@@ -53,6 +53,9 @@ async def lifespan(app: FastAPI):
     db_path = os.environ.get("LAMBDA_ERP_DB", "lambda_erp.db")
     setup(db_path)
 
+    from api.mentions import initialize_mentions
+    initialize_mentions()
+
     # Load customer extension plugins before anything creates documents.
     load_plugins()
 

lambda_erp-1.2.0/api/mentions.py

@@ -0,0 +1,235 @@
+"""Personal mentions with explicit recipients, atomic delivery and plugin sources.
+
+No email/push delivery, inferred recipients, or caller-selectable inbox owner.
+Plugins own record access and note storage; this module owns notifications.
+"""
+import hashlib
+import json
+import uuid
+
+from fastapi import HTTPException
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Literal
+
+from api import services
+from lambda_erp.database import get_db
+from lambda_erp.utils import now
+
+SOURCES = {}
+REAL_ROLES = {"viewer", "manager", "admin"}
+
+
+def register_mention_source(doctype, *, label, can_access, create_note, resolve_note, resolve_notes=None):
+    """Register a record type's internal notes.
+
+    can_access(record_id, principal) must check live record visibility.
+    create_note(record_id, body, principal) returns a saved note ID; it must
+    participate in db.atomic() without committing independently.
+    resolve_note(note_id, principal) returns {record_id,title,body,view_url},
+    or None for hidden/deleted notes. Check parent AND note visibility here.
+    Optional resolve_notes(ids, principal) batches the same checks for inboxes.
+    """
+    SOURCES[doctype] = dict(label=label, can_access=can_access,
+                           create_note=create_note, resolve_note=resolve_note, resolve_notes=resolve_notes)
+
+
+class Input(BaseModel):
+    model_config = ConfigDict(extra="forbid", strict=True)
+
+
+class Search(Input):
+    query: str = Field(default="", max_length=100)
+
+
+class Note(Input):
+    doctype: str = Field(min_length=1, max_length=100)
+    record_id: str = Field(min_length=1, max_length=200)
+    body: str = Field(min_length=1, max_length=8000)
+    mention_user_ids: list[str] = Field(default_factory=list, max_length=20)
+    request_id: str = Field(min_length=8, max_length=100)
+
+
+class Inbox(Input):
+    view: Literal["open", "unread", "done", "all"] = "open"
+    limit: int = Field(default=25, ge=1, le=100)
+    offset: int = Field(default=0, ge=0)
+
+
+class State(Input):
+    notification_id: str = Field(min_length=1, max_length=100)
+    state: Literal["read", "unread", "done", "reopen"]
+
+
+def _actor(user):
+    from api.auth import refresh_auth_principal
+    actor = refresh_auth_principal(user)
+    if not actor or actor.get("role") not in REAL_ROLES:
+        raise PermissionError("Sign in with a personal ERP account to use mentions.")
+    return {**actor, "user_id": actor.get("user_id") or actor["name"]}
+
+
+def _identity(actor):
+    return {"user_id": actor.get("user_id") or actor["name"],
+            "full_name": actor.get("full_name"), "email": actor.get("email")}
+
+
+def _source(doctype):
+    source = SOURCES.get(doctype)
+    if not source:
+        raise ValueError("This record type does not support mention notes.")
+    return source
+
+
+def search_mention_users(args, user):
+    data, actor = Search.model_validate(args), _actor(user)
+    q = data.query.strip().lower().replace("!", "!!").replace("%", "!%").replace("_", "!_")
+    rows = get_db().sql(
+        'SELECT name, full_name, email FROM "User" WHERE enabled = 1 '
+        "AND role IN ('viewer','manager','admin') "
+        "AND (LOWER(COALESCE(full_name,'')) LIKE ? ESCAPE '!' OR LOWER(email) LIKE ? ESCAPE '!') "
+        'ORDER BY full_name, name LIMIT 20', [f"%{q}%", f"%{q}%"])
+    return {"users": rows, "acting_user": _identity(actor),
+            "sources": [{"doctype": key, "label": value["label"]} for key, value in SOURCES.items()]}
+
+
+def add_record_note(args, user):
+    data, actor = Note.model_validate(args), _actor(user)
+    if actor["role"] not in {"manager", "admin"}:
+        raise PermissionError("Manager access is required to add notes.")
+    if not data.body.strip():
+        raise ValueError("Note body must not be blank.")
+    source, db = _source(data.doctype), get_db()
+    actor_id = _identity(actor)["user_id"]
+    recipients = sorted(set(data.mention_user_ids))
+    payload = {**data.model_dump(exclude={"request_id"}), "mention_user_ids": recipients}
+    digest = hashlib.sha256(json.dumps(payload, sort_keys=True).encode()).hexdigest()
+    request_pk = uuid.uuid4().hex
+    with db.atomic():
+        if not source["can_access"](data.record_id, actor):
+            raise HTTPException(404, "Record is unavailable")
+        # The unique constraint also serializes concurrent retries on Postgres.
+        db.sql('INSERT INTO "Mention Request" (id, actor_id, request_id, payload_hash, doctype, record_id) '
+               'VALUES (?, ?, ?, ?, ?, ?) ON CONFLICT (actor_id, request_id) DO NOTHING',
+               [request_pk, actor_id, data.request_id, digest, data.doctype, data.record_id])
+        saved = db.sql('SELECT * FROM "Mention Request" WHERE actor_id = ? AND request_id = ?',
+                       [actor_id, data.request_id])[0]
+        if saved["payload_hash"] != digest:
+            raise ValueError("request_id was already used for a different note; use a new request_id.")
+        repeated = saved["id"] != request_pk
+        if repeated:
+            note_id = saved["note_id"]
+            notified_count = db.sql('SELECT COUNT(*) AS n FROM "Mention Notification" WHERE doctype = ? AND note_id = ?',
+                                    [data.doctype, note_id])[0]["n"]
+        else:
+            targets = []
+            for recipient_id in recipients:
+                recipient = db.get_value("User", recipient_id, ["name", "full_name", "email", "role", "enabled"])
+                if (not recipient or not recipient.get("enabled") or recipient.get("role") not in REAL_ROLES
+                        or not source["can_access"](data.record_id, dict(recipient))):
+                    raise ValueError("A mentioned colleague cannot access this record. No note was saved.")
+                if recipient_id != actor_id:
+                    targets.append(recipient_id)
+            note_id = source["create_note"](data.record_id, data.body.strip(), actor)
+            db.sql('UPDATE "Mention Request" SET note_id = ? WHERE id = ?', [note_id, request_pk])
+            for recipient_id in targets:
+                db.insert("Mention Notification", {
+                    "id": uuid.uuid4().hex, "recipient_id": recipient_id, "actor_id": actor_id,
+                    "doctype": data.doctype, "note_id": note_id, "created_at": now(),
+                })
+            notified_count = len(targets)
+        note = source["resolve_note"](note_id, actor)
+        if not note:
+            raise HTTPException(404, "Note is no longer available")
+    return {"note_id": note_id, "record_id": data.record_id, "view_url": note["view_url"],
+            "notified_count": notified_count, "replayed": repeated, "acting_user": _identity(actor)}
+
+
+def _visible(row, actor, notes=None, authors=None):
+    source = SOURCES.get(row["doctype"])
+    note = (notes.get((row["doctype"], row["note_id"])) if notes is not None else
+            source["resolve_note"](row["note_id"], actor) if source else None)
+    if not note:
+        return None
+    author = (authors.get(row["actor_id"]) if authors is not None else
+              get_db().get_value("User", row["actor_id"], ["full_name", "email"]))
+    return {"id": row["id"], "doctype": row["doctype"], "note_id": row["note_id"],
+            "record_id": note["record_id"], "title": note["title"], "excerpt": note["body"][:240],
+            "view_url": note["view_url"], "actor_name": (author or {}).get("full_name") or (author or {}).get("email") or row["actor_id"],
+            "created_at": row["created_at"], "read_at": row["read_at"], "done_at": row["done_at"]}
+
+
+def list_my_mentions(args, user):
+    data, actor = Inbox.model_validate(args), _actor(user)
+    rows = get_db().sql('SELECT * FROM "Mention Notification" WHERE recipient_id = ? ORDER BY created_at DESC, id DESC',
+                        [_identity(actor)["user_id"]])
+    # Re-check live access before exposing either excerpts or counts. Batch
+    # source and author lookups so polling a populated inbox avoids N+1 queries.
+    notes, authors = {}, {}
+    for doctype in {row["doctype"] for row in rows}:
+        source = SOURCES.get(doctype)
+        if not source:
+            continue
+        ids = list({row["note_id"] for row in rows if row["doctype"] == doctype})
+        for start in range(0, len(ids), 250):
+            chunk = ids[start:start + 250]
+            resolved = (source["resolve_notes"](chunk, actor) if source.get("resolve_notes") else
+                        {note_id: source["resolve_note"](note_id, actor) for note_id in chunk})
+            notes.update({(doctype, key): value for key, value in resolved.items()})
+    author_ids = list({row["actor_id"] for row in rows})
+    for start in range(0, len(author_ids), 250):
+        chunk = author_ids[start:start + 250]
+        authors.update({row["name"]: row for row in get_db().sql(
+            'SELECT name, full_name, email FROM "User" WHERE name IN (' + ','.join('?' for _ in chunk) + ')', chunk)})
+    visible = [item for row in rows if (item := _visible(row, actor, notes, authors))]
+    unread = sum(not r["read_at"] and not r["done_at"] for r in visible)
+    filtered = [r for r in visible if data.view == "all" or
+                (data.view == "done" and r["done_at"]) or
+                (data.view == "open" and not r["done_at"]) or
+                (data.view == "unread" and not r["done_at"] and not r["read_at"])]
+    return {"rows": filtered[data.offset:data.offset + data.limit], "total": len(filtered),
+            "unread_count": unread, "has_more": data.offset + data.limit < len(filtered),
+            "acting_user": _identity(actor)}
+
+
+def set_mention_state(args, user):
+    data, actor = State.model_validate(args), _actor(user)
+    db, owner = get_db(), _identity(actor)["user_id"]
+    with db.atomic():
+        rows = db.sql('SELECT * FROM "Mention Notification" WHERE id = ? AND recipient_id = ?',
+                      [data.notification_id, owner])
+        if not rows or not _visible(rows[0], actor):
+            raise HTTPException(404, "Mention is unavailable")
+        assignments = {"read": 'read_at = COALESCE(read_at, ?)',
+                       "unread": 'read_at = NULL, done_at = NULL',
+                       "done": 'done_at = COALESCE(done_at, ?), read_at = COALESCE(read_at, ?)',
+                       "reopen": 'done_at = NULL'}
+        stamps = [now()] * (2 if data.state == "done" else 1 if data.state == "read" else 0)
+        db.sql('UPDATE "Mention Notification" SET ' + assignments[data.state] +
+               ' WHERE id = ? AND recipient_id = ?', [*stamps, data.notification_id, owner])
+    return {"success": True, "notification_id": data.notification_id, "state": data.state}
+
+
+def initialize_mentions():
+    db = get_db()
+    with db.atomic():
+        db.sql('CREATE TABLE IF NOT EXISTS "Mention Request" ('
+               'id TEXT PRIMARY KEY, actor_id TEXT NOT NULL, request_id TEXT NOT NULL, '
+               'payload_hash TEXT NOT NULL, doctype TEXT NOT NULL, record_id TEXT NOT NULL, note_id TEXT, '
+               'UNIQUE(actor_id, request_id))')
+        db.sql('CREATE TABLE IF NOT EXISTS "Mention Notification" ('
+               'id TEXT PRIMARY KEY, recipient_id TEXT NOT NULL, actor_id TEXT NOT NULL, '
+               'doctype TEXT NOT NULL, note_id TEXT NOT NULL, created_at TEXT NOT NULL, read_at TEXT, done_at TEXT, '
+               'UNIQUE(recipient_id, doctype, note_id))')
+        db.sql('CREATE INDEX IF NOT EXISTS mention_inbox ON "Mention Notification" (recipient_id, created_at)')
+    for name, handler, schema, role, description in (
+        ("search_mention_users", search_mention_users, Search, "viewer",
+         "Find enabled ERP colleagues for explicit @mentions by name/email. Returns canonical user IDs, acting_user and supported record types. Do not guess a person when ambiguous."),
+        ("add_record_note", add_record_note, Note, "manager",
+         "Save an internal note on a supported record and notify explicitly selected colleagues. Resolve mention_user_ids using search_mention_users. Use a new request_id (UUID) per intended note; reuse it unchanged on retries. No email is sent. Authorship is the authenticated ERP account. Self-mentions do not notify."),
+        ("list_my_mentions", list_my_mentions, Inbox, "viewer",
+         "List the authenticated ERP user's mentions, with record/note links. open means not done; unread is separate. Use this for 'my mentions', never guess or pass another user. Returns acting_user, unread_count and pagination."),
+        ("set_mention_state", set_mention_state, State, "viewer",
+         "Mark one of the authenticated user's mentions read, unread, done, or reopen it. Done only clears this personal notification; it does not complete or modify the business record."),
+    ):
+        services.register_action(name, handler, description=description,
+                                 parameters=schema.model_json_schema(), minimum_role=role, pass_user=True)

{lambda_erp-1.1.9 → lambda_erp-1.2.0}/api/pdf.py

@@ -193,17 +193,17 @@ def _render_commercial_pdf(doctype_slug, name, doc, contract):
     if doc.get("status"):
         meta_fields.append({"label": "Status", "value": doc["status"]})
 
-    # Items — refresh each line's item_name from the Item master so a later
-    # correction to an item's name appears on the PDF, consistent with the
-    # party/company names. Quantities, rates, and amounts stay as transacted.
-    # Falls back to the name stored on the line if the master is gone.
+    # Items — print the name written on each line. A line may carry its own
+    # wording under a generic article (e.g. one project service with a
+    # "Phase 1: …" line per step), so the Item master's name is only a
+    # fallback for a line that has none.
     items = doc.get("items", [])
     for item in items:
         code = item.get("item_code")
-        if code:
-            live_item_name = db.get_value("Item", code, "item_name")
-            if live_item_name:
-                item["item_name"] = live_item_name
+        if code and not item.get("item_name"):
+            master_item_name = db.get_value("Item", code, "item_name")
+            if master_item_name:
+                item["item_name"] = master_item_name
 
     taxes = doc.get("taxes", [])
 
@@ -340,11 +340,11 @@ def _render_proposal_pdf(name, proposal, contract):
         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.
+        # The line's own name wins; the master's only fills an empty one,
+        # consistent with the single-document path.
         for item in items:
             code = item.get("item_code")
-            if code:
+            if code and not item.get("item_name"):
                 live = db.get_value("Item", code, "item_name")
                 if live:
                     item["item_name"] = live

{lambda_erp-1.1.9 → lambda_erp-1.2.0}/api/pdf_contract.py

@@ -254,8 +254,9 @@ def _item(row, tokens, index):
     if not any(not missing(row.get(k)) for k in ('item_code', 'item_name', 'description')):
         raise PDFError(f'PDF requires item identity: items[{index}]')
     if row.get('item_code'):
-        live = resolve('Item', row['item_code'])
-        row['item_name'] = live  # only the isolated output snapshot is changed
+        master_name = resolve('Item', row['item_code'])  # the article must still exist
+        if missing(row.get('item_name')):
+            row['item_name'] = master_name  # only the isolated output snapshot is changed
     tokens.append(str(row.get('item_name') or row.get('item_code') or row['description']))
 
 

{lambda_erp-1.1.9 → lambda_erp-1.2.0}/api/routers/mcp.py

@@ -49,6 +49,7 @@ _EXCLUDE = {
 }
 
 _READ_ONLY = {
+    'search_mention_users', 'list_my_mentions',
     'get_erp_context',
     'list_documents', 'get_document_fields', 'get_document', 'get_master_fields',
     'search_masters', 'get_report', 'get_current_time', 'query_dataset',

{lambda_erp-1.1.9 → lambda_erp-1.2.0}/api/services.py

@@ -300,13 +300,16 @@ _ROLE_LEVEL = {"viewer": 1, "manager": 2, "public_manager": 2, "admin": 3}
 def register_action(name: str, handler, *, description: str,
                     parameters: dict | None = None,
                     minimum_role: str = "manager",
-                    allow_public_manager: bool = False) -> None:
+                    allow_public_manager: bool = False,
+                    pass_user: bool = False) -> None:
     """Register a deployment action across REST, chat, and MCP.
 
     ``handler`` receives one JSON-compatible argument dict and returns a
     JSON-compatible result. ``parameters`` is a JSON Schema object for that
     dict. Mutating actions should keep the default manager requirement; demo
     ``public_manager`` users are excluded unless explicitly opted in.
+    With ``pass_user=True``, the authenticated principal is a second argument;
+    never accept caller identity from model-supplied arguments instead.
     """
     if not _ACTION_NAME_RE.fullmatch(name):
         raise ValueError(f"Invalid action name: {name!r}")
@@ -318,6 +321,7 @@ def register_action(name: str, handler, *, description: str,
         "parameters": parameters or {"type": "object", "properties": {}},
         "minimum_role": minimum_role,
         "allow_public_manager": allow_public_manager,
+        "pass_user": pass_user,
     }
 
 
@@ -354,6 +358,8 @@ def run_registered_action(name: str, args: dict | None, user_info: dict | None =
         raise PermissionError(
             f"Action '{name}' requires {meta['minimum_role']} access."
         )
+    if meta.get("pass_user"):
+        return meta["handler"](args or {}, user_info)
     return meta["handler"](args or {})
 
 

{lambda_erp-1.1.9 → lambda_erp-1.2.0}/pyproject.toml

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