code-meter 0.1.0__py3-none-any.whl

code_meter/pricing/anthropic.py

@@ -0,0 +1,78 @@
+"""Default seed pricing data for Anthropic models."""
+
+from typing import Any, Dict, List
+
+DEFAULT_ANTHROPIC_PRICING: List[Dict[str, Any]] = [
+    {
+        "provider": "claude_code",
+        "model": "claude-3-7-sonnet-20250219",
+        "input_price_per_million": 3.00,
+        "output_price_per_million": 15.00,
+        "cache_read_price_per_million": 0.30,
+        "cache_write_price_per_million": 3.75,
+        "effective_from": "2025-02-19T00:00:00Z",
+    },
+    {
+        "provider": "claude_code",
+        "model": "claude-3-5-sonnet-20241022",
+        "input_price_per_million": 3.00,
+        "output_price_per_million": 15.00,
+        "cache_read_price_per_million": 0.30,
+        "cache_write_price_per_million": 3.75,
+        "effective_from": "2024-10-22T00:00:00Z",
+    },
+    {
+        "provider": "claude_code",
+        "model": "claude-3-5-sonnet-20240620",
+        "input_price_per_million": 3.00,
+        "output_price_per_million": 15.00,
+        "cache_read_price_per_million": 0.30,
+        "cache_write_price_per_million": 3.75,
+        "effective_from": "2024-06-20T00:00:00Z",
+    },
+    {
+        "provider": "claude_code",
+        "model": "claude-sonnet",
+        "input_price_per_million": 3.00,
+        "output_price_per_million": 15.00,
+        "cache_read_price_per_million": 0.30,
+        "cache_write_price_per_million": 3.75,
+        "effective_from": "2024-01-01T00:00:00Z",
+    },
+    {
+        "provider": "claude_code",
+        "model": "claude-3-5-haiku-20241022",
+        "input_price_per_million": 0.80,
+        "output_price_per_million": 4.00,
+        "cache_read_price_per_million": 0.08,
+        "cache_write_price_per_million": 1.00,
+        "effective_from": "2024-10-22T00:00:00Z",
+    },
+    {
+        "provider": "claude_code",
+        "model": "claude-haiku",
+        "input_price_per_million": 0.80,
+        "output_price_per_million": 4.00,
+        "cache_read_price_per_million": 0.08,
+        "cache_write_price_per_million": 1.00,
+        "effective_from": "2024-01-01T00:00:00Z",
+    },
+    {
+        "provider": "claude_code",
+        "model": "claude-3-opus-20240229",
+        "input_price_per_million": 15.00,
+        "output_price_per_million": 75.00,
+        "cache_read_price_per_million": 1.50,
+        "cache_write_price_per_million": 18.75,
+        "effective_from": "2024-02-29T00:00:00Z",
+    },
+    {
+        "provider": "claude_code",
+        "model": "claude-opus",
+        "input_price_per_million": 15.00,
+        "output_price_per_million": 75.00,
+        "cache_read_price_per_million": 1.50,
+        "cache_write_price_per_million": 18.75,
+        "effective_from": "2024-01-01T00:00:00Z",
+    },
+]

code_meter/pricing/engine.py

