omega-code 0.4.0__py3-none-any.whl

omega/config.py

@@ -0,0 +1,285 @@
+import json
+import os
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Literal
+
+from . import secrets
+
+CONFIG_PATH = Path(os.environ.get("OMEGA_CONFIG", Path.home() / ".omega" / "config.json"))
+
+DEFAULTS: dict[str, Any] = {
+    "providers": {
+        "inference-net": {
+            "baseUrl": "https://api.inference.net/v1",
+            "apiKeyEnv": "INFERENCE_API_KEY",
+        },
+        "openrouter": {
+            "baseUrl": "https://openrouter.ai/api/v1",
+            "apiKeyEnv": "OPENROUTER_API_KEY",
+        },
+        "anthropic": {
+            "type": "anthropic",
+            "apiKeyEnv": "ANTHROPIC_API_KEY",
+        },
+        "openai": {
+            "baseUrl": "https://api.openai.com/v1",
+            "apiKeyEnv": "OPENAI_API_KEY",
+        },
+    },
+    "models": {
+        "fable":  {"model": "claude-fable-5-1", "provider": "anthropic", "context": 1048576,
+                   "effort": "xhigh", "fallback": "opus"},
+        "opus":   {"model": "claude-opus-5", "provider": "anthropic", "context": 1048576,
+                   "effort": "high", "fallback": "sonnet"},
+        "sonnet": {"model": "claude-sonnet-5", "provider": "anthropic", "context": 1048576,
+                   "effort": "high", "fallback": "haiku"},
+        "haiku":  {"model": "claude-haiku-4-5", "provider": "anthropic", "context": 200000},
+        "spark":  {"model": "meta/muse-spark-1.3", "provider": "openrouter", "context": 1048576,
+                   "fallback": "kimi"},
+        "kimi":   {"model": "moonshotai/kimi-k3", "provider": "openrouter", "context": 1048576},
+        "glm":    {"model": "z-ai/glm-5.3-flash", "provider": "openrouter", "context": 128000},
+        # GPT-6 Astra is in limited rollout and not on OpenRouter yet, so it
+        # needs the native OpenAI provider; the GPT-5.6 tiers are on both.
+        "astra":  {"model": "gpt-6-astra", "provider": "openai", "context": 1050000,
+                   "fallback": "sol"},
+        "sol":    {"model": "openai/gpt-5.6-sol", "provider": "openrouter", "context": 1050000,
+                   "fallback": "terra"},
+        "terra":  {"model": "openai/gpt-5.6-terra", "provider": "openrouter", "context": 1050000,
+                   "fallback": "luna"},
+        "luna":   {"model": "openai/gpt-5.6-luna", "provider": "openrouter", "context": 1050000},
+        "codex":  {"model": "openai/gpt-5.3-codex", "provider": "openrouter", "context": 400000,
+                   "fallback": "sol"},
+        "grok":   {"model": "x-ai/grok-4.6", "provider": "openrouter", "context": 500000,
+                   "fallback": "grok-build"},
+        "grok-build": {"model": "x-ai/grok-build-0.1", "provider": "openrouter", "context": 256000},
+    },
+    "roles": {
+        "main":          {"alias": "opus"},
+        "plan":          {"alias": "opus"},
+        "subagent_fast": {"alias": "glm"},
+        "subagent_mid":  {"alias": "kimi"},
+        "compact":       {"alias": "glm"},
+        "memory":        {"alias": "glm"},
+    },
+}
+
+
+@dataclass
+class Provider:
+    name: str
+    type: Literal["openai", "anthropic"] = "openai"
+    base_url: str = ""
+    api_key_env: str = ""
+    api_key_literal: str = ""
+    api_key_cmd: str = ""
+
+    def _resolve(self) -> str:
+        """The key, or "" if nothing supplies one.
+
+        Order is most-explicit-first: a literal in the config, then a command,
+        then an environment variable, then the OS keychain. The keychain is
+        last because it is the one source the config does not mention -- so a
+        key written down in front of you always beats one found by
+        convention, and `omega keys migrate` can move a literal into the
+        keychain without the two fighting over which wins."""
+        if self.api_key_literal:
+            return self.api_key_literal
+        if self.api_key_cmd:
+            return secrets.from_command(self.api_key_cmd)
+        if self.api_key_env:
+            from_env = os.environ.get(self.api_key_env, "")
+            if from_env:
+                return from_env
+        return secrets.keychain_get(self.name) or ""
+
+    @property
+    def has_key(self) -> bool:
+        """Non-raising check -- lets callers (onboarding, first-run detection)
+        probe key availability without triggering the SystemExit below."""
+        try:
+            return bool(self._resolve())
+        except RuntimeError:
+            # A broken `apiKeyCmd` is a real misconfiguration, but this
+            # property exists precisely so probing cannot blow up its caller.
+            return False
+
+    @property
+    def key_source(self) -> str:
+        """Where the key comes from, for `omega keys` and `omega doctor`.
+        Never the value itself."""
+        return secrets.describe_source(self.api_key_env, self.api_key_cmd,
+                                       self.api_key_literal, self.name)
+
+    @property
+    def api_key(self) -> str:
+        # Resolved lazily -- at load() time we don't yet know which providers a
+        # session will actually use, and a provider with no key configured must
+        # not block startup for users who haven't set it up yet.
+        try:
+            key = self._resolve()
+        except RuntimeError as e:
+            raise SystemExit(f"omega: could not read the API key for provider "
+                             f"{self.name!r}: {secrets.redact(str(e))}") from None
+        if not key:
+            hint = (f"export {self.api_key_env}=..." if self.api_key_env
+                    else f"omega keys set {self.name}")
+            raise SystemExit(
+                f"omega: no API key for provider {self.name!r}.\n"
+                f"  Run `omega setup` to configure one, or {hint}")
+        return key
+
+
+@dataclass
+class Model:
+    alias: str
+    model: str
+    provider: str
+    context: int = 128000
+    effort: str | None = None
+    fallback: str | None = None
+
+
+@dataclass
+class Role:
+    model: str
+    provider: Provider
+    context: int = 128000
+    effort: str | None = None
+    alias: str | None = None
+    fallback_alias: str | None = None
+
+
+@dataclass(frozen=True)
+class HookRule:
+    """One `hooks.json` entry: `command` runs (with OMEGA_* env vars) whenever a
+    call to one of `tools` is dispatched -- see hooks.py."""
+    tools: list[str]
+    command: str
+
+
+@dataclass
+class Config:
+    roles: dict[str, Role] = field(default_factory=dict)
+    models: dict[str, Model] = field(default_factory=dict)
+    providers: dict[str, Provider] = field(default_factory=dict)
+    # B1 edit-safety config: read from top-level "verify"/"hooks"/"review_auto"
+    # keys in config.json -- see verify.py, hooks.py and subagent.review().
+    verify_auto: bool = True
+    verify_checks: list[str] | None = None
+    review_auto: bool = True
+    hooks: dict[str, list[HookRule]] = field(default_factory=dict)
+
+    def role(self, name: str) -> Role:
+        if name not in self.roles:
+            raise KeyError(f"no role {name!r}; have {sorted(self.roles)}")
+        return self.roles[name]
+
+    def model(self, alias: str) -> Role:
+        if alias not in self.models:
+            raise KeyError(f"no model {alias!r}; have {sorted(self.models)}")
+        m = self.models[alias]
+        if m.provider not in self.providers:
+            raise KeyError(f"model {alias!r} references unknown provider {m.provider!r}")
+        return Role(m.model, self.providers[m.provider], m.context, m.effort, alias, m.fallback)
+
+    def resolve_alias(self, text: str) -> str:
+        """Resolve a `--model`/`/model` argument to a catalog alias: an exact
+        alias match first, else a bare model id matched against catalog entries."""
+        if text in self.models:
+            return text
+        for alias, m in self.models.items():
+            if m.model == text:
+                return alias
+        raise SystemExit(f"omega: unknown model {text!r}; have {sorted(self.models)}")
+
+
+def _strip_jsonc(text: str) -> str:
+    text = re.sub(r"^\s*//.*$", "", text, flags=re.M)
+    return re.sub(r",(\s*[}\]])", r"\1", text)
+
+
+def _json_or_default() -> dict[str, Any]:
+    """The raw config dict as written on disk, or an empty skeleton -- used by
+    onboarding to merge its additions into whatever is already there instead
+    of clobbering unrelated providers/roles/mcp entries."""
+    if CONFIG_PATH.exists():
+        return dict(json.loads(_strip_jsonc(CONFIG_PATH.read_text())))
+    return {"providers": {}, "models": {}, "roles": {}}
+
+
+def load() -> Config:
+    raw: dict[str, Any] = DEFAULTS
+    if CONFIG_PATH.exists():
+        raw = json.loads(_strip_jsonc(CONFIG_PATH.read_text()))
+
+    providers: dict[str, Provider] = {}
+    for name, p in raw["providers"].items():
+        ptype = p.get("type", "openai")
+        # Only strip a trailing slash -- an anthropic provider's baseUrl (when
+        # given at all) is passed straight to AsyncAnthropic as base_url=, and
+        # the SDK's own default already omits a "/v1" suffix.
+        base_url = (p.get("baseUrl") or "").rstrip("/")
+        if ptype == "openai" and not base_url:
+            raise SystemExit(f"omega: provider {name!r} is missing \"baseUrl\" in {CONFIG_PATH}")
+        providers[name] = Provider(
+            name=name, type=ptype, base_url=base_url,
+            api_key_env=p.get("apiKeyEnv", ""),
+            api_key_literal=p.get("apiKey", ""),
+            api_key_cmd=p.get("apiKeyCmd", ""),
+        )
+
+    models: dict[str, Model] = {}
+    for alias, m in (raw.get("models") or {}).items():
+        models[alias] = Model(alias, m["model"], m["provider"], m.get("context", 128000),
+                              m.get("effort"), m.get("fallback"))
+    # A hand-written config predating the catalog would otherwise leave the
+    # /model picker empty; built-ins fill in wherever their provider exists.
+    for alias, m in DEFAULTS["models"].items():
+        if alias not in models and m["provider"] in providers:
+            models[alias] = Model(alias, m["model"], m["provider"], m.get("context", 128000),
+                                  m.get("effort"), m.get("fallback"))
+
+    verify_raw = raw.get("verify") or {}
+    verify_checks = verify_raw.get("checks")
+    if verify_checks is not None:
+        verify_checks = [str(c) for c in verify_checks]
+
+    hooks_raw = raw.get("hooks") or {}
+    hooks_cfg: dict[str, list[HookRule]] = {}
+    for stage in ("pre_tool", "post_tool"):
+        hooks_cfg[stage] = [HookRule(tools=list(entry.get("tools", [])), command=entry["command"])
+                            for entry in (hooks_raw.get(stage) or [])]
+
+    cfg = Config(models=models, providers=providers,
+                verify_auto=bool(verify_raw.get("auto", True)),
+                verify_checks=verify_checks,
+                review_auto=bool(raw.get("review_auto", True)),
+                hooks=hooks_cfg)
+
+    roles: dict[str, Role] = {}
+    for name, r in raw["roles"].items():
+        if "alias" in r:
+            roles[name] = cfg.model(r["alias"])
+        else:
+            roles[name] = Role(r["model"], providers[r["provider"]], r.get("context", 128000), r.get("effort"))
+    cfg.roles = roles
+    return cfg
+
+
+def mcp_names() -> list[str]:
+    if not CONFIG_PATH.exists():
+        return []
+    import json as _json
+    return list(_json.loads(_strip_jsonc(CONFIG_PATH.read_text())).get("mcp", {}))
+
+
+def mcp_config() -> dict[str, dict[str, Any]]:
+    """The omega-owned "mcp" block as written on disk -- unlike mcp.discover(),
+    this never mixes in Claude Code's servers, so the connections manager can
+    tell "configured in omega" apart from "merely importable"."""
+    if not CONFIG_PATH.exists():
+        return {}
+    raw: dict[str, Any] = json.loads(_strip_jsonc(CONFIG_PATH.read_text())).get("mcp", {})
+    return raw

