klaude-code 1.7.0__tar.gz → 1.8.0__tar.gz

{klaude_code-1.7.0 → klaude_code-1.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: klaude-code
-Version: 1.7.0
+Version: 1.8.0
 Summary: Minimal code agent CLI
 Requires-Dist: anthropic>=0.66.0
 Requires-Dist: chardet>=5.2.0
@@ -146,20 +146,62 @@ klaude config
 
 ##### Adding Models to Built-in Providers
 
-You can add custom models to existing providers without redefining the entire provider:
+You can add custom models to existing built-in providers without redefining the entire provider. Just reference the `provider_name` and add your `model_list`:
 
 ```yaml
-# Just specify provider_name and your new models - no need for protocol/api_key
+# ~/.klaude/klaude-config.yaml
 provider_list:
+  - provider_name: openrouter  # Reference existing built-in provider
+    model_list:
+      - model_name: seed
+        model_params:
+          model: bytedance-seed/seed-1.6  # Model ID from OpenRouter
+          context_limit: 262000
+          cost:
+            input: 0.25
+            output: 2
+```
+
+**How merging works:**
+- Your models are merged with the built-in models for that provider
+- You only need `provider_name` and `model_list` - protocol, api_key, etc. are inherited from the built-in config
+- To override a built-in model, use the same `model_name` (e.g., `sonnet` to customize the built-in sonnet)
+
+**More examples:**
+
+```yaml
+provider_list:
+  # Add multiple models to OpenRouter
   - provider_name: openrouter
     model_list:
-      - model_name: my-custom-model
+      - model_name: qwen-coder
+        model_params:
+          model: qwen/qwen-2.5-coder-32b-instruct
+          context_limit: 131072
+          cost:
+            input: 0.3
+            output: 0.9
+      - model_name: llama-405b
         model_params:
-          model: some-provider/some-model-id
+          model: meta-llama/llama-3.1-405b-instruct
+          context_limit: 131072
+          cost:
+            input: 0.8
+            output: 0.8
+
+  # Add models to Anthropic provider
+  - provider_name: anthropic
+    model_list:
+      - model_name: haiku@ant
+        model_params:
+          model: claude-3-5-haiku-20241022
           context_limit: 200000
+          cost:
+            input: 1.0
+            output: 5.0
 ```
 
-Your models are merged with built-in models. To override a built-in model, use the same `model_name`.
+After adding models, run `klaude list` to verify they appear in the model list.
 
 ##### Overriding Provider Settings
 
@@ -230,6 +272,8 @@ provider_list:
 - `openai` - OpenAI-compatible API
 - `responses` - OpenAI Responses API (for o-series, GPT-5, Codex)
 - `openrouter` - OpenRouter API
+- `google` - Google Gemini API
+- `bedrock` - AWS Bedrock (uses AWS credentials instead of api_key)
 - `codex` - OpenAI Codex CLI (OAuth-based)
 
 List configured providers and models:
@@ -253,6 +297,18 @@ klaude session clean --min 10
 klaude session clean-all
 ```
 
+### Cost Tracking
+
+View aggregated usage statistics across all sessions:
+
+```bash
+# Show all historical usage data
+klaude cost
+
+# Show usage for the last 7 days only
+klaude cost --days 7
+```
+
 ### Slash Commands
 
 Inside the interactive session (`klaude`), use these commands to streamline your workflow:

{klaude_code-1.7.0 → klaude_code-1.8.0}/README.md

@@ -125,20 +125,62 @@ klaude config
 
 ##### Adding Models to Built-in Providers
 
-You can add custom models to existing providers without redefining the entire provider:
+You can add custom models to existing built-in providers without redefining the entire provider. Just reference the `provider_name` and add your `model_list`:
 
 ```yaml
-# Just specify provider_name and your new models - no need for protocol/api_key
+# ~/.klaude/klaude-config.yaml
 provider_list:
+  - provider_name: openrouter  # Reference existing built-in provider
+    model_list:
+      - model_name: seed
+        model_params:
+          model: bytedance-seed/seed-1.6  # Model ID from OpenRouter
+          context_limit: 262000
+          cost:
+            input: 0.25
+            output: 2
+```
+
+**How merging works:**
+- Your models are merged with the built-in models for that provider
+- You only need `provider_name` and `model_list` - protocol, api_key, etc. are inherited from the built-in config
+- To override a built-in model, use the same `model_name` (e.g., `sonnet` to customize the built-in sonnet)
+
+**More examples:**
+
+```yaml
+provider_list:
+  # Add multiple models to OpenRouter
   - provider_name: openrouter
     model_list:
-      - model_name: my-custom-model
+      - model_name: qwen-coder
+        model_params:
+          model: qwen/qwen-2.5-coder-32b-instruct
+          context_limit: 131072
+          cost:
+            input: 0.3
+            output: 0.9
+      - model_name: llama-405b
         model_params:
-          model: some-provider/some-model-id
+          model: meta-llama/llama-3.1-405b-instruct
+          context_limit: 131072
+          cost:
+            input: 0.8
+            output: 0.8
+
+  # Add models to Anthropic provider
+  - provider_name: anthropic
+    model_list:
+      - model_name: haiku@ant
+        model_params:
+          model: claude-3-5-haiku-20241022
           context_limit: 200000
+          cost:
+            input: 1.0
+            output: 5.0
 ```
 
-Your models are merged with built-in models. To override a built-in model, use the same `model_name`.
+After adding models, run `klaude list` to verify they appear in the model list.
 
 ##### Overriding Provider Settings
 
@@ -209,6 +251,8 @@ provider_list:
 - `openai` - OpenAI-compatible API
 - `responses` - OpenAI Responses API (for o-series, GPT-5, Codex)
 - `openrouter` - OpenRouter API
+- `google` - Google Gemini API
+- `bedrock` - AWS Bedrock (uses AWS credentials instead of api_key)
 - `codex` - OpenAI Codex CLI (OAuth-based)
 
 List configured providers and models:
@@ -232,6 +276,18 @@ klaude session clean --min 10
 klaude session clean-all
 ```
 
+### Cost Tracking
+
+View aggregated usage statistics across all sessions:
+
+```bash
+# Show all historical usage data
+klaude cost
+
+# Show usage for the last 7 days only
+klaude cost --days 7
+```
+
 ### Slash Commands
 
 Inside the interactive session (`klaude`), use these commands to streamline your workflow:

{klaude_code-1.7.0 → klaude_code-1.8.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "klaude-code"
-version = "1.7.0"
+version = "1.8.0"
 description = "Minimal code agent CLI"
 readme = "README.md"
 requires-python = ">=3.13"

klaude_code-1.8.0/src/klaude_code/cli/cost_cmd.py

@@ -0,0 +1,338 @@
+"""Cost command for aggregating usage statistics across all sessions."""
+
+from collections import defaultdict
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+
+from rich.box import Box
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from klaude_code.command.status_cmd import format_cost, format_tokens
+from klaude_code.protocol import model
+from klaude_code.session.codec import decode_jsonl_line
+
+ASCII_HORIZONAL = Box(" -- \n    \n -- \n    \n -- \n -- \n    \n -- \n")
+
+
+@dataclass
+class ModelUsageStats:
+    """Aggregated usage stats for a single model."""
+
+    model_name: str
+    input_tokens: int = 0
+    output_tokens: int = 0
+    cached_tokens: int = 0
+    cost_usd: float = 0.0
+    cost_cny: float = 0.0
+
+    @property
+    def total_tokens(self) -> int:
+        return self.input_tokens + self.output_tokens
+
+    def add_usage(self, usage: model.Usage) -> None:
+        self.input_tokens += usage.input_tokens
+        self.output_tokens += usage.output_tokens
+        self.cached_tokens += usage.cached_tokens
+        if usage.total_cost is not None:
+            if usage.currency == "CNY":
+                self.cost_cny += usage.total_cost
+            else:
+                self.cost_usd += usage.total_cost
+
+
+@dataclass
+class DailyStats:
+    """Aggregated stats for a single day."""
+
+    date: str
+    by_model: dict[str, ModelUsageStats] = field(default_factory=lambda: dict[str, ModelUsageStats]())
+
+    def add_task_metadata(self, meta: model.TaskMetadata, date_str: str) -> None:
+        """Add a TaskMetadata to this day's stats."""
+        del date_str  # unused, date is already set
+        if not meta.usage or not meta.model_name:
+            return
+
+        model_key = meta.model_name
+        if model_key not in self.by_model:
+            self.by_model[model_key] = ModelUsageStats(model_name=model_key)
+
+        self.by_model[model_key].add_usage(meta.usage)
+
+    def get_subtotal(self) -> ModelUsageStats:
+        """Get subtotal across all models for this day."""
+        subtotal = ModelUsageStats(model_name="(subtotal)")
+        for stats in self.by_model.values():
+            subtotal.input_tokens += stats.input_tokens
+            subtotal.output_tokens += stats.output_tokens
+            subtotal.cached_tokens += stats.cached_tokens
+            subtotal.cost_usd += stats.cost_usd
+            subtotal.cost_cny += stats.cost_cny
+        return subtotal
+
+
+def iter_all_sessions() -> list[tuple[str, Path]]:
+    """Iterate over all sessions across all projects.
+
+    Returns list of (session_id, events_file_path) tuples.
+    """
+    projects_dir = Path.home() / ".klaude" / "projects"
+    if not projects_dir.exists():
+        return []
+
+    sessions: list[tuple[str, Path]] = []
+    for project_dir in projects_dir.iterdir():
+        if not project_dir.is_dir():
+            continue
+        sessions_dir = project_dir / "sessions"
+        if not sessions_dir.exists():
+            continue
+        for session_dir in sessions_dir.iterdir():
+            if not session_dir.is_dir():
+                continue
+            events_file = session_dir / "events.jsonl"
+            meta_file = session_dir / "meta.json"
+            # Skip sub-agent sessions by checking meta.json
+            if meta_file.exists():
+                import json
+
+                try:
+                    meta = json.loads(meta_file.read_text(encoding="utf-8"))
+                    if meta.get("sub_agent_state") is not None:
+                        continue
+                except (json.JSONDecodeError, OSError):
+                    pass
+            if events_file.exists():
+                sessions.append((session_dir.name, events_file))
+
+    return sessions
+
+
+def extract_task_metadata_from_events(events_path: Path) -> list[tuple[str, model.TaskMetadataItem]]:
+    """Extract TaskMetadataItem entries from events.jsonl with their dates.
+
+    Returns list of (date_str, TaskMetadataItem) tuples.
+    """
+    results: list[tuple[str, model.TaskMetadataItem]] = []
+    try:
+        content = events_path.read_text(encoding="utf-8")
+    except OSError:
+        return results
+
+    for line in content.splitlines():
+        item = decode_jsonl_line(line)
+        if isinstance(item, model.TaskMetadataItem):
+            date_str = item.created_at.strftime("%Y-%m-%d")
+            results.append((date_str, item))
+
+    return results
+
+
+def aggregate_all_sessions() -> dict[str, DailyStats]:
+    """Aggregate usage stats from all sessions, grouped by date.
+
+    Returns dict mapping date string to DailyStats.
+    """
+    daily_stats: dict[str, DailyStats] = defaultdict(lambda: DailyStats(date=""))
+
+    sessions = iter_all_sessions()
+    for _session_id, events_path in sessions:
+        metadata_items = extract_task_metadata_from_events(events_path)
+        for date_str, metadata_item in metadata_items:
+            if daily_stats[date_str].date == "":
+                daily_stats[date_str] = DailyStats(date=date_str)
+
+            # Process main agent metadata
+            daily_stats[date_str].add_task_metadata(metadata_item.main_agent, date_str)
+
+            # Process sub-agent metadata
+            for sub_meta in metadata_item.sub_agent_task_metadata:
+                daily_stats[date_str].add_task_metadata(sub_meta, date_str)
+
+    return dict(daily_stats)
+
+
+def format_cost_dual(cost_usd: float, cost_cny: float) -> tuple[str, str]:
+    """Format costs for both currencies."""
+    usd_str = format_cost(cost_usd if cost_usd > 0 else None, "USD")
+    cny_str = format_cost(cost_cny if cost_cny > 0 else None, "CNY")
+    return usd_str, cny_str
+
+
+def format_date_display(date_str: str) -> str:
+    """Format date string YYYY-MM-DD to 'YYYY M-D' for table display."""
+    parts = date_str.split("-")
+    if len(parts) == 3:
+        month = int(parts[1])
+        day = int(parts[2])
+        return f"{parts[0]} {month}-{day}"
+    return date_str
+
+
+def render_cost_table(daily_stats: dict[str, DailyStats]) -> Table:
+    """Render the cost table using rich."""
+    table = Table(
+        title="Usage Statistics",
+        show_header=True,
+        header_style="bold",
+        padding=(0, 1, 0, 2),
+        box=ASCII_HORIZONAL,
+    )
+
+    table.add_column("Date", style="cyan", no_wrap=True)
+    table.add_column("Model", no_wrap=True)
+    table.add_column("Input", justify="right", no_wrap=True)
+    table.add_column("Output", justify="right", no_wrap=True)
+    table.add_column("Cache", justify="right", no_wrap=True)
+    table.add_column("Total", justify="right", no_wrap=True)
+    table.add_column("USD", justify="right", no_wrap=True)
+    table.add_column("CNY", justify="right", no_wrap=True)
+
+    # Sort dates
+    sorted_dates = sorted(daily_stats.keys())
+
+    # Track global totals by model
+    global_by_model: dict[str, ModelUsageStats] = {}
+
+    def sort_by_cost(stats: ModelUsageStats) -> tuple[float, float]:
+        """Sort key: USD desc, then CNY desc."""
+        return (-stats.cost_usd, -stats.cost_cny)
+
+    for date_str in sorted_dates:
+        day = daily_stats[date_str]
+        sorted_models = [s.model_name for s in sorted(day.by_model.values(), key=sort_by_cost)]
+
+        first_row = True
+        for model_name in sorted_models:
+            stats = day.by_model[model_name]
+            usd_str, cny_str = format_cost_dual(stats.cost_usd, stats.cost_cny)
+
+            # Accumulate to global totals
+            if model_name not in global_by_model:
+                global_by_model[model_name] = ModelUsageStats(model_name=model_name)
+            global_by_model[model_name].input_tokens += stats.input_tokens
+            global_by_model[model_name].output_tokens += stats.output_tokens
+            global_by_model[model_name].cached_tokens += stats.cached_tokens
+            global_by_model[model_name].cost_usd += stats.cost_usd
+            global_by_model[model_name].cost_cny += stats.cost_cny
+
+            table.add_row(
+                format_date_display(date_str) if first_row else "",
+                f"- {model_name}",
+                format_tokens(stats.input_tokens),
+                format_tokens(stats.output_tokens),
+                format_tokens(stats.cached_tokens),
+                format_tokens(stats.total_tokens),
+                usd_str,
+                cny_str,
+            )
+            first_row = False
+
+        # Add subtotal row for this day
+        subtotal = day.get_subtotal()
+        usd_str, cny_str = format_cost_dual(subtotal.cost_usd, subtotal.cost_cny)
+        table.add_row(
+            "",
+            "[cyan]  (subtotal)[/cyan]",
+            f"[cyan]{format_tokens(subtotal.input_tokens)}[/cyan]",
+            f"[cyan]{format_tokens(subtotal.output_tokens)}[/cyan]",
+            f"[cyan]{format_tokens(subtotal.cached_tokens)}[/cyan]",
+            f"[cyan]{format_tokens(subtotal.total_tokens)}[/cyan]",
+            f"[cyan]{usd_str}[/cyan]",
+            f"[cyan]{cny_str}[/cyan]",
+        )
+
+        # Add separator between days
+        if date_str != sorted_dates[-1]:
+            table.add_section()
+
+    # Add final section for totals
+    table.add_section()
+
+    # Build date range label for Total
+    if sorted_dates:
+        first_date = format_date_display(sorted_dates[0])
+        last_date = format_date_display(sorted_dates[-1])
+        if first_date == last_date:
+            total_label = f"[bold]Total[/bold]\n[dim]{first_date}[/dim]"
+        else:
+            total_label = f"[bold]Total[/bold]\n[dim]{first_date} ~[/dim]\n[dim]{last_date}[/dim]"
+    else:
+        total_label = "[bold]Total[/bold]"
+
+    # Add per-model totals
+    sorted_global_models = [s.model_name for s in sorted(global_by_model.values(), key=sort_by_cost)]
+    first_total_row = True
+    for model_name in sorted_global_models:
+        stats = global_by_model[model_name]
+        usd_str, cny_str = format_cost_dual(stats.cost_usd, stats.cost_cny)
+        table.add_row(
+            total_label if first_total_row else "",
+            f"- {model_name}",
+            format_tokens(stats.input_tokens),
+            format_tokens(stats.output_tokens),
+            format_tokens(stats.cached_tokens),
+            format_tokens(stats.total_tokens),
+            usd_str,
+            cny_str,
+        )
+        first_total_row = False
+
+    # Add grand total row
+    grand_total = ModelUsageStats(model_name="(total)")
+    for stats in global_by_model.values():
+        grand_total.input_tokens += stats.input_tokens
+        grand_total.output_tokens += stats.output_tokens
+        grand_total.cached_tokens += stats.cached_tokens
+        grand_total.cost_usd += stats.cost_usd
+        grand_total.cost_cny += stats.cost_cny
+
+    usd_str, cny_str = format_cost_dual(grand_total.cost_usd, grand_total.cost_cny)
+    table.add_row(
+        "",
+        "[bold]  (total)[/bold]",
+        f"[bold]{format_tokens(grand_total.input_tokens)}[/bold]",
+        f"[bold]{format_tokens(grand_total.output_tokens)}[/bold]",
+        f"[bold]{format_tokens(grand_total.cached_tokens)}[/bold]",
+        f"[bold]{format_tokens(grand_total.total_tokens)}[/bold]",
+        f"[bold]{usd_str}[/bold]",
+        f"[bold]{cny_str}[/bold]",
+    )
+
+    return table
+
+
+def cost_command(
+    days: int | None = typer.Option(None, "--days", "-d", help="Limit to last N days"),
+) -> None:
+    """Display aggregated usage statistics across all sessions."""
+    daily_stats = aggregate_all_sessions()
+
+    if not daily_stats:
+        typer.echo("No usage data found.")
+        raise typer.Exit(0)
+
+    # Filter by days if specified
+    if days is not None:
+        cutoff = datetime.now().strftime("%Y-%m-%d")
+        from datetime import timedelta
+
+        cutoff_date = datetime.now() - timedelta(days=days)
+        cutoff = cutoff_date.strftime("%Y-%m-%d")
+        daily_stats = {k: v for k, v in daily_stats.items() if k >= cutoff}
+
+    if not daily_stats:
+        typer.echo(f"No usage data found in the last {days} days.")
+        raise typer.Exit(0)
+
+    table = render_cost_table(daily_stats)
+    console = Console()
+    console.print(table)
+
+
+def register_cost_commands(app: typer.Typer) -> None:
+    """Register cost command to the given Typer app."""
+    app.command("cost")(cost_command)

{klaude_code-1.7.0 → klaude_code-1.8.0}/src/klaude_code/cli/main.py

@@ -8,6 +8,7 @@ import typer
 
 from klaude_code.cli.auth_cmd import register_auth_commands
 from klaude_code.cli.config_cmd import register_config_commands
+from klaude_code.cli.cost_cmd import register_cost_commands
 from klaude_code.cli.debug import DEBUG_FILTER_HELP, open_log_file_in_editor, resolve_debug_settings
 from klaude_code.cli.self_update import register_self_update_commands, version_option_callback
 from klaude_code.cli.session_cmd import register_session_commands
@@ -95,16 +96,27 @@ def read_input_content(cli_argument: str) -> str | None:
     return content
 
 
+ENV_HELP = """\
+Environment Variables:
+
+  KLAUDE_READ_GLOBAL_LINE_CAP  Max lines to read (default: 2000)
+
+  KLAUDE_READ_MAX_CHARS        Max total chars to read (default: 50000)
+"""
+
 app = typer.Typer(
     add_completion=False,
     pretty_exceptions_enable=False,
     no_args_is_help=False,
+    rich_markup_mode="rich",
+    epilog=ENV_HELP,
 )
 
 # Register subcommands from modules
 register_session_commands(app)
 register_auth_commands(app)
 register_config_commands(app)
+register_cost_commands(app)
 
 register_self_update_commands(app)
 

{klaude_code-1.7.0 → klaude_code-1.8.0}/src/klaude_code/cli/runtime.py

@@ -379,7 +379,7 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
                 model_name=model_name,
                 save_as_default=False,
                 defer_thinking_selection=True,
-                emit_welcome_event=False,
+                emit_welcome_event=True,
                 emit_switch_message=False,
             )
         )