@@ -0,0 +1,97 @@
+"""Dynamic Pricing Engine for calculating USD estimated cost of AI token usage."""
+
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+from code_meter.pricing.anthropic import DEFAULT_ANTHROPIC_PRICING
+from code_meter.pricing.google import DEFAULT_GOOGLE_PRICING
+from code_meter.pricing.openai import DEFAULT_OPENAI_PRICING
+from code_meter.storage.repository import UsageRepository
+
+DEFAULT_PRICING = DEFAULT_ANTHROPIC_PRICING + DEFAULT_OPENAI_PRICING + DEFAULT_GOOGLE_PRICING
+
+
+class PricingEngine:
+    """Calculates estimated token usage costs based on model pricing rules."""
+
+    def __init__(self, repository: Optional[UsageRepository] = None):
+        self.repository = repository
+        self._pricing_cache: List[Dict[str, Any]] = []
+        self.reload_pricing()
+
+    def reload_pricing(self) -> None:
+        """Seed initial pricing if needed and load active pricing records."""
+        if self.repository:
+            db_pricing = self.repository.get_pricing_table()
+            if not db_pricing:
+                self.repository.save_pricing(DEFAULT_PRICING)
+                db_pricing = self.repository.get_pricing_table()
+            self._pricing_cache = db_pricing
+        else:
+            self._pricing_cache = DEFAULT_PRICING
+
+    def calculate_cost(
+        self,
+        provider: str,
+        model: str,
+        input_tokens: int,
+        output_tokens: int,
+        cache_read_tokens: int = 0,
+        cache_write_tokens: int = 0,
+        timestamp: Optional[datetime] = None,
+    ) -> Optional[float]:
+        """Calculate USD estimated cost. Returns None if model pricing is unknown."""
+        rule = self._find_matching_rule(provider, model, timestamp)
+        if not rule:
+            return None
+
+        input_cost = (input_tokens / 1_000_000.0) * rule["input_price_per_million"]
+        output_cost = (output_tokens / 1_000_000.0) * rule["output_price_per_million"]
+        cache_read_cost = (cache_read_tokens / 1_000_000.0) * rule.get("cache_read_price_per_million", 0.0)
+        cache_write_cost = (cache_write_tokens / 1_000_000.0) * rule.get("cache_write_price_per_million", 0.0)
+
+        return round(input_cost + output_cost + cache_read_cost + cache_write_cost, 6)
+
+    def _find_matching_rule(
+        self,
+        provider: str,
+        model: str,
+        timestamp: Optional[datetime] = None,
+    ) -> Optional[Dict[str, Any]]:
+        """Find best matching pricing rule for provider and model based on string matching and effective date."""
+        if not model or model == "<synthetic>" or model == "unknown":
+            return None
+
+        norm_model = model.lower().strip()
+        norm_provider = provider.lower().strip() if provider else ""
+
+        # Filter by provider if applicable
+        provider_cache = [
+            p for p in self._pricing_cache
+            if not norm_provider or p.get("provider", "").lower().strip() == norm_provider
+        ]
+        search_pool = provider_cache if provider_cache else self._pricing_cache
+
+        # 1. Exact match
+        exact_matches = [p for p in search_pool if p["model"].lower().strip() == norm_model]
+        if exact_matches:
+            exact_matches.sort(key=lambda x: x.get("effective_from", ""), reverse=True)
+            return exact_matches[0]
+
+        # 2. Substring/family matches
+        candidates = []
+        for p in search_pool:
+            p_model = p["model"].lower().strip()
+            if p_model in norm_model or norm_model in p_model:
+                candidates.append(p)
+            elif "sonnet" in norm_model and "sonnet" in p_model:
+                candidates.append(p)
+            elif "haiku" in norm_model and "haiku" in p_model:
+                candidates.append(p)
+            elif "opus" in norm_model and "opus" in p_model:
+                candidates.append(p)
+
+        if not candidates:
+            return None
+
+        candidates.sort(key=lambda x: x.get("effective_from", ""), reverse=True)
+        return candidates[0]

code_meter/pricing/google.py

@@ -0,0 +1,60 @@
+"""Default seed pricing data for Google / Antigravity / Gemini models."""
+
+from typing import Any, Dict, List
+
+DEFAULT_GOOGLE_PRICING: List[Dict[str, Any]] = [
+    {
+        "provider": "antigravity",
+        "model": "gemini-2.5-flash",
+        "input_price_per_million": 0.15,
+        "output_price_per_million": 0.60,
+        "cache_read_price_per_million": 0.0375,
+        "cache_write_price_per_million": 0.00,
+        "effective_from": "2025-01-01T00:00:00Z",
+    },
+    {
+        "provider": "antigravity",
+        "model": "gemini-3.6-flash",
+        "input_price_per_million": 0.15,
+        "output_price_per_million": 0.60,
+        "cache_read_price_per_million": 0.0375,
+        "cache_write_price_per_million": 0.00,
+        "effective_from": "2026-01-01T00:00:00Z",
+    },
+    {
+        "provider": "antigravity",
+        "model": "gemini-2.5-pro",
+        "input_price_per_million": 1.25,
+        "output_price_per_million": 5.00,
+        "cache_read_price_per_million": 0.3125,
+        "cache_write_price_per_million": 0.00,
+        "effective_from": "2025-01-01T00:00:00Z",
+    },
+    {
+        "provider": "antigravity",
+        "model": "gemini-1.5-pro",
+        "input_price_per_million": 1.25,
+        "output_price_per_million": 5.00,
+        "cache_read_price_per_million": 0.3125,
+        "cache_write_price_per_million": 0.00,
+        "effective_from": "2024-05-01T00:00:00Z",
+    },
+    {
+        "provider": "antigravity",
+        "model": "gemini-1.5-flash",
+        "input_price_per_million": 0.075,
+        "output_price_per_million": 0.30,
+        "cache_read_price_per_million": 0.01875,
+        "cache_write_price_per_million": 0.00,
+        "effective_from": "2024-05-01T00:00:00Z",
+    },
+    {
+        "provider": "antigravity",
+        "model": "antigravity",
+        "input_price_per_million": 0.15,
+        "output_price_per_million": 0.60,
+        "cache_read_price_per_million": 0.0375,
+        "cache_write_price_per_million": 0.00,
+        "effective_from": "2024-01-01T00:00:00Z",
+    },
+]

