devcouncil 0.1.1 → 0.3.0

package/src/devcouncil/telemetry/logging_setup.py

@@ -0,0 +1,244 @@
+"""Central logging configuration for DevCouncil.
+
+The codebase is sprinkled with ``logging.getLogger(__name__)`` calls across the
+orchestrator, planner, executors, verifier, and LLM layers — but historically no
+handler was ever installed, so every ``logger.info``/``logger.debug`` was silently
+discarded and only uncaught WARNING+ records reached stderr via Python's "last
+resort" handler. That made diagnosing the recurring run failures nearly
+impossible: the breadcrumbs existed but went nowhere.
+
+:func:`configure_logging` wires up two sinks, once per process:
+
+* a **rotating file** at ``.devcouncil/logs/devcouncil.log`` that always captures
+  *everything* at DEBUG — this is the durable record you grep after a bad run;
+* a **console** (stderr) handler whose level is dialed by ``-v``/``-q`` flags or
+  the ``DEVCOUNCIL_LOG_LEVEL`` env var, defaulting to WARNING so normal Rich CLI
+  output stays clean.
+
+It is idempotent: calling it again only adjusts the console level (e.g. when a
+command re-points at a different ``--project-root``), so importing modules can
+call it freely without stacking duplicate handlers.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from contextlib import contextmanager
+from logging.handlers import RotatingFileHandler
+from pathlib import Path
+from typing import Iterator, Optional
+
+# Sentinels so we can find (and reconfigure) our own handlers on repeat calls
+# without disturbing handlers another library may have installed on the root.
+_FILE_HANDLER_TAG = "devcouncil.file"
+_CONSOLE_HANDLER_TAG = "devcouncil.console"
+
+_LOG_FORMAT = "%(asctime)s %(levelname)-7s [%(name)s] %(message)s"
+_DATE_FORMAT = "%Y-%m-%d %H:%M:%S"
+
+# Default file location (relative to a project root) for the durable run log.
+LOG_RELATIVE_PATH = Path(".devcouncil") / "logs" / "devcouncil.log"
+
+
+def _level_from_verbosity(verbosity: int, quiet: bool) -> int:
+    """Map ``-v`` count / ``-q`` flag to a console log level.
+
+    quiet -> ERROR; default(0) -> WARNING; -v -> INFO; -vv (or more) -> DEBUG.
+    """
+    if quiet:
+        return logging.ERROR
+    if verbosity <= 0:
+        return logging.WARNING
+    if verbosity == 1:
+        return logging.INFO
+    return logging.DEBUG
+
+
+def _resolve_console_level(verbosity: int, quiet: bool, log_level: Optional[str]) -> int:
+    """Console level precedence: explicit arg > env var > verbosity flags."""
+    explicit = log_level or os.environ.get("DEVCOUNCIL_LOG_LEVEL")
+    if explicit:
+        resolved = logging.getLevelName(explicit.strip().upper())
+        if isinstance(resolved, int):
+            return resolved
+    return _level_from_verbosity(verbosity, quiet)
+
+
+def _find_tagged_handler(logger: logging.Logger, tag: str) -> Optional[logging.Handler]:
+    for handler in logger.handlers:
+        if getattr(handler, "_devcouncil_tag", None) == tag:
+            return handler
+    return None
+
+
+def configure_logging(
+    project_root: Optional[Path] = None,
+    *,
+    verbosity: int = 0,
+    quiet: bool = False,
+    log_level: Optional[str] = None,
+) -> Optional[Path]:
+    """Install DevCouncil's file + console log handlers on the root logger.
+
+    Safe to call repeatedly. The file handler (DEBUG, rotating) is created once;
+    subsequent calls only update the console handler's level so a later command
+    invocation can raise/lower verbosity. Returns the resolved log file path, or
+    ``None`` if the file sink could not be created (console logging still works).
+    """
+    root = logging.getLogger()
+    # The root must pass DEBUG records through to handlers; each handler then
+    # applies its own threshold (file=DEBUG, console=user-selected).
+    root.setLevel(logging.DEBUG)
+
+    formatter = logging.Formatter(_LOG_FORMAT, datefmt=_DATE_FORMAT)
+    console_level = _resolve_console_level(verbosity, quiet, log_level)
+
+    # --- Console handler (stderr) -------------------------------------------
+    console = _find_tagged_handler(root, _CONSOLE_HANDLER_TAG)
+    if console is None:
+        console = logging.StreamHandler()  # defaults to stderr, keeps stdout clean
+        console._devcouncil_tag = _CONSOLE_HANDLER_TAG  # type: ignore[attr-defined]
+        console.setFormatter(formatter)
+        root.addHandler(console)
+    console.setLevel(console_level)
+
+    # --- Rotating file handler (always DEBUG) -------------------------------
+    log_path: Optional[Path] = None
+    if _find_tagged_handler(root, _FILE_HANDLER_TAG) is None:
+        base = Path(project_root) if project_root is not None else Path.cwd()
+        log_path = base / LOG_RELATIVE_PATH
+        try:
+            log_path.parent.mkdir(parents=True, exist_ok=True)
+            file_handler = RotatingFileHandler(
+                log_path,
+                maxBytes=5 * 1024 * 1024,  # 5 MB per file
+                backupCount=5,             # keep ~25 MB of history
+                encoding="utf-8",
+            )
+            file_handler._devcouncil_tag = _FILE_HANDLER_TAG  # type: ignore[attr-defined]
+            file_handler.setLevel(logging.DEBUG)
+            file_handler.setFormatter(formatter)
+            root.addHandler(file_handler)
+        except OSError:
+            # Read-only FS or unwritable path: degrade to console-only rather
+            # than crashing the command the user actually asked for.
+            log_path = None
+    else:
+        base = Path(project_root) if project_root is not None else Path.cwd()
+        log_path = base / LOG_RELATIVE_PATH
+
+    # Quieten chatty third-party loggers on the console; the file still gets them.
+    for noisy in ("httpx", "httpcore", "urllib3", "asyncio"):
+        logging.getLogger(noisy).setLevel(logging.WARNING)
+
+    _install_excepthook()
+
+    logging.getLogger(__name__).debug(
+        "Logging configured (console=%s, file=%s)",
+        logging.getLevelName(console_level),
+        log_path,
+    )
+    return log_path
+
+
+def _install_excepthook() -> None:
+    """Ensure an uncaught exception is written to the log (with traceback) before exit.
+
+    A crash otherwise only prints a traceback to the terminal — gone once the scrollback
+    is. Routing it through logging means the full stack also lands in the durable DEBUG
+    file (and any active per-run log), which is exactly what you need to diagnose the
+    recurring failures. ``KeyboardInterrupt`` is left to the default handler so Ctrl-C
+    stays clean. Installed once; idempotent across repeat ``configure_logging`` calls.
+    """
+    import sys
+
+    if getattr(sys.excepthook, "_devcouncil_hook", False):
+        return
+    previous = sys.excepthook
+
+    def _hook(exc_type, exc_value, exc_tb):
+        if not issubclass(exc_type, KeyboardInterrupt):
+            logging.getLogger("devcouncil.crash").critical(
+                "Uncaught exception", exc_info=(exc_type, exc_value, exc_tb)
+            )
+        previous(exc_type, exc_value, exc_tb)
+
+    _hook._devcouncil_hook = True  # type: ignore[attr-defined]
+    sys.excepthook = _hook
+
+
+def set_log_dir(project_root: Path) -> Optional[Path]:
+    """Re-point the shared DEBUG file handler at ``project_root/.devcouncil/logs``.
+
+    The CLI callback configures logging before any command knows its ``--project-root``,
+    so the file handler initially lands under the current working directory. When a
+    command operates on a *different* root (``dev go --project-root /other/repo``), its
+    log should live with that project, not in cwd. Each command calls this once it has
+    resolved its root; if the handler already points there (the common ``.`` case) this
+    is a cheap no-op. Returns the (re)resolved log path, or ``None`` if it could not be
+    created (logging then stays on the previous handler / console).
+    """
+    target = Path(project_root) / LOG_RELATIVE_PATH
+    root = logging.getLogger()
+    existing = _find_tagged_handler(root, _FILE_HANDLER_TAG)
+    if existing is not None:
+        current = getattr(existing, "baseFilename", None)
+        if current and Path(current) == target.resolve():
+            return target  # already logging to this project's file — nothing to do
+
+    try:
+        target.parent.mkdir(parents=True, exist_ok=True)
+        new_handler = RotatingFileHandler(
+            target, maxBytes=5 * 1024 * 1024, backupCount=5, encoding="utf-8"
+        )
+        new_handler._devcouncil_tag = _FILE_HANDLER_TAG  # type: ignore[attr-defined]
+        new_handler.setLevel(logging.DEBUG)
+        new_handler.setFormatter(logging.Formatter(_LOG_FORMAT, datefmt=_DATE_FORMAT))
+    except OSError:
+        return None
+
+    if existing is not None:
+        root.removeHandler(existing)
+        existing.close()
+    root.addHandler(new_handler)
+    logging.getLogger(__name__).debug("Log file re-pointed to %s", target)
+    return target
+
+
+@contextmanager
+def run_log(log_file: Path) -> Iterator[Optional[Path]]:
+    """Capture everything logged during a single invocation into its own DEBUG file.
+
+    The shared rotating ``devcouncil.log`` interleaves every command and rotates by
+    size, so isolating one run's complete trail there means grepping across rotations
+    and unrelated activity. This attaches a second, run-scoped DEBUG file handler for
+    the duration of the ``with`` block (e.g. ``.devcouncil/runs/<id>/run.log``) and
+    detaches it on exit — giving a clean, self-contained log for exactly that run on
+    top of the always-on shared log.
+
+    Best-effort: if the file can't be opened (read-only FS, bad path) the block still
+    runs with only the shared log. Yields the resolved path, or ``None`` on failure.
+    """
+    root = logging.getLogger()
+    handler: Optional[logging.Handler] = None
+    try:
+        log_file.parent.mkdir(parents=True, exist_ok=True)
+        handler = logging.FileHandler(log_file, encoding="utf-8")
+        handler._devcouncil_tag = "devcouncil.run"  # type: ignore[attr-defined]
+        handler.setLevel(logging.DEBUG)
+        handler.setFormatter(logging.Formatter(_LOG_FORMAT, datefmt=_DATE_FORMAT))
+        root.addHandler(handler)
+    except OSError:
+        if handler is not None:
+            root.removeHandler(handler)
+        handler = None
+        log_file = None  # type: ignore[assignment]
+
+    try:
+        yield log_file
+    finally:
+        if handler is not None:
+            handler.flush()
+            handler.close()
+            root.removeHandler(handler)

package/src/devcouncil/telemetry/model_pricing.yaml

@@ -0,0 +1,48 @@
+anthropic/claude-3-opus:
+  prompt_per_1k: 0.015
+  completion_per_1k: 0.075
+anthropic/claude-3.5-sonnet:
+  prompt_per_1k: 0.003
+  completion_per_1k: 0.015
+anthropic/claude-sonnet-4:
+  prompt_per_1k: 0.003
+  completion_per_1k: 0.015
+google/gemini-pro-1.5:
+  prompt_per_1k: 0.00125
+  completion_per_1k: 0.005
+google/gemini-2.5-pro:
+  prompt_per_1k: 0.00125
+  completion_per_1k: 0.01
+openai/gpt-4o:
+  prompt_per_1k: 0.005
+  completion_per_1k: 0.015
+openai/o3-mini:
+  prompt_per_1k: 0.0011
+  completion_per_1k: 0.0044
+anthropic/claude-sonnet-4.6:
+  prompt_per_1k: 0.003
+  completion_per_1k: 0.015
+anthropic/claude-opus-4.8:
+  prompt_per_1k: 0.005
+  completion_per_1k: 0.025
+openai/gpt-5.5:
+  prompt_per_1k: 0.005
+  completion_per_1k: 0.03
+google/gemini-2.5-flash:
+  prompt_per_1k: 0.0003
+  completion_per_1k: 0.0025
+# Local Ollama models run on-device and are free. Bare tags (no ``ollama/``
+# prefix) are listed here so the cost reporter shows $0; the cost.py prefix
+# guard covers any other ``ollama/`` or ``ollama:`` model id.
+qwen2.5-coder:7b:
+  prompt_per_1k: 0.0
+  completion_per_1k: 0.0
+qwen2.5-coder:14b:
+  prompt_per_1k: 0.0
+  completion_per_1k: 0.0
+qwen2.5-coder:32b:
+  prompt_per_1k: 0.0
+  completion_per_1k: 0.0
+llama3.1:
+  prompt_per_1k: 0.0
+  completion_per_1k: 0.0

package/src/devcouncil/telemetry/pricing.py

@@ -0,0 +1,28 @@
+from functools import lru_cache
+from importlib import resources
+from typing import Dict
+
+import yaml
+
+MODEL_PRICING_RESOURCE = "model_pricing.yaml"
+
+
+@lru_cache(maxsize=1)
+def load_model_pricing() -> Dict[str, Dict[str, float]]:
+    data = resources.files(__package__).joinpath(MODEL_PRICING_RESOURCE).read_text(encoding="utf-8")
+    loaded = yaml.safe_load(data) or {}
+    return {
+        str(model): {
+            "prompt_per_1k": float(pricing.get("prompt_per_1k", 0.0)),
+            "completion_per_1k": float(pricing.get("completion_per_1k", 0.0)),
+        }
+        for model, pricing in loaded.items()
+        if isinstance(pricing, dict)
+    }
+
+
+def pricing_for_model(model: str, default: Dict[str, float] | None = None) -> Dict[str, float]:
+    pricing = load_model_pricing().get(model)
+    if pricing is not None:
+        return pricing
+    return default or {"prompt_per_1k": 0.0, "completion_per_1k": 0.0}

package/src/devcouncil/telemetry/stages.py

@@ -0,0 +1,141 @@
+"""Stage and step instrumentation for DevCouncil pipelines.
+
+A DevCouncil run moves through coarse *stages* (plan, execute, verify, repair,
+reconcile, report) each made of finer *steps*. When a run misbehaves, the first
+question is always "how far did it get, and what was the last thing it tried?".
+This module gives one consistent way to answer that:
+
+* :func:`log_stage` — a context manager that logs ``▶ <stage>`` on entry and
+  ``✔ <stage> (1.23s)`` / ``✖ <stage> failed (1.23s): ...`` on exit, with wall
+  time. It also mirrors the boundary to the structured JSONL trace
+  (:class:`~devcouncil.telemetry.traces.TraceLogger`) when a ``project_root`` is
+  given, so the human log and the machine trace stay in lock-step.
+* :func:`log_step` — a one-liner for a single step inside a stage.
+
+Both are best-effort: instrumentation must never be the reason a run fails, so
+trace-write errors are swallowed (the Python log line still goes out).
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Any, Iterator, Optional
+
+logger = logging.getLogger("devcouncil.stage")
+
+
+def _safe_trace(
+    project_root: Optional[Path],
+    event_type: str,
+    details: dict[str, Any],
+    *,
+    run_id: Optional[str],
+    task_id: Optional[str],
+    summary: str,
+) -> None:
+    """Mirror a stage/step boundary to the JSONL trace, swallowing any error."""
+    if project_root is None:
+        return
+    try:
+        from devcouncil.telemetry.traces import TraceLogger
+
+        TraceLogger(Path(project_root)).log_event(
+            event_type, details, run_id=run_id, task_id=task_id, summary=summary
+        )
+    except Exception:  # pragma: no cover - tracing is strictly best-effort
+        logger.debug("Failed to mirror %s to trace", event_type, exc_info=True)
+
+
+def _context_suffix(context: dict[str, Any]) -> str:
+    if not context:
+        return ""
+    return " " + " ".join(f"{k}={v}" for k, v in context.items())
+
+
+@contextmanager
+def log_stage(
+    name: str,
+    *,
+    project_root: Optional[Path] = None,
+    run_id: Optional[str] = None,
+    task_id: Optional[str] = None,
+    **context: Any,
+) -> Iterator[None]:
+    """Log entry/exit (with timing) around a coarse pipeline stage.
+
+    Usage::
+
+        with log_stage("plan", project_root=root, run_id=run_id, goal=goal):
+            ...
+
+    Logs at INFO on success, ERROR on exception, and always reports elapsed time.
+    Re-raises whatever the body raised so control flow is unchanged.
+    """
+    suffix = _context_suffix(context)
+    logger.info("▶ %s%s", name, suffix)
+    _safe_trace(
+        project_root,
+        "stage_started",
+        {"stage": name, **context},
+        run_id=run_id,
+        task_id=task_id,
+        summary=f"Stage started: {name}",
+    )
+    start = time.monotonic()
+    try:
+        yield
+    except BaseException as exc:
+        elapsed = time.monotonic() - start
+        logger.error("✖ %s failed (%.2fs): %s", name, elapsed, exc)
+        _safe_trace(
+            project_root,
+            "stage_failed",
+            {"stage": name, "error": str(exc), "elapsed_s": round(elapsed, 3), **context},
+            run_id=run_id,
+            task_id=task_id,
+            summary=f"Stage failed: {name}",
+        )
+        raise
+    else:
+        elapsed = time.monotonic() - start
+        logger.info("✔ %s (%.2fs)", name, elapsed)
+        _safe_trace(
+            project_root,
+            "stage_completed",
+            {"stage": name, "elapsed_s": round(elapsed, 3), **context},
+            run_id=run_id,
+            task_id=task_id,
+            summary=f"Stage completed: {name}",
+        )
+
+
+def log_step(
+    message: str,
+    *,
+    project_root: Optional[Path] = None,
+    run_id: Optional[str] = None,
+    task_id: Optional[str] = None,
+    level: int = logging.INFO,
+    trace: bool = False,
+    **context: Any,
+) -> None:
+    """Log a single step within a stage.
+
+    By default this only writes the Python log (cheap, captured in full by the
+    file handler). Set ``trace=True`` for milestone steps worth recording in the
+    structured JSONL trace as well.
+    """
+    suffix = _context_suffix(context)
+    logger.log(level, "• %s%s", message, suffix)
+    if trace:
+        _safe_trace(
+            project_root,
+            "step",
+            {"message": message, **context},
+            run_id=run_id,
+            task_id=task_id,
+            summary=message,
+        )

