loopview 0.1.0__py3-none-any.whl

loopview/__init__.py

@@ -0,0 +1,3 @@
+"""loopview: watch AI agents run as a live graph, from any OpenTelemetry trace."""
+
+__version__ = "0.1.0"

loopview/app.py

@@ -0,0 +1,252 @@
+"""The FastAPI application.
+
+One process serves everything on one port:
+- the OTLP/HTTP trace receiver at POST /v1/traces,
+- the JSON API and the live event stream under /api,
+- the browser UI (static files built from ui/).
+
+The UI only ever receives the normalized schema (normalize/schema.py), never
+raw spans; /api/runs/{id}/spans exists for debugging.
+"""
+
+import inspect
+import json
+import time
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+from pathlib import Path
+from typing import Any
+
+from fastapi import FastAPI, HTTPException, Request, Response
+from fastapi.responses import HTMLResponse, StreamingResponse
+from fastapi.staticfiles import StaticFiles
+
+from loopview import __version__
+from loopview.cost.pricing import Pricing
+from loopview.ingest.otlp import (
+    JSON,
+    MAX_BODY_BYTES,
+    BodyTooLarge,
+    OtlpDecodeError,
+    UnsupportedContentType,
+    decode_body,
+    decompress,
+    encode_success_response,
+    spans_to_otlp_json,
+)
+from loopview.ingest.raw import RawSpan
+from loopview.live import LiveHub, running
+from loopview.normalize.schema import NormalizedRun, RunInfo
+from loopview.store.capture import CapturedRequest, CaptureWriter, from_line, load_capture, to_line
+from loopview.store.memory import SessionSummary, TraceStore
+from loopview.tools.report import tools_report
+
+# The UI build (vite) writes its output here. It is generated, not committed.
+STATIC_DIR = Path(__file__).parent / "static"
+# The flagship demo run, recorded from examples/demo (a copy of fixtures/flagship.otlp.jsonl).
+DEMO_RECORDING = Path(__file__).parent / "demo_data" / "flagship.otlp.jsonl"
+
+# Shown when someone runs the server from a source checkout without building the UI.
+_MISSING_UI_PAGE = """<!doctype html>
+<html><body style="font-family:sans-serif;background:#0a0a0b;color:#e5e5e5;padding:40px">
+<h1>loopview is running</h1>
+<p>The UI has not been built. Run <code>npm run build</code> in <code>ui/</code>.</p>
+</body></html>"""
+
+
+# Recent FastAPI versions trace themselves and, on startup, export to the OTLP
+# endpoint in OTEL_* variables: the very ones users set to point their agents at
+# loopview. loopview would then trace every request it receives and send the spans
+# to itself, a loop without end. Older versions have no such option.
+_NO_SELF_TELEMETRY = (
+    {"telemetry": {"tracing": False, "metrics": False, "logs": False, "auto_configure": False}}
+    if "telemetry" in inspect.signature(FastAPI.__init__).parameters
+    else {}
+)
+
+
+def create_app(
+    store: TraceStore | None = None,
+    capture: CaptureWriter | None = None,
+    static_dir: Path = STATIC_DIR,
+    pricing: Pricing | None = None,
+) -> FastAPI:
+    store = store if store is not None else TraceStore()
+    hub = LiveHub(store, pricing)
+    hub.mark(run.trace_id for run in store.runs())  # runs loaded from --persist
+
+    @asynccontextmanager
+    async def lifespan(_: FastAPI) -> AsyncIterator[None]:
+        async with running(hub):
+            yield
+
+    app = FastAPI(title="loopview", version=__version__, lifespan=lifespan, **_NO_SELF_TELEMETRY)
+    app.state.store = store
+    app.state.hub = hub
+
+    # --- OTLP receiver ----------------------------------------------------------
+
+    @app.post("/v1/traces")
+    async def receive_traces(request: Request) -> Response:
+        # `async def` keeps every store update on the event loop, one at a time.
+        content_type = request.headers.get("content-type", "")
+        declared_length = int(request.headers.get("content-length") or 0)
+        if declared_length > MAX_BODY_BYTES:
+            raise HTTPException(413, "request body too large")
+        try:
+            body = decompress(await request.body(), request.headers.get("content-encoding"))
+            spans = decode_body(body, content_type)
+        except UnsupportedContentType as exc:
+            raise HTTPException(415, str(exc)) from exc
+        except BodyTooLarge as exc:
+            raise HTTPException(413, str(exc)) from exc
+        except OtlpDecodeError as exc:
+            # 400 tells the exporter not to retry.
+            raise HTTPException(400, str(exc)) from exc
+
+        received_at_ns = time.time_ns()
+        hub.mark(store.add_spans(spans, received_at_ns=received_at_ns))
+        if capture is not None:
+            capture.write(CapturedRequest(received_at_ns, content_type, body))
+
+        payload, media_type = encode_success_response(content_type)
+        return Response(content=payload, media_type=media_type)
+
+    @app.post("/v1/loopview/span-starts")
+    async def receive_span_starts(request: Request) -> Response:
+        """Start reports from loopview-sdk: OTLP-encoded spans that have just
+        started (no end time). Standard exporters only send ended spans, so this
+        is what lets a step show as running the moment it begins."""
+        content_type = request.headers.get("content-type", "")
+        try:
+            body = decompress(await request.body(), request.headers.get("content-encoding"))
+            spans = decode_body(body, content_type)
+        except UnsupportedContentType as exc:
+            raise HTTPException(415, str(exc)) from exc
+        except OtlpDecodeError as exc:
+            raise HTTPException(400, str(exc)) from exc
+        hub.mark(store.add_started_spans(spans))
+        payload, media_type = encode_success_response(content_type)
+        return Response(content=payload, media_type=media_type)
+
+    # --- normalized runs and live events ------------------------------------------
+
+    @app.get("/api/health")
+    def health() -> dict[str, str]:
+        return {"status": "ok", "version": __version__}
+
+    @app.get("/api/runs")
+    def list_runs() -> list[RunInfo]:
+        return hub.run_infos()
+
+    @app.get("/api/runs/{trace_id}")
+    def get_run(trace_id: str) -> NormalizedRun:
+        normalized = hub.get(trace_id)
+        if normalized is None:
+            raise HTTPException(404, "run not found")
+        return normalized
+
+    @app.get("/api/sessions")
+    def list_sessions() -> list[SessionSummary]:
+        return store.sessions()
+
+    @app.get("/api/tools")
+    def tools(session: str | None = None, runs: str | None = None) -> dict[str, Any]:
+        """The Tools tab: how tools behave across runs. All runs by default, or one
+        session's (`?session=id`), or a list (`?runs=id1,id2`). Recomputed on
+        every request, which is cheap at a few hundred runs."""
+        if runs:
+            trace_ids = [t for t in runs.split(",") if t]
+        elif session:
+            match = [s for s in store.sessions() if s.session_id == session]
+            if not match:
+                raise HTTPException(404, "session not found")
+            trace_ids = match[0].trace_ids
+        else:
+            trace_ids = [run.trace_id for run in store.runs()]
+        normalized = [n for n in (hub.get(t) for t in trace_ids) if n is not None]
+        if runs and not normalized:
+            raise HTTPException(404, "none of these runs were found")
+        return tools_report(normalized)
+
+    @app.get("/api/events")
+    async def events() -> StreamingResponse:
+        return StreamingResponse(
+            hub.events(),
+            media_type="text/event-stream",
+            headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
+        )
+
+    # --- import, export, demo -----------------------------------------------------
+
+    @app.get("/api/runs/{trace_id}/export")
+    def export_run(trace_id: str) -> Response:
+        """The run as a capture file: one OTLP/JSON request per original arrival
+        batch, so importing it replays the same timing."""
+        run = store.get_run(trace_id)
+        if run is None:
+            raise HTTPException(404, "run not found")
+        batches: dict[int, list[RawSpan]] = {}
+        for span_id, span in run.spans.items():
+            batches.setdefault(run.received_ns[span_id], []).append(span)
+        lines = [
+            to_line(CapturedRequest(received, JSON, json.dumps(spans_to_otlp_json(spans)).encode()))
+            for received, spans in sorted(batches.items())
+        ]
+        return Response(
+            content="\n".join(lines) + "\n",
+            media_type="application/x-ndjson",
+            headers={"Content-Disposition": f'attachment; filename="run-{trace_id[:8]}.jsonl"'},
+        )
+
+    @app.post("/api/import")
+    async def import_runs(request: Request) -> dict[str, list[str]]:
+        changed: list[str] = []
+        try:
+            for line in (await request.body()).decode("utf-8").splitlines():
+                if not line.strip():
+                    continue
+                captured = from_line(line)
+                spans = decode_body(captured.body, captured.content_type)
+                changed += store.add_spans(spans, received_at_ns=captured.received_at_ns)
+        except (ValueError, KeyError, TypeError) as exc:
+            raise HTTPException(400, f"not a loopview JSONL file: {exc}") from exc
+        hub.mark(changed)
+        return {"trace_ids": sorted(set(changed))}
+
+    @app.post("/api/demo")
+    def load_demo() -> dict[str, list[str]]:
+        return {"trace_ids": load_demo_into(store, hub)}
+
+    @app.get("/api/runs/{trace_id}/spans")
+    def run_spans(trace_id: str) -> list[RawSpan]:
+        """Raw spans of one run, for debugging only. The UI never uses this."""
+        run = store.get_run(trace_id)
+        if run is None:
+            raise HTTPException(404, "run not found")
+        return sorted(run.spans.values(), key=lambda s: s.start_time_unix_nano)
+
+    # --- UI ---------------------------------------------------------------------
+
+    if (static_dir / "index.html").exists():
+        # html=True makes "/" serve index.html. Mounted last so /api and /v1 win.
+        app.mount("/", StaticFiles(directory=static_dir, html=True), name="ui")
+    else:
+
+        @app.get("/", response_class=HTMLResponse)
+        def missing_ui() -> str:
+            return _MISSING_UI_PAGE
+
+    return app
+
+
+def load_demo_into(store: TraceStore, hub: LiveHub | None = None) -> list[str]:
+    """Load the bundled demo recording. Loading it twice is harmless: spans are
+    keyed by id, so the same run is simply updated."""
+    demo = TraceStore()
+    load_capture(demo, DEMO_RECORDING)
+    trace_ids = [run.trace_id for run in demo.runs()]
+    load_capture(store, DEMO_RECORDING)
+    if hub is not None:
+        hub.mark(trace_ids)
+    return trace_ids