omega/eval/__init__.py

@@ -0,0 +1,3 @@
+from . import cli, manifest, prices, report, runner, tasks
+
+__all__ = ["cli", "manifest", "prices", "report", "runner", "tasks"]

omega/eval/cli.py

@@ -0,0 +1,127 @@
+import json
+import time
+from pathlib import Path
+
+from .. import config
+from ..ui import plain
+from . import runner
+from .report import Report, load_report, new_run_dir, render_table, write_report
+from .report import compare as compare_reports
+from .tasks import TaskError, init_examples, load_tasks
+
+console = plain.console
+
+_USAGE = """omega eval -- headless task-suite runner
+
+usage:
+  omega eval init                    copy example tasks into .omega/evals/
+  omega eval run [path] [flags]      run tasks (default: .omega/evals/*.yaml)
+  omega eval compare <runA> <runB>   diff two reports (run id, dir, or report.json path)
+
+flags for `run`:
+  --models a,b,c    model aliases to run against (default: the `main` role)
+  --repeat N        repeat each task N times (default 1)
+  --jobs N          max concurrent runs (default 1)
+  --json            print the report as JSON instead of a table"""
+
+
+async def main(argv: list[str]) -> None:
+    if not argv or argv[0] in ("-h", "--help"):
+        return console.print(_USAGE, markup=False, highlight=False)
+    sub, rest = argv[0], argv[1:]
+
+    if sub == "init":
+        dest = Path.cwd() / ".omega" / "evals"
+        written = init_examples(dest)
+        console.print(f"[green]wrote {len(written)} example task(s) to {dest}[/green]")
+        for p in written:
+            console.print(f"  {p.name}")
+        return
+
+    if sub == "run":
+        return await _run(rest)
+
+    if sub == "compare":
+        return _compare(rest)
+
+    console.print(f"[red]unknown `omega eval {sub}`[/red] -- init, run, compare")
+
+
+def _parse_run_args(rest: list[str]) -> tuple[str | None, str | None, int, int, bool]:
+    models_arg: str | None = None
+    repeat, jobs, as_json = 1, 1, False
+    positional: list[str] = []
+    i = 0
+    while i < len(rest):
+        a = rest[i]
+        if a == "--models" and i + 1 < len(rest):
+            models_arg, i = rest[i + 1], i + 2
+        elif a == "--repeat" and i + 1 < len(rest):
+            repeat, i = int(rest[i + 1]), i + 2
+        elif a == "--jobs" and i + 1 < len(rest):
+            jobs, i = int(rest[i + 1]), i + 2
+        elif a == "--json":
+            as_json, i = True, i + 1
+        else:
+            positional.append(a)
+            i += 1
+    path = positional[0] if positional else None
+    return path, models_arg, repeat, jobs, as_json
+
+
+async def _run(rest: list[str]) -> None:
+    path, models_arg, repeat, jobs, as_json = _parse_run_args(rest)
+    try:
+        tasks = load_tasks(path)
+    except TaskError as e:
+        return console.print(f"[red]{e}[/red]")
+    if not tasks:
+        return console.print("[dim]no eval tasks found -- run `omega eval init` first[/dim]")
+
+    cfg = config.load()
+    try:
+        roles = runner.resolve_models(cfg, models_arg)
+    except KeyError as e:
+        return console.print(f"[red]{e}[/red]")
+
+    if not as_json:
+        console.print(f"[dim]running {len(tasks)} task(s) x {len(roles)} model(s) "
+                      f"x {repeat} repeat(s)…[/dim]")
+    results = await runner.run_suite(cfg, tasks, roles, repeat=repeat, jobs=jobs)
+    report = Report(created=time.time(), results=tuple(results))
+
+    run_dir = new_run_dir(Path.cwd() / ".omega" / "evals" / "runs")
+    out_path = write_report(report, run_dir)
+
+    if as_json:
+        console.print(json.dumps(report.to_dict(), indent=1))
+    else:
+        console.print(render_table(report))
+        console.print(f"\n[dim]report saved to {out_path}[/dim]")
+
+
+def _resolve_run_path(ref: str) -> Path:
+    p = Path(ref)
+    if p.is_file():
+        return p
+    if p.is_dir():
+        return p / "report.json"
+    runs_root = Path.cwd() / ".omega" / "evals" / "runs"
+    candidate = runs_root / ref / "report.json"
+    if candidate.exists():
+        return candidate
+    matches = sorted(runs_root.glob(f"{ref}*/report.json")) if runs_root.exists() else []
+    if matches:
+        return matches[-1]
+    raise TaskError(f"no report found for {ref!r}")
+
+
+def _compare(rest: list[str]) -> None:
+    if len(rest) < 2:
+        return console.print("[red]usage: omega eval compare <runA> <runB>[/red]")
+    try:
+        a = load_report(_resolve_run_path(rest[0]))
+        b = load_report(_resolve_run_path(rest[1]))
+    except (TaskError, FileNotFoundError) as e:
+        return console.print(f"[red]{e}[/red]")
+    console.print(compare_reports(a, b))