package/src/devcouncil/telemetry/traces.py

@@ -3,7 +3,7 @@ import logging
 import uuid
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Any, Dict, Iterable, Optional
+from typing import Any, Dict, Iterable, List, Optional, Tuple
 
 from pydantic import BaseModel, ConfigDict, Field
 
@@ -31,14 +31,17 @@ class TraceEvent(BaseModel):
     def from_legacy(cls, raw: Dict[str, Any]) -> "TraceEvent":
         if raw.get("schema") == TRACE_SCHEMA_VERSION:
             return cls.model_validate(raw)
-        details = raw.get("details") if isinstance(raw.get("details"), dict) else {}
-        task_id = details.get("task_id") if isinstance(details.get("task_id"), str) else None
-        summary = details.get("summary") if isinstance(details.get("summary"), str) else ""
+        raw_details = raw.get("details")
+        details: Dict[str, Any] = raw_details if isinstance(raw_details, dict) else {}
+        raw_task_id = details.get("task_id")
+        raw_summary = details.get("summary")
+        raw_run_id = raw.get("run_id")
         return cls(
+            schema=TRACE_SCHEMA_VERSION,
             type=str(raw.get("type", "legacy_event")),
-            run_id=raw.get("run_id"),
-            task_id=task_id,
-            summary=summary,
+            run_id=raw_run_id if isinstance(raw_run_id, str) else None,
+            task_id=raw_task_id if isinstance(raw_task_id, str) else None,
+            summary=raw_summary if isinstance(raw_summary, str) else "",
             details=details,
         )
 