code_meter/pricing/openai.py

@@ -0,0 +1,69 @@
+"""Default seed pricing data for OpenAI / Codex models."""
+
+from typing import Any, Dict, List
+
+DEFAULT_OPENAI_PRICING: List[Dict[str, Any]] = [
+    {
+        "provider": "codex",
+        "model": "gpt-4o",
+        "input_price_per_million": 2.50,
+        "output_price_per_million": 10.00,
+        "cache_read_price_per_million": 1.25,
+        "cache_write_price_per_million": 0.00,
+        "effective_from": "2024-05-13T00:00:00Z",
+    },
+    {
+        "provider": "codex",
+        "model": "gpt-4o-mini",
+        "input_price_per_million": 0.15,
+        "output_price_per_million": 0.60,
+        "cache_read_price_per_million": 0.075,
+        "cache_write_price_per_million": 0.00,
+        "effective_from": "2024-07-18T00:00:00Z",
+    },
+    {
+        "provider": "codex",
+        "model": "o1",
+        "input_price_per_million": 15.00,
+        "output_price_per_million": 60.00,
+        "cache_read_price_per_million": 7.50,
+        "cache_write_price_per_million": 0.00,
+        "effective_from": "2024-12-05T00:00:00Z",
+    },
+    {
+        "provider": "codex",
+        "model": "o3-mini",
+        "input_price_per_million": 1.10,
+        "output_price_per_million": 4.40,
+        "cache_read_price_per_million": 0.55,
+        "cache_write_price_per_million": 0.00,
+        "effective_from": "2025-01-31T00:00:00Z",
+    },
+    {
+        "provider": "codex",
+        "model": "gpt-4-turbo",
+        "input_price_per_million": 10.00,
+        "output_price_per_million": 30.00,
+        "cache_read_price_per_million": 0.00,
+        "cache_write_price_per_million": 0.00,
+        "effective_from": "2024-04-09T00:00:00Z",
+    },
+    {
+        "provider": "codex",
+        "model": "code-davinci-002",
+        "input_price_per_million": 20.00,
+        "output_price_per_million": 20.00,
+        "cache_read_price_per_million": 0.00,
+        "cache_write_price_per_million": 0.00,
+        "effective_from": "2022-01-01T00:00:00Z",
+    },
+    {
+        "provider": "codex",
+        "model": "codex",
+        "input_price_per_million": 2.50,
+        "output_price_per_million": 10.00,
+        "cache_read_price_per_million": 1.25,
+        "cache_write_price_per_million": 0.00,
+        "effective_from": "2024-01-01T00:00:00Z",
+    },
+]

code_meter/providers/__init__.py

@@ -0,0 +1,15 @@
+"""Providers package for token usage scanners."""
+
+from code_meter.providers.antigravity import AntigravityProvider
+from code_meter.providers.base import FileScanState, ScanResult, UsageProvider
+from code_meter.providers.claude_code import ClaudeCodeProvider
+from code_meter.providers.codex import CodexProvider
+
+__all__ = [
+    "UsageProvider",
+    "ScanResult",
+    "FileScanState",
+    "ClaudeCodeProvider",
+    "CodexProvider",
+    "AntigravityProvider",
+]

code_meter/providers/antigravity.py