omega/eval/examples/plan-version-flag.yaml

@@ -0,0 +1,11 @@
+name: plan-version-flag
+prompt: >
+  Investigate omega's CLI entry point (omega/__main__.py) and produce a plan
+  for adding a `--version` flag that prints the installed package version.
+  Name every real file you would touch and the exact function or block
+  you would change in each. Do not write any code -- you are read-only.
+repo: .
+check: "grep -q 'omega/__main__.py' TRANSCRIPT.md"
+timeout_s: 300
+mode: plan
+tags: [planning]

omega/eval/examples/relative-age-negative-delta.yaml

@@ -0,0 +1,14 @@
+name: relative-age-negative-delta
+prompt: >
+  In omega/gitlog.py, `_relative_age(seconds)` clamps a negative delta to
+  zero with `max(0.0, seconds)`, which silently reports a commit timestamp
+  from the future as "0s ago" instead of surfacing the clock skew. Change it
+  to handle negative deltas explicitly (your choice of representation -- e.g.
+  a leading sign or "in the future"), and add a test in tests/test_gitlog.py
+  that pins the behavior you chose. Keep the rest of the function and the
+  existing tests in tests/test_gitlog.py passing.
+repo: .
+check: "uv run pytest tests/test_gitlog.py -q"
+timeout_s: 600
+mode: build
+tags: [regression, unit-test]