@@ -61,6 +64,7 @@ class TraceLogger:
     ) -> TraceEvent:
         """Append an orchestration event trace."""
         trace = TraceEvent(
+            schema=TRACE_SCHEMA_VERSION,
             type=event_type,
             details=details,
             run_id=run_id,
@@ -89,3 +93,54 @@ def read_trace_events(project_root: Path) -> Iterable[TraceEvent]:
         except Exception as exc:
             logger.debug("Skipping invalid trace line: %s", exc)
     return events
+
+
+def read_trace_events_since(
+    project_root: Path, cursor: Optional[int] = None
+) -> Tuple[List[TraceEvent], int]:
+    """Incrementally read trace events appended after ``cursor``.
+
+    The cursor is a byte offset into the trace file, which is robust to appends
+    (the file is append-only) and makes repeated polling O(new bytes) rather than
+    O(all events). Returns ``(events, next_cursor)`` where ``next_cursor`` should
+    be passed back on the next call to fetch only newer events.
+
+    Never raises: on any error it returns an empty batch and a safe cursor. A
+    ``cursor`` past the current end-of-file (e.g. the log was rotated/truncated)
+    is treated as a reset so the caller still makes progress.
+    """
+    trace_file = project_root / ".devcouncil" / "logs" / "traces.jsonl"
+    start = cursor if isinstance(cursor, int) and cursor >= 0 else 0
+    if not trace_file.exists():
+        return [], start
+
+    try:
+        size = trace_file.stat().st_size
+        # File shrank (rotation/truncation) — restart from the beginning.
+        if start > size:
+            start = 0
+
+        with open(trace_file, "rb") as f:
+            f.seek(start)
+            chunk = f.read()
+    except Exception as exc:
+        logger.debug("Failed incremental trace read: %s", exc)
+        return [], start
+
+    # Only consume up to the last complete line so a half-written final line is
+    # re-read (not skipped) on the next poll once it is fully flushed.
+    last_newline = chunk.rfind(b"\n")
+    if last_newline == -1:
+        return [], start
+    consumed = chunk[: last_newline + 1]
+    next_cursor = start + len(consumed)
+
+    events: List[TraceEvent] = []
+    for raw_line in consumed.decode("utf-8", errors="replace").splitlines():
+        if not raw_line.strip():
+            continue
+        try:
+            events.append(TraceEvent.from_legacy(json.loads(raw_line)))
+        except Exception as exc:
+            logger.debug("Skipping invalid trace line: %s", exc)
+    return events, next_cursor

package/src/devcouncil/telemetry/tracker.py

@@ -2,17 +2,16 @@ import json
 from pathlib import Path
 from typing import Dict, Any
 
-COST_PER_1K_TOKENS = {
-    "anthropic/claude-3-opus": {"prompt": 0.015, "completion": 0.075},
-    "anthropic/claude-3.5-sonnet": {"prompt": 0.003, "completion": 0.015},
-    "openai/gpt-4o": {"prompt": 0.005, "completion": 0.015},
-    "google/gemini-pro-1.5": {"prompt": 0.00125, "completion": 0.00375},
-}
+from devcouncil.telemetry.pricing import pricing_for_model
 
 class TelemetryTracker:
     def __init__(self, project_root: Path):
         self.log_file = project_root / ".devcouncil" / "logs" / "telemetry.json"
-        self.stats = self._load()
+        # log_usage() reloads the ledger immediately before saving (for concurrent-write
+        # safety), so any value read here would always be overwritten before use. Start
+        # from the same default shape _load() returns for a missing file instead of
+        # doing a dead disk read at construction.
+        self.stats: Dict[str, Any] = {"total_cost": 0.0, "total_prompt_tokens": 0, "total_completion_tokens": 0, "models": {}}
 
     def _load(self) -> Dict[str, Any]:
         if self.log_file.exists():
@@ -28,12 +27,27 @@ class TelemetryTracker:
         with open(self.log_file, "w") as f:
             json.dump(self.stats, f, indent=2)
 
-    def log_usage(self, model: str, usage: Dict[str, int]):
+    def log_usage(self, model: str, usage: Dict[str, int], *, local: bool = False):
+        # Re-read the ledger immediately before mutating so the whole load->mutate->save
+        # runs as one synchronous (await-free) step. The router constructs a fresh tracker
+        # per call and only calls log_usage *after* the LLM await, so snapshotting the
+        # baseline at construction would let concurrent calls (e.g. plan.py's gather, or a
+        # parallelized SkillOpt _evaluate) each load the same baseline and clobber each
+        # other's entries on save. Reloading here makes the last writer additive, not lossy.
+        self.stats = self._load()
         prompt_tokens = usage.get("prompt_tokens", 0)
         completion_tokens = usage.get("completion_tokens", 0)
 
-        rates = COST_PER_1K_TOKENS.get(model, {"prompt": 0.0, "completion": 0.0})
-        cost = (prompt_tokens / 1000.0) * rates["prompt"] + (completion_tokens / 1000.0) * rates["completion"]
+        if local:
+            # On-device providers (Ollama) incur no per-token cost. Zero by provider, not
+            # by model-id matching — consistent with telemetry/cost.py — so a local tag
+            # that happens to collide with a priced entry is never billed.
+            cost = 0.0
+        else:
+            rates = pricing_for_model(model)
+            cost = (prompt_tokens / 1000.0) * rates["prompt_per_1k"] + (
+                completion_tokens / 1000.0
+            ) * rates["completion_per_1k"]
 
         self.stats["total_cost"] += cost
         self.stats["total_prompt_tokens"] += prompt_tokens