lambda-erp 1.3.1__tar.gz → 1.3.3__tar.gz

{lambda_erp-1.3.1 → lambda_erp-1.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lambda-erp
-Version: 1.3.1
+Version: 1.3.3
 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.1 → lambda_erp-1.3.3}/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.1 → lambda_erp-1.3.3}/api/chat.py

@@ -3283,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,
@@ -3299,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(
@@ -3317,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(
@@ -3334,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)
 
 
 # ---------------------------------------------------------------------------
@@ -3356,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
 #
@@ -3373,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.
@@ -3535,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),
@@ -3550,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,
@@ -3715,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})
@@ -3902,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.1 → lambda_erp-1.3.3}/api/erp_context.py

@@ -29,6 +29,8 @@ field. Internal team remarks ("customer disputes line 2", "@Anna please check")
 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.1 → lambda_erp-1.3.3}/api/main.py

@@ -61,6 +61,8 @@ async def lifespan(app: FastAPI):
         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.3/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.1 → lambda_erp-1.3.3}/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")

{lambda_erp-1.3.1 → lambda_erp-1.3.3}/api/routers/mcp.py

@@ -50,7 +50,7 @@ _EXCLUDE = {
 }
 
 _READ_ONLY = {
-    'search_mention_users', 'list_my_mentions', 'list_record_notes',
+    '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-1.3.1 → lambda_erp-1.3.3}/pyproject.toml

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