loopview/cli.py

@@ -0,0 +1,128 @@
+"""Command line entry point: `loopview`.
+
+argparse (standard library) instead of click/typer: we only need a few flags,
+so an extra dependency is not worth it.
+"""
+
+import argparse
+import logging
+import threading
+import webbrowser
+from pathlib import Path
+from types import FrameType
+
+import uvicorn
+
+from loopview import __version__
+from loopview.app import create_app, load_demo_into
+from loopview.cost.pricing import merged_pricing
+from loopview.live import LiveHub
+from loopview.store.capture import CaptureWriter, load_capture
+from loopview.store.memory import DEFAULT_MAX_RUNS, TraceStore
+
+# 4318 is the standard OTLP/HTTP port, so exporters work with only an endpoint change.
+DEFAULT_PORT = 4318
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(
+        prog="loopview", description="Watch your AI agents run as a live graph."
+    )
+    parser.add_argument(
+        "command",
+        nargs="?",
+        choices=["demo"],
+        help="demo: start with a recorded multi-agent run loaded and open the browser",
+    )
+    parser.add_argument(
+        "--host", default="127.0.0.1", help="interface to bind (default: localhost only)"
+    )
+    parser.add_argument(
+        "--port", type=int, default=DEFAULT_PORT, help=f"port (default: {DEFAULT_PORT})"
+    )
+    parser.add_argument(
+        "--persist",
+        type=Path,
+        metavar="FILE",
+        help="save every received request to this JSONL file and reload it on start",
+    )
+    parser.add_argument(
+        "--max-runs",
+        type=int,
+        default=DEFAULT_MAX_RUNS,
+        help=f"how many recent runs to keep in memory (default: {DEFAULT_MAX_RUNS})",
+    )
+    parser.add_argument(
+        "--prices",
+        type=Path,
+        metavar="FILE",
+        help="JSON file of model prices, replacing the bundled ones (see cost/pricing.json)",
+    )
+    parser.add_argument("--no-browser", action="store_true", help="don't open the browser")
+    parser.add_argument("--version", action="version", version=f"loopview {__version__}")
+    args = parser.parse_args(argv)
+
+    logging.basicConfig(level=logging.INFO, format="%(levelname)s %(name)s: %(message)s")
+    logging.getLogger("asyncio").addFilter(_IgnoreWindowsConnectionReset())
+    store = TraceStore(max_runs=args.max_runs)
+    capture = None
+    if args.persist is not None:
+        if args.persist.exists():
+            loaded = load_capture(store, args.persist)
+            print(f"loaded {loaded} requests from {args.persist}")
+        capture = CaptureWriter(args.persist)
+    if args.command == "demo":
+        load_demo_into(store)
+
+    print(f"loopview {__version__}")
+    print(f"  UI:            http://{args.host}:{args.port}")
+    print(f"  OTLP endpoint: http://{args.host}:{args.port}/v1/traces")
+    if capture is not None:
+        print(f"  persisting to: {args.persist}")
+    # Flush now: when stdout is a pipe, Python buffers it and the banner would
+    # only appear when the server stops.
+    print(flush=True)
+    if args.command == "demo" and not args.no_browser:
+        # Give the server a moment to start listening before the browser asks.
+        url = f"http://{args.host}:{args.port}"
+        threading.Timer(1.0, webbrowser.open, args=[url]).start()
+    app = create_app(store=store, capture=capture, pricing=merged_pricing(args.prices))
+    server = _Server(
+        uvicorn.Config(app, host=args.host, port=args.port, log_level="warning"), app.state.hub
+    )
+    try:
+        server.run()
+    except KeyboardInterrupt:
+        # uvicorn re-raises Ctrl+C once it has shut down cleanly; that's the
+        # normal way out, not an error.
+        print("loopview stopped")
+    finally:
+        if capture is not None:
+            capture.close()
+
+
+class _Server(uvicorn.Server):
+    """uvicorn's server, which also ends the live streams as soon as Ctrl+C is
+    pressed. Otherwise it would wait for the browser's open event stream, which
+    never closes on its own, and then cancel it with a traceback."""
+
+    def __init__(self, config: uvicorn.Config, hub: LiveHub) -> None:
+        super().__init__(config)
+        self.hub = hub
+
+    def handle_exit(self, sig: int, frame: FrameType | None) -> None:
+        self.hub.close()
+        super().handle_exit(sig, frame)
+
+
+class _IgnoreWindowsConnectionReset(logging.Filter):
+    """On Windows, asyncio logs a ConnectionResetError when a browser closes a
+    connection abruptly (a known, harmless Python issue). Drop that one record."""
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        error = record.exc_info[1] if record.exc_info else None
+        return not isinstance(error, ConnectionResetError)
+
+
+if __name__ == "__main__":
+    main()