omega/eval/examples/version-flag.yaml

@@ -0,0 +1,10 @@
+name: version-flag
+prompt: >
+  Add a `--version` flag to omega's CLI: `omega --version` should print the
+  installed package version and exit without starting an agent turn. Wire it
+  into omega/__main__.py next to the other top-level flags.
+repo: .
+check: "uv run omega --version | grep -Eq '[0-9]+\\.[0-9]+\\.[0-9]+'"
+timeout_s: 600
+mode: build
+tags: [cli, smoke]

omega/eval/manifest.py

@@ -0,0 +1,129 @@
+from dataclasses import dataclass
+from typing import Any
+
+from .. import compact, events
+from ..session import Message
+
+VOLATILE_MARKER = "<!-- volatile -->"
+
+
+@dataclass(frozen=True)
+class ToolCallRecord:
+    name: str
+    duration_s: float
+    result_chars: int
+
+    def to_dict(self) -> dict[str, Any]:
+        return {"name": self.name, "duration_s": round(self.duration_s, 3),
+                "result_chars": self.result_chars}
+
+
+@dataclass(frozen=True)
+class RoundRecord:
+    index: int
+    prompt_tokens: int | None
+    completion_tokens: int | None
+    cache_tokens: int
+    estimated_tokens: int
+    tool_calls: tuple[ToolCallRecord, ...]
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "index": self.index, "prompt_tokens": self.prompt_tokens,
+            "completion_tokens": self.completion_tokens, "cache_tokens": self.cache_tokens,
+            "estimated_tokens": self.estimated_tokens,
+            "tool_calls": [c.to_dict() for c in self.tool_calls],
+        }
+
+
+@dataclass(frozen=True)
+class DriftPoint:
+    round: int
+    estimated: int
+    actual: int
+
+    @property
+    def drift(self) -> int:
+        return self.actual - self.estimated
+
+    @property
+    def drift_pct(self) -> float | None:
+        return (self.drift / self.actual) if self.actual else None
+
+    def to_dict(self) -> dict[str, Any]:
+        return {"round": self.round, "estimated": self.estimated, "actual": self.actual,
+                "drift": self.drift, "drift_pct": self.drift_pct}
+
+
+@dataclass(frozen=True)
+class SystemZones:
+    fixed_chars: int
+    volatile_chars: int
+
+    def to_dict(self) -> dict[str, Any]:
+        return {"fixed_chars": self.fixed_chars, "volatile_chars": self.volatile_chars}
+
+
+@dataclass(frozen=True)
+class ContextManifest:
+    rounds: tuple[RoundRecord, ...]
+    system_zones: SystemZones
+    drift: tuple[DriftPoint, ...]
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "rounds": [r.to_dict() for r in self.rounds],
+            "system_zones": self.system_zones.to_dict(),
+            "drift": [d.to_dict() for d in self.drift],
+        }
+
+
+def split_system_zones(system: str, marker: str = VOLATILE_MARKER) -> SystemZones:
+    if marker not in system:
+        return SystemZones(fixed_chars=len(system), volatile_chars=0)
+    fixed, _, volatile = system.partition(marker)
+    return SystemZones(fixed_chars=len(fixed), volatile_chars=len(volatile))
+
+
+def _cache_tokens(usage: events.Usage) -> int:
+    # `cached_tokens`/`cache_read` may not exist on every Usage build -- A2 is
+    # adding cache fields to this event independently of this module.
+    return int(getattr(usage, "cached_tokens", None) or getattr(usage, "cache_read", None) or 0)
+
+
+def build_manifest(evs: list[events.Event], system: str, schemas: list[dict[str, Any]],
+                   initial_history: list[Message], final_history: list[Message]) -> ContextManifest:
+    """Reconstructs per-round token/tool telemetry from the events emitted by
+    `loop.run_agent` plus the `history` list it mutates in place. Each round
+    appends exactly 1 (assistant) + len(tool_calls) messages to `history`
+    before the next request goes out -- except the final round (no tool
+    calls), which ends in `Done` instead of `Usage` and so has no actual
+    `prompt_tokens` in the current event schema; its drift point is skipped,
+    though the round itself is still recorded with `prompt_tokens=None`."""
+    overhead = compact.estimate_tokens([{"role": "system", "content": system}]) \
+        + compact.estimate_tokens(schemas)
+
+    rounds: list[RoundRecord] = []
+    drift: list[DriftPoint] = []
+    msg_idx = len(initial_history)
+    round_calls: list[ToolCallRecord] = []
+    round_index = -1
+
+    for ev in evs:
+        if isinstance(ev, events.Phase) and ev.state == "waiting":
+            round_index += 1
+            round_calls = []
+        elif isinstance(ev, events.ToolEnd):
+            round_calls.append(ToolCallRecord(ev.name, ev.duration_s, ev.result_chars))
+        elif isinstance(ev, events.Usage):
+            estimated = overhead + compact.estimate_tokens(final_history[:msg_idx])
+            rounds.append(RoundRecord(round_index, ev.prompt_tokens, ev.completion_tokens,
+                                      _cache_tokens(ev), estimated, tuple(round_calls)))
+            if ev.prompt_tokens:
+                drift.append(DriftPoint(round_index, estimated, ev.prompt_tokens))
+            msg_idx += 1 + len(round_calls)
+        elif isinstance(ev, events.Done):
+            estimated = overhead + compact.estimate_tokens(final_history[:msg_idx])
+            rounds.append(RoundRecord(round_index, None, None, 0, estimated, tuple(round_calls)))
+
+    return ContextManifest(tuple(rounds), split_system_zones(system), tuple(drift))

