lambda-erp 1.3.0__tar.gz → 1.3.2__tar.gz

{lambda_erp-1.3.0 → lambda_erp-1.3.2}/PKG-INFO

@@ -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 → lambda_erp-1.3.2}/README.md

@@ -233,15 +233,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 → lambda_erp-1.3.2}/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,

{lambda_erp-1.3.0 → lambda_erp-1.3.2}/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.

{lambda_erp-1.3.0 → lambda_erp-1.3.2}/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()

{lambda_erp-1.3.0 → lambda_erp-1.3.2}/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",

lambda_erp-1.3.2/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."))

{lambda_erp-1.3.0 → lambda_erp-1.3.2}/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")