trap-cli 0.0.4__tar.gz → 0.0.6__tar.gz

{trap_cli-0.0.4 → trap_cli-0.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trap-cli
-Version: 0.0.4
+Version: 0.0.6
 Summary: tp — non-invasive CLI testing framework for AI workflows. Submits results to trapstreet.run.
 Project-URL: Homepage, https://trapstreet.run
 Project-URL: Repository, https://github.com/trapstreet/trap
@@ -27,7 +27,6 @@ Requires-Dist: py-cpuinfo>=9.0.0
 Requires-Dist: pydantic>=2.0
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: rich>=13.0
-Requires-Dist: tokencost>=0.1.26
 Requires-Dist: typer>=0.12
 Description-Content-Type: text/markdown
 

{trap_cli-0.0.4 → trap_cli-0.0.6}/pyproject.toml

@@ -29,7 +29,6 @@ dependencies = [
     "pyyaml>=6.0",
     "rich>=13.0",
     "httpx>=0.27",
-    "tokencost>=0.1.26",
     "gitpython>=3.1",
     "psutil>=7.2.2",
     "py-cpuinfo>=9.0.0",

{trap_cli-0.0.4 → trap_cli-0.0.6}/src/trap/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.0.4'
-__version_tuple__ = version_tuple = (0, 0, 4)
+__version__ = version = '0.0.6'
+__version_tuple__ = version_tuple = (0, 0, 6)
 
 __commit_id__ = commit_id = None

{trap_cli-0.0.4 → trap_cli-0.0.6}/src/trap/auth/client.py

@@ -52,6 +52,15 @@ class ApiClient:
             resp.raise_for_status()
             return resp.json()
         except httpx.HTTPStatusError as e:
-            raise ApiError(f"http {e.response.status_code}: {e.response.text}") from None
+            raise ApiError(f"http {e.response.status_code}: {_error_detail(e.response)}") from None
         except httpx.RequestError as e:
             raise ApiError(f"connection error: {e}") from None
+
+
+def _error_detail(resp: httpx.Response) -> str:
+    """The server's JSON {error} message when present, else the raw body text."""
+    try:
+        error = resp.json().get("error")
+    except (ValueError, AttributeError):
+        return resp.text
+    return str(error) if error else resp.text

trap_cli-0.0.6/src/trap/cost/calculator.py

@@ -0,0 +1,58 @@
+"""Cost calculation for LLM token usage.
+
+Isolated so this logic can be moved server-side without touching the proxy infrastructure.
+The only public symbol is :func:`calculate_call_cost`.
+
+Prices are maintained here rather than pulled from a third-party table: the previous
+dependency (tokencost) lagged behind provider releases, silently pricing current models
+at 0 or at a stale predecessor's rate. An explicit table with a NaN fallback keeps the
+failure mode honest — an unknown cost is reported as unknown, never as a wrong number.
+"""
+
+from __future__ import annotations
+
+import math
+
+# USD per million tokens (input, output), keyed by model-id prefix so one entry covers
+# both a version alias ("claude-haiku-4-5") and the dated full id the API reports
+# ("claude-haiku-4-5-20251001"). First match wins: keep more-specific prefixes
+# ("gpt-5.5-pro") ahead of the prefixes they extend ("gpt-5.5").
+_PRICES_PER_MTOK: list[tuple[str, float, float]] = [
+    # Anthropic
+    ("claude-fable-5", 10.0, 50.0),
+    ("claude-mythos-5", 10.0, 50.0),
+    # Introductory pricing through 2026-08-31; reverts to 3.0 / 15.0 after.
+    ("claude-sonnet-5", 2.0, 10.0),
+    ("claude-opus-4-8", 5.0, 25.0),
+    ("claude-opus-4-7", 5.0, 25.0),
+    ("claude-opus-4-6", 5.0, 25.0),
+    ("claude-opus-4-5", 5.0, 25.0),
+    ("claude-opus-4-1", 15.0, 75.0),
+    ("claude-sonnet-4-6", 3.0, 15.0),
+    ("claude-sonnet-4-5", 3.0, 15.0),
+    ("claude-haiku-4-5", 1.0, 5.0),
+    # OpenAI
+    ("gpt-5.6-sol", 5.0, 30.0),
+    ("gpt-5.6-terra", 2.5, 15.0),
+    ("gpt-5.6-luna", 1.0, 6.0),
+    ("gpt-5.5-pro", 30.0, 180.0),
+    ("gpt-5.5", 5.0, 30.0),
+    ("gpt-5.4-pro", 30.0, 180.0),
+    ("gpt-5.4-mini", 0.75, 4.5),
+    ("gpt-5.4-nano", 0.2, 1.25),
+    ("gpt-5.4", 2.5, 15.0),
+]
+
+
+def calculate_call_cost(prompt_tokens: int, completion_tokens: int, model: str | None) -> float:
+    """Return the USD cost for one API call.
+
+    Returns NaN when the model is unknown or absent from the pricing table — an
+    unknown cost is not a zero cost (pydantic serialises the NaN as JSON null)."""
+    if model is None:
+        return math.nan
+    name = model.lower()
+    for prefix, input_per_mtok, output_per_mtok in _PRICES_PER_MTOK:
+        if name.startswith(prefix):
+            return (prompt_tokens * input_per_mtok + completion_tokens * output_per_mtok) / 1_000_000
+    return math.nan

{trap_cli-0.0.4 → trap_cli-0.0.6}/src/trap/cost/providers.py

@@ -23,7 +23,12 @@ class _ProtocolStyle(enum.StrEnum):
             case (_ProtocolStyle.OPENAI_COMPATIBLE, True):
                 return self._parse_openai_style_sse(body.decode("utf-8", errors="replace"))
             case (_ProtocolStyle.OPENAI_COMPATIBLE, False):
-                return self._parse_json(body, "prompt_tokens", "completion_tokens")
+                parsed = self._parse_json(body, "prompt_tokens", "completion_tokens")
+                if parsed[0] or parsed[1]:
+                    return parsed
+                # The OpenAI Responses API names its usage fields input_/output_tokens
+                # (like Anthropic), not the Chat Completions prompt_/completion_tokens.
+                return self._parse_json(body, "input_tokens", "output_tokens")
             case _:  # pragma: no cover - exhaustive over the two styles above
                 raise ValueError(f"Unsupported protocol style: {self!r}")
 

{trap_cli-0.0.4 → trap_cli-0.0.6}/src/trap/cost/proxy.py

@@ -65,7 +65,7 @@ class CostProxy:
     ) -> None:
         if not (prompt_tokens or completion_tokens):
             return
-        call_cost = _calc_cost(prompt_tokens, completion_tokens, model) if model else 0.0
+        call_cost = _calc_cost(prompt_tokens, completion_tokens, model)
         with self._lock:
             key = (provider, model)
             entry = self._cost_buckets.get(key)

{trap_cli-0.0.4 → trap_cli-0.0.6}/src/trap/display/submit.py

@@ -7,14 +7,17 @@ console = Console()
 
 
 def render_submit_result(resp_data: dict) -> None:
+    """Render a successful POST /api/submit response: {run: {id}, view_url}.
+
+    Success is decided by the HTTP status alone (ApiClient.submit raises on
+    non-2xx), so this only confirms the upload and points at the run page —
+    scores and case detail live there, not in the response."""
     run_obj = resp_data.get("run") or {}
-    passed = run_obj.get("passed")
+    console.print("[green]✓ submitted[/green]")
     table = Table.grid(padding=(0, 2))
     table.add_column(style="dim")
     table.add_column()
-    table.add_row("status", "[green]✓ passed[/green]" if passed else "[red]✗ failed[/red]")
-    table.add_row("run", f"[bold]{run_obj.get('id', '?')}[/bold]")
-    table.add_row("score", f"[cyan]{run_obj.get('total_score')}[/cyan]")
+    table.add_row("run_id", f"[bold]{run_obj.get('id', '?')}[/bold]")
     if view_url := resp_data.get("view_url"):
         table.add_row("url", f"[link={view_url}]{view_url}[/link]")
     console.print(table)

trap_cli-0.0.4/src/trap/cost/calculator.py

@@ -1,41 +0,0 @@
-"""Cost calculation for LLM token usage.
-
-Isolated so this logic can be moved server-side without touching the proxy infrastructure.
-The only public symbol is :func:`calculate_call_cost`.
-"""
-
-from __future__ import annotations
-
-from tokencost import TOKEN_COSTS as _TOKEN_COSTS  # type: ignore[import-untyped]
-from tokencost import calculate_cost_by_tokens as _calc_cost  # type: ignore[import-untyped]
-from tokencost import register_model_pattern as _register_pattern  # type: ignore[import-untyped]
-
-
-def _register_anthropic_version_patterns() -> None:
-    # Anthropic now returns version-based names (e.g. "claude-sonnet-4-6") but tokencost only
-    # has date-based entries (e.g. "claude-sonnet-4-20250514"). Register wildcard patterns so
-    # calculate_cost_by_tokens can resolve them via _normalize_model_for_pricing.
-    for pattern, canonical in [
-        ("claude-sonnet-4-*", "claude-sonnet-4-20250514"),
-        ("claude-opus-4-*", "claude-opus-4-20250514"),
-    ]:
-        entry = _TOKEN_COSTS.get(canonical)
-        if entry:  # pragma: no branch - both canonicals ship in tokencost
-            _register_pattern(
-                pattern,
-                float(entry["input_cost_per_token"]) * 1000,
-                float(entry["output_cost_per_token"]) * 1000,
-            )
-
-
-_register_anthropic_version_patterns()
-
-
-def calculate_call_cost(prompt_tokens: int, completion_tokens: int, model: str) -> float:
-    """Return the USD cost for one API call. Returns 0.0 if the model is not in the pricing table."""
-    try:
-        return float(
-            _calc_cost(prompt_tokens, model, "input") + _calc_cost(completion_tokens, model, "output")
-        )
-    except KeyError:
-        return 0.0