loopview/cost/__init__.py

@@ -0,0 +1 @@
+"""Cost: where the tokens of each model call came from, and what they cost."""

loopview/cost/pricing.json

@@ -0,0 +1,62 @@
+{
+  "_about": [
+    "Prices per million tokens, in USD. Edit this file, or pass your own with `loopview --prices FILE` (entries there replace these).",
+    "A model matches the longest key it starts with, so dated IDs like claude-haiku-4-5-20251001 match claude-haiku-4-5.",
+    "cache_write is the 5-minute cache write price; 1-hour cache writes cost more and are not told apart in traces.",
+    "tool_prompt_tokens: input tokens the provider adds when tools are passed (tool_choice auto or none); shown as its own segment.",
+    "OpenAI: Standard tier. OpenAI caches automatically and charges nothing to write the cache, so cache_write is the input price; models without a cached price get cache_read = input.",
+    "Not modelled: OpenAI's long-context rates (input doubles above 272K tokens on newer models), Batch/Flex/Priority tiers, regional pricing.",
+    "A model missing here is shown in tokens only, never with a guessed price."
+  ],
+  "models": {
+    "claude-fable-5-1": {"input": 10, "cache_write": 12.5, "cache_read": 0.25, "output": 50, "source": "https://platform.claude.com/docs/en/about-claude/pricing", "checked": "2026-10-02"},
+    "claude-fable-5": {"input": 10, "cache_write": 12.5, "cache_read": 1, "output": 50, "source": "https://platform.claude.com/docs/en/about-claude/pricing", "checked": "2026-10-02"},
+    "claude-opus-5-5": {"input": 4, "cache_write": 5, "cache_read": 0.2, "output": 20, "tool_prompt_tokens": 286, "source": "https://platform.claude.com/docs/en/about-claude/pricing", "checked": "2026-10-02"},
+    "claude-opus-5": {"input": 5, "cache_write": 6.25, "cache_read": 0.5, "output": 25, "tool_prompt_tokens": 286, "source": "https://platform.claude.com/docs/en/about-claude/pricing", "checked": "2026-10-02"},
+    "claude-opus-4-8": {"input": 5, "cache_write": 6.25, "cache_read": 0.5, "output": 25, "tool_prompt_tokens": 290, "source": "https://platform.claude.com/docs/en/about-claude/pricing", "checked": "2026-10-02"},
+    "claude-opus-4-7": {"input": 5, "cache_write": 6.25, "cache_read": 0.5, "output": 25, "tool_prompt_tokens": 675, "source": "https://platform.claude.com/docs/en/about-claude/pricing", "checked": "2026-10-02"},
+    "claude-opus-4-6": {"input": 5, "cache_write": 6.25, "cache_read": 0.5, "output": 25, "tool_prompt_tokens": 497, "source": "https://platform.claude.com/docs/en/about-claude/pricing", "checked": "2026-10-02"},
+    "claude-opus-4-5": {"input": 5, "cache_write": 6.25, "cache_read": 0.5, "output": 25, "tool_prompt_tokens": 496, "source": "https://platform.claude.com/docs/en/about-claude/pricing", "checked": "2026-10-02"},
+    "claude-sonnet-5-5": {"input": 2, "cache_write": 2.5, "cache_read": 0.2, "output": 10, "tool_prompt_tokens": 286, "source": "https://platform.claude.com/docs/en/about-claude/pricing", "checked": "2026-10-02"},
+    "claude-sonnet-5": {"input": 2, "cache_write": 2.5, "cache_read": 0.2, "output": 10, "tool_prompt_tokens": 354, "source": "https://platform.claude.com/docs/en/about-claude/pricing", "checked": "2026-10-02"},
+    "claude-sonnet-4-6": {"input": 3, "cache_write": 3.75, "cache_read": 0.3, "output": 15, "tool_prompt_tokens": 497, "source": "https://platform.claude.com/docs/en/about-claude/pricing", "checked": "2026-10-02"},
+    "claude-sonnet-4-5": {"input": 3, "cache_write": 3.75, "cache_read": 0.3, "output": 15, "tool_prompt_tokens": 496, "source": "https://platform.claude.com/docs/en/about-claude/pricing", "checked": "2026-10-02"},
+    "claude-haiku-4-5": {"input": 1, "cache_write": 1.25, "cache_read": 0.1, "output": 5, "tool_prompt_tokens": 496, "source": "https://platform.claude.com/docs/en/about-claude/pricing", "checked": "2026-10-02"},
+    "gpt-6-astra": {"input": 10.0, "cache_write": 10.0, "cache_read": 1.0, "output": 50.0, "source": "https://developers.openai.com/api/docs/pricing", "checked": "2026-10-03"},
+    "gpt-6.1-sol": {"input": 2.0, "cache_write": 2.0, "cache_read": 0.1, "output": 10.0, "source": "https://developers.openai.com/api/docs/pricing", "checked": "2026-10-03"},
+    "gpt-6-sol": {"input": 2.0, "cache_write": 2.0, "cache_read": 0.2, "output": 10.0, "source": "https://developers.openai.com/api/docs/pricing", "checked": "2026-10-03"},
+    "gpt-6-luna": {"input": 0.1, "cache_write": 0.1, "cache_read": 0.01, "output": 0.5, "source": "https://developers.openai.com/api/docs/pricing", "checked": "2026-10-03"},
+    "gpt-5.6-sol": {"input": 4.0, "cache_write": 4.0, "cache_read": 0.4, "output": 20.0, "source": "https://developers.openai.com/api/docs/pricing", "checked": "2026-10-03"},
+    "gpt-5.6-terra": {"input": 2.0, "cache_write": 2.0, "cache_read": 0.2, "output": 12.0, "source": "https://developers.openai.com/api/docs/pricing", "checked": "2026-10-03"},
+    "gpt-5.6-luna": {"input": 0.2, "cache_write": 0.2, "cache_read": 0.02, "output": 1.2, "source": "https://developers.openai.com/api/docs/pricing", "checked": "2026-10-03"},
+    "gpt-5.5": {"input": 5.0, "cache_write": 5.0, "cache_read": 0.5, "output": 30.0, "source": "https://developers.openai.com/api/docs/pricing", "checked": "2026-10-03"},
+    "gpt-5.5-pro": {"input": 30.0, "cache_write": 30.0, "cache_read": 30.0, "output": 180.0, "source": "https://developers.openai.com/api/docs/pricing", "checked": "2026-10-03"},
+    "gpt-5.4": {"input": 2.5, "cache_write": 2.5, "cache_read": 0.25, "output": 15.0, "source": "https://developers.openai.com/api/docs/pricing", "checked": "2026-10-03"},
+    "gpt-5.4-mini": {"input": 0.75, "cache_write": 0.75, "cache_read": 0.075, "output": 4.5, "source": "https://developers.openai.com/api/docs/pricing", "checked": "2026-10-03"},
+    "gpt-5.4-nano": {"input": 0.2, "cache_write": 0.2, "cache_read": 0.02, "output": 1.25, "source": "https://developers.openai.com/api/docs/pricing", "checked": "2026-10-03"},
+    "gpt-5.4-pro": {"input": 30.0, "cache_write": 30.0, "cache_read": 30.0, "output": 180.0, "source": "https://developers.openai.com/api/docs/pricing", "checked": "2026-10-03"},
+    "gpt-5.2": {"input": 1.75, "cache_write": 1.75, "cache_read": 0.175, "output": 14.0, "source": "https://developers.openai.com/api/docs/pricing", "checked": "2026-10-03"},
+    "gpt-5.2-pro": {"input": 21.0, "cache_write": 21.0, "cache_read": 21.0, "output": 168.0, "source": "https://developers.openai.com/api/docs/pricing", "checked": "2026-10-03"},
+    "gpt-5.1": {"input": 1.25, "cache_write": 1.25, "cache_read": 0.125, "output": 10.0, "source": "https://developers.openai.com/api/docs/pricing", "checked": "2026-10-03"},
+    "gpt-5": {"input": 1.25, "cache_write": 1.25, "cache_read": 0.125, "output": 10.0, "source": "https://developers.openai.com/api/docs/pricing", "checked": "2026-10-03"},
+    "gpt-5-mini": {"input": 0.25, "cache_write": 0.25, "cache_read": 0.025, "output": 2.0, "source": "https://developers.openai.com/api/docs/pricing", "checked": "2026-10-03"},
+    "gpt-5-nano": {"input": 0.05, "cache_write": 0.05, "cache_read": 0.005, "output": 0.4, "source": "https://developers.openai.com/api/docs/pricing", "checked": "2026-10-03"},
+    "gpt-5-pro": {"input": 15.0, "cache_write": 15.0, "cache_read": 15.0, "output": 120.0, "source": "https://developers.openai.com/api/docs/pricing", "checked": "2026-10-03"},
+    "gpt-4.1": {"input": 2.0, "cache_write": 2.0, "cache_read": 0.5, "output": 8.0, "source": "https://developers.openai.com/api/docs/pricing", "checked": "2026-10-03"},
+    "gpt-4.1-mini": {"input": 0.4, "cache_write": 0.4, "cache_read": 0.1, "output": 1.6, "source": "https://developers.openai.com/api/docs/pricing", "checked": "2026-10-03"},
+    "gpt-4.1-nano": {"input": 0.1, "cache_write": 0.1, "cache_read": 0.025, "output": 0.4, "source": "https://developers.openai.com/api/docs/pricing", "checked": "2026-10-03"},
+    "gpt-4o": {"input": 2.5, "cache_write": 2.5, "cache_read": 1.25, "output": 10.0, "source": "https://developers.openai.com/api/docs/pricing", "checked": "2026-10-03"},
+    "gpt-4o-2024-05-13": {"input": 5.0, "cache_write": 5.0, "cache_read": 5.0, "output": 15.0, "source": "https://developers.openai.com/api/docs/pricing", "checked": "2026-10-03"},
+    "gpt-4o-mini": {"input": 0.15, "cache_write": 0.15, "cache_read": 0.075, "output": 0.6, "source": "https://developers.openai.com/api/docs/pricing", "checked": "2026-10-03"},
+    "o1": {"input": 15.0, "cache_write": 15.0, "cache_read": 7.5, "output": 60.0, "source": "https://developers.openai.com/api/docs/pricing", "checked": "2026-10-03"},
+    "o1-pro": {"input": 150.0, "cache_write": 150.0, "cache_read": 150.0, "output": 600.0, "source": "https://developers.openai.com/api/docs/pricing", "checked": "2026-10-03"},
+    "o3": {"input": 2.0, "cache_write": 2.0, "cache_read": 0.5, "output": 8.0, "source": "https://developers.openai.com/api/docs/pricing", "checked": "2026-10-03"},
+    "o3-pro": {"input": 20.0, "cache_write": 20.0, "cache_read": 20.0, "output": 80.0, "source": "https://developers.openai.com/api/docs/pricing", "checked": "2026-10-03"},
+    "o3-mini": {"input": 1.1, "cache_write": 1.1, "cache_read": 0.55, "output": 4.4, "source": "https://developers.openai.com/api/docs/pricing", "checked": "2026-10-03"},
+    "o4-mini": {"input": 1.1, "cache_write": 1.1, "cache_read": 0.275, "output": 4.4, "source": "https://developers.openai.com/api/docs/pricing", "checked": "2026-10-03"},
+    "gpt-4-turbo": {"input": 10.0, "cache_write": 10.0, "cache_read": 10.0, "output": 30.0, "source": "https://developers.openai.com/api/docs/pricing", "checked": "2026-10-03"},
+    "gpt-4-0613": {"input": 30.0, "cache_write": 30.0, "cache_read": 30.0, "output": 60.0, "source": "https://developers.openai.com/api/docs/pricing", "checked": "2026-10-03"},
+    "gpt-3.5-turbo": {"input": 0.5, "cache_write": 0.5, "cache_read": 0.5, "output": 1.5, "source": "https://developers.openai.com/api/docs/pricing", "checked": "2026-10-03"},
+    "gpt-3.5-turbo-1106": {"input": 1.0, "cache_write": 1.0, "cache_read": 1.0, "output": 2.0, "source": "https://developers.openai.com/api/docs/pricing", "checked": "2026-10-03"}
+  }
+}