@@ -398,7 +398,7 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
             op.ChangeThinkingOperation(
                 session_id=sid,
                 thinking=thinking,
-                emit_welcome_event=False,
+                emit_welcome_event=True,
                 emit_switch_message=False,
             )
         )

{klaude_code-1.7.0 → klaude_code-1.8.0}/src/klaude_code/command/fork_session_cmd.py

@@ -7,6 +7,7 @@ from prompt_toolkit.styles import Style
 
 from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
 from klaude_code.protocol import commands, events, model
+from klaude_code.ui.modes.repl.clipboard import copy_to_clipboard
 from klaude_code.ui.terminal.selector import SelectItem, select_one
 
 FORK_SELECT_STYLE = Style(
@@ -215,6 +216,9 @@ class ForkSessionCommand(CommandABC):
             new_session = agent.session.fork()
             await new_session.wait_for_flush()
 
+            resume_cmd = f"klaude --resume-by-id {new_session.id}"
+            copy_to_clipboard(resume_cmd)
+
             event = events.DeveloperMessageEvent(
                 session_id=agent.session.id,
                 item=model.DeveloperMessageItem(
@@ -247,6 +251,9 @@ class ForkSessionCommand(CommandABC):
         # Build result message
         fork_description = "entire conversation" if selected is None else f"up to message index {selected}"
 
+        resume_cmd = f"klaude --resume-by-id {new_session.id}"
+        copy_to_clipboard(resume_cmd)
+
         event = events.DeveloperMessageEvent(
             session_id=agent.session.id,
             item=model.DeveloperMessageItem(

{klaude_code-1.7.0 → klaude_code-1.8.0}/src/klaude_code/command/status_cmd.py

@@ -64,7 +64,7 @@ def accumulate_session_usage(session: Session) -> AggregatedUsage:
     return AggregatedUsage(total=total, by_model=by_model, task_count=task_count)
 
 
-def _format_tokens(tokens: int) -> str:
+def format_tokens(tokens: int) -> str:
     """Format token count with K/M suffix for readability."""
     if tokens >= 1_000_000:
         return f"{tokens / 1_000_000:.2f}M"
@@ -73,7 +73,7 @@ def _format_tokens(tokens: int) -> str:
     return str(tokens)
 
 
-def _format_cost(cost: float | None, currency: str = "USD") -> str:
+def format_cost(cost: float | None, currency: str = "USD") -> str:
     """Format cost with currency symbol."""
     if cost is None:
         return "-"
@@ -93,13 +93,13 @@ def _format_model_usage_line(meta: model.TaskMetadata) -> str:
     if not usage:
         return f"      {model_label}: no usage data"
 
-    cost_str = _format_cost(usage.total_cost, usage.currency)
+    cost_str = format_cost(usage.total_cost, usage.currency)
     return (
         f"      {model_label}: "
-        f"{_format_tokens(usage.input_tokens)} input, "
-        f"{_format_tokens(usage.output_tokens)} output, "
-        f"{_format_tokens(usage.cached_tokens)} cache read, "
-        f"{_format_tokens(usage.reasoning_tokens)} thinking, "
+        f"{format_tokens(usage.input_tokens)} input, "
+        f"{format_tokens(usage.output_tokens)} output, "
+        f"{format_tokens(usage.cached_tokens)} cache read, "
+        f"{format_tokens(usage.reasoning_tokens)} thinking, "
         f"({cost_str})"
     )
 
@@ -109,7 +109,7 @@ def format_status_content(aggregated: AggregatedUsage) -> str:
     lines: list[str] = []
 
     # Total cost line
-    total_cost_str = _format_cost(aggregated.total.total_cost, aggregated.total.currency)
+    total_cost_str = format_cost(aggregated.total.total_cost, aggregated.total.currency)
     lines.append(f"Total cost: {total_cost_str}")
 
     # Per-model breakdown