lambda-erp 1.1.6__tar.gz → 1.1.8__tar.gz

{lambda_erp-1.1.6 → lambda_erp-1.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lambda-erp
-Version: 1.1.6
+Version: 1.1.8
 Summary: Core ERP logic - accounting, sales, purchasing, inventory
 Author: TORUS INVESTMENTS AG
 License-Expression: Apache-2.0
@@ -261,7 +261,7 @@ Open `http://localhost:5173`. Vite proxies `/api/*` to the backend.
 
 ```
 OPENAI_API_KEY=sk-...
-LAMBDA_ERP_REPORT_MODEL=gpt-5.6-terra  # optional specialist override; default shown
+LAMBDA_ERP_REPORT_MODEL=gpt-6.1-sol  # 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

{lambda_erp-1.1.6 → lambda_erp-1.1.8}/README.md

@@ -233,7 +233,7 @@ Open `http://localhost:5173`. Vite proxies `/api/*` to the backend.
 
 ```
 OPENAI_API_KEY=sk-...
-LAMBDA_ERP_REPORT_MODEL=gpt-5.6-terra  # optional specialist override; default shown
+LAMBDA_ERP_REPORT_MODEL=gpt-6.1-sol  # 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

{lambda_erp-1.1.6 → lambda_erp-1.1.8}/api/chat.py

@@ -2860,14 +2860,14 @@ Users can attach PDFs and images (receipts, bills, contracts, screenshots) to th
 # ---------------------------------------------------------------------------
 # OpenAI report-spec specialist
 #
-# GPT-5.6 Terra stays as the planner/orchestrator. When it decides a report needs
+# GPT-6.1 Sol acts as the planner/orchestrator. When it decides a report needs
 # a custom analytics view it calls the create/update custom analytics tools.
-# Those handlers make a separate, narrowly prompted Terra call for the bounded
+# Those handlers make a separate, narrowly prompted GPT-6.1 Sol call for the bounded
 # declarative report spec. Both roles use the existing OPENAI_API_KEY.
 # ---------------------------------------------------------------------------
 
 
-REPORT_SPECIALIST_MODEL = "gpt-5.6-terra"
+REPORT_SPECIALIST_MODEL = "gpt-6.1-sol"
 
 
 def _report_specialist_model() -> str:
@@ -3148,7 +3148,7 @@ def _generate_report_spec_via_openai(
                 instructions=_REPORT_CODE_SYSTEM_PROMPT,
                 input=attempt_input,
                 max_output_tokens=4096,
-                reasoning={"effort": "low"},
+                reasoning={"effort": "medium"},
             )
             # Log every call for the admin dashboard. Only public_manager rows
             # count against the demo cap — other roles are logged for
@@ -3275,18 +3275,18 @@ async def generate_title(
 # Reasoning loop
 # ---------------------------------------------------------------------------
 
-# The agentic orchestrator model. Function tools on /v1/chat/completions
-# require reasoning_effort="none" for the gpt-5.6 family (400 otherwise).
-ORCHESTRATOR_MODEL = "gpt-5.6-terra"
+# 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.
+ORCHESTRATOR_MODEL = "gpt-6.1-sol"
 
 
 # ---------------------------------------------------------------------------
-# LLM API selector: Chat Completions (default) vs Responses API
+# LLM API selector: Responses API (default) vs Chat Completions
 #
 # The Responses API (/v1/responses) is what accepts non-PDF file inputs
 # (Office documents via input_file), and it does reasoning natively (no
 # reasoning_effort="none" hack). Migrating the whole loop is risky, so it's
-# behind a flag and OFF by default. To keep the blast radius tiny, ALL
+# controlled by ERP_CHAT_API. To keep the blast radius tiny, ALL
 # conversation state stays Chat-Completions-shaped; we translate to/from the
 # Responses shape only at the single orchestrator call boundary
 # (_orchestrator_turn), and shim the Responses output back into the
@@ -3294,6 +3294,9 @@ ORCHESTRATOR_MODEL = "gpt-5.6-terra"
 # ---------------------------------------------------------------------------
 
 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":
+        return True
     # Default: the Responses API (needed for Office attachments + native
     # reasoning). Set ERP_CHAT_API=chat to fall back to Chat Completions.
     return os.environ.get("ERP_CHAT_API", "responses").strip().lower() != "chat"
@@ -3451,9 +3454,9 @@ def _shim_usage_from_responses(usage):
     return _ShimUsage(inp, out, cached)
 
 
-def _orchestrator_turn(client, messages, tools, max_tokens):
+def _orchestrator_turn(client, messages, tools, max_tokens, *, tool_choice="auto"):
     """One orchestrator LLM turn. Returns (message, usage) shaped like Chat
-    Completions, using either the Chat or Responses API per ERP_CHAT_API.
+    Completions. Sol 6.1 always uses Responses; compatible models honor ERP_CHAT_API.
     Blocking — call via asyncio.to_thread."""
     if _use_responses_api():
         instructions, input_items = _responses_request_from_chat(messages)
@@ -3462,7 +3465,7 @@ def _orchestrator_turn(client, messages, tools, max_tokens):
             instructions=instructions,
             input=input_items,
             tools=_responses_tools_from_chat(tools),
-            tool_choice="auto",
+            tool_choice=tool_choice,
             max_output_tokens=max_tokens,
             reasoning={"effort": _RESPONSES_REASONING_EFFORT},
         )
@@ -3471,9 +3474,9 @@ def _orchestrator_turn(client, messages, tools, max_tokens):
         model=ORCHESTRATOR_MODEL,
         messages=messages,
         tools=tools,
-        tool_choice="auto",
+        tool_choice=tool_choice,
         max_completion_tokens=max_tokens,
-        # gpt-5.6-terra rejects function tools on /v1/chat/completions unless
+        # gpt-6-luna rejects function tools on /v1/chat/completions unless
         # reasoning_effort is "none" (400 otherwise).
         reasoning_effort="none",
     )
@@ -3490,10 +3493,11 @@ async def run_thinking_loop(
 ):
     """Run the agentic reasoning loop.
 
-    The orchestrator and report specialist both use OpenAI gpt-5.6-terra. When GPT decides to call
+    The orchestrator and the report specialist use GPT-6.1 Sol.
+    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 a separate narrowly prompted Terra call. We emit an
+    declarative-spec step to a separate narrowly prompted GPT-6.1 Sol 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", "")
@@ -3637,8 +3641,8 @@ async def run_thinking_loop(
             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})
             try:
-                # One orchestrator turn via Chat Completions (default) or the
-                # Responses API (ERP_CHAT_API=responses). Returns Chat-shaped
+                # One orchestrator turn via Responses (required for Sol 6.1)
+                # or the legacy API for compatible models. Returns Chat-shaped
                 # (message, usage) either way, so everything below is unchanged.
                 message, usage = await asyncio.to_thread(
                     _orchestrator_turn, openai_client, messages, build_tools(user_info), max_completion,
@@ -3702,7 +3706,7 @@ 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 the orchestrator is delegating report-spec generation to Terra,
+            # If the orchestrator is delegating report-spec generation to GPT-6.1 Sol,
             # surface the handoff in the UI.
             will_delegate_to_report_specialist = (
                 tool_allowed(fn_name, live_role)
@@ -3800,10 +3804,10 @@ async def run_thinking_loop(
     content = "I've reached the maximum number of reasoning steps. Here's what I've done so far — please check the results above."
     if not demo_mode:
         try:
-            wrap = await asyncio.to_thread(
-                openai_client.chat.completions.create,
-                model=ORCHESTRATOR_MODEL,
-                messages=messages + [{
+            wrap, usage = await asyncio.to_thread(
+                _orchestrator_turn,
+                openai_client,
+                messages + [{
                     "role": "user",
                     "content": (
                         "You hit the step limit before finishing. In the user's language, state "
@@ -3813,10 +3817,19 @@ async def run_thinking_loop(
                         "stands alone: do NOT refer to 'the results above' or to earlier messages."
                     ),
                 }],
-                max_completion_tokens=600,
-                reasoning_effort="none",
+                build_tools(user_info),
+                2048,
+                tool_choice="none",
+            )
+            demo_limiter.settle(
+                None, actual_cost_usd=cost_of_openai_call(ORCHESTRATOR_MODEL, usage),
+                ip=client_ip or "unknown", role=user_role, provider="openai",
+                model=ORCHESTRATOR_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,
             )
-            wrap_text = (wrap.choices[0].message.content or "").strip()
+            wrap_text = (wrap.content or "").strip()
             if wrap_text:
                 content = wrap_text
         except Exception:

{lambda_erp-1.1.6 → lambda_erp-1.1.8}/api/erp_context.py

@@ -8,6 +8,17 @@ WORKFLOW_GUIDANCE = """Discover record types and inspect get_document_fields/get
 writes; use their canonical field names, required fields, link targets and PDF requirements.
 Resolve existing records by their returned name; never invent identifiers or silently choose
 between ambiguous matches. Custom document records use document tools, not master tools.
+Ground every written fact in the user's message or a retrieved record for the specific
+target entity. This applies to free-text notes, descriptions and activity bodies as well
+as structured fields. When the user switches company, lead or document, re-establish the
+target and its relationships; do not carry a person's name, employer, sender identity,
+contact details or other attributes over from the previous topic without explicit evidence.
+A known contact at a company is not proof that they sent an unsigned message. If the source
+only identifies a team/company, attribute it to that team/company, leave the person/contact
+unset and preserve the source wording. Ask only if identifying the person is necessary to
+perform the requested operation; never invent a sender to fill the gap.
+Keep dates, times and time zones consistent between structured fields, notes and the final
+answer. Convert the source time once; if the source zone is ambiguous, ask before writing.
 Create/update, submit, cancel and convert are separate business operations. A successful
 draft creation does not imply submission, stock movement or ledger posting. Check returned
 status and warnings. Correct validation errors using the field metadata and user information.

{lambda_erp-1.1.6 → lambda_erp-1.1.8}/api/providers.py

@@ -1,8 +1,8 @@
 """Pricing data for external LLM APIs the chat orchestrator uses.
 
-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.
+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;
+see docs/llm-pricing.md for sources and billing scope.
 
 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
@@ -19,6 +19,36 @@ 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).
+    "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},
+        ],
+    },
+    "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},
+        ],
+    },
     "gpt-5.4": {
         "tiered": True,
         "tiers": [
@@ -31,8 +61,8 @@ OPENAI_PRICING: dict[str, dict[str, Any]] = {
     "gpt-5.6-terra": {
         "tiered": True,
         "tiers": [
-            {"max_input_tokens": 272_000, "input": 2.50, "cached_input": 0.25, "cache_write": 3.125, "output": 15.00},
-            {"max_input_tokens": None,    "input": 5.00, "cached_input": 0.50, "cache_write": 6.25,  "output": 22.50},
+            {"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},
         ],
     },
     "gpt-4.1-nano": {"input": 0.10, "cached_input": 0.025, "output": 0.40},
@@ -54,8 +84,8 @@ TRANSCRIBE_PRICING: dict[str, dict[str, float]] = {
 
 
 # ---------------------------------------------------------------------------
-# Rate lookup — unknown models fall back to the most expensive model in each
-# family so we never under-count a call we forgot to register.
+# Rate lookup — preserve the legacy gpt-5.4 estimate for unknown model IDs.
+# 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]:

{lambda_erp-1.1.6 → lambda_erp-1.1.8}/pyproject.toml

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