sessioncost 0.2.0__py3-none-any.whl

sessioncost/fixes.py

@@ -0,0 +1,182 @@
+"""Fixes: each one names what to change and a saving measured from this session's own calls.
+
+The open tool ships three simple detectors (BasicFixes). Every saving is the cost of the tokens or calls involved
+in THIS session, priced like the rest of the report - nothing is projected or guessed.
+
+PLUG-IN POINT: a separate fix engine can add detectors without changing this repo. Set the environment variable
+SESSIONCOST_ENGINE to an importable module name; that module must expose `Engine()`, an object with a `name` and
+`find(session, pricer) -> list[Fix]` (the FixEngine interface below). It runs after the built-in detectors and its
+fixes are ranked together with theirs.
+"""
+from __future__ import annotations
+
+import importlib
+import os
+import re
+from typing import Protocol
+
+from . import prices as pricemod
+from .model import Call, Fix, Session
+
+MAX_FIXES = 3
+CONFIRM = {"y", "yes", "yes please", "yep", "yeah", "ok", "okay", "k", "sure", "go", "go ahead", "go on", "do it",
+           "proceed", "continue", "save", "save it", "confirm", "confirmed", "approve", "approved", "lgtm",
+           "sounds good", "looks good", "ship it", "fine"}
+
+
+def tok(chars: int) -> int:
+    return max(0, int(chars) // 4)
+
+
+def is_confirm(text: str) -> bool:
+    t = re.sub(r"[^\w\s]", "", (text or "").lower()).strip()
+    t = re.sub(r"\s+", " ", t)
+    return bool(t) and len(t) <= 25 and t in CONFIRM
+
+
+def sent_usd(c: Call, r: dict) -> float:
+    cc = pricemod.cost(c.usage, r)
+    return cc["input"] + cc["cache_write_5m"] + cc["cache_write_1h"] + cc["cache_read"]
+
+
+class FixEngine(Protocol):
+    name: str
+
+    def find(self, session: Session, pricer) -> list[Fix]: ...
+
+
+def unused_tools(s: Session, P) -> Fix | None:
+    """Tool definitions sent with every call that the session never used."""
+    if not s.setup.tools or not s.calls:
+        return None
+    used = {a.tool for a in s.actions()}
+    unused = [t for t in s.setup.tools if t.what not in used]
+    tokens = sum(tok(t.chars) for t in unused)
+    if not tokens:
+        return None
+    usd = 0.0
+    for c in s.calls:
+        # The setup is the front of the prompt, so it comes from the cache first; only what the call really
+        # wrote as new input can be priced as new input. The saving can never exceed what the call paid to send.
+        r, u = P.rates(c), c.usage
+        from_cache = min(tokens, u.cache_read)
+        as_new = min(tokens - from_cache, u.new_input)
+        usd += (from_cache * r["cache_read"] + as_new * pricemod.new_input_rate(u, r)) / 1e6
+    top = sorted(unused, key=lambda t: -t.chars)
+    return Fix(
+        id="unused-tools", title="Turn off tools this session never used",
+        why=(f"{len(unused)} of {len(s.setup.tools)} tool definitions (~{tokens:,} tokens) went out with every one "
+             f"of the {len(s.calls)} calls and were never used. If this project does not need them (MCP servers and "
+             "plugins are the usual ones), turning them off saves this much on a session like this one."),
+        saving_usd=usd, saving_tokens=tokens * len(s.calls), where="every call",
+        items=[f"{t.what} ~{tok(t.chars):,} tokens" for t in top[:8]] + (
+            [f"and {len(top) - 8} more"] if len(top) > 8 else []))
+
+
+def repeated_reads(s: Session, P) -> Fix | None:
+    """The same file read again with exactly the same content, in the same thread."""
+    threads = [s.calls] + [h.calls for h in s.helpers]
+    usd, tokens, items, turns = 0.0, 0, [], set()
+    for calls in threads:
+        seen: dict[str, str] = {}
+        for i, c in enumerate(calls):
+            for a in c.actions:
+                if a.kind in ("write", "edit"):
+                    for f in a.target.splitlines() or [""]:
+                        seen.pop(f, None)
+                        for k in [k for k in seen if f and f in k.splitlines()]:
+                            seen.pop(k)
+                    continue
+                if a.kind != "read" or a.result_chars < 200 or not a.result_hash:
+                    continue
+                key = a.target
+                if seen.get(key) == a.result_hash + str(a.label):
+                    t = tok(a.result_chars)
+                    if i + 1 < len(calls):
+                        nxt = calls[i + 1]
+                        cost = t * pricemod.new_input_rate(nxt.usage, P.rates(nxt))
+                        cost += sum(t * P.rates(k)["cache_read"] for k in calls[i + 2:])
+                        usd += cost / 1e6
+                    tokens += t
+                    turns.add(c.turn)
+                    items.append(f"{a.label} again (~{t:,} tokens, unchanged), call {c.n}"
+                                 + ("" if c.agent == "main" else f" of helper {c.agent.split(':')[-1]}"))
+                else:
+                    seen[key] = a.result_hash + str(a.label)
+    if not items:
+        return None
+    return Fix(
+        id="repeated-reads", title="Don't re-read a file that has not changed",
+        why=(f"{len(items)} read{'s' if len(items) > 1 else ''} returned exactly the same text as an earlier read in "
+             "the same chat. The copy was paid for when it came in and again on every later call that carried it."),
+        saving_usd=usd, saving_tokens=tokens, where=_where(turns), turns=sorted(turns), items=items[:8])
+
+
+def confirm_turns(s: Session, P) -> Fix | None:
+    """A stop where the user only said yes / ok / save, and the next call just acted on it."""
+    usd, hits, turns, tokens = 0.0, [], set(), 0
+    for t in s.turns:
+        if t.kind in ("typed", "queued") and t.calls and is_confirm(t.text):
+            c = t.calls[0]
+            usd += sent_usd(c, P.rates(c))
+            tokens += c.usage.context
+            hits.append(f"turn {t.n}: you typed “{t.text}”; the next call re-sent "
+                        f"{c.usage.context:,} tokens to receive it")
+            turns.add(t.n)
+        for e in t.events:
+            if e.kind != "answer" or not e.ts:
+                continue
+            answers = [x for x in e.text.split("; ") if x.strip()]
+            if answers and all(is_confirm(x) for x in answers):
+                nxt = next((c for c in t.calls if c.ts_first and c.ts_first >= e.ts), None)
+                if nxt is None:
+                    continue
+                usd += sent_usd(nxt, P.rates(nxt))
+                tokens += nxt.usage.context
+                hits.append(f"turn {t.n}: you picked “{e.text}” on a question card; the next call re-sent "
+                            f"{nxt.usage.context:,} tokens to receive it")
+                turns.add(t.n)
+    if not hits:
+        return None
+    return Fix(
+        id="confirm-turn", title="Skip the stop that only asks you to confirm",
+        why=("The agent stopped and waited for a yes. Receiving it meant re-sending the whole conversation once "
+             "more. Let it go ahead and ask “change anything?” afterwards instead."),
+        saving_usd=usd, saving_tokens=tokens, where=_where(turns), turns=sorted(turns), items=hits)
+
+
+def _where(turns) -> str:
+    ts = sorted(turns)
+    return ("turn " if len(ts) == 1 else "turns ") + ", ".join(str(t) for t in ts) if ts else ""
+
+
+class BasicFixes:
+    name = "built-in"
+
+    def find(self, session: Session, pricer) -> list[Fix]:
+        return [f for f in (unused_tools(session, pricer), repeated_reads(session, pricer),
+                            confirm_turns(session, pricer)) if f]
+
+
+def load_engines() -> list:
+    engines: list = [BasicFixes()]
+    # ---- PLUG-IN POINT (see the module docstring). Only loaded when the user names it explicitly.
+    mod = os.environ.get("SESSIONCOST_ENGINE", "").strip()
+    if mod:
+        try:
+            engines.append(importlib.import_module(mod).Engine())
+        except Exception as e:  # an engine problem must never break the report
+            print(f"sessioncost: fix engine {mod!r} not loaded: {e}")
+    return engines
+
+
+def find(session: Session, pricer, engines: list | None = None) -> list[Fix]:
+    out: list[Fix] = []
+    for eng in engines if engines is not None else load_engines():
+        for f in eng.find(session, pricer) or []:
+            if f.source == "built-in" and getattr(eng, "name", "built-in") != "built-in":
+                f.source = eng.name
+            out.append(f)
+    out = [f for f in out if f.saving_usd > 0]
+    out.sort(key=lambda f: (-f.saving_tokens, -f.saving_usd))   # tokens cut first; money follows
+    return out[:MAX_FIXES]

sessioncost/locate.py

@@ -0,0 +1,178 @@
+"""Finding Claude Code, Codex, Antigravity and Cursor sessions on this machine.
+
+Codex keeps every thread under $CODEX_HOME/sessions/YYYY/MM/DD/rollout-<time>-<id>.jsonl (CODEX_HOME defaults to
+~/.codex); the project is the `cwd` in each file's first row. Helper threads (they carry a parent thread id) are
+read with their main session, never listed on their own.
+
+Antigravity keeps one SQLite file per conversation under ~/.gemini/antigravity-ide/conversations (or
+$ANTIGRAVITY_HOME/conversations); the project is the workspace stored inside it.
+
+Cursor keeps every chat in one SQLite file (see readers/cursor.py for where); a chat stands in for a session file
+as a `CursorChat`. Helper chats are read with the chat that started them, never listed on their own.
+
+Claude Code keeps one folder per project under ~/.claude/projects (or $CLAUDE_CONFIG_DIR/projects). The folder name
+is the project path with every character other than a letter or digit replaced by '-', e.g. c:\\Users\\x\\my_proj
+-> c--Users-x-my-proj. Matching is case-insensitive (Windows drive letters come in both cases).
+"""
+from __future__ import annotations
+
+import json
+import os
+import re
+from datetime import datetime
+from pathlib import Path
+
+
+def claude_home() -> Path:
+    base = os.environ.get("CLAUDE_CONFIG_DIR")
+    return Path(base).expanduser() if base else Path.home() / ".claude"
+
+
+def codex_home() -> Path:
+    base = os.environ.get("CODEX_HOME")
+    return Path(base).expanduser() if base else Path.home() / ".codex"
+
+
+def session_id(path: Path) -> str:
+    """The id a user types: a Claude Code file is named by it; a Codex file ends with it."""
+    m = re.search(r"([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})$", path.stem)
+    return m.group(1) if m and path.stem.startswith("rollout-") else path.stem   # (a CursorChat's stem is its id)
+
+
+def short_id(path: Path) -> str:
+    return session_id(path)[:8]
+
+
+def project_key(path: str | Path) -> str:
+    return re.sub(r"[^A-Za-z0-9]", "-", str(Path(path).expanduser().resolve()))
+
+
+def project_dir(project: str | Path | None = None, home: Path | None = None) -> Path | None:
+    root = (home or claude_home()) / "projects"
+    if not root.is_dir():
+        return None
+    want = project_key(project or os.getcwd()).lower()
+    for d in root.iterdir():
+        if d.is_dir() and d.name.lower() == want:
+            return d
+    return None
+
+
+def last_stamp(path: Path, tail_bytes: int = 262144, types=("user", "assistant")) -> datetime | None:
+    """The timestamp of the newest row that has one. Reading only the end of the file keeps this fast.
+    (Newest by file time can pick an old chat that was merely reopened; its last row stays old.)"""
+    size = path.stat().st_size
+    with path.open("rb") as f:
+        f.seek(max(0, size - tail_bytes))
+        lines = f.read().decode("utf-8", "replace").splitlines()
+    for line in reversed(lines):
+        if '"timestamp"' not in line:
+            continue
+        try:
+            row = json.loads(line)
+        except ValueError:
+            continue
+        if types and row.get("type") not in types:
+            continue
+        try:
+            return datetime.fromisoformat(str(row["timestamp"]).replace("Z", "+00:00"))
+        except (KeyError, ValueError):
+            continue
+    return None
+
+
+def _same_dir(a: str | Path, b: str | Path) -> bool:
+    try:
+        return os.path.normcase(str(Path(a).expanduser().resolve())) ==             os.path.normcase(str(Path(b).expanduser().resolve()))
+    except OSError:
+        return False
+
+
+def codex_sessions(project: str | Path | None = None, home: Path | None = None) -> list[Path]:
+    """Main Codex threads whose working folder is the project."""
+    root = (home or codex_home()) / "sessions"
+    if not root.is_dir():
+        return []
+    want = project or os.getcwd()
+    out = []
+    for p in root.glob("*/*/*/rollout-*.jsonl"):
+        try:
+            with p.open(encoding="utf-8", errors="replace") as f:
+                row = json.loads(f.readline())
+        except (OSError, ValueError):
+            continue
+        meta = row.get("payload") if isinstance(row, dict) and row.get("type") == "session_meta" else None
+        if isinstance(meta, dict) and not meta.get("parent_thread_id") and meta.get("cwd") and                 _same_dir(meta["cwd"], want):
+            out.append(p)
+    return out
+
+
+def antigravity_home() -> Path:
+    base = os.environ.get("ANTIGRAVITY_HOME")
+    return Path(base).expanduser() if base else Path.home() / ".gemini" / "antigravity-ide"
+
+
+def antigravity_sessions(project: str | Path | None = None,
+                         home: Path | None = None) -> list[tuple[datetime | None, Path]]:
+    """Antigravity conversations whose workspace is the project, with the time of their last step."""
+    from .readers import _pb
+    from .readers.antigravity import _ts, connect, workspace
+    root = (home or antigravity_home()) / "conversations"
+    if not root.is_dir():
+        return []
+    want = project or os.getcwd()
+    out = []
+    for p in root.glob("*.db"):
+        try:
+            con = connect(p)
+            try:
+                ws = workspace(con)
+                if not ws or not _same_dir(ws, want):
+                    continue
+                row = con.execute("select metadata from steps order by idx desc limit 1").fetchone()
+            finally:
+                con.close()
+        except Exception:   # a locked or half-written file must not break the list
+            continue
+        out.append((_ts(row[0], 1) if row else None, p))
+    return out
+
+
+def cursor_sessions(project: str | Path | None = None, db: Path | None = None) -> list[tuple[datetime | None, object]]:
+    """Cursor chats (not helper chats) whose workspace is the project, with their last update time."""
+    from .readers.cursor import CursorChat, chats, connect, helper_ids, state_db, workspace
+    db = db or state_db()
+    if not Path(db).is_file():
+        return []
+    want = project or os.getcwd()
+    try:
+        con = connect(db)
+        try:
+            found = chats(con)
+        finally:
+            con.close()
+    except Exception:   # Cursor may hold the file; the other agents must still be listed
+        return []
+    helpers = helper_ids(found)
+    out = []
+    for d in found:
+        ws = workspace(d)
+        if d["composerId"] in helpers or not ws or not _same_dir(ws, want) or                 not (d.get("fullConversationHeadersOnly") or d.get("conversation")):
+            continue
+        ms = d.get("lastUpdatedAt") or d.get("createdAt")
+        when = datetime.fromtimestamp(ms / 1000).astimezone() if isinstance(ms, (int, float)) else None
+        out.append((when, CursorChat(Path(db), str(d["composerId"]))))
+    return out
+
+
+def sessions(project: str | Path | None = None, home: Path | None = None, codex: Path | None = None,
+             antigravity: Path | None = None, cursor: Path | None = None) -> list[tuple[datetime, Path]]:
+    """Main sessions of a project (Claude Code, Codex, Antigravity, Cursor), newest first."""
+    d = project_dir(project, home)
+    found = [(last_stamp(p), p) for p in d.glob("*.jsonl")] if d is not None else []
+    found += [(last_stamp(p, types=None), p) for p in codex_sessions(project, codex)]
+    found += antigravity_sessions(project, antigravity)
+    found += cursor_sessions(project, cursor)
+    out = [(t, p) for t, p in found if t is not None]
+    out.sort(key=lambda x: x[0], reverse=True)
+    return out

sessioncost/model.py

@@ -0,0 +1,175 @@
+"""The one in-memory shape every reader produces.
+
+A reader for any coding agent (Claude Code today; Codex, Antigravity, Cursor later) turns that agent's own log
+into a `Session`. Everything after the reader (cost, drill-down, fixes, the report) works on a `Session` only, so
+a new agent needs a reader and nothing else.
+
+Session -> Turns (each starts with something the user really typed) -> Calls (one model call each, counted once)
+-> Actions (the tools a call asked for). Helpers (subagents) keep their own calls.
+
+A number the log does not hold stays None; the report then says "not in this log" instead of guessing.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+
+
+@dataclass
+class Usage:
+    """Token counts of one model call, split by how each class is priced."""
+    fresh_input: int = 0        # new input, not cached
+    cache_write_5m: int = 0     # new input written to the 5-minute cache
+    cache_write_1h: int = 0     # new input written to the 1-hour cache
+    cache_read: int = 0         # input re-read from the cache
+    output: int = 0             # everything the model wrote, hidden thinking included
+    thinking: int | None = None  # the hidden-thinking share of `output`; None = the log does not separate it
+    write_split_known: bool = True  # False: the log does not say which cache writes were 5-minute or 1-hour
+
+    @property
+    def cache_write(self) -> int:
+        return self.cache_write_5m + self.cache_write_1h
+
+    @property
+    def new_input(self) -> int:
+        return self.fresh_input + self.cache_write
+
+    @property
+    def context(self) -> int:
+        """Everything sent to the model in this call."""
+        return self.fresh_input + self.cache_write + self.cache_read
+
+
+@dataclass
+class Action:
+    """One tool use a call asked for."""
+    id: str
+    tool: str                    # the agent's own tool name, e.g. "Read"
+    kind: str                    # read | search | edit | write | command | web | helper | question | skill | plan | other
+    label: str                   # plain words, e.g. "read `plan.md`"
+    target: str = ""             # the file, command, query or url
+    args_chars: int = 0          # size of what the model wrote into the call
+    written_chars: int = 0       # text put into a file (write / edit)
+    result_chars: int = 0        # size of what came back
+    result_hash: str = ""        # fingerprint of the result (to spot an unchanged re-read); the text is not kept
+    is_error: bool = False
+    ts: datetime | None = None
+    result_ts: datetime | None = None
+    answer_text: str = ""        # question cards: the answers given
+
+
+@dataclass
+class Call:
+    n: int                       # 1-based within its thread (main or one helper)
+    msg_id: str
+    agent: str                   # "main" or the helper's id
+    model: str
+    usage: Usage
+    ts_first: datetime | None = None
+    ts_last: datetime | None = None
+    turn: int = 0                # the turn it belongs to
+    text_chars: int = 0          # visible text written to the user
+    first_text: str = ""         # the first sentence it wrote (for plain-words labels)
+    thinking_chars: int = 0      # visible thinking text (usually empty: thinking is hidden)
+    actions: list[Action] = field(default_factory=list)
+
+
+@dataclass
+class Event:
+    """Something that entered the conversation that is not a model call: what the user typed, a command, a question
+    card answer, or text the agent's harness injected (labelled, never shown as typed by the user)."""
+    kind: str                    # typed | command | queued | answer | injected | instructions
+    label: str                   # plain words: "you typed", "editor selection (added by the IDE)", ...
+    text: str                    # cleaned text (short)
+    chars: int                   # full size of what entered
+    ts: datetime | None = None
+
+
+@dataclass
+class Turn:
+    n: int
+    kind: str                    # typed | command | queued | start (calls before any user message)
+    text: str                    # what the user asked, cleaned
+    ts: datetime | None = None
+    waited_s: float = 0.0        # time the agent waited for the user before this turn started
+    events: list[Event] = field(default_factory=list)
+    calls: list[Call] = field(default_factory=list)
+
+
+@dataclass
+class Helper:
+    id: str
+    description: str
+    agent_type: str
+    calls: list[Call] = field(default_factory=list)
+    turn: int = 0                # the main turn it ran in
+
+
+@dataclass
+class SetupPart:
+    what: str
+    chars: int
+
+
+@dataclass
+class Setup:
+    """What the agent sends with every call before anyone says a word: system prompt, tool definitions, lists."""
+    known: bool = False
+    parts: list[SetupPart] = field(default_factory=list)
+    tools: list[SetupPart] = field(default_factory=list)     # one entry per tool definition
+
+    @property
+    def chars(self) -> int:
+        return sum(p.chars for p in self.parts)
+
+
+@dataclass
+class Fix:
+    """One fix, with a saving measured from this session's own calls."""
+    id: str
+    title: str
+    why: str                     # one or two plain sentences
+    saving_usd: float
+    saving_tokens: int
+    where: str = ""              # "turn 4", "calls 3, 9, 12"
+    turns: list[int] = field(default_factory=list)
+    items: list[str] = field(default_factory=list)
+    source: str = "built-in"     # which engine found it
+
+
+@dataclass
+class Session:
+    agent: str                   # "claude-code"
+    session_id: str
+    source: str
+    title: str = ""
+    cwd: str = ""
+    model: str = ""
+    agent_version: str = ""
+    started: datetime | None = None
+    ended: datetime | None = None
+    turns: list[Turn] = field(default_factory=list)
+    helpers: list[Helper] = field(default_factory=list)
+    setup: Setup = field(default_factory=Setup)
+    own_cost_usd: float | None = None   # the agent's own running total, when its log carries one
+    billed_per_token: bool = True       # False: the agent's plan never bills per token (money is API-equivalent)
+    tokens_exact: bool = True           # False: the log has no token counts; they are estimated from text size
+    notes: list[str] = field(default_factory=list)
+    fixes: list[Fix] = field(default_factory=list)   # filled by the fix engines (see fixes.py)
+
+    @property
+    def calls(self) -> list[Call]:
+        """Main-thread calls, in order."""
+        return [c for t in self.turns for c in t.calls]
+
+    @property
+    def helper_calls(self) -> list[Call]:
+        return [c for h in self.helpers for c in h.calls]
+
+    @property
+    def all_calls(self) -> list[Call]:
+        return self.calls + self.helper_calls
+
+    def actions(self, include_helpers: bool = True) -> list[Action]:
+        cs = self.all_calls if include_helpers else self.calls
+        return [a for c in cs for a in c.actions]

sessioncost/prices.json

@@ -0,0 +1,36 @@
+{
+  "_read_me": "USD per million tokens. cache_write_5m / cache_write_1h = new input written to the 5-minute / 1-hour prompt cache; cache_read = input re-read from the cache. 'checked': true = the rate was checked against the source below on as_of; false = a guess, shown as an estimate. Override any entry in ~/.sessioncost/prices.json (merged) or with --prices <file>.",
+  "as_of": "2026-10-08",
+  "source": "Anthropic's first-party API price list (model table cached 2026-09-25; cache writes 1.25x input for 5 minutes, 2x for 1 hour; cache reads 0.1x input except where listed). claude-opus-5-5 and claude-haiku-4-5 also cross-checked against Claude Code's own logged cost to the cent. OpenAI (Codex) rows: list prices from third-party price trackers on 2026-10-08, NOT checked against OpenAI's own page (sources disagree; GPT-5.6 Sol has a temporary lower promo rate; long prompts over ~272K tokens may cost more), so they are shown as estimates. OpenAI does not charge extra to write the cache, so the cache-write rates equal input. Unlisted gpt-* / codex-* models use default-openai. Gemini (Antigravity) rows: introductory list prices from third-party trackers on 2026-10-08 (said to run to 2026-12-31, then $1.50 / $0.15 / $7.50), NOT checked against Google's own page; unlisted gemini-* models use default-gemini. Antigravity is not billed per token, so its money is always shown as API-equivalent.",
+  "models": {
+    "default": {"input": 5.0, "output": 25.0, "cache_write_5m": 6.25, "cache_write_1h": 10.0, "cache_read": 0.5, "checked": false},
+    "claude-fable-5-1": {"input": 10.0, "output": 50.0, "cache_write_5m": 12.5, "cache_write_1h": 20.0, "cache_read": 0.25, "checked": true},
+    "claude-mythos-5-1": {"input": 10.0, "output": 50.0, "cache_write_5m": 12.5, "cache_write_1h": 20.0, "cache_read": 0.25, "checked": true},
+    "claude-fable-5": {"input": 10.0, "output": 50.0, "cache_write_5m": 12.5, "cache_write_1h": 20.0, "cache_read": 1.0, "checked": true},
+    "claude-mythos-5": {"input": 10.0, "output": 50.0, "cache_write_5m": 12.5, "cache_write_1h": 20.0, "cache_read": 1.0, "checked": true},
+    "claude-opus-5-5": {"input": 4.0, "output": 20.0, "cache_write_5m": 5.0, "cache_write_1h": 8.0, "cache_read": 0.2, "checked": true},
+    "claude-opus-5": {"input": 5.0, "output": 25.0, "cache_write_5m": 6.25, "cache_write_1h": 10.0, "cache_read": 0.5, "checked": true},
+    "claude-opus-4-8": {"input": 5.0, "output": 25.0, "cache_write_5m": 6.25, "cache_write_1h": 10.0, "cache_read": 0.5, "checked": true},
+    "claude-opus-4-7": {"input": 5.0, "output": 25.0, "cache_write_5m": 6.25, "cache_write_1h": 10.0, "cache_read": 0.5, "checked": true},
+    "claude-opus-4-6": {"input": 5.0, "output": 25.0, "cache_write_5m": 6.25, "cache_write_1h": 10.0, "cache_read": 0.5, "checked": true},
+    "claude-sonnet-5-5": {"input": 2.0, "output": 10.0, "cache_write_5m": 2.5, "cache_write_1h": 4.0, "cache_read": 0.2, "checked": true},
+    "claude-sonnet-5": {"input": 2.0, "output": 10.0, "cache_write_5m": 2.5, "cache_write_1h": 4.0, "cache_read": 0.2, "checked": true},
+    "claude-sonnet-4-6": {"input": 3.0, "output": 15.0, "cache_write_5m": 3.75, "cache_write_1h": 6.0, "cache_read": 0.3, "checked": true},
+    "claude-haiku-4-5": {"input": 1.0, "output": 5.0, "cache_write_5m": 1.25, "cache_write_1h": 2.0, "cache_read": 0.1, "checked": true},
+    "default-openai": {"input": 5.0, "output": 30.0, "cache_write_5m": 5.0, "cache_write_1h": 5.0, "cache_read": 0.5, "checked": false},
+    "gpt-5.5": {"input": 5.0, "output": 30.0, "cache_write_5m": 5.0, "cache_write_1h": 5.0, "cache_read": 0.5, "checked": false},
+    "gpt-5.6-sol": {"input": 5.0, "output": 30.0, "cache_write_5m": 5.0, "cache_write_1h": 5.0, "cache_read": 0.5, "checked": false},
+    "gpt-5.6-terra": {"input": 2.0, "output": 12.0, "cache_write_5m": 2.0, "cache_write_1h": 2.0, "cache_read": 0.2, "checked": false},
+    "gpt-5.6-luna": {"input": 0.2, "output": 1.2, "cache_write_5m": 0.2, "cache_write_1h": 0.2, "cache_read": 0.02, "checked": false},
+    "gpt-6-astra": {"input": 10.0, "output": 50.0, "cache_write_5m": 10.0, "cache_write_1h": 10.0, "cache_read": 1.0, "checked": false},
+    "gpt-6-sol": {"input": 2.0, "output": 10.0, "cache_write_5m": 2.0, "cache_write_1h": 2.0, "cache_read": 0.2, "checked": false},
+    "gpt-6-luna": {"input": 0.1, "output": 0.5, "cache_write_5m": 0.1, "cache_write_1h": 0.1, "cache_read": 0.01, "checked": false},
+    "gpt-5.3-codex": {"input": 1.75, "output": 14.0, "cache_write_5m": 1.75, "cache_write_1h": 1.75, "cache_read": 0.175, "checked": false},
+    "gpt-5.2": {"input": 1.75, "output": 14.0, "cache_write_5m": 1.75, "cache_write_1h": 1.75, "cache_read": 0.175, "checked": false},
+    "default-gemini": {"input": 0.75, "output": 3.75, "cache_write_5m": 0.75, "cache_write_1h": 0.75, "cache_read": 0.075, "checked": false},
+    "gemini-3.8-flash": {"input": 0.75, "output": 3.75, "cache_write_5m": 0.75, "cache_write_1h": 0.75, "cache_read": 0.075, "checked": false},
+    "gemini-3.8-flash-n": {"input": 0.75, "output": 3.75, "cache_write_5m": 0.75, "cache_write_1h": 0.75, "cache_read": 0.075, "checked": false},
+    "gemini-3.7-flash": {"input": 0.75, "output": 3.75, "cache_write_5m": 0.75, "cache_write_1h": 0.75, "cache_read": 0.075, "checked": false},
+    "gemini-3.6-flash": {"input": 0.75, "output": 3.75, "cache_write_5m": 0.75, "cache_write_1h": 0.75, "cache_read": 0.075, "checked": false}
+  }
+}

sessioncost/prices.py

@@ -0,0 +1,72 @@
+"""Prices: built-in table, merged with the user's ~/.sessioncost/prices.json, then with --prices <file>."""
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+
+from .model import Usage
+
+HERE = Path(__file__).parent
+USER_FILE = Path.home() / ".sessioncost" / "prices.json"
+CLASSES = ("input", "cache_write_5m", "cache_write_1h", "cache_read", "output")
+
+
+def _merge(base: dict, extra: dict) -> dict:
+    out = dict(base)
+    for k, v in extra.items():
+        if k == "models" and isinstance(v, dict):
+            models = {m: dict(r) for m, r in base.get("models", {}).items()}
+            for m, r in v.items():
+                models[m] = {**models.get(m, {}), **r}
+            out["models"] = models
+        else:
+            out[k] = v
+    return out
+
+
+def load(extra_file: str | None = None, user_file: Path | None = USER_FILE) -> dict:
+    prices = json.loads((HERE / "prices.json").read_text(encoding="utf-8"))
+    for f in (user_file, Path(extra_file).expanduser() if extra_file else None):
+        if f and Path(f).is_file():
+            prices = _merge(prices, json.loads(Path(f).read_text(encoding="utf-8")))
+    return prices
+
+
+def normalise(model: str) -> str:
+    """'claude-opus-5[1m]' -> 'claude-opus-5'; 'claude-haiku-4-5-20251001' -> 'claude-haiku-4-5'."""
+    m = re.sub(r"\[.*?\]", "", (model or "").strip().lower())
+    return re.sub(r"-\d{8}$", "", m)
+
+
+def rates(model: str, prices: dict) -> tuple[dict, bool, str]:
+    """(rates per million, checked?, the price-table key used)."""
+    table = prices["models"]
+    for key in (model, normalise(model)):
+        if key in table:
+            r = table[key]
+            return r, bool(r.get("checked")), key
+    m = normalise(model)
+    key = "default-openai" if re.match(r"(gpt|codex|o\d)", m) else "default-gemini" if m.startswith("gemini") else ""
+    key = key if key in table else "default"
+    return table[key], False, key
+
+
+def cost(u: Usage, r: dict) -> dict:
+    """USD per token class for one call. Every token is counted in exactly one class."""
+    return {
+        "input": u.fresh_input * r["input"] / 1e6,
+        "cache_write_5m": u.cache_write_5m * r["cache_write_5m"] / 1e6,
+        "cache_write_1h": u.cache_write_1h * r["cache_write_1h"] / 1e6,
+        "cache_read": u.cache_read * r["cache_read"] / 1e6,
+        "output": u.output * r["output"] / 1e6,
+    }
+
+
+def new_input_rate(u: Usage, r: dict) -> float:
+    """Average USD per million for the new (not re-read) input of this call."""
+    n = u.new_input
+    if not n:
+        return r["cache_write_1h"] if u.cache_read else r["input"]
+    return (u.fresh_input * r["input"] + u.cache_write_5m * r["cache_write_5m"]
+            + u.cache_write_1h * r["cache_write_1h"]) / n