omega/eval/prices.py

@@ -0,0 +1,29 @@
+# Per-million-token USD prices (input, output), keyed by the model catalog
+# alias (config.DEFAULTS["models"]) -- not the provider's raw model id, so a
+# `--models opus,sonnet` run can price itself without a network round trip.
+PRICES: dict[str, tuple[float, float]] = {
+    "fable":  (10.0, 50.0),
+    "opus":   (5.0, 25.0),
+    "sonnet": (2.0, 10.0),
+    "haiku":  (1.0, 5.0),
+    "spark":  (1.25, 4.25),
+    "kimi":   (3.0, 15.0),
+    "glm":    (0.6, 2.2),
+    "astra":  (10.0, 50.0),
+    "sol":    (2.0, 10.0),
+    "terra":  (2.0, 12.0),
+    "luna":   (0.2, 1.2),
+    "codex":  (1.75, 14.0),
+    "grok":   (2.0, 6.0),
+    "grok-build": (1.0, 2.0),
+}
+
+
+def estimate_cost(alias: str, tokens_in: int, tokens_out: int) -> float | None:
+    """None for an alias absent from PRICES -- an unpriced model must show up
+    as "unknown" in a report, never as a silent $0."""
+    prices = PRICES.get(alias)
+    if prices is None:
+        return None
+    price_in, price_out = prices
+    return tokens_in / 1_000_000 * price_in + tokens_out / 1_000_000 * price_out