lambda-erp 0.8.30__tar.gz → 0.8.31__tar.gz

{lambda_erp-0.8.30 → lambda_erp-0.8.31}/PKG-INFO

@@ -1,12 +1,11 @@
 Metadata-Version: 2.5
 Name: lambda-erp
-Version: 0.8.30
+Version: 0.8.31
 Summary: Core ERP logic - accounting, sales, purchasing, inventory
 Author: TORUS INVESTMENTS AG
 License-Expression: Apache-2.0
 License-File: LICENSE
 Requires-Python: >=3.10
-Requires-Dist: anthropic>=0.40
 Requires-Dist: bcrypt>=5
 Requires-Dist: defusedxml>=0.7
 Requires-Dist: fastapi>=0.115
@@ -96,8 +95,8 @@ Each of those is hours of skilled work today. With a capable LLM in the loop, th
                            │  - GPT-5.6 drives the reasoning loop     │
                            │  - Tool-use: document CRUD, search,      │
                            │    reports, aggregations, analytics      │
-                           │  - Delegates report specs to Anthropic   │
-                           │    report-specialist model               │
+                           │  - Delegates report specs to a separate │
+                           │    GPT-5.6 Terra specialist call         │
                            └──────────────────┬───────────────────────┘
                                               │
                                               ▼
@@ -133,7 +132,7 @@ Each of those is hours of skilled work today. With a capable LLM in the loop, th
 | Frontend | React + Vite + TypeScript + Tailwind + Recharts |
 | Chat transport | WebSocket |
 | LLM orchestrator | OpenAI (configurable) |
-| Code specialist | Anthropic (configurable) |
+| Report specialist | OpenAI GPT-5.6 Terra (configurable) |
 | Auth | JWT httponly cookie, three roles + demo |
 
 ---
@@ -217,7 +216,7 @@ You need Docker and Compose v2. The canonical installs:
 Then, from the repo root:
 
 ```bash
-cp .env.example .env          # add your OPENAI_API_KEY and ANTHROPIC_API_KEY (for custom analytics)
+cp .env.example .env          # add your OPENAI_API_KEY
 docker compose up --build
 ```
 
@@ -262,14 +261,15 @@ Open `http://localhost:5173`. Vite proxies `/api/*` to the backend.
 
 ```
 OPENAI_API_KEY=sk-...
-ANTHROPIC_API_KEY=sk-ant-...    # optional, used for the report-specialist model
-ANTHROPIC_CODE_MODEL=claude-opus-4-7   # optional, default shown
+LAMBDA_ERP_REPORT_MODEL=gpt-5.6-terra  # optional specialist 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 needs `OPENAI_API_KEY`. Custom-report specification generation uses `ANTHROPIC_API_KEY` when set; otherwise the chat will tell you it can't generate reports.
+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`.
 
 **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.
 
@@ -487,4 +487,4 @@ Release notes live in [CHANGELOG.md](./CHANGELOG.md). Releases are tagged
 
 ## Trademarks and affiliations
 