@@ -0,0 +1,358 @@
+"""Antigravity provider for scanning local Google Antigravity / AGY transcript and session logs (~/.gemini/antigravity-ide)."""
+
+import hashlib
+import json
+import logging
+import os
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+from code_meter.models.usage import SessionCodeChange, SessionPrompt, UsageRecord
+from code_meter.providers.base import FileScanState, ScanResult, UsageProvider
+
+logger = logging.getLogger(__name__)
+
+
+class AntigravityProvider(UsageProvider):
+    """Scanner for Google Antigravity / AGY session transcript files."""
+
+    def __init__(self, antigravity_dir: Path):
+        self.antigravity_dir = Path(os.path.expanduser(antigravity_dir)).resolve()
+
+    @property
+    def provider_name(self) -> str:
+        return "antigravity"
+
+    def scan(self, existing_states: Optional[Dict[str, FileScanState]] = None) -> ScanResult:
+        """Incrementally scan session files and transcript logs in Antigravity directory."""
+        existing = existing_states or {}
+        records: List[UsageRecord] = []
+        prompts: List[SessionPrompt] = []
+        code_changes: List[SessionCodeChange] = []
+        updated_states: List[FileScanState] = []
+        files_scanned = 0
+        malformed_lines = 0
+
+        if not self.antigravity_dir.exists():
+            logger.warning(f"Antigravity directory does not exist: {self.antigravity_dir}")
+            return ScanResult(records=[], prompts=[], code_changes=[], updated_states=[], files_scanned=0, malformed_lines=0)
+
+        transcript_files = self._find_transcript_files()
+
+        for file_path in transcript_files:
+            try:
+                stat = file_path.stat()
+                file_str = str(file_path.resolve())
+                size = stat.st_size
+                mtime = stat.st_mtime
+
+                prev_state = existing.get(file_str)
+
+                if prev_state:
+                    if size == prev_state.file_size and mtime == prev_state.modified_time:
+                        updated_states.append(prev_state)
+                        continue
+
+                    start_offset = 0 if size < prev_state.file_size else prev_state.read_offset
+                else:
+                    start_offset = 0
+
+                files_scanned += 1
+                new_records, new_prompts, new_changes, new_offset, malformed = self._scan_file(
+                    file_path=file_path,
+                    start_offset=start_offset,
+                )
+
+                records.extend(new_records)
+                prompts.extend(new_prompts)
+                code_changes.extend(new_changes)
+                malformed_lines += malformed
+
+                updated_states.append(
+                    FileScanState(
+                        file_path=file_str,
+                        file_size=size,
+                        modified_time=mtime,
+                        read_offset=new_offset,
+                    )
+                )
+
+            except Exception as e:
+                logger.error(f"Error scanning Antigravity file {file_path}: {e}", exc_info=True)
+
+        return ScanResult(
+            records=records,
+            prompts=prompts,
+            code_changes=code_changes,
+            updated_states=updated_states,
+            files_scanned=files_scanned,
+            malformed_lines=malformed_lines,
+        )
+
+    def _find_transcript_files(self) -> List[Path]:
+        """Find transcript files and session jsonl logs recursively."""
+        files: List[Path] = []
+        try:
+            for root, _, filenames in os.walk(self.antigravity_dir):
+                for fname in filenames:
+                    if fname.endswith(".jsonl") or fname.endswith(".json"):
+                        files.append(Path(root) / fname)
+        except PermissionError as e:
+            logger.warning(f"Permission denied accessing {self.antigravity_dir}: {e}")
+        return files
+
+    def _scan_file(
+        self, file_path: Path, start_offset: int
+    ) -> Tuple[List[UsageRecord], List[SessionPrompt], List[SessionCodeChange], int, int]:
+        """Scan transcript file from start_offset."""
+        records: List[UsageRecord] = []
+        prompts: List[SessionPrompt] = []
+        changes: List[SessionCodeChange] = []
+        malformed = 0
+        current_offset = start_offset
+
+        session_id_from_path = self._infer_session_id(file_path)
+        project_name = self._infer_project_name(file_path)
+
+        line_index = 0
+        with open(file_path, "r", encoding="utf-8", errors="replace") as f:
+            if start_offset > 0:
+                f.seek(start_offset)
+
+            while True:
+                line = f.readline()
+                if not line:
+                    break
+
+                current_offset = f.tell()
+                line_index += 1
+                line_str = line.strip()
+                if not line_str:
+                    continue
+
+                try:
+                    data = json.loads(line_str)
+                except Exception:
+                    malformed += 1
+                    continue
+
+                rec, pmt, chgs = self._process_data_item(data, str(file_path.resolve()), session_id_from_path, project_name, line_index)
+                if rec:
+                    records.append(rec)
+                if pmt:
+                    prompts.append(pmt)
+                if chgs:
+                    changes.extend(chgs)
+
+        return records, prompts, changes, current_offset, malformed
+
+    def _process_data_item(
+        self,
+        data: dict,
+        file_path: str,
+        session_id_from_path: str,
+        project_name: Optional[str],
+        line_index: int,
+    ) -> Tuple[Optional[UsageRecord], Optional[SessionPrompt], List[SessionCodeChange]]:
+        if not isinstance(data, dict):
+            return None, None, []
+
+        session_id = data.get("conversation_id") or data.get("session_id") or session_id_from_path
+        cwd = data.get("cwd") or data.get("project_path")
+        p_name = data.get("project") or (os.path.basename(cwd) if cwd else project_name)
+
+        rec = self._parse_usage_record(data, file_path, session_id, cwd, p_name)
+        pmt = self._parse_user_prompt(data, session_id, p_name, line_index)
+        chgs = self._parse_code_changes(data, session_id, p_name, line_index)
+
+        return rec, pmt, chgs
+
+    def _parse_usage_record(
+        self,
+        data: dict,
+        file_path: str,
+        session_id: str,
+        cwd: Optional[str],
+        project_name: Optional[str],
+    ) -> Optional[UsageRecord]:
+        usage = data.get("usage") or data.get("token_usage") or data.get("usage_metadata")
+        if not isinstance(usage, dict):
+            # Check if stored in item directly
+            if "input_tokens" in data or "prompt_token_count" in data:
+                usage = data
+
+        if not isinstance(usage, dict):
+            return None
+
+        input_tokens = int(usage.get("input_tokens") or usage.get("prompt_token_count") or 0)
+        output_tokens = int(usage.get("output_tokens") or usage.get("candidates_token_count") or 0)
+        cache_read_tokens = int(usage.get("cache_read_tokens") or usage.get("cached_content_token_count") or 0)
+        cache_write_tokens = int(usage.get("cache_write_tokens") or 0)
+
+        if (input_tokens + output_tokens + cache_read_tokens + cache_write_tokens) == 0:
+            return None
+
+        model = data.get("model") or usage.get("model") or "gemini-2.5-flash"
+        if not isinstance(model, str):
+            model = str(model)
+
+        raw_ts = data.get("timestamp") or data.get("created_at") or data.get("time")
+        ts = self._parse_timestamp(raw_ts)
+
+        request_id = data.get("id") or data.get("step_index") or data.get("request_id")
+        if not request_id or not isinstance(request_id, str):
+            request_id = self._generate_deterministic_id(
+                file_path=file_path,
+                timestamp=ts,
+                model=model,
+                input_tokens=input_tokens,
+                output_tokens=output_tokens,
+                cache_read_tokens=cache_read_tokens,
+                cache_write_tokens=cache_write_tokens,
+            )
+
+        return UsageRecord(
+            provider="antigravity",
+            request_id=str(request_id),
+            session_id=session_id,
+            timestamp=ts,
+            user_id=data.get("user_id"),
+            project_id=project_name,
+            project_path=cwd,
+            model=model,
+            input_tokens=input_tokens,
+            output_tokens=output_tokens,
+            cache_read_tokens=cache_read_tokens,
+            cache_write_tokens=cache_write_tokens,
+            metadata={"file_path": file_path, "type": data.get("type")},
+        )
+
+    def _parse_user_prompt(
+        self, data: dict, session_id: str, project_id: Optional[str], line_index: int
+    ) -> Optional[SessionPrompt]:
+        line_type = data.get("type")
+        source = data.get("source")
+        
+        if line_type not in ["USER_INPUT", "user", "prompt"] and source != "USER_EXPLICIT":
+            return None
+
+        content = data.get("content") or data.get("text") or data.get("prompt")
+        prompt_text = ""
+
+        if isinstance(content, str):
+            prompt_text = content.strip()
+        elif isinstance(content, list):
+            texts = []
+            for item in content:
+                if isinstance(item, str):
+                    texts.append(item)
+                elif isinstance(item, dict) and item.get("text"):
+                    texts.append(item.get("text", ""))
+            prompt_text = "\n".join(texts).strip()
+
+        if not prompt_text:
+            return None
+
+        raw_ts = data.get("timestamp") or data.get("created_at")
+        ts = self._parse_timestamp(raw_ts)
+
+        prompt_id = data.get("prompt_id") or data.get("id") or f"agy_prompt_{session_id}_{line_index}"
+
+        return SessionPrompt(
+            provider="antigravity",
+            session_id=session_id,
+            prompt_id=str(prompt_id),
+            timestamp=ts,
+            prompt_text=prompt_text,
+            project_id=project_id,
+        )
+
+    def _parse_code_changes(
+        self, data: dict, session_id: str, project_id: Optional[str], line_index: int
+    ) -> List[SessionCodeChange]:
+        changes: List[SessionCodeChange] = []
+        raw_ts = data.get("timestamp") or data.get("created_at")
+        ts = self._parse_timestamp(raw_ts)
+
+        tool_calls = data.get("tool_calls")
+        if isinstance(tool_calls, list):
+            for idx, call in enumerate(tool_calls):
+                if isinstance(call, dict):
+                    name = call.get("name") or call.get("function", {}).get("name", "")
+                    args = call.get("args") or call.get("arguments") or call.get("function", {}).get("arguments", {})
+                    if isinstance(args, str):
+                        try:
+                            args = json.loads(args)
+                        except Exception:
+                            args = {}
+
+                    if isinstance(args, dict) and name in [
+                        "replace_file_content",
+                        "multi_replace_file_content",
+                        "write_to_file",
+                        "edit_file",
+                        "write_file",
+                    ]:
+                        fpath = args.get("TargetFile") or args.get("file_path") or args.get("path") or "unknown_file"
+                        target_content = args.get("TargetContent") or args.get("old_content") or ""
+                        replacement_content = args.get("ReplacementContent") or args.get("CodeContent") or args.get("new_content") or ""
+
+                        diff_lines = []
+                        if target_content:
+                            diff_lines.append(f"- {target_content[:150]}")
+                        if replacement_content:
+                            diff_lines.append(f"+ {replacement_content[:150]}")
+                        diff_summary = "\n".join(diff_lines) if diff_lines else f"Antigravity action: {name}"
+
+                        change_id = call.get("id") or f"agy_edit_{session_id}_{line_index}_{idx}"
+                        changes.append(
+                            SessionCodeChange(
+                                provider="antigravity",
+                                session_id=session_id,
+                                change_id=str(change_id),
+                                timestamp=ts,
+                                file_path=str(fpath),
+                                change_type=name.lower(),
+                                diff_summary=diff_summary,
+                                project_id=project_id,
+                            )
+                        )
+
+        return changes
+
+    def _infer_session_id(self, file_path: Path) -> str:
+        for parent in file_path.parents:
+            if len(parent.name) == 36 and "-" in parent.name:
+                return parent.name
+        return file_path.stem
+
+    def _infer_project_name(self, file_path: Path) -> Optional[str]:
+        for parent in file_path.parents:
+            if parent.name not in ["brain", "logs", ".system_generated", "antigravity-ide"]:
+                return parent.name
+        return None
+
+    def _parse_timestamp(self, raw_ts: Optional[str]) -> datetime:
+        if not raw_ts:
+            return datetime.now(timezone.utc)
+        if isinstance(raw_ts, (int, float)):
+            return datetime.fromtimestamp(raw_ts if raw_ts < 1e11 else raw_ts / 1000.0, tz=timezone.utc)
+        try:
+            ts_str = str(raw_ts).replace("Z", "+00:00")
+            return datetime.fromisoformat(ts_str)
+        except ValueError:
+            return datetime.now(timezone.utc)
+
+    def _generate_deterministic_id(
+        self,
+        file_path: str,
+        timestamp: datetime,
+        model: str,
+        input_tokens: int,
+        output_tokens: int,
+        cache_read_tokens: int,
+        cache_write_tokens: int,
+    ) -> str:
+        seed = f"antigravity:{file_path}:{timestamp.isoformat()}:{model}:{input_tokens}:{output_tokens}:{cache_read_tokens}:{cache_write_tokens}"
+        return "gen_agy_" + hashlib.sha256(seed.encode("utf-8")).hexdigest()[:24]