lambda-erp 0.1.18__tar.gz → 0.1.20__tar.gz

{lambda_erp-0.1.18 → lambda_erp-0.1.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lambda-erp
-Version: 0.1.18
+Version: 0.1.20
 Summary: Core ERP logic - accounting, sales, purchasing, inventory
 Author: TORUS INVESTMENTS AG
 License-Expression: MIT

{lambda_erp-0.1.18 → lambda_erp-0.1.20}/api/chat.py

@@ -9,9 +9,12 @@ Supports multiple chat sessions, each with their own history and auto-generated
 """
 
 import asyncio
+import base64
+import io
 import json
 import logging
 import os
+import re
 import traceback
 import uuid
 from datetime import date
@@ -29,7 +32,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
+from api.providers import cost_of_anthropic_call, cost_of_openai_call, cost_of_transcription
 from api.routers.masters import create_master_record, update_master_record, MASTER_IDENTITY_ALIAS
 from lambda_erp.database import get_db
 from lambda_erp.utils import flt, now, nowdate
@@ -597,7 +600,7 @@ TOOLS = [
             "description": (
                 "Create a new master record. You MUST include the full `data` object using the EXACT field names listed below — unknown fields are silently dropped.\n\n"
                 "Every record's id is `name`. Customer/Supplier/Item/Warehouse auto-generate it (CUST-/SUPP-/ITEM-/WH-NNN) when omitted; Company/Account/Cost Center have NO auto-id, so `name` is required for them.\n\n"
-                "**Customer fields:** name (optional custom id; auto CUST-NNN), customer_name (required), customer_group, territory, default_currency, credit_limit, email, phone, address, city, zip_code, country, tax_id.\n"
+                "**Customer fields:** name (optional custom id; auto CUST-NNN), customer_name (required), customer_group, territory, default_currency, credit_limit, email, phone, address, city, zip_code, country, tax_id, contact_person (named contact at the customer), contact_email, contact_phone.\n"
                 "**Supplier fields:** name (optional custom id; auto SUPP-NNN), supplier_name (required), supplier_group, default_currency, email, phone, address, city, zip_code, country, tax_id.\n"
                 "**Item fields:** item_code (the unique item code/id, e.g. \"SVC-SPARK\" — optional, may use ANY prefix, not just ITEM; auto-generated as ITEM-NNN if omitted), item_name (required, the human-readable name), item_group, stock_uom, standard_rate, is_stock_item, default_warehouse, description.\n"
                 "**Warehouse fields:** name (optional custom id; auto WH-NNN), warehouse_name (required), company, parent_warehouse (omit or null when not needed), address, city, zip_code, country.\n"
@@ -623,7 +626,7 @@ TOOLS = [
         "function": {
             "name": "update_master",
             "description": (
-                "Update an existing master record. You MUST include the `name` of the existing record and a `data` object with the fields to change. Use the same field names listed in create_master (customer: customer_name, email, phone, address, city, zip_code, country, tax_id, etc.). Example: {\"master_type\":\"customer\",\"name\":\"CUST-001\",\"data\":{\"address\":\"123 New Street\",\"city\":\"Boston\",\"zip_code\":\"02110\"}}"
+                "Update an existing master record. You MUST include the `name` of the existing record and a `data` object with the fields to change. Use the same field names listed in create_master (customer: customer_name, email, phone, address, city, zip_code, country, tax_id, contact_person, contact_email, contact_phone, etc.). Example: {\"master_type\":\"customer\",\"name\":\"CUST-001\",\"data\":{\"address\":\"123 New Street\",\"city\":\"Boston\",\"zip_code\":\"02110\"}}"
             ),
             "parameters": {
                 "type": "object",
@@ -2326,6 +2329,65 @@ async def run_thinking_loop(
     await on_event({"type": "complete", "content": content})
 
 
+# ---------------------------------------------------------------------------
+# Speech-to-text (voice → text)
+# ---------------------------------------------------------------------------
+
+# Domain-vocabulary biasing for the transcription `prompt`. A bare term list,
+# NO language constraint — the spoken language is auto-detected, and a
+# locale-derived hint would mis-transcribe users who speak another language
+# than their UI. Swiss German transcribes to Standard German on its own, which
+# is what the thinking loop wants. These are the ERP terms short utterances
+# otherwise mangle.
+VOICE_TRANSCRIBE_PROMPT = (
+    "Lambda, ERP, Offerte, Angebot, Auftrag, Rechnung, Gutschrift, Beleg, "
+    "Lieferschein, Bestellung, Zahlung, Buchung, Kunde, Lieferant, Artikel, "
+    "Lager, Konto, Kostenstelle, quotation, sales order, invoice, credit note, "
+    "purchase order, payment, journal entry, customer, supplier, item, warehouse"
+)
+
+# Below this the API rejects the clip as "too short"; we treat it as a no-op
+# (the user tapped the mic by accident) rather than an error.
+_MIN_TRANSCRIBE_BYTES = 1500  # ~1s of webm/opus at the ~1.5 KB/s we assume below
+
+
+def transcribe_audio(audio_bytes: bytes, audio_format: str, api_key: str) -> str:
+    """Transcribe audio to text via OpenAI gpt-4o-transcribe.
+
+    Returns the transcript, or "" when the model detects silence/near-silence
+    (empty result or a prompt-echo hallucination on a near-silent clip).
+    Raises on an actual API error so the caller can surface it.
+    """
+    client = OpenAI(api_key=api_key, timeout=httpx.Timeout(60.0, connect=10.0))
+
+    audio_file = io.BytesIO(audio_bytes)
+    audio_file.name = f"voice.{audio_format or 'webm'}"
+
+    transcription = client.audio.transcriptions.create(
+        model="gpt-4o-transcribe",
+        file=audio_file,
+        response_format="json",
+        prompt=VOICE_TRANSCRIBE_PROMPT,
+    )
+
+    text = (getattr(transcription, "text", "") or "").strip()
+    if len(text) < 2:
+        return ""
+
+    # Prompt-echo guard: on silent/noise audio, prompt-biased transcription
+    # tends to hallucinate the biasing vocabulary back. If (nearly) every word
+    # of the transcript is drawn from the prompt itself, it's an echo, not
+    # speech — real utterances carry verbs/objects outside the glossary.
+    prompt_tokens = set(re.findall(r"[\w'-]+", VOICE_TRANSCRIBE_PROMPT.lower()))
+    text_tokens = re.findall(r"[\w'-]+", text.lower())
+    if text_tokens:
+        coverage = sum(1 for tok in text_tokens if tok in prompt_tokens) / len(text_tokens)
+        if coverage >= 0.8:
+            return ""
+
+    return text
+
+
 # ---------------------------------------------------------------------------
 # WebSocket endpoint
 # ---------------------------------------------------------------------------
@@ -2675,6 +2737,77 @@ async def chat_websocket(
                 session_tasks[session_id] = asyncio.create_task(replay_demo_session(session_id))
                 continue
 
+            if msg_type == "transcribe":
+                # Voice → text: transcribe a recorded clip and return the text
+                # for the composer. No LLM turn here — the user reviews/edits
+                # the text and sends it like any typed message.
+                openai_api_key = os.environ.get("OPENAI_API_KEY", "")
+                if not openai_api_key or openai_api_key == "sk-your-key-here":
+                    await send_event(
+                        "transcription_result", request_id=request_id,
+                        success=False, error="Speech-to-text is not available (OPENAI_API_KEY not configured).",
+                    )
+                    continue
+
+                # Demo visitors are rate-limited the same way as LLM turns — a
+                # paid OpenAI call still costs money. Block before transcribing.
+                if is_demo_role(ws_user_role) and client_ip:
+                    blocked = demo_limiter.check(client_ip)
+                    if blocked:
+                        await send_event(
+                            "transcription_result", request_id=request_id,
+                            success=False, error=blocked,
+                        )
+                        continue
+
+                audio_b64 = data.get("audio_data") or ""
+                audio_format = (data.get("audio_format") or "webm").lower()
+                try:
+                    audio_bytes = base64.b64decode(audio_b64) if audio_b64 else b""
+                except Exception:
+                    audio_bytes = b""
+
+                if len(audio_bytes) < _MIN_TRANSCRIBE_BYTES:
+                    # Too short to be speech (accidental tap) — treat as empty,
+                    # no API call, no cost.
+                    await send_event(
+                        "transcription_result", request_id=request_id,
+                        success=True, text="",
+                    )
+                    continue
+
+                try:
+                    text = await asyncio.to_thread(
+                        transcribe_audio, audio_bytes, audio_format, openai_api_key,
+                    )
+                except Exception as e:
+                    logger.warning("Transcription failed: %s", e)
+                    await send_event(
+                        "transcription_result", request_id=request_id,
+                        success=False, error="Transcription failed. Please try again.",
+                    )
+                    continue
+
+                # Track the spend. Audio duration is estimated from byte size
+                # (~1.5 KB/s for webm/opus); the Demo Spend Log records every
+                # role for the admin dashboard, and counts public_manager rows
+                # against the hourly cap.
+                estimated_seconds = len(audio_bytes) / 1500
+                demo_limiter.record(
+                    client_ip or "unknown",
+                    cost_of_transcription("gpt-4o-transcribe", estimated_seconds),
+                    role=ws_user_role,
+                    provider="openai",
+                    model="gpt-4o-transcribe",
+                    session_id=data.get("session_id"),
+                )
+
+                await send_event(
+                    "transcription_result", request_id=request_id,
+                    success=True, text=text,
+                )
+                continue
+
             if msg_type != "send_message":
                 await send_error(f"Unknown message type: {msg_type}", request_id=request_id)
                 continue

{lambda_erp-0.1.18 → lambda_erp-0.1.20}/api/providers.py

@@ -43,6 +43,13 @@ ANTHROPIC_PRICING: dict[str, dict[str, Any]] = {
     "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},
+    "gpt-4o-mini-transcribe": {"per_minute": 0.003},
+    "whisper-1":              {"per_minute": 0.006},
+}
+
 
 # ---------------------------------------------------------------------------
 # Rate lookup — unknown models fall back to the most expensive model in each
@@ -114,3 +121,14 @@ def cost_of_anthropic_call(model: str, usage: Optional[Any]) -> float:
         + 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.
+
+    Unknown models fall back to the most expensive STT rate so we never
+    under-count. `audio_seconds` is the (estimated) audio duration."""
+    rates = TRANSCRIBE_PRICING.get(model)
+    if rates is None:
+        rates = max(TRANSCRIBE_PRICING.values(), key=lambda r: r["per_minute"])
+    return max(float(audio_seconds or 0.0), 0.0) / 60.0 * rates["per_minute"]

{lambda_erp-0.1.18 → lambda_erp-0.1.20}/lambda_erp/database.py

@@ -331,7 +331,10 @@ class Database:
                 city TEXT,
                 zip_code TEXT,
                 country TEXT,
-                tax_id TEXT
+                tax_id TEXT,
+                contact_person TEXT,
+                contact_email TEXT,
+                contact_phone TEXT
             )""",
 
             """CREATE TABLE IF NOT EXISTS "Supplier" (
@@ -1743,6 +1746,15 @@ def _m015_document_discarded(db: "Database") -> None:
         db._add_column_if_missing(table, "discarded", "INTEGER DEFAULT 0")
 
 
+def _m016_customer_contact_person(db: "Database") -> None:
+    """Add a named contact person (Ansprechperson) to the Customer master:
+    a free-text name plus their own email and phone, kept separate from the
+    company-level email/phone already on the record."""
+    db._add_column_if_missing("Customer", "contact_person", "TEXT")
+    db._add_column_if_missing("Customer", "contact_email", "TEXT")
+    db._add_column_if_missing("Customer", "contact_phone", "TEXT")
+
+
 Database.MIGRATIONS = [
     (1, "chat_message_session_id", _m001_chat_message_session_id),
     (2, "chat_session_user_id", _m002_chat_session_user_id),
@@ -1759,6 +1771,7 @@ Database.MIGRATIONS = [
     (13, "unrealized_exchange_account", _m013_unrealized_exchange_account),
     (14, "company_iban", _m014_company_iban),
     (15, "document_discarded", _m015_document_discarded),
+    (16, "customer_contact_person", _m016_customer_contact_person),
 ]
 
 

{lambda_erp-0.1.18 → lambda_erp-0.1.20}/pyproject.toml

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