-Lambda ERP and [lambda.dev](https://lambda.dev/) are product and trade names of **TORUS INVESTMENTS AG**. It is not affiliated with, endorsed by, or sponsored by OpenAI, Anthropic, SAP, Oracle, Microsoft, or any other company named in this repository. SAP, Business One, S/4HANA, Oracle, NetSuite, Microsoft, Dynamics, OpenAI, GPT, Anthropic, and Claude are trademarks of their respective owners and are referenced here only for descriptive and comparative purposes (nominative fair use). We interoperate with OpenAI and Anthropic APIs as a customer like anyone else; you supply your own API keys.
+Lambda ERP and [lambda.dev](https://lambda.dev/) are product and trade names of **TORUS INVESTMENTS AG**. It is not affiliated with, endorsed by, or sponsored by OpenAI, Anthropic, SAP, Oracle, Microsoft, or any other company named in this repository. SAP, Business One, S/4HANA, Oracle, NetSuite, Microsoft, Dynamics, OpenAI, GPT, Anthropic, and Claude are trademarks of their respective owners and are referenced here only for descriptive and comparative purposes (nominative fair use). The ERP uses the OpenAI API as a customer; you supply your own API key.

{lambda_erp-0.8.30 → lambda_erp-0.8.31}/README.md

@@ -67,8 +67,8 @@ Each of those is hours of skilled work today. With a capable LLM in the loop, th
                            │  - GPT-5.6 drives the reasoning loop     │
                            │  - Tool-use: document CRUD, search,      │
                            │    reports, aggregations, analytics      │
-                           │  - Delegates report specs to Anthropic   │
-                           │    report-specialist model               │
+                           │  - Delegates report specs to a separate │
+                           │    GPT-5.6 Terra specialist call         │
                            └──────────────────┬───────────────────────┘
                                               │
                                               ▼
@@ -104,7 +104,7 @@ Each of those is hours of skilled work today. With a capable LLM in the loop, th
 | Frontend | React + Vite + TypeScript + Tailwind + Recharts |
 | Chat transport | WebSocket |
 | LLM orchestrator | OpenAI (configurable) |
-| Code specialist | Anthropic (configurable) |
+| Report specialist | OpenAI GPT-5.6 Terra (configurable) |
 | Auth | JWT httponly cookie, three roles + demo |
 
 ---
@@ -188,7 +188,7 @@ You need Docker and Compose v2. The canonical installs:
 Then, from the repo root:
 
 ```bash
-cp .env.example .env          # add your OPENAI_API_KEY and ANTHROPIC_API_KEY (for custom analytics)
+cp .env.example .env          # add your OPENAI_API_KEY
 docker compose up --build
 ```
 
@@ -233,14 +233,15 @@ Open `http://localhost:5173`. Vite proxies `/api/*` to the backend.
 
 ```
 OPENAI_API_KEY=sk-...
-ANTHROPIC_API_KEY=sk-ant-...    # optional, used for the report-specialist model
-ANTHROPIC_CODE_MODEL=claude-opus-4-7   # optional, default shown
+LAMBDA_ERP_REPORT_MODEL=gpt-5.6-terra  # optional specialist 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 needs `OPENAI_API_KEY`. Custom-report specification generation uses `ANTHROPIC_API_KEY` when set; otherwise the chat will tell you it can't generate reports.
+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`.
 
 **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.
 
@@ -458,4 +459,4 @@ Release notes live in [CHANGELOG.md](./CHANGELOG.md). Releases are tagged
 
 ## Trademarks and affiliations
 
-Lambda ERP and [lambda.dev](https://lambda.dev/) are product and trade names of **TORUS INVESTMENTS AG**. It is not affiliated with, endorsed by, or sponsored by OpenAI, Anthropic, SAP, Oracle, Microsoft, or any other company named in this repository. SAP, Business One, S/4HANA, Oracle, NetSuite, Microsoft, Dynamics, OpenAI, GPT, Anthropic, and Claude are trademarks of their respective owners and are referenced here only for descriptive and comparative purposes (nominative fair use). We interoperate with OpenAI and Anthropic APIs as a customer like anyone else; you supply your own API keys.
+Lambda ERP and [lambda.dev](https://lambda.dev/) are product and trade names of **TORUS INVESTMENTS AG**. It is not affiliated with, endorsed by, or sponsored by OpenAI, Anthropic, SAP, Oracle, Microsoft, or any other company named in this repository. SAP, Business One, S/4HANA, Oracle, NetSuite, Microsoft, Dynamics, OpenAI, GPT, Anthropic, and Claude are trademarks of their respective owners and are referenced here only for descriptive and comparative purposes (nominative fair use). The ERP uses the OpenAI API as a customer; you supply your own API key.

{lambda_erp-0.8.30 → lambda_erp-0.8.31}/api/chat.py

@@ -35,7 +35,7 @@ from api.demo_limits import (
     is_demo_role,
     limiter as demo_limiter,
 )
-from api.providers import cost_of_anthropic_call, cost_of_openai_call, cost_of_transcription
+from api.providers import cost_of_openai_call, cost_of_transcription
 from api.routers.masters import create_master_record, update_master_record, delete_master_record, MASTER_IDENTITY_ALIAS
 from lambda_erp.database import get_db
 from lambda_erp.utils import flt, now, nowdate
@@ -985,7 +985,11 @@ TOOLS = [
                 "- `ap_open_items` — outstanding purchase invoice amounts\n"
                 "- `stock_balances` — current stock on hand by item × warehouse\n"
                 "- `stock_movements` — stock ledger entries (movement history); "
-                "`abs_qty` = units moved (use `sum`), `actual_qty` = net flow\n\n"
+                "`abs_qty` = units moved (use `sum`), `actual_qty` = net flow\n"
+                "- `gl_entries` — posted ledger rows; use `income_amount` and "
+                "`expense_amount` for P&L analysis\n"
+                "- `bank_transactions` — imported cash movements; use `deposit` "
+                "and `withdrawal` for bank inflow/outflow analysis\n\n"
                 "Shape your call like: `{dataset, group_by, measures, filters?, "
                 "order_by?, limit?}`. `group_by` is a list of field names. "
                 "`measures` is an object of `{alias: [op, field]}` where `op` "
@@ -1025,6 +1029,9 @@ TOOLS = [
                             "ar_open_items",
                             "ap_open_items",
                             "stock_balances",
+                            "stock_movements",
+                            "gl_entries",
+                            "bank_transactions",
                         ],
                     },
                     "group_by": {
@@ -1067,10 +1074,11 @@ TOOLS = [
                 "Available semantic datasets include: sales_invoices, "
                 "sales_invoice_lines, purchase_invoices, purchase_invoice_lines, "
                 "payments, ar_open_items, ap_open_items, stock_balances, "
-                "stock_movements.\n\n"
+                "stock_movements, gl_entries, bank_transactions.\n\n"
                 "The report language supports grouped dimensions, month/quarter/year "
                 "date buckets, sum/count/avg/min/max measures and KPIs, sorting, "
-                "limits, tables, and bar/line/pie charts. Request only fields "
+                "limits, tables, and single- or multi-series bar/line charts plus "
+                "pie charts. Request only fields "
                 "exposed by dataset metadata. Always include the returned URL."
             ),
             "parameters": {
@@ -1105,6 +1113,9 @@ TOOLS = [
                                         "ar_open_items",
                                         "ap_open_items",
                                         "stock_balances",
+                                        "stock_movements",
+                                        "gl_entries",
+                                        "bank_transactions",
                                     ],
                                 },
                                 "fields": {"type": "array", "items": {"type": "string"}},
@@ -1153,7 +1164,7 @@ TOOLS = [
                 "sales_invoice_lines; use amount instead\", or \"add a line "
                 "chart showing monthly trend\"). The backend will hand both "
                 "the current draft and your feedback to the report specialist "
-                "model (Anthropic) to rewrite the declarative spec.\n\n"
+                "model to rewrite the declarative spec.\n\n"
                 "Only pass `data_requests` or `report` directly if you already "
                 "have a complete version-1 declarative definition."
             ),
@@ -1188,6 +1199,9 @@ TOOLS = [
                                         "ar_open_items",
                                         "ap_open_items",
                                         "stock_balances",
+                                        "stock_movements",
+                                        "gl_entries",
+                                        "bank_transactions",
                                     ],
                                 },
                                 "fields": {"type": "array", "items": {"type": "string"}},
@@ -2100,17 +2114,18 @@ def _handle_query_dataset(args):
 def _handle_create_custom_analytics_report(args, user_info: dict | None = None, session_id: str | None = None, client_ip: str | None = None):
     from api.routers.analytics import create_report_draft_record
 
-    # GPT may pass intent + (optionally) a sketch. If the code spec is
-    # missing, delegate to the Anthropic report-spec specialist.
+    # GPT may pass intent + (optionally) a sketch. If the declarative spec is
+    # missing, delegate to the report-spec specialist.
     if not args.get("report") or not args.get("data_requests"):
         intent = args.get("intent") or args.get("description") or args.get("title")
         if not intent:
             return {"error": "Provide either `intent` or a complete spec (data_requests + report)."}
         try:
-            spec = _generate_report_spec_via_anthropic(
+            spec = _generate_report_spec_via_openai(
                 intent,
                 client_ip=client_ip,
                 user_role=(user_info or {}).get("role"),
+                session_id=session_id,
             )
         except Exception as e:
             return {"error": f"Report specialist failed: {e}"}
@@ -2138,7 +2153,12 @@ def _handle_get_custom_analytics_report(args, user_info: dict | None = None):
     return row
 
 
-def _handle_update_custom_analytics_report(args, user_info: dict | None = None, client_ip: str | None = None):
+def _handle_update_custom_analytics_report(
+    args,
+    user_info: dict | None = None,
+    client_ip: str | None = None,
+    session_id: str | None = None,
+):
     from api.routers.analytics import get_report_draft_record, update_report_draft_record
 
     report_id = args.get("report_id")
@@ -2154,12 +2174,13 @@ def _handle_update_custom_analytics_report(args, user_info: dict | None = None,
         if not existing:
             return {"error": f"Report draft '{report_id}' not found"}
         try:
-            spec = _generate_report_spec_via_anthropic(
+            spec = _generate_report_spec_via_openai(
                 intent=existing.get("description") or existing.get("title") or "",
                 existing_spec=existing,
                 feedback=feedback,
                 client_ip=client_ip,
                 user_role=(user_info or {}).get("role"),
+                session_id=session_id,
             )
         except Exception as e:
             return {"error": f"Report specialist failed: {e}"}
@@ -2441,11 +2462,11 @@ Only state that something was done — created, changed, enabled/disabled, booke
 
 **Path 2: aggregated facts → `query_dataset`.** For "who is our top customer by revenue", "total sales this month", "outstanding AR by customer", "average invoice size", "count of POs per supplier" — anything that requires summing, counting, ranking, or grouping across many rows — call `query_dataset`. It runs a deterministic SQL aggregation server-side and returns the actual aggregated numbers you can cite in chat. NEVER try to compute a top-N or sum by eyeballing a `list_documents` sample — it defaults to 20 rows and will give a wrong answer on any meaningful dataset.
 
-**Path 3: charts / complex reports → `create_custom_analytics_report`.** Only call this when the user **explicitly asks for** a chart, graph, visualization, dashboard, trend, pivot, breakdown, or saved report — or when the analysis genuinely combines multiple datasets (e.g. purchases vs sales joined by month). Do **not** invoke it for a factual question `query_dataset` could answer in one call.
+**Path 3: charts / complex reports → `create_custom_analytics_report`.** Only call this when the user **explicitly asks for** a chart, graph, visualization, dashboard, trend, pivot, breakdown, or saved report — or when the analysis genuinely needs a reusable report. Do **not** invoke it for a factual question `query_dataset` could answer in one call.
 
-Important constraint on the analytics report tool: the JS transform runs **client-side only** — you never see its output. So you cannot "open the report to read the numbers." If the user asks you to summarise or interpret the result after the fact, tell them you don't have access to the executed data and either (a) re-answer via `query_dataset`, or (b) ask them what they see on the page. Never claim you'll look at the report yourself.
+Important constraint on the analytics report tool: its bounded declarative specification runs **client-side only** — you never see its output. So you cannot "open the report to read the numbers." If the user asks you to summarise or interpret the result after the fact, re-answer via `query_dataset` or a standard financial report; do not infer data coverage from an empty invoice dataset when GL or bank data may exist.
 
-When you do build a custom report, pass a plain-language `intent` to `create_custom_analytics_report` (a specialist model writes the code for you) and reply with the returned `/reports/analytics?report_id=…` link as a markdown link. The draft appears under **Custom Analytics** in the sidebar so the user can reopen or share it.
+When you do build a custom report, pass a plain-language `intent` to `create_custom_analytics_report` (a specialist model writes the bounded declarative spec for you) and reply with the returned `/reports/analytics?report_id=…` link as a markdown link. The draft appears under **Custom Analytics** in the sidebar so the user can reopen or share it.
 
 {markdown_links_section}
 
@@ -2675,9 +2696,9 @@ Master records CAN be deleted — use the `delete_master` tool (ADMIN role only)
 
   When you do call `create_custom_analytics_report`, pass `title` and
   `intent` — a clear plain-language description (filters, groupings, sort
-  orders, chart type). A specialist model writes the JS transform for you.
+  orders, chart type). A specialist model writes the declarative report spec for you.
   Relay the returned `/reports/analytics?report_id=…` link as a markdown
-  link. You will NOT see the executed data — the transform runs in the
+  link. You will NOT see the rendered data — the declarative spec runs in the
   user's browser. So do not promise to "read" or "interpret" the report
   yourself; if the user wants a narrative answer, use `list_documents`
   instead.
@@ -2762,33 +2783,20 @@ Users can attach PDFs and images (receipts, bills, contracts, screenshots) to th
 
 
 # ---------------------------------------------------------------------------
-# Anthropic report-spec specialist
+# OpenAI report-spec specialist
 #
-# GPT-5.4 stays as the planner/orchestrator. When it decides a report needs
+# GPT-5.6 Terra stays as the planner/orchestrator. When it decides a report needs
 # a custom analytics view it calls the create/update custom analytics tools.
-# Those handlers delegate the bounded declarative spec to Anthropic. The
-# `ANTHROPIC_CODE_MODEL` environment name is retained for deployment backwards
-# compatibility even though executable report code is no longer accepted.
+# Those handlers make a separate, narrowly prompted Terra call for the bounded
+# declarative report spec. Both roles use the existing OPENAI_API_KEY.
 # ---------------------------------------------------------------------------
 
 
-def _code_model() -> str:
-    return (
-        os.environ.get("ANTHROPIC_CODE_MODEL")
-        or os.environ.get("ANTHROPIC_REPORT_REPAIR_MODEL")  # legacy fallback
-        or "claude-sonnet-4-20250514"
-    )
+REPORT_SPECIALIST_MODEL = "gpt-5.6-terra"
 
 
-def _anthropic_available() -> tuple[bool, str]:
-    api_key = os.environ.get("ANTHROPIC_API_KEY", "")
-    if not api_key or api_key == "your-anthropic-key-here":
-        return False, "ANTHROPIC_API_KEY is not configured"
-    try:
-        import anthropic  # noqa: F401  # type: ignore
-    except Exception as e:
-        return False, f"Anthropic SDK not available: {e}"
-    return True, ""
+def _report_specialist_model() -> str:
+    return os.environ.get("LAMBDA_ERP_REPORT_MODEL") or REPORT_SPECIALIST_MODEL
 
 
 _REPORT_CODE_SYSTEM_PROMPT = """You are a report-spec specialist for Lambda ERP.
@@ -2824,6 +2832,17 @@ all except count require a field. KPI operations use the same set. Formats are
 currency, percent, number, date, or string as appropriate. Charts are bar, line,
 or pie and must reference a table id via data_table.
 
+For a chart with multiple bars or lines per x value, omit `y` and use
+`series`: [{"key":"income","label":"Income"},{"key":"expenses","label":"Expenses"}].
+Every series key must be an output column of the chart's data_table. Pie charts
+allow only one series. A single-series chart should keep using `y`.
+
+Use `gl_entries` with `income_amount` and `expense_amount` for accounting
+income/expense or profit-and-loss analysis. Use `bank_transactions` with
+`deposit` and `withdrawal` only when the user asks for cash/bank inflows and
+outflows. Do not infer that there is no financial activity merely because the
+sales_invoices or purchase_invoices datasets are empty.
+
 Filters are objects keyed by an exposed filter field: equality values, arrays
 for IN, or {"from":...,"to":...} for ranges. Never use SQL or operator strings.
 Use only dataset fields provided in the user message. Identifier fields (name,
@@ -2856,25 +2875,24 @@ def _extract_json_object(text: str) -> dict:
     start = text.find("{")
     end = text.rfind("}")
     if start == -1 or end == -1 or end <= start:
-        raise ValueError("Code specialist did not return a JSON object.")
+        raise ValueError("Report specialist did not return a JSON object.")
     candidate = text[start : end + 1]
     return json.loads(candidate)
 
 
-def _generate_report_spec_via_anthropic(
+def _generate_report_spec_via_openai(
     intent: str,
     existing_spec: dict | None = None,
     feedback: str | None = None,
     client_ip: str | None = None,
     user_role: str | None = None,
+    session_id: str | None = None,
 ) -> dict:
-    ok, reason = _anthropic_available()
-    if not ok:
-        raise RuntimeError(reason)
-    import anthropic  # type: ignore
+    api_key = os.environ.get("OPENAI_API_KEY", "")
+    if not api_key or api_key == "sk-your-key-here":
+        raise RuntimeError("OPENAI_API_KEY is not configured")
 
-    model = _code_model()
-    api_key = os.environ["ANTHROPIC_API_KEY"]
+    model = _report_specialist_model()
 
     user_parts: list[str] = []
     user_parts.append(f"## Today's date\n{date.today().isoformat()}")
@@ -2903,10 +2921,13 @@ def _generate_report_spec_via_anthropic(
     user_msg = "\n\n".join(user_parts)
 
     print(
-        f"[chat_llm] provider=anthropic role=code_specialist model={model}",
+        f"[chat_llm] provider=openai role=report_specialist model={model}",
         flush=True,
     )
-    client = anthropic.Anthropic(api_key=api_key, timeout=120.0)
+    client = OpenAI(
+        api_key=api_key,
+        timeout=httpx.Timeout(120.0, connect=10.0),
+    )
     reservation_id = None
     if is_demo_role(user_role):
         _blocked, reservation_id = demo_limiter.reserve(
@@ -2923,11 +2944,12 @@ def _generate_report_spec_via_anthropic(
     # reservation for the process lifetime (or until TTL sweep).
     settled = False
     try:
-        response = client.messages.create(
+        response = client.responses.create(
             model=model,
-            system=_REPORT_CODE_SYSTEM_PROMPT,
-            messages=[{"role": "user", "content": user_msg}],
-            max_tokens=4096,
+            instructions=_REPORT_CODE_SYSTEM_PROMPT,
+            input=user_msg,
+            max_output_tokens=4096,
+            reasoning={"effort": "low"},
         )
         # Log every call for the admin dashboard. Only public_manager rows
         # count against the demo cap — other roles are logged for
@@ -2935,22 +2957,28 @@ def _generate_report_spec_via_anthropic(
         usage = getattr(response, "usage", None)
         demo_limiter.settle(
             reservation_id,
-            actual_cost_usd=cost_of_anthropic_call(model, usage),
+            actual_cost_usd=cost_of_openai_call(model, usage),
             ip=client_ip or "unknown",
             role=user_role,
-            provider="anthropic",
+            provider="openai",
             model=model,
             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
     finally:
         if not settled:
             demo_limiter.release(reservation_id)
 
-    text = "".join(
-        block.text for block in response.content if getattr(block, "type", "") == "text"
-    )
+    text = getattr(response, "output_text", "") or ""
+    if not text:
+        text = "".join(
+            getattr(block, "text", "") or ""
+            for item in (getattr(response, "output", None) or [])
+            for block in (getattr(item, "content", None) or [])
+            if getattr(block, "type", "") in ("output_text", "text")
+        )
     spec = _extract_json_object(text)
     if not spec.get("report") or not spec.get("data_requests"):
         raise RuntimeError("Report specialist returned an incomplete spec.")
@@ -3251,10 +3279,10 @@ async def run_thinking_loop(
 ):
     """Run the agentic reasoning loop.
 
-    The orchestrator is always OpenAI (gpt-5.6-terra). When GPT decides to call
+    The orchestrator and report specialist both use OpenAI gpt-5.6-terra. When GPT decides to call
     `create_custom_analytics_report` or `update_custom_analytics_report`
     with an intent/feedback hint, the tool handler itself delegates the
-    declarative-spec step to Anthropic (ANTHROPIC_CODE_MODEL). We emit an
+    declarative-spec step to a separate narrowly prompted Terra call. We emit an
     `llm_provider` event around that delegation so the UI can surface it.
     """
     openai_api_key = os.environ.get("OPENAI_API_KEY", "")
@@ -3337,7 +3365,9 @@ async def run_thinking_loop(
             lambda args: _handle_get_custom_analytics_report(args, principal_ref[0])
         )
         tool_handlers["update_custom_analytics_report"] = (
-            lambda args: _handle_update_custom_analytics_report(args, principal_ref[0], client_ip=client_ip)
+            lambda args: _handle_update_custom_analytics_report(
+                args, principal_ref[0], client_ip=client_ip, session_id=session_id
+            )
         )
 
         # Demo sessions get a per-turn cap on attachment retrieval: each
@@ -3458,20 +3488,20 @@ async def run_thinking_loop(
             principal_ref[0] = refresh_auth_principal(principal_ref[0])
             live_role = principal_ref[0].get("role") if principal_ref[0] else None
 
-            # If GPT is delegating report-spec generation to the Anthropic specialist,
+            # If the orchestrator is delegating report-spec generation to Terra,
             # surface the handoff in the UI.
-            will_delegate_to_code_specialist = (
+            will_delegate_to_report_specialist = (
                 tool_allowed(fn_name, live_role)
                 and fn_name in ("create_custom_analytics_report", "update_custom_analytics_report")
                 and not fn_args.get("report")
                 and not fn_args.get("data_requests")
             )
-            if will_delegate_to_code_specialist:
+            if will_delegate_to_report_specialist:
                 await on_event({
                     "type": "llm_provider",
-                    "provider": "anthropic",
-                    "model": _code_model(),
-                    "role": "code_specialist",
+                    "provider": "openai",
+                    "model": _report_specialist_model(),
+                    "role": "report_specialist",
                 })
 
             handler = tool_handlers.get(fn_name)

{lambda_erp-0.8.30 → lambda_erp-0.8.31}/api/demo_limits.py

@@ -37,7 +37,7 @@ _WINDOW_SECONDS = 3600  # 1 hour
 
 # Upper bound on how long a reservation may hold budget before it's
 # considered stale and ignored. Must exceed the longest provider call
-# timeout (OpenAI/Anthropic clients use 120s) plus a fudge for the
+# timeout (OpenAI clients use 120s) plus a fudge for the
 # event-loop latency between the SDK call returning and settle() firing.
 # Defence-in-depth against cancellation leaks that slip past try/finally.
 _RESERVATION_TTL_SECONDS = 180

{lambda_erp-0.8.30 → lambda_erp-0.8.31}/api/providers.py

@@ -4,8 +4,9 @@ Mirrors the shape of `lambda-web/backend/providers.py`. Only the models
 this app actually calls are listed — refresh this dict when model
 choices change. Prices are USD per 1M tokens.
 
-Consumers import `cost_of_openai_call` / `cost_of_anthropic_call` to
-turn an SDK `response.usage` object into a USD amount.
+Consumers import `cost_of_openai_call` to turn an SDK `response.usage` object
+into a USD amount. Both Chat Completions and Responses usage shapes are
+accepted because the orchestrator and report specialist use different calls.
 """
 
 from __future__ import annotations
@@ -44,14 +45,6 @@ OPENAI_PRICING: dict[str, dict[str, Any]] = {
     "gpt-4o-mini":  {"input": 0.15, "cached_input": 0.075, "output": 0.60},
 }
 
-ANTHROPIC_PRICING: dict[str, dict[str, Any]] = {
-    "claude-opus-4-7":   {"input": 5.00, "output": 25.00, "cache_write": 6.25, "cache_read": 0.50},
-    "claude-opus-4-6":   {"input": 5.00, "output": 25.00, "cache_write": 6.25, "cache_read": 0.50},
-    "claude-sonnet-4-6": {"input": 3.00, "output": 15.00, "cache_write": 3.75, "cache_read": 0.30},
-    "claude-sonnet-4-5": {"input": 3.00, "output": 15.00, "cache_write": 3.75, "cache_read": 0.30},
-    "claude-haiku-4-5":  {"input": 1.00, "output": 5.00,  "cache_write": 1.25, "cache_read": 0.10},
-}
-
 # Speech-to-text, priced per minute of audio (not per token).
 TRANSCRIBE_PRICING: dict[str, dict[str, float]] = {
     "gpt-4o-transcribe":      {"per_minute": 0.006},
@@ -78,27 +71,34 @@ def get_openai_rates(model: str, input_tokens: int = 0) -> dict[str, float]:
     return entry
 
 
-def get_anthropic_rates(model: str) -> dict[str, float]:
-    return ANTHROPIC_PRICING.get(model) or ANTHROPIC_PRICING["claude-opus-4-7"]
-
-
 # ---------------------------------------------------------------------------
 # Cost calculators. `usage` is the SDK's raw usage object; we accept None
 # and degrade to 0 so callers don't need to pre-check.
 # ---------------------------------------------------------------------------
 
 def cost_of_openai_call(model: str, usage: Optional[Any]) -> float:
-    """USD cost of one OpenAI chat.completions call from `response.usage`.
+    """USD cost of one OpenAI Chat Completions or Responses API call.
 
-    Understands the `prompt_tokens_details.cached_tokens` breakdown so cache
-    hits are billed at the discounted rate."""
+    Understands either endpoint's cached-token breakdown so cache hits are
+    billed at the discounted rate."""
     if usage is None:
         return 0.0
-    prompt_tokens = int(getattr(usage, "prompt_tokens", 0) or 0)
-    completion_tokens = int(getattr(usage, "completion_tokens", 0) or 0)
+    prompt_tokens = int(
+        getattr(usage, "prompt_tokens", 0)
+        or getattr(usage, "input_tokens", 0)
+        or 0
+    )
+    completion_tokens = int(
+        getattr(usage, "completion_tokens", 0)
+        or getattr(usage, "output_tokens", 0)
+        or 0
+    )
 
     cached = 0
-    details = getattr(usage, "prompt_tokens_details", None)
+    details = (
+        getattr(usage, "prompt_tokens_details", None)
+        or getattr(usage, "input_tokens_details", None)
+    )
     if details is not None:
         cached = int(getattr(details, "cached_tokens", 0) or 0)
 
@@ -111,27 +111,6 @@ def cost_of_openai_call(model: str, usage: Optional[Any]) -> float:
         + completion_tokens * rates["output"]
     )
     return total / 1_000_000
-
-
-def cost_of_anthropic_call(model: str, usage: Optional[Any]) -> float:
-    """USD cost of one Anthropic messages.create call from `response.usage`."""
-    if usage is None:
-        return 0.0
-    input_tokens = int(getattr(usage, "input_tokens", 0) or 0)
-    output_tokens = int(getattr(usage, "output_tokens", 0) or 0)
-    cache_create = int(getattr(usage, "cache_creation_input_tokens", 0) or 0)
-    cache_read = int(getattr(usage, "cache_read_input_tokens", 0) or 0)
-
-    rates = get_anthropic_rates(model)
-    total = (
-        input_tokens * rates["input"]
-        + cache_create * rates.get("cache_write", rates["input"])
-        + cache_read * rates.get("cache_read", rates["input"])
-        + output_tokens * rates["output"]
-    )
-    return total / 1_000_000
-
-
 def cost_of_transcription(model: str, audio_seconds: float) -> float:
     """USD cost of one speech-to-text call, billed per minute of audio.
 

{lambda_erp-0.8.30 → lambda_erp-0.8.31}/api/routers/admin.py

@@ -83,8 +83,8 @@ def demo_spend_overview(_user: dict = Depends(require_admin)):
     Only `public_manager` spend counts against the demo cap — `demo_usd`
     in each window is the number the global cap compares against. Non-
     demo calls (your own admin/manager sessions) are included in
-    `total_usd` so you can see the full OpenAI + Anthropic bill from this
-    deployment.
+    `total_usd` so you can see the full model bill from this deployment,
+    including historical provider rows recorded before a provider change.
     """
     init_schema()
     now = time.time()

{lambda_erp-0.8.30 → lambda_erp-0.8.31}/api/routers/analytics.py

@@ -3,9 +3,9 @@
 This module now exposes two layers:
 
 1. The original preset analytics API used by the current /reports/analytics page.
-2. A semantic dataset registry + bounded data-fetch endpoint for client-side
-   programmable reports. The browser can request approved datasets, then run an
-   arbitrary JS transform locally in a worker without direct database access.
+2. A semantic dataset registry + bounded data-fetch endpoint for declarative
+   reports. The browser can request approved datasets, then group, aggregate,
+   and chart them without executing report-provided code.
 """
 
 import json
@@ -381,13 +381,31 @@ class ReportKpiDefinition(StrictReportModel):
         return self
 
 
+class ReportChartSeries(StrictReportModel):
+    key: str = Field(pattern=r"^[A-Za-z_][A-Za-z0-9_]{0,63}$")
+    label: str | None = Field(default=None, max_length=200)
+
+
 class ReportChartDefinition(StrictReportModel):
     id: str | None = Field(default=None, pattern=r"^[A-Za-z_][A-Za-z0-9_]{0,63}$")
     title: str = Field(max_length=200)
     type: Literal["bar", "line", "pie"]
     data_table: str = Field(pattern=r"^[A-Za-z_][A-Za-z0-9_]{0,63}$")
     x: str = Field(pattern=r"^[A-Za-z_][A-Za-z0-9_]{0,63}$")
-    y: str = Field(pattern=r"^[A-Za-z_][A-Za-z0-9_]{0,63}$")
+    # `y` keeps existing single-series v1 drafts working. New reports may use
+    # `series` for grouped bars / multiple lines over the same table.
+    y: str | None = Field(default=None, pattern=r"^[A-Za-z_][A-Za-z0-9_]{0,63}$")
+    series: list[ReportChartSeries] = Field(default_factory=list, max_length=8)
+
+    @model_validator(mode="after")
+    def require_series(self):
+        if bool(self.y) == bool(self.series):
+            raise ValueError("Chart must define exactly one of 'y' or 'series'")
+        if self.type == "pie" and len(self.series) > 1:
+            raise ValueError("Pie charts support only one series")
+        if len({series.key for series in self.series}) != len(self.series):
+            raise ValueError("Chart series keys must be unique")
+        return self
 
 
 class DeclarativeReportDefinition(StrictReportModel):
@@ -477,9 +495,10 @@ class ReportDraftPayload(StrictReportModel):
                 raise ValueError(
                     f"Chart '{chart.title}' references unknown table '{chart.data_table}'"
                 )
-            if chart.x not in available or chart.y not in available:
+            series_keys = [chart.y] if chart.y else [series.key for series in chart.series]
+            if chart.x not in available or any(key not in available for key in series_keys):
                 raise ValueError(
-                    f"Chart '{chart.title}' references unknown x/y table output"
+                    f"Chart '{chart.title}' references unknown x/series table output"
                 )
         return self
 
@@ -672,6 +691,119 @@ SEMANTIC_DATASETS: dict[str, dict[str, Any]] = {
         "max_limit": 10000,
         "default_order_by": "pe.posting_date DESC, pe.name DESC",
     },
+    "gl_entries": {
+        "label": "General Ledger Entries",
+        "description": (
+            "Posted double-entry accounting rows joined to the chart of accounts. "
+            "Use income_amount and expense_amount for profit-and-loss charts; they "
+            "apply the correct normal-balance sign and are zero for other account "
+            "roots. Use debit/credit for raw ledger movement."
+        ),
+        "sql_from": 'FROM "GL Entry" gle LEFT JOIN "Account" a ON a.name = gle.account',
+        "fields": {
+            "name": "string",
+            "posting_date": "date",
+            "company": "string",
+            "account": "string",
+            "account_name": "string",
+            "root_type": "string",
+            "account_type": "string",
+            "party_type": "string",
+            "party": "string",
+            "cost_center": "string",
+            "voucher_type": "string",
+            "voucher_no": "string",
+            "debit": "number",
+            "credit": "number",
+            "normal_balance_amount": "number",
+            "income_amount": "number",
+            "expense_amount": "number",
+            "is_opening": "string",
+        },
+        "field_sql": {
+            "name": "gle.name",
+            "posting_date": "gle.posting_date",
+            "company": "gle.company",
+            "account": "gle.account",
+            "account_name": "a.account_name",
+            "root_type": "a.root_type",
+            "account_type": "a.account_type",
+            "party_type": "gle.party_type",
+            "party": "gle.party",
+            "cost_center": "gle.cost_center",
+            "voucher_type": "gle.voucher_type",
+            "voucher_no": "gle.voucher_no",
+            "debit": "gle.debit",
+            "credit": "gle.credit",
+            "normal_balance_amount": (
+                "CASE WHEN a.root_type IN ('Liability', 'Equity', 'Income') "
+                "THEN gle.credit - gle.debit ELSE gle.debit - gle.credit END"
+            ),
+            "income_amount": (
+                "CASE WHEN a.root_type = 'Income' THEN gle.credit - gle.debit ELSE 0 END"
+            ),
+            "expense_amount": (
+                "CASE WHEN a.root_type = 'Expense' THEN gle.debit - gle.credit ELSE 0 END"
+            ),
+            "is_opening": "gle.is_opening",
+        },
+        "default_where": ["COALESCE(gle.is_cancelled, 0) = 0"],
+        "filter_fields": {
+            "posting_date", "company", "account", "root_type", "account_type",
+            "party_type", "party", "cost_center", "voucher_type", "voucher_no",
+            "is_opening",
+        },
+        "default_limit": 1000,
+        "max_limit": 10000,
+        "default_order_by": "gle.posting_date DESC, gle.name DESC",
+    },
+    "bank_transactions": {
+        "label": "Bank Transactions",
+        "description": (
+            "Imported bank-statement movements. Use deposit for cash inflows and "
+            "withdrawal for cash outflows. These are cash movements, not accounting "
+            "income/expenses; use gl_entries for a profit-and-loss view."
+        ),
+        "sql_from": 'FROM "Bank Transaction" bt',
+        "fields": {
+            "name": "string",
+            "posting_date": "date",
+            "value_date": "date",
+            "bank_account": "string",
+            "currency": "string",
+            "deposit": "number",
+            "withdrawal": "number",
+            "counterparty_name": "string",
+            "description": "string",
+            "reference_number": "string",
+            "status": "string",
+            "reference_doctype": "string",
+            "reference_name": "string",
+        },
+        "field_sql": {
+            "name": "bt.name",
+            "posting_date": "bt.posting_date",
+            "value_date": "bt.value_date",
+            "bank_account": "bt.bank_account",
+            "currency": "bt.currency",
+            "deposit": "bt.deposit",
+            "withdrawal": "bt.withdrawal",
+            "counterparty_name": "bt.counterparty_name",
+            "description": "bt.description",
+            "reference_number": "bt.reference_number",
+            "status": "bt.status",
+            "reference_doctype": "bt.reference_doctype",
+            "reference_name": "bt.reference_name",
+        },
+        "default_where": ["COALESCE(bt.reversal_indicator, 0) = 0"],
+        "filter_fields": {
+            "posting_date", "value_date", "bank_account", "currency", "status",
+            "reference_doctype", "reference_name",
+        },
+        "default_limit": 1000,
+        "max_limit": 10000,
+        "default_order_by": "bt.posting_date DESC, bt.name DESC",
+    },
     "ar_open_items": {
         "label": "AR Open Items",
         "description": "Open submitted non-return sales invoices with positive outstanding amounts.",

{lambda_erp-0.8.30 → lambda_erp-0.8.31}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lambda-erp"
-version = "0.8.30"
+version = "0.8.31"
 description = "Core ERP logic - accounting, sales, purchasing, inventory"
 readme = "README.md"
 license = "Apache-2.0"
@@ -11,7 +11,6 @@ dependencies = [
     "uvicorn[standard]>=0.30",
     "python-multipart>=0.0.9",
     "pydantic>=2.0",
-    "anthropic>=0.40",
     "openai>=1.0",
     "httpx>=0.27",
     "python-dotenv>=1.0",

{lambda_erp-0.8.30 → lambda_erp-0.8.31}/terraform/README.md

@@ -27,10 +27,8 @@ rate/cost, not the VM.
 ### 1. Gather inputs
 
 - **Azure subscription ID** — `az account show --query id -o tsv`
-- **OpenAI API key** — required; chat orchestration runs on GPT.
-- **Anthropic API key** — required; the code-specialist sub-agent that
-  generates custom-analytics JS runs on Claude. The demo still boots
-  without it but custom-report code generation will fail.
+- **OpenAI API key** — required; chat orchestration and the report specialist
+  both run on GPT-5.6 Terra.
 - **JWT secret** — a stable 64-char hex string used to sign login cookies:
   ```bash
   python -c "import secrets; print(secrets.token_hex(32))"
@@ -38,19 +36,19 @@ rate/cost, not the VM.
   Generate once, keep stable across revisions (users' cookies survive
   rollouts that way).
 
-You collect these four items once, then paste them into GitHub — they
+You collect these three items once, then paste them into GitHub — they
 never need to sit on a laptop during any terraform run:
 
 - **Subscription ID** goes into `terraform.tfvars` in step 3 (also into
   GitHub Actions Variables for CI).
-- **OpenAI key, Anthropic key, JWT secret** go directly into **GitHub
+- **OpenAI key and JWT secret** go directly into **GitHub
   Actions Secrets** in step 6. From that point on, the
   `terraform-apply` workflow reads them as `TF_VAR_*` env vars on
   every CI-driven apply and pushes them into the Container App's
   secret store.
 
 The bootstrap `terraform apply` in step 4 runs with **no real secrets
-at all** — the three secret-backed variables all default to a
+at all** — the two secret-backed variables both default to a
 placeholder string, which terraform writes into the Container App
 alongside the Microsoft quickstart image. The first CI-driven
 `terraform-apply` run (step 7) is where real secrets first reach
@@ -117,8 +115,8 @@ run has to happen from a machine where you can sign in as an owner of
 the subscription + Entra tenant. No further applies will run from a
 laptop after this.
 
-**No secrets go in on this run.** The three secret-backed variables
-(`openai_api_key`, `anthropic_api_key`, `jwt_secret_key`) all default
+**No secrets go in on this run.** The two secret-backed variables
+(`openai_api_key`, `jwt_secret_key`) both default
 to the placeholder string `"placeholder-will-be-set-by-github-actions"`;
 terraform writes that string into the Container App's secret store,
 which is fine because the app image isn't real yet either (the
@@ -175,7 +173,6 @@ Under **Secrets** tab (same page), add:
 | Secret              | Value                                         |
 |---------------------|-----------------------------------------------|
 | `OPENAI_API_KEY`    | your OpenAI key                               |
-| `ANTHROPIC_API_KEY` | your Anthropic key                            |
 | `JWT_SECRET_KEY`    | the 64-hex-char string from step 1            |
 
 These are what the `terraform-apply` workflow reads as `TF_VAR_*` env
@@ -208,7 +205,7 @@ From this point on, **no secret ever sits on a laptop**:
 |----------------------------------------------|---------------------------------------------------------------------------|
 | New app code (Python/React)                  | Push to `master`. `deploy.yml` builds, pushes, rolls the revision.        |
 | New infra, env var, or demo cap              | Edit `terraform/app/*.tf`, push, then run `terraform-apply` workflow.     |
-| Rotate `OPENAI_API_KEY` / `ANTHROPIC_API_KEY` | Update the GitHub Secret, then run `terraform-apply` with `action=apply`. |
+| Rotate `OPENAI_API_KEY`                       | Update the GitHub Secret, then run `terraform-apply` with `action=apply`. |
 | Rotate `JWT_SECRET_KEY`                      | Same as above. All existing login cookies will become invalid.            |
 
 The `terraform-apply` workflow has a `plan | apply` dropdown on manual
@@ -217,8 +214,8 @@ before applying.
 
 ## Secrets: who owns what
 
-- **Container App secrets** (`openai-api-key`, `anthropic-api-key`,
-  `jwt-secret-key`) live in **GitHub Secrets** and are applied to
+- **Container App secrets** (`openai-api-key`, `jwt-secret-key`) live in
+  **GitHub Secrets** and are applied to
   Azure by the `terraform-apply` workflow, which passes them as
   `TF_VAR_*` env vars. Terraform then writes them into the Container
   App's own secret store. No copy on disk anywhere else.
@@ -269,7 +266,7 @@ Set `custom_domain = "erp-demo.example.com"` in `terraform.tfvars`. After
 | Log Analytics (minimal)                  | ~$5                |
 | **Total infra**                          | **~$40**           |
 
-LLM usage is billed separately by OpenAI/Anthropic. The demo cap above
+LLM usage is billed separately by OpenAI. The demo cap above
 targets ~$50/day ceiling for visitor traffic, so the worst-case combined
 monthly bill is roughly $40 infra + $1500 LLM if the demo is slammed
 24/7.