lambda-erp 1.3.0__py3-none-any.whl → 1.3.2__py3-none-any.whl

api/chat.py

@@ -2720,6 +2720,9 @@ The `remarks` (Notes / Terms) field on quotations, sales orders, and invoices re
 - Separate blocks with a blank line; a single newline is just a line break.
 Plain text (no special characters) still renders fine, so only reach for the markup when it improves a customer-facing note.
 
+### Internal notes (never printed)
+`remarks` is PRINTED and goes to the customer or supplier. Internal team remarks ("customer disputes line 2", "@Anna please check the price") belong in an internal note on the record instead: `add_record_note` (doctype = the record type slug, e.g. `sales-invoice` or `customer`; record_id = its name), read with `list_record_notes`, change with `update_record_note` / `delete_record_note`. Every document and master type supports them; they appear in the record's "Internal notes" card and never change the record. To notify a colleague, first `search_mention_users` and put their exact `mention_text` in the body. Never put internal remarks into `remarks`, and never copy internal notes into customer-facing text.
+
 ### Purchase Cycle
 Purchase Order → Purchase Receipt (receiving) / Purchase Invoice (billing) → Payment Entry
 
@@ -3280,6 +3283,15 @@ def _generate_report_spec_via_openai(
 # ---------------------------------------------------------------------------
 
 
+# Small and cheap: a 3-6 word label. gpt-4.1-nano was retired by OpenAI and
+# every call failed silently, leaving all chats as "New Chat".
+TITLE_MODEL = "gpt-6-luna"
+
+
+def _title_model() -> str:
+    return os.environ.get("LAMBDA_ERP_TITLE_MODEL") or TITLE_MODEL
+
+
 async def generate_title(
     session_id: str,
     user_message: str,
@@ -3296,12 +3308,12 @@ async def generate_title(
     if not api_key or api_key == "sk-your-key-here":
         return
 
+    title_model = _title_model()
     try:
         client = OpenAI(
             api_key=api_key,
             timeout=httpx.Timeout(30.0, connect=5.0),
         )
-        title_model = "gpt-4.1-nano"
         reservation_id = None
         if is_demo_role(user_role):
             _blocked, reservation_id = demo_limiter.reserve(
@@ -3314,14 +3326,15 @@ async def generate_title(
 
         settled = False
         try:
+            # Responses API with low effort: GPT-6 models reason, and the
+            # output budget must leave room for that before the title itself.
             response = await asyncio.to_thread(
-                client.chat.completions.create,
+                client.responses.create,
                 model=title_model,
-                messages=[
-                    {"role": "system", "content": "Generate a very short title (3-6 words, no quotes) for this chat based on the first exchange. Just the title, nothing else."},
-                    {"role": "user", "content": f"User: {user_message[:200]}\nAssistant: {assistant_message[:200]}"},
-                ],
-                max_completion_tokens=30,
+                instructions="Generate a very short title (3-6 words, no quotes) for this chat based on the first exchange. Just the title, nothing else.",
+                input=f"User: {user_message[:200]}\nAssistant: {assistant_message[:200]}",
+                max_output_tokens=400,
+                reasoning={"effort": "low"},
             )
             usage = getattr(response, "usage", None)
             demo_limiter.settle(
@@ -3331,20 +3344,25 @@ async def generate_title(
                 role=user_role,
                 provider="openai",
                 model=title_model,
-                prompt_tokens=int(getattr(usage, "prompt_tokens", 0) or 0) if usage else 0,
-                completion_tokens=int(getattr(usage, "completion_tokens", 0) or 0) if usage else 0,
+                prompt_tokens=int(getattr(usage, "input_tokens", 0) or 0) if usage else 0,
+                completion_tokens=int(getattr(usage, "output_tokens", 0) or 0) if usage else 0,
                 session_id=session_id,
             )
             settled = True
 
-            title = response.choices[0].message.content.strip().strip('"\'')
+            title = (response.output_text or "").strip().strip('"\'')[:120]
             if title:
                 update_session_title(session_id, title)
+            else:
+                logger.warning("[chat_title] model=%s returned no title (status=%s)",
+                               title_model, getattr(response, "status", None))
         finally:
             if not settled:
                 demo_limiter.release(reservation_id)
-    except Exception:
-        pass  # Title generation is best-effort
+    except Exception as exc:
+        # Best-effort, but never silent: a retired model once left every chat
+        # untitled without a single log line.
+        logger.warning("[chat_title] model=%s failed: %s", title_model, exc)
 
 
 # ---------------------------------------------------------------------------
@@ -3353,9 +3371,15 @@ async def generate_title(
 
 # GPT-6.1 Sol requires Responses for function tools and does not support
 # reasoning effort "none", including tool-free wrap-ups after the step limit.
+# LAMBDA_ERP_CHAT_MODEL overrides it per deployment (e.g. to trial a cheaper
+# model on dev); see docs/llm-pricing.md.
 ORCHESTRATOR_MODEL = "gpt-6.1-sol"
 
 
+def _chat_model() -> str:
+    return os.environ.get("LAMBDA_ERP_CHAT_MODEL") or ORCHESTRATOR_MODEL
+
+
 # ---------------------------------------------------------------------------
 # LLM API selector: Responses API (default) vs Chat Completions
 #
@@ -3370,8 +3394,9 @@ ORCHESTRATOR_MODEL = "gpt-6.1-sol"
 # ---------------------------------------------------------------------------
 
 def _use_responses_api() -> bool:
-    # A legacy deployment flag must not route Sol 6.1 into an unsupported API.
-    if ORCHESTRATOR_MODEL == "gpt-6.1-sol":
+    # A legacy deployment flag must not route a GPT-6.1 model into an
+    # unsupported API.
+    if _chat_model().startswith("gpt-6.1-"):
         return True
     # Default: the Responses API (needed for Office attachments + native
     # reasoning). Set ERP_CHAT_API=chat to fall back to Chat Completions.
@@ -3532,12 +3557,12 @@ def _shim_usage_from_responses(usage):
 
 def _orchestrator_turn(client, messages, tools, max_tokens, *, tool_choice="auto"):
     """One orchestrator LLM turn. Returns (message, usage) shaped like Chat
-    Completions. Sol 6.1 always uses Responses; compatible models honor ERP_CHAT_API.
+    Completions. GPT-6.1 models always use Responses; others honor ERP_CHAT_API.
     Blocking — call via asyncio.to_thread."""
     if _use_responses_api():
         instructions, input_items = _responses_request_from_chat(messages)
         resp = client.responses.create(
-            model=ORCHESTRATOR_MODEL,
+            model=_chat_model(),
             instructions=instructions,
             input=input_items,
             tools=_responses_tools_from_chat(tools),
@@ -3547,7 +3572,7 @@ def _orchestrator_turn(client, messages, tools, max_tokens, *, tool_choice="auto
         )
         return _shim_message_from_responses(resp), _shim_usage_from_responses(getattr(resp, "usage", None))
     resp = client.chat.completions.create(
-        model=ORCHESTRATOR_MODEL,
+        model=_chat_model(),
         messages=messages,
         tools=tools,
         tool_choice=tool_choice,
@@ -3712,7 +3737,7 @@ async def run_thinking_loop(
         # on ANY exit path — including asyncio.CancelledError raised after
         # the SDK call has already returned but before settle() ran.
         settled = False
-        model_name = ORCHESTRATOR_MODEL
+        model_name = _chat_model()
         try:
             print(f"[chat_llm] provider=openai model={model_name} session_id={session_id or '-'} iter={iteration + 1}", flush=True)
             await on_event({"type": "llm_provider", "provider": "openai", "model": model_name})
@@ -3899,9 +3924,9 @@ async def run_thinking_loop(
                 tool_choice="none",
             )
             demo_limiter.settle(
-                None, actual_cost_usd=cost_of_openai_call(ORCHESTRATOR_MODEL, usage),
+                None, actual_cost_usd=cost_of_openai_call(_chat_model(), usage),
                 ip=client_ip or "unknown", role=user_role, provider="openai",
-                model=ORCHESTRATOR_MODEL,
+                model=_chat_model(),
                 prompt_tokens=int(getattr(usage, "prompt_tokens", 0) or 0) if usage else 0,
                 completion_tokens=int(getattr(usage, "completion_tokens", 0) or 0) if usage else 0,
                 session_id=session_id,

api/erp_context.py

@@ -24,6 +24,13 @@ draft creation does not imply submission, stock movement or ledger posting. Chec
 status and warnings. Correct validation errors using the field metadata and user information.
 Use list/search filters and pagination; an empty or partial search is not proof of zero
 stock. Use query_dataset/get_report for totals and stock, with the requested scope and dates.
+Text for the customer or supplier goes in a document's printed `remarks` (Notes / Terms)
+field. Internal team remarks ("customer disputes line 2", "@Anna please check") go in an
+internal note instead (add_record_note / list_record_notes): never printed, visible to
+signed-in colleagues only, and @mentions there notify colleagues. Never put internal
+remarks into `remarks`, and never copy internal notes into a document the customer sees.
+Requests about the user's own sidebar menu ("hide rentals", "put CRM first") use
+get_menu_layout, then update_menu_layout. They change only that user's menu, not access.
 Generate a fresh PDF after edits. Only a successful artifact descriptor proves generation;
 download that artifact, check its SHA-256 and deliver it through the calling application's
 attachment mechanism. Do not invent download URLs or reuse a stale document attachment.

api/main.py

@@ -59,6 +59,10 @@ async def lifespan(app: FastAPI):
     with db.startup_lock():
         from api.mentions import initialize_mentions
         initialize_mentions()
+        from api.record_notes import initialize_record_notes
+        initialize_record_notes()
+        from api.menu_layout import initialize_menu_layout
+        initialize_menu_layout()
 
         # Load customer extension plugins before anything creates documents.
         load_plugins()

api/mentions.py

@@ -18,6 +18,7 @@ from lambda_erp.database import get_db
 from lambda_erp.utils import now
 
 SOURCES = {}
+_FALLBACKS = []  # (resolve(doctype) -> source | None, list_types() -> [doctype]) for unregistered types
 REAL_ROLES = {"viewer", "manager", "admin"}
 _WRITING_MENTION_NOTE = ContextVar("writing_mention_note", default=False)
 _MENTION_START = re.compile(r"(?<![\w@./+\-])@(?=\S)")
@@ -79,6 +80,31 @@ def register_mention_source(doctype, *, label, can_access, create_note, resolve_
                            create_note=create_note, resolve_note=resolve_note, resolve_notes=resolve_notes)
 
 
+def register_mention_source_fallback(resolve, list_types):
+    """Resolve sources for record types without an explicit registration
+    (api.record_notes uses this for every document and master type)."""
+    if all(entry[0] is not resolve for entry in _FALLBACKS):
+        _FALLBACKS.append((resolve, list_types))
+
+
+def find_source(doctype):
+    source = SOURCES.get(doctype)
+    for resolve, _ in _FALLBACKS:
+        if source:
+            break
+        source = resolve(doctype)
+    return source
+
+
+def supported_sources():
+    sources = {key: value["label"] for key, value in SOURCES.items()}
+    for resolve, list_types in _FALLBACKS:
+        for doctype in list_types():
+            if doctype not in sources and (source := resolve(doctype)):
+                sources[doctype] = source["label"]
+    return [{"doctype": key, "label": label} for key, label in sources.items()]
+
+
 class Input(BaseModel):
     model_config = ConfigDict(extra="forbid", strict=True)
 
@@ -121,7 +147,7 @@ def _identity(actor):
 
 
 def _source(doctype):
-    source = SOURCES.get(doctype)
+    source = find_source(doctype)
     if not source:
         raise ValueError("This record type does not support mention notes.")
     return source
@@ -141,7 +167,7 @@ def search_mention_users(args, user):
         token = full_name if full_name and len(aliases.get(full_name.lower(), {})) == 1 else row["email"]
         row["mention_text"] = "@" + token
     return {"users": rows, "acting_user": _identity(actor),
-            "sources": [{"doctype": key, "label": value["label"]} for key, value in SOURCES.items()]}
+            "sources": supported_sources()}
 
 
 def add_record_note(args, user):
@@ -221,7 +247,7 @@ def sync_note_mentions(doctype, record_id, note_id, body, user):
 
 
 def _visible(row, actor, notes=None, authors=None):
-    source = SOURCES.get(row["doctype"])
+    source = find_source(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:
@@ -242,7 +268,7 @@ def list_my_mentions(args, user):
     # 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)
+        source = find_source(doctype)
         if not source:
             continue
         ids = list({row["note_id"] for row in rows if row["doctype"] == doctype})
@@ -301,7 +327,7 @@ def initialize_mentions():
         ("search_mention_users", search_mention_users, Search, "viewer",
          "Find enabled ERP colleagues for visible @mentions by name/email. Returns mention_text: insert that exact text in the note body to tag the person. Also 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 and notify people visibly @mentioned in its body, including yourself. First use search_mention_users, then include each recipient's exact mention_text in body, e.g. 'salü vom johnny @Jon Torus'. Recipients are determined only from body; there is no recipient-ID argument. Unknown @handles and ordinary emails remain text. Ambiguous names require @email. Generic CRM note writes use the same mention processing. Use a new request_id (UUID) per intended note; reuse it unchanged on retries. No email is sent. Authorship is the authenticated ERP account."),
+         "Save an internal team note on a record and notify people visibly @mentioned in its body, including yourself. doctype is the record type slug: any document or master type (e.g. sales-invoice, purchase-order, customer, supplier, item) or a plugin type listed in search_mention_users sources; record_id is the record's name. Internal notes are never printed and do not change the record; customer-facing text belongs in the document's printed `remarks` (Notes / Terms) field instead. A note needs no mention. To tag someone, first use search_mention_users, then include each recipient's exact mention_text in body, e.g. 'salü vom johnny @Jon Torus'. Recipients are determined only from body; there is no recipient-ID argument. Unknown @handles and ordinary emails remain text. Ambiguous names require @email. CRM lead notes written through the generic document tools use the same mention processing. Use a new request_id (UUID) per intended note; reuse it unchanged on retries. No email is sent. Authorship is the authenticated ERP account."),
         ("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",

api/menu_layout.py

@@ -0,0 +1,206 @@
+"""Personal sidebar menu: hide and reorder groups and items, per user.
+
+The menu itself is defined by the frontend (core groups plus whatever plugins
+register), so the web app publishes what it shows to each user as the
+`nav_catalog` preference. Reads and writes here validate against that catalog;
+the layout is stored as the `nav_layout` preference. Hiding only tidies the
+menu: routes and permissions are unchanged.
+"""
+import json
+
+from pydantic import Field
+
+from api import mentions, services
+from lambda_erp.database import get_db
+
+CATALOG_KEY = "nav_catalog"
+LAYOUT_KEY = "nav_layout"
+# The page that edits the menu can never be hidden, or a user could lock
+# themselves out of undoing it. Its group therefore can't be hidden either.
+LOCKED_ITEM = "/settings/menu"
+REF = Field(min_length=1, max_length=200)
+
+
+def _actor(user):
+    if (user or {}).get("_shared_connection"):
+        raise PermissionError("The menu is personal. The shared team key identifies its owner, "
+                              "not the current user; connect with a personal ERP account.")
+    from api.auth import refresh_auth_principal
+    actor = refresh_auth_principal(user)
+    if not actor or actor.get("role") not in mentions.REAL_ROLES:
+        raise PermissionError("Sign in with a personal ERP account to change your menu.")
+    return actor.get("user_id") or actor["name"]
+
+
+def _read(user_name, key, default):
+    rows = get_db().sql('SELECT value FROM "User Preference" WHERE user_name = ? AND key = ?',
+                        [user_name, key])
+    try:
+        return json.loads(rows[0]["value"]) if rows else default
+    except (TypeError, ValueError):
+        return default
+
+
+def _write(user_name, key, value):
+    db, text = get_db(), json.dumps(value, separators=(",", ":"))
+    with db.atomic():
+        if db.sql('SELECT 1 FROM "User Preference" WHERE user_name = ? AND key = ?', [user_name, key]):
+            db.sql('UPDATE "User Preference" SET value = ? WHERE user_name = ? AND key = ?',
+                   [text, user_name, key])
+        else:
+            db.sql('INSERT INTO "User Preference" (user_name, key, value) VALUES (?, ?, ?)',
+                   [user_name, key, text])
+
+
+def _layout(user_name):
+    raw = _read(user_name, LAYOUT_KEY, {})
+    raw = raw if isinstance(raw, dict) else {}
+    items = raw.get("items") if isinstance(raw.get("items"), dict) else {}
+    return {"order": [k for k in raw.get("order") or [] if isinstance(k, str)],
+            "items": {g: [k for k in v if isinstance(k, str)] for g, v in items.items() if isinstance(v, list)},
+            "hidden": [k for k in raw.get("hidden") or [] if isinstance(k, str)]}
+
+
+def _catalog(user_name):
+    raw = _read(user_name, CATALOG_KEY, [])
+    groups = []
+    for group in raw if isinstance(raw, list) else []:
+        if not isinstance(group, dict) or not isinstance(group.get("key"), str):
+            continue
+        items = [{"key": i["key"], "label": str(i.get("label") or i["key"]), "title": str(i.get("title") or "")}
+                 for i in group.get("items") or [] if isinstance(i, dict) and isinstance(i.get("key"), str)]
+        groups.append({"key": group["key"], "label": str(group.get("label") or group["key"]),
+                       "title": str(group.get("title") or ""), "items": items})
+    return groups
+
+
+def _ordered(default, preferred):
+    """Keys named in `preferred` first, in that order; the rest keep their default order."""
+    first = [k for k in dict.fromkeys(preferred) if k in default]
+    return first + [k for k in default if k not in first]
+
+
+def effective_menu(catalog, layout):
+    hidden = set(layout["hidden"])
+    by_key = {g["key"]: g for g in catalog}
+    menu = []
+    for key in _ordered([g["key"] for g in catalog], layout["order"]):
+        group = by_key[key]
+        items = {i["key"]: i for i in group["items"]}
+        menu.append({**{k: group[k] for k in ("key", "label", "title")}, "hidden": key in hidden,
+                     "items": [{**items[i], "hidden": i in hidden, "locked": i == LOCKED_ITEM}
+                               for i in _ordered(list(items), layout["items"].get(key, []))],
+                     "locked": LOCKED_ITEM in items})
+    return menu
+
+
+def _resolver(catalog):
+    """Map a reference (group key, item path, or an English or translated label) to a key."""
+    exact, named = {}, {}
+    for group in catalog:
+        exact[group["key"]] = ("group", group["key"], None)
+        for item in group["items"]:
+            exact[item["key"]] = ("item", item["key"], group["key"])
+    for group in catalog:
+        refs = [(group, "group", None)] + [(item, "item", group["key"]) for item in group["items"]]
+        for entry, kind, parent in refs:
+            for name in {entry["label"].casefold(), entry["title"].casefold()} - {""}:
+                named.setdefault(name, set()).add((kind, entry["key"], parent))
+
+    def resolve(ref):
+        if ref in exact:
+            return exact[ref]
+        matches = named.get(ref.strip().casefold(), set())
+        if len(matches) == 1:
+            return next(iter(matches))
+        if matches:
+            raise ValueError(f"{ref!r} is ambiguous: use one of the keys "
+                             f"{', '.join(sorted(m[1] for m in matches))}.")
+        raise ValueError(f"Unknown menu entry {ref!r}. Call get_menu_layout for the available "
+                         "groups and items.")
+    return resolve
+
+
+class GetLayout(mentions.Input):
+    pass
+
+
+class UpdateLayout(mentions.Input):
+    hide: list[str] = Field(default_factory=list, max_length=200)
+    show: list[str] = Field(default_factory=list, max_length=200)
+    group_order: list[str] | None = Field(default=None, max_length=200)
+    item_order: dict[str, list[str]] = Field(default_factory=dict, max_length=100)
+    reset: bool = False
+
+
+def _response(catalog, layout, note=None):
+    result = {"menu": effective_menu(catalog, layout), "layout": layout}
+    if not catalog:
+        result["note"] = ("Your menu is not known yet: open the ERP web app once, then try again.")
+    if note:
+        result["note"] = note
+    return result
+
+
+def get_menu_layout(args, user):
+    GetLayout.model_validate(args)
+    user_name = _actor(user)
+    return _response(_catalog(user_name), _layout(user_name))
+
+
+def update_menu_layout(args, user):
+    data, user_name = UpdateLayout.model_validate(args), _actor(user)
+    catalog = _catalog(user_name)
+    if not catalog:
+        raise ValueError("Your menu is not known yet: open the ERP web app once, then try again.")
+    resolve = _resolver(catalog)
+    layout = {"order": [], "items": {}, "hidden": []} if data.reset else _layout(user_name)
+    hidden = dict.fromkeys(layout["hidden"])
+    for ref in data.show:
+        hidden.pop(resolve(ref)[1], None)
+    locked_group = next((g["key"] for g in catalog if any(i["key"] == LOCKED_ITEM for i in g["items"])), None)
+    for ref in data.hide:
+        kind, key, _ = resolve(ref)
+        if key == LOCKED_ITEM or key == locked_group:
+            raise ValueError(f"{ref!r} can't be hidden: it holds the menu settings page. "
+                             "Hide the other items in it instead.")
+        hidden[key] = None
+    layout["hidden"] = list(hidden)
+    if data.group_order is not None:
+        keys = [resolve(ref) for ref in data.group_order]
+        if any(kind != "group" for kind, _, _ in keys):
+            raise ValueError("group_order takes groups only; reorder items with item_order.")
+        layout["order"] = [key for _, key, _ in keys]
+    for group_ref, refs in data.item_order.items():
+        kind, group, _ = resolve(group_ref)
+        if kind != "group":
+            raise ValueError(f"item_order keys are groups; {group_ref!r} is an item.")
+        keys = [resolve(ref) for ref in refs]
+        if any(kind != "item" or parent != group for kind, _, parent in keys):
+            raise ValueError(f"item_order[{group_ref!r}] may only list items of that group; "
+                             "items can't move between groups.")
+        layout["items"][group] = [key for _, key, _ in keys]
+    _write(user_name, LAYOUT_KEY, layout)
+    return _response(catalog, layout)
+
+
+def initialize_menu_layout():
+    services.register_action(
+        "get_menu_layout", get_menu_layout, minimum_role="viewer", pass_user=True,
+        parameters=GetLayout.model_json_schema(),
+        description=(
+            "Show the current user's personal sidebar menu: every group and item in display order, "
+            "with its key, English label, label in the user's language (title) and whether it is "
+            "hidden. Call this before update_menu_layout."))
+    services.register_action(
+        "update_menu_layout", update_menu_layout, minimum_role="viewer", pass_user=True,
+        parameters=UpdateLayout.model_json_schema(),
+        description=(
+            "Hide, show or reorder entries in the current user's own sidebar menu (no one else's). "
+            "Refer to an entry by its key from get_menu_layout (a group label such as 'Rentals', or "
+            "an item path such as '/app/asset') or by its label. hide/show take groups or items; "
+            "hiding a group hides all of it. group_order lists groups to put first, in that order "
+            "(the rest follow); item_order maps a group to its items in the new order. Items stay "
+            "in their group. reset=true restores the default menu before applying the rest. The "
+            "menu settings entry can't be hidden. Hiding only tidies the menu: pages stay "
+            "reachable and permissions are unchanged."))

api/providers.py

@@ -1,7 +1,7 @@
 """Pricing data for external LLM APIs the chat orchestrator uses.
 
-Mirrors the shape of `lambda-web/backend/providers.py`. Includes active models
-and GPT-6 alternatives for comparison. Prices are Standard USD per 1M tokens;
+Mirrors the shape of `lambda-web/backend/providers.py`. Lists the OpenAI models
+available to us. Prices are Standard USD per 1M tokens;
 see docs/llm-pricing.md for sources and billing scope.
 
 Consumers import `cost_of_openai_call` to turn an SDK `response.usage` object
@@ -19,60 +19,38 @@ from typing import Any, Optional
 # ---------------------------------------------------------------------------
 
 OPENAI_PRICING: dict[str, dict[str, Any]] = {
-    # Official model pages, verified 2026-09-29. Above 272K input tokens,
-    # the higher rates apply to the entire request (including cache hits).
+    # The models available to us, Standard tier, verified 2026-10-30. Above
+    # 272K input tokens the higher rates apply to the entire request
+    # (including cache hits). cache_write is the 30-minute retention rate,
+    # cache_write_12h the 12-hour one.
     "gpt-6-astra": {
         "tiered": True,
         "tiers": [
-            {"max_input_tokens": 272_000, "input": 10.00, "cached_input": 1.00, "cache_write": 12.50, "output": 50.00},
-            {"max_input_tokens": None,    "input": 20.00, "cached_input": 2.00, "cache_write": 25.00, "output": 75.00},
-        ],
-    },
-    "gpt-6-sol": {
-        "tiered": True,
-        "tiers": [
-            {"max_input_tokens": 272_000, "input": 2.00, "cached_input": 0.20, "cache_write": 2.50, "output": 10.00},
-            {"max_input_tokens": None,    "input": 4.00, "cached_input": 0.40, "cache_write": 5.00, "output": 15.00},
-        ],
-    },
-    "gpt-6-luna": {
-        "tiered": True,
-        "tiers": [
-            {"max_input_tokens": 272_000, "input": 0.10, "cached_input": 0.01, "cache_write": 0.125, "output": 0.50},
-            {"max_input_tokens": None,    "input": 0.20, "cached_input": 0.02, "cache_write": 0.25, "output": 0.75},
+            {"max_input_tokens": 272_000, "input": 10.00, "cached_input": 1.00, "cache_write": 12.50, "cache_write_12h": 25.00, "output": 50.00},
+            {"max_input_tokens": None,    "input": 20.00, "cached_input": 2.00, "cache_write": 25.00, "cache_write_12h": 50.00, "output": 75.00},
         ],
     },
     "gpt-6.1-sol": {
         "tiered": True,
         "tiers": [
-            {"max_input_tokens": 272_000, "input": 2.00, "cached_input": 0.10, "cache_write": 2.50, "output": 10.00},
-            {"max_input_tokens": None,    "input": 4.00, "cached_input": 0.20, "cache_write": 5.00, "output": 15.00},
+            {"max_input_tokens": 272_000, "input": 2.00, "cached_input": 0.10, "cache_write": 2.50, "cache_write_12h": 5.00, "output": 10.00},
+            {"max_input_tokens": None,    "input": 4.00, "cached_input": 0.20, "cache_write": 5.00, "cache_write_12h": 10.00, "output": 15.00},
         ],
     },
-    "gpt-5.4": {
+    "gpt-6.1-terra": {
         "tiered": True,
         "tiers": [
-            {"max_input_tokens": 272_000, "input": 2.50, "cached_input": 0.25, "output": 15.00},
-            {"max_input_tokens": None,    "input": 5.00, "cached_input": 0.50, "output": 22.50},
+            {"max_input_tokens": 272_000, "input": 1.00, "cached_input": 0.05, "cache_write": 1.25, "cache_write_12h": 2.50, "output": 5.00},
+            {"max_input_tokens": None,    "input": 2.00, "cached_input": 0.10, "cache_write": 2.50, "cache_write_12h": 5.00, "output": 7.50},
         ],
     },
-    # GPT-5.6 Terra — tiered like gpt-5.4 (official pricing: 2x input, 1.5x
-    # output above 272K input; the 5.6 family also prices cache writes).
-    "gpt-5.6-terra": {
+    "gpt-6-luna": {
         "tiered": True,
         "tiers": [
-            {"max_input_tokens": 272_000, "input": 2.00, "cached_input": 0.20, "cache_write": 2.50, "output": 12.00},
-            {"max_input_tokens": None,    "input": 4.00, "cached_input": 0.40, "cache_write": 5.00, "output": 18.00},
+            {"max_input_tokens": 272_000, "input": 0.10, "cached_input": 0.01, "cache_write": 0.125, "cache_write_12h": 0.25, "output": 0.50},
+            {"max_input_tokens": None,    "input": 0.20, "cached_input": 0.02, "cache_write": 0.25, "cache_write_12h": 0.50, "output": 0.75},
         ],
     },
-    "gpt-4.1-nano": {"input": 0.10, "cached_input": 0.025, "output": 0.40},
-    "gpt-4.1-mini": {"input": 0.40, "cached_input": 0.10,  "output": 1.60},
-    "gpt-4.1":      {"input": 2.00, "cached_input": 0.50,  "output": 8.00},
-    "gpt-5":        {"input": 1.25, "cached_input": 0.125, "output": 10.00},
-    "gpt-5-mini":   {"input": 0.25, "cached_input": 0.025, "output": 2.00},
-    "gpt-5-nano":   {"input": 0.05, "cached_input": 0.005, "output": 0.40},
-    "gpt-4o":       {"input": 2.50, "cached_input": 1.25,  "output": 10.00},
-    "gpt-4o-mini":  {"input": 0.15, "cached_input": 0.075, "output": 0.60},
 }
 
 # Speech-to-text, priced per minute of audio (not per token).
@@ -84,14 +62,14 @@ TRANSCRIBE_PRICING: dict[str, dict[str, float]] = {
 
 
 # ---------------------------------------------------------------------------
-# Rate lookup — preserve the legacy gpt-5.4 estimate for unknown model IDs.
+# Rate lookup — unknown model IDs are estimated at the gpt-6.1-sol rates.
 # Register a model explicitly before using it; this fallback is not a price cap.
 # ---------------------------------------------------------------------------
 
 def get_openai_rates(model: str, input_tokens: int = 0) -> dict[str, float]:
     entry = OPENAI_PRICING.get(model)
     if entry is None:
-        entry = OPENAI_PRICING["gpt-5.4"]
+        entry = OPENAI_PRICING["gpt-6.1-sol"]
     if entry.get("tiered"):
         for tier in entry["tiers"]:
             cap = tier.get("max_input_tokens")

api/record_notes.py

@@ -0,0 +1,233 @@
+"""Internal notes on any ERP document or master record.
+
+Notes are private to the team: they never print and never change the record
+itself (no `modified` bump, so open forms are not marked stale). They plug into
+the personal mention inbox as a fallback source, so every document and master
+type supports @mentions without registering anything. Record types with their
+own notes (a plugin's explicit mention source, e.g. CRM leads) keep theirs.
+"""
+import uuid
+from urllib.parse import quote
+
+from fastapi import HTTPException
+from pydantic import Field
+
+from api import mentions, services
+from lambda_erp.database import get_db
+from lambda_erp.utils import now
+
+TABLE = "Record Note"
+_DISABLED: set[str] = set()
+
+
+def disable_record_notes(record_type):
+    """Opt a record type out, e.g. one whose rows are themselves notes."""
+    _DISABLED.add(record_type)
+
+
+def _target(record_type):
+    """(table, kind) for a record type that takes generic notes, else None."""
+    if record_type in _DISABLED or record_type in mentions.SOURCES:
+        return None
+    doctype = services.SLUG_TO_DOCTYPE.get(record_type)
+    if doctype:
+        return doctype, "document"
+    master = services.MASTER_TABLES.get(record_type)
+    if master:
+        return master[0], "master"
+    return None
+
+
+def record_types():
+    return sorted({*services.SLUG_TO_DOCTYPE, *services.MASTER_TABLES} - _DISABLED - mentions.SOURCES.keys())
+
+
+def _reader(user):
+    return (user or {}).get("role") in mentions.REAL_ROLES
+
+
+def _existing(table, ids):
+    db, found = get_db(), {}
+    ids = list(ids)
+    for start in range(0, len(ids), 250):
+        chunk = ids[start:start + 250]
+        found.update({row["name"]: row for row in db.sql(
+            f'SELECT * FROM "{table}" WHERE name IN (' + ','.join('?' for _ in chunk) + ')', chunk)})
+    return found
+
+
+def _title(record_type, record):
+    table, kind = _target(record_type)
+    if kind == "master":
+        label = record.get(services.MASTER_TABLES[record_type][1])
+        return f"{table} {record['name']}" + (f" · {label}" if label and label != record["name"] else "")
+    party = record.get("customer_name") or record.get("supplier_name") or record.get("party_name")
+    return f"{table} {record['name']}" + (f" · {party}" if party else "")
+
+
+def view_url(record_type, record_id, note_id=None):
+    _, kind = _target(record_type)
+    base = "/app" if kind == "document" else "/masters"
+    url = f"{base}/{record_type}/{quote(record_id, safe='')}"
+    return url + (f"#note-{note_id}" if note_id else "")
+
+
+def _can_access(record_type, record_id, user):
+    target = _target(record_type)
+    return bool(target and _reader(user) and get_db().exists(target[0], record_id))
+
+
+def _create(record_type, record_id, body, user):
+    note_id, stamp = uuid.uuid4().hex, now()
+    get_db().insert(TABLE, {
+        "name": note_id, "record_type": record_type, "record_id": record_id, "body": body,
+        "author_id": user.get("user_id") or user["name"], "created_at": stamp, "updated_at": stamp,
+    })
+    return note_id
+
+
+def _resolve(record_type, note_ids, user):
+    target = _target(record_type)
+    if not note_ids or not target or not _reader(user):
+        return {}
+    rows = get_db().sql(f'SELECT name, record_id, body FROM "{TABLE}" WHERE record_type = ? AND name IN ('
+                        + ','.join('?' for _ in note_ids) + ')', [record_type, *note_ids])
+    records = _existing(target[0], {row["record_id"] for row in rows})
+    return {row["name"]: {
+        "record_id": row["record_id"], "title": _title(record_type, records[row["record_id"]]),
+        "body": row["body"], "view_url": view_url(record_type, row["record_id"], row["name"]),
+    } for row in rows if row["record_id"] in records}
+
+
+def _source(record_type):
+    target = _target(record_type)
+    if not target:
+        return None
+    return dict(
+        label=target[0],
+        can_access=lambda record_id, user: _can_access(record_type, record_id, user),
+        create_note=lambda record_id, body, user: _create(record_type, record_id, body, user),
+        resolve_note=lambda note_id, user: _resolve(record_type, [note_id], user).get(note_id),
+        resolve_notes=lambda note_ids, user: _resolve(record_type, note_ids, user),
+    )
+
+
+class ListNotes(mentions.Input):
+    record_type: str = Field(min_length=1, max_length=100)
+    record_id: str = Field(min_length=1, max_length=200)
+    limit: int = Field(default=50, ge=1, le=200)
+    offset: int = Field(default=0, ge=0)
+
+
+class EditNote(mentions.Input):
+    note_id: str = Field(min_length=1, max_length=100)
+    body: str = Field(min_length=1, max_length=8000)
+
+
+class DeleteNote(mentions.Input):
+    note_id: str = Field(min_length=1, max_length=100)
+
+
+def _require_record(record_type, record_id, user):
+    if not _target(record_type):
+        raise ValueError(f"{record_type!r} does not take internal notes. "
+                         f"Supported record types: {', '.join(record_types())}.")
+    if not _can_access(record_type, record_id, user):
+        raise HTTPException(404, "Record is unavailable")
+
+
+def list_record_notes(args, user):
+    data = ListNotes.model_validate(args)
+    if not _reader(user):
+        raise PermissionError("Sign in with an ERP account to read internal notes.")
+    _require_record(data.record_type, data.record_id, user)
+    db, me = get_db(), user.get("user_id") or user.get("name")
+    where = [data.record_type, data.record_id]
+    total = db.sql(f'SELECT COUNT(*) AS n FROM "{TABLE}" WHERE record_type = ? AND record_id = ?', where)[0]["n"]
+    rows = db.sql(f'SELECT * FROM "{TABLE}" WHERE record_type = ? AND record_id = ? '
+                  'ORDER BY created_at DESC, name DESC LIMIT ? OFFSET ?', [*where, data.limit, data.offset])
+    authors = _existing("User", {row["author_id"] for row in rows})
+    notes = [{
+        "id": row["name"], "body": row["body"], "author_id": row["author_id"],
+        "author_name": (authors.get(row["author_id"]) or {}).get("full_name")
+        or (authors.get(row["author_id"]) or {}).get("email") or row["author_id"],
+        "created_at": row["created_at"], "updated_at": row["updated_at"],
+        "edited": row["updated_at"] != row["created_at"],
+        "can_edit": row["author_id"] == me,
+        "can_delete": row["author_id"] == me or user.get("role") == "admin",
+        "view_url": view_url(data.record_type, data.record_id, row["name"]),
+    } for row in rows]
+    return {"record_type": data.record_type, "record_id": data.record_id, "notes": notes,
+            "total": total, "has_more": data.offset + len(notes) < total}
+
+
+def _load_note(note_id):
+    rows = get_db().sql(f'SELECT * FROM "{TABLE}" WHERE name = ?', [note_id])
+    if not rows:
+        raise HTTPException(404, "Note not found")
+    return rows[0]
+
+
+def update_record_note(args, user):
+    data, actor = EditNote.model_validate(args), mentions._actor(user)
+    body = data.body.strip()
+    if not body:
+        raise ValueError("Note body must not be blank.")
+    db = get_db()
+    with db.atomic():
+        note = _load_note(data.note_id)
+        _require_record(note["record_type"], note["record_id"], actor)
+        if note["author_id"] != actor["user_id"]:
+            raise PermissionError("Only the author can edit a note.")
+        db.sql(f'UPDATE "{TABLE}" SET body = ?, updated_at = ? WHERE name = ?', [body, now(), note["name"]])
+        notified = mentions.sync_note_mentions(note["record_type"], note["record_id"], note["name"], body, actor)
+    return {"note_id": note["name"], "notified_count": notified,
+            "view_url": view_url(note["record_type"], note["record_id"], note["name"])}
+
+
+def delete_record_note(args, user):
+    data, actor = DeleteNote.model_validate(args), mentions._actor(user)
+    db = get_db()
+    with db.atomic():
+        note = _load_note(data.note_id)
+        _require_record(note["record_type"], note["record_id"], actor)
+        if note["author_id"] != actor["user_id"] and actor["role"] != "admin":
+            raise PermissionError("Only the author or an admin can delete a note.")
+        db.sql('DELETE FROM "Mention Notification" WHERE doctype = ? AND note_id = ?',
+               [note["record_type"], note["name"]])
+        db.sql(f'DELETE FROM "{TABLE}" WHERE name = ?', [note["name"]])
+    return {"success": True, "note_id": note["name"]}
+
+
+def delete_record_notes_for(record_type, record_id):
+    """Drop a hard-deleted record's notes and their inbox entries."""
+    db = get_db()
+    ids = [row["name"] for row in db.sql(
+        f'SELECT name FROM "{TABLE}" WHERE record_type = ? AND record_id = ?', [record_type, record_id])]
+    for start in range(0, len(ids), 250):
+        chunk = ids[start:start + 250]
+        db.sql('DELETE FROM "Mention Notification" WHERE doctype = ? AND note_id IN ('
+               + ','.join('?' for _ in chunk) + ')', [record_type, *chunk])
+    db.sql(f'DELETE FROM "{TABLE}" WHERE record_type = ? AND record_id = ?', [record_type, record_id])
+
+
+_NOT_PRINTED = ("Internal notes are visible to signed-in colleagues only; they are never printed and "
+                "never change the record. Not the printed `remarks` (Notes / Terms) field.")
+
+
+def initialize_record_notes():
+    mentions.register_mention_source_fallback(_source, record_types)
+    for name, handler, schema, role, description in (
+        ("list_record_notes", list_record_notes, ListNotes, "viewer",
+         "List the internal team notes on one document or master record, newest first. record_type is the "
+         "document or master type slug (e.g. sales-invoice, customer) and record_id its name. "
+         + _NOT_PRINTED),
+        ("update_record_note", update_record_note, EditNote, "manager",
+         "Replace the text of an internal note you wrote (note_id from list_record_notes). @mentions are "
+         "re-read from the new text: added colleagues are notified, removed ones lose the notification."),
+        ("delete_record_note", delete_record_note, DeleteNote, "manager",
+         "Delete an internal note. Authors can delete their own notes; admins can delete any. Also removes "
+         "its mention notifications."),
+    ):
+        services.register_action(name, handler, description=description,
+                                 parameters=schema.model_json_schema(), minimum_role=role, pass_user=True)

api/routers/masters.py

@@ -748,7 +748,10 @@ def delete_master_record(master_type: str, name: str) -> dict:
             return {"ok": True, "status": "disabled", "reason": f"Referenced by {reference}"}
         raise HTTPException(status_code=409, detail=f"Cannot delete {doctype} {name}: referenced by {reference}")
 
-    db.delete(doctype, name=name)
+    from api.record_notes import delete_record_notes_for
+    with db.atomic():
+        delete_record_notes_for(master_type, name)
+        db.delete(doctype, name=name)
     return {"ok": True, "status": "deleted"}
 
 

api/routers/mcp.py

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

lambda_erp/database.py

@@ -3063,6 +3063,25 @@ def _m041_chat_turn_lease(db: "Database") -> None:
     db.ensure_column("Chat Session", "active_turn_until", "TEXT")
 
 
+def _m042_record_notes(db: "Database") -> None:
+    """Internal team notes on any document or master (see api.record_notes)."""
+    db.conn.execute(
+        """CREATE TABLE IF NOT EXISTS "Record Note" (
+            name TEXT PRIMARY KEY,
+            record_type TEXT NOT NULL,
+            record_id TEXT NOT NULL,
+            body TEXT NOT NULL,
+            author_id TEXT NOT NULL,
+            created_at TEXT NOT NULL,
+            updated_at TEXT NOT NULL
+        )"""
+    )
+    db.conn.execute(
+        'CREATE INDEX IF NOT EXISTS record_note_record ON "Record Note" (record_type, record_id, created_at)'
+    )
+    db.conn.commit()
+
+
 Database.MIGRATIONS = [
     (1, "chat_message_session_id", _m001_chat_message_session_id),
     (2, "chat_session_user_id", _m002_chat_session_user_id),
@@ -3105,6 +3124,7 @@ Database.MIGRATIONS = [
     (39, "connection_app_type", _m039_connection_app_type),
     (40, "naming_series", _m040_naming_series),
     (41, "chat_turn_lease", _m041_chat_turn_lease),
+    (42, "record_notes", _m042_record_notes),
 ]
 
 

{lambda_erp-1.3.0.dist-info → lambda_erp-1.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lambda-erp
-Version: 1.3.0
+Version: 1.3.2
 Summary: Core ERP logic - accounting, sales, purchasing, inventory
 Author: TORUS INVESTMENTS AG
 License-Expression: Apache-2.0
@@ -261,15 +261,17 @@ Open `http://localhost:5173`. Vite proxies `/api/*` to the backend.
 
 ```
 OPENAI_API_KEY=sk-...
+LAMBDA_ERP_CHAT_MODEL=gpt-6.1-sol    # optional chat override; default shown
 LAMBDA_ERP_REPORT_MODEL=gpt-6.1-sol  # optional specialist override; default shown
+LAMBDA_ERP_TITLE_MODEL=gpt-6-luna    # optional chat-title override; default shown
 LAMBDA_ERP_ADMIN_EMAIL=admin@example.com   # optional, seeds the admin at boot
 LAMBDA_ERP_ADMIN_PASSWORD=...              # optional, required with the line above
 LAMBDA_ERP_ADMIN_NAME=Administrator        # optional, display name for the seeded admin
 ```
 
-Chat and custom-report specification generation share `OPENAI_API_KEY`. Both
-the orchestrator and report specialist default to GPT-5.6 Terra; the specialist
-can be overridden with `LAMBDA_ERP_REPORT_MODEL`.
+Chat, chat titles and custom-report specification generation share
+`OPENAI_API_KEY`. The chat and the report specialist default to GPT-6.1 Sol,
+titles to GPT-6 Luna; see [docs/llm-pricing.md](docs/llm-pricing.md) for prices.
 
 **Seeded admin.** By default the first person to register becomes the admin. Set `LAMBDA_ERP_ADMIN_EMAIL` + `LAMBDA_ERP_ADMIN_PASSWORD` to instead provision that admin automatically at startup — useful when the database is recreated on every deploy, so a redeployed instance can't be claimed by whoever visits first. It's create-if-missing and idempotent (an existing account with that email is promoted to an enabled admin; its password is left untouched), and the password is only ever read from the environment.
 

{lambda_erp-1.3.0.dist-info → lambda_erp-1.3.2.dist-info}/RECORD

@@ -2,22 +2,24 @@ api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 api/attachments.py,sha256=v5WAGUafYqA4tHWkPHHnP5pYxsJx9wDf6Mn1fTyUmYc,20496
 api/auth.py,sha256=IcZnUBMv_6u4CrEPENUtsV2DdLQ2rgZGzgpbGXX7s4o,44073
 api/bootstrap.py,sha256=9r6Bz93Puhz06d8C5LsbYk2NUt2Gr6Nz85FJxOWriCc,21308
-api/chat.py,sha256=JaifG2AiT5OtBOGLC3nXuZ-hLhwKwpLJkLXnhj0eWKY,245353
+api/chat.py,sha256=4VPRhHwVxT91LwrP6VMFkK-If8ghe8U7EScOufuO0UI,246998
 api/chat_links.py,sha256=eHuGxuMvWh42-UC3i97GVxV04NemXGMQDUhfoKiLO-A,2344
 api/demo_limits.py,sha256=b5PSNWgPIRuIVsAcJZyGLCivUv4RorEzJlZXf5LNwh0,14191
 api/deps.py,sha256=HaFNz0q0NlX49kNMs1xMe0rrO6Slqpt8-TlPOATirT4,140
-api/erp_context.py,sha256=FTVou9bGO_9X7xPBqaf2H9QG7qmKJvWPcw4Kduc4qBc,4483
+api/erp_context.py,sha256=c_Jkik6iPtZr__fLU81rHtYCB9EcROhYjJu_f-v8xoo,5092
 api/errors.py,sha256=kEC6BUU4koPlyGoCDobAA8sHRoMqw50Xtc2105ZFKF4,5376
 api/list_values.py,sha256=mGe74gJ4fHPa5X2djJNTsRE8txa0hG40GAxMfTumU_w,963
-api/main.py,sha256=t4fj7kpXURkpU39O3Tv9SFc30Un7jtB75wmZtraZk1k,11345
+api/main.py,sha256=jBqyJGtswyf7MBBtdbDDKYvlR4oxF2hjbuD96XJmODg,11532
 api/mcp_oauth.py,sha256=MjmScAvihkvEXdmM3QJP0FLqqXq-pQ1zmWa67LiArDM,21392
-api/mentions.py,sha256=3A4hJ8mUD9IVisz21x6XtsHeR0tHqMyIbLPRn3mb9Ps,16712
+api/mentions.py,sha256=4XS8yEjVroIlxdfxCxiu7WIxtaekrG6Z7iqCs-6DqLY,18104
+api/menu_layout.py,sha256=0uqL2Co1SX7_XqVdtjovL70UWOS0qaJfwr_0PeM0CE4,9574
 api/oauth.py,sha256=w1XO__oQVQse0S3U03DYLN-_jUPOTliZ4Grr1Nhs4Fs,22450
 api/pdf.py,sha256=HnJzRYVx6D43ULvYCb2ehwqrGVvaqbzT1vsNg1Gxg7M,19228
 api/pdf_contract.py,sha256=cEUntXz951OaXTvGdhYnL58LbR_efowGGHhNEBP7y5Q,16118
 api/pdf_exports.py,sha256=bFdfJVInkCH3BV8e9PpBLF9sOX2OkcFnNO0emuVnrps,3199
 api/pdf_profiles.py,sha256=gqMRM-T6nzQnJ0DTxUf9MBFtpJws07MpNUQHHgI3Y7c,9206
-api/providers.py,sha256=ZwuDtukTpHh553wln-AEvRKQ5kE4296rj5_Kgh84O30,6525
+api/providers.py,sha256=3B4P4J6Ox-biA8lGsGWR4AaAkz8SI4TmF68rsv6kRNQ,5468
+api/record_notes.py,sha256=ohaQcWsCSxgRDha9wc8Lk7nOUS0p4uqolv_Or_EuEd4,10320
 api/remarks_md.py,sha256=8MZ5oO3TNLDbjdMF2PjdFW13LdAffogOxT2nT0eYrVY,3754
 api/services.py,sha256=F-7O9faPulVFV11RNLquxmPli1dEezUMztsip8h5-E4,61682
 api/time_filters.py,sha256=nAlyyZD7i3UOMq8kJdLGo2-jKYl84IZ8ad-oYBTjg1c,4882
@@ -33,8 +35,8 @@ api/routers/bank_reconciliation.py,sha256=USv3-WEsgmXvpXALkwVvE9E536hYQ8Wdlr3c1z
 api/routers/bank_statements.py,sha256=QCUW0Fu3nBnPuM9zky3ne_7FEkKoCEitibheBP0EJ1I,4678
 api/routers/chat_api.py,sha256=AdnKm5XtrdMnaMhhwYm_Ck8bvh8RnExtP9K0z2o47eo,8050
 api/routers/documents.py,sha256=Ww3bL-BN0uIYPRg6UO-Gq3YjtC-nX2DUYNKOqkZOn0Q,11736
-api/routers/masters.py,sha256=oAPwv_zaByl_R-krloUch5NkA0BT0tmvyPvUf0VUqiI,38697
-api/routers/mcp.py,sha256=X91Bigk3RDmshQ49tQeAFqp3HCKO6xZGheGzweHqF1E,11168
+api/routers/masters.py,sha256=C18L7i9r7jiZuDXjC6uJLOph2KqP1iQVqV2Q-wzfO0E,38831
+api/routers/mcp.py,sha256=hiHKEIJH2ec7ex_SOLccRsbSzYComuy-Fh696D7cuSY,11208
 api/routers/proposals.py,sha256=KtIITJ-GHa3GSMzSDE205nnFNvMwt0KUVAxU1M8-uyU,4520
 api/routers/reports.py,sha256=6GLlUJQfstS2p_7F5Il_XYwmZIifSHqaVjFdxTQM1OU,29738
 api/routers/setup.py,sha256=4qVLO0TExVCTGORDI4dNMUyxauvhLRbUS1VydnSubNw,16206
@@ -44,7 +46,7 @@ api/templates/document.html,sha256=6B1fhdrgq2WaEHmpcGR_LkbZ7hNU6wggLt-a9ojO5Pw,9
 api/templates/proposal.html,sha256=sx2qRsfl0kp8VeqgYrU_4MVs7rokWavfuDH0fU71ppU,5169
 api/templates/record.html,sha256=aPCWz4uB1ZBEf8KTFHeChMAbWgObEvx3VuhV1aC4x7A,34
 lambda_erp/__init__.py,sha256=ahOPqWyRzyy70oKnhA95TZnOWOCSaOZIjGSQ-qLojro,1088
-lambda_erp/database.py,sha256=v3JcOZrg8hhTLxze2mmNLoSOMHKtLalLrXSut64JMFs,136250
+lambda_erp/database.py,sha256=WGgbWy5palYdohL8LPN4OJcCNdwskj7pKHlUJMuIz8I,136933
 lambda_erp/exceptions.py,sha256=ml-iuIefPDTNKqsOJCbdipstaAEKK5re9djIG-UFDxw,516
 lambda_erp/hooks.py,sha256=koA8a_kNGVIknIhDWjqaq_LI0OYS9Tjt3JT08O5XJcc,1369
 lambda_erp/master_integrity.py,sha256=xGonkRsJZn92CrBcj8oFBnNnzIncIR1C3fuTOM3UrOw,1191
@@ -104,7 +106,7 @@ lambda_erp/stock/delivery_note.py,sha256=Z3s57gVA7oSIpLauSd3DIWu-1y3tmvEE-zsopTv
 lambda_erp/stock/purchase_receipt.py,sha256=E42oHRO4MAowQniLumbOjYY38vVfHbHchkxCWyM3KDg,11463
 lambda_erp/stock/stock_entry.py,sha256=Itbt9a1u8b1s1OItKwVYMJDLjbNze2-UI2raIemCuts,12493
 lambda_erp/stock/stock_ledger.py,sha256=AFybuScWwfaTvsqOSAon3gwsjIza7skXvrvyQowL7b0,13265
-lambda_erp-1.3.0.dist-info/METADATA,sha256=ifoUfHeiHp1YhAATK6TabtikjcCPGS-r9QRLEwSglu0,31852
-lambda_erp-1.3.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
-lambda_erp-1.3.0.dist-info/licenses/LICENSE,sha256=8H08P22jiM0mJ97SgnpYchU0NeaPunGxZc3IqEaLgtc,11394
-lambda_erp-1.3.0.dist-info/RECORD,,
+lambda_erp-1.3.2.dist-info/METADATA,sha256=kg58R1l0PQtbb_xN_n9ccGliyrW1YHjGKIDK0pXQOJI,32030
+lambda_erp-1.3.2.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+lambda_erp-1.3.2.dist-info/licenses/LICENSE,sha256=8H08P22jiM0mJ97SgnpYchU0NeaPunGxZc3IqEaLgtc,11394
+lambda_erp-1.3.2.dist-info/RECORD,,