loopview/cost/pricing.py

@@ -0,0 +1,74 @@
+"""Model prices, from a small JSON file the user can edit.
+
+JSON rather than YAML: Python and browsers read it with no extra dependency.
+JSON has no comments, so the file explains itself in an "_about" list, and each
+price carries its source and the date it was checked.
+"""
+
+import json
+import re
+from functools import cache
+from pathlib import Path
+
+from pydantic import BaseModel
+
+DEFAULT_PRICES = Path(__file__).parent / "pricing.json"
+
+
+class ModelPrice(BaseModel):
+    """USD per million tokens."""
+
+    input: float
+    output: float
+    cache_read: float
+    cache_write: float
+    tool_prompt_tokens: int | None = None
+    source: str
+    checked: str
+
+
+class Pricing(BaseModel):
+    models: dict[str, ModelPrice]
+
+    def for_model(self, model: str | None) -> tuple[str, ModelPrice] | None:
+        """The longest key the model ID equals or starts with (then a dash), so a
+        dated ID like claude-haiku-4-5-20251001 matches claude-haiku-4-5, and
+        claude-sonnet-5-5 doesn't fall back to claude-sonnet-5."""
+        if not model:
+            return None
+        for name in _model_names(model.lower()):
+            matches = [k for k in self.models if name == k or name.startswith(k + "-")]
+            if matches:
+                key = max(matches, key=len)
+                return key, self.models[key]
+        return None
+
+
+# Routers and clouds prefix the provider's model ID: LiteLLM "anthropic/...",
+# Bedrock "us.anthropic.claude-...-v1:0", Vertex "claude-...@20251001".
+_PROVIDER_PREFIX = re.compile(r"^(?:[a-z]{2,4}\.)?(?:anthropic|openai|meta|mistral)\.")
+
+
+def _model_names(model: str) -> list[str]:
+    """The ID as given, then without a router's or cloud's prefix."""
+    bare = model.rsplit("/", 1)[-1].replace("@", "-")
+    bare = _PROVIDER_PREFIX.sub("", bare)
+    return [model] if bare == model else [model, bare]
+
+
+def load_pricing(path: Path) -> Pricing:
+    data = json.loads(path.read_text(encoding="utf-8"))
+    return Pricing(models=data["models"])
+
+
+@cache
+def default_pricing() -> Pricing:
+    return load_pricing(DEFAULT_PRICES)
+
+
+def merged_pricing(override: Path | None) -> Pricing:
+    """The bundled prices, with the user's file replacing or adding models."""
+    base = default_pricing()
+    if override is None:
+        return base
+    return Pricing(models={**base.models, **load_pricing(override).models})