baar-core 0.1.0__tar.gz

baar_core-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 BAAR-Algo Authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

baar_core-0.1.0/PKG-INFO

@@ -0,0 +1,157 @@
+Metadata-Version: 2.4
+Name: baar-core
+Version: 0.1.0
+Summary: Budget-Aware Agentic Routing — route LLM calls intelligently between cheap and powerful models with a hard budget cap.
+License: MIT
+Project-URL: Homepage, https://github.com/orvi2014/Baar-Core
+Project-URL: Issues, https://github.com/orvi2014/Baar-Core/issues
+Keywords: llm,agents,routing,budget,cost,openai,langchain
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: litellm>=1.30.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Requires-Dist: datasets>=2.15.0; extra == "dev"
+Requires-Dist: huggingface_hub>=0.19.0; extra == "dev"
+Dynamic: license-file
+
+# baar-core (BAAR-Algo)
+
+[![PyPI version](https://badge.fury.io/py/baar-core.svg)](https://badge.fury.io/py/baar-core)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![Scientific Validation](https://img.shields.io/badge/Validated-MMLU%20%7C%20GSM8K%20%7C%20HumanEval-success)](https://github.com/orvi2014/Baar-Core/blob/main/RESEARCH.md)
+
+**Route LLM calls intelligently between cheap and powerful models — with a hard financial kill-switch that never breaks.**
+
+---
+
+## 🚀 Why BAAR?
+
+Every agent developer using GPT-4o has seen this:
+- **Simple task** → sent to GPT-4o anyway → **15× more expensive** than necessary.
+- **Budget set to $0.10** → agent burns $0.40 → **surprise invoice**.
+- **No visibility** into which agent step cost what, or why.
+
+**BAAR (Budget-Aware Agentic Routing)** solves this at the protocol level.
+
+---
+
+## 🧠 How it Works
+
+BAAR acts as a semantic gateway between your application and the LLM providers. 
+
+```mermaid
+graph TD
+    A[Your Task] --> B{Semantic Router}
+    B -- Complexity < 0.65 --> C[gpt-4o-mini]
+    B -- Complexity >= 0.65 --> D[Budget Kill-Switch]
+    
+    D -- "Affordable?" --> E[gpt-4o]
+    D -- "Too Expensive" --> F[Force Downgrade to Mini]
+    
+    E --> G[Audit & Spend Tracking]
+    F --> G
+    C --> G
+    
+    G --> H[Final Response]
+```
+
+1.  **Semantic Scoring**: Uses a cheap model to score task complexity (0.0–1.0).
+2.  **BCD (Budget-Constrained Decoding)**: If the powerful model is too expensive for your remaining budget, BAAR **automatically downgrades** to a cheaper one to ensure the task completes without an overage.
+3.  **Local Rejection**: If even the cheapest model exceeds the budget, the request is rejected **locally** with zero network cost.
+
+---
+
+## 🔬 Benchmarking Results
+
+To ensure frontier-grade quality, BAAR-Algo is validated on industry-standard datasets.
+
+| Dataset | Strategy | Accuracy % | Cost (USD) | Savings vs BIG |
+| :--- | :--- | :---: | :---: | :---: |
+| **MMLU** | ALWAYS-BIG | 100.0% | $0.0905 | - |
+| (Knowledge) | **BAAR-Algo** | **70.0%** | **$0.0050** | **93.3%** |
+| **GSM8K** | ALWAYS-BIG | 100.0% | $0.0905 | - |
+| (Math) | **BAAR-Algo** | **80.0%** | **$0.0050** | **93.3%** |
+| **HumanEval** | ALWAYS-BIG | 100.0% | $0.0105 | - |
+| (Coding) | **BAAR-Algo** | **100.0%** | **$0.0105** | **0.0%*** |
+
+*\*On HumanEval, BAAR correctly detects 100% complexity and uses the Big model, ensuring zero quality loss for critical code.*
+
+### Run the Benchmark Yourself (Free)
+```bash
+baar-bench --dataset all --mock
+```
+
+---
+
+## 📦 Installation
+
+```bash
+pip install baar-core
+```
+
+## ⚡ Quick Start
+
+```python
+from baar import BAARRouter
+
+# Set a hard $0.10 budget cap
+router = BAARRouter(budget=0.10)
+
+# This will be routed to gpt-4o-mini (Complexity ~0.1)
+response = router.chat("What is the capital of France?")
+
+# This will be routed to gpt-4o (Complexity ~0.9)
+code = router.chat("Write a complex matrix multiplication in CUDA.")
+```
+
+---
+
+## 🛡️ Resilience & Security
+
+BAAR is designed for **Financial Safety** (Anti-Denial of Wallet).
+
+| Attack Vector | BAAR Response | Proof |
+| :--- | :--- | :--- |
+| **Unbounded Consumption** | Zero-Call Rejection | Blocks request locally with **Zero** network calls. |
+| **Complexity Inflation** | Semantic Scoring | Ignores gibberish/padding intended to drain budget. |
+| **Sensitivity Toggling** | Tunable Threshold | Adjust `complexity_threshold` to match your quality needs. |
+
+Verify resilience locally:
+```bash
+baar-stress
+```
+
+---
+
+## 🛠️ Configuration
+
+```python
+router = BAARRouter(
+    budget=0.10,                    # Hard cap in USD
+    small_model="gpt-4o-mini",      # Cheap model
+    big_model="gpt-4o",             # Powerful model
+    complexity_threshold=0.65,      # 0–1: above this → use big model
+)
+```
+
+---
+
+## 📄 License & Research
+
+Distributed under the **MIT License**. See [LICENSE](https://github.com/orvi2014/Baar-Core/blob/main/LICENSE) for more information.
+
+For architectural details and mapping to the **OWASP LLM10** security framework, see [RESEARCH.md](https://github.com/orvi2014/Baar-Core/blob/main/RESEARCH.md).
+

baar_core-0.1.0/README.md

@@ -0,0 +1,129 @@
+# baar-core (BAAR-Algo)
+
+[![PyPI version](https://badge.fury.io/py/baar-core.svg)](https://badge.fury.io/py/baar-core)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![Scientific Validation](https://img.shields.io/badge/Validated-MMLU%20%7C%20GSM8K%20%7C%20HumanEval-success)](https://github.com/orvi2014/Baar-Core/blob/main/RESEARCH.md)
+
+**Route LLM calls intelligently between cheap and powerful models — with a hard financial kill-switch that never breaks.**
+
+---
+
+## 🚀 Why BAAR?
+
+Every agent developer using GPT-4o has seen this:
+- **Simple task** → sent to GPT-4o anyway → **15× more expensive** than necessary.
+- **Budget set to $0.10** → agent burns $0.40 → **surprise invoice**.
+- **No visibility** into which agent step cost what, or why.
+
+**BAAR (Budget-Aware Agentic Routing)** solves this at the protocol level.
+
+---
+
+## 🧠 How it Works
+
+BAAR acts as a semantic gateway between your application and the LLM providers. 
+
+```mermaid
+graph TD
+    A[Your Task] --> B{Semantic Router}
+    B -- Complexity < 0.65 --> C[gpt-4o-mini]
+    B -- Complexity >= 0.65 --> D[Budget Kill-Switch]
+    
+    D -- "Affordable?" --> E[gpt-4o]
+    D -- "Too Expensive" --> F[Force Downgrade to Mini]
+    
+    E --> G[Audit & Spend Tracking]
+    F --> G
+    C --> G
+    
+    G --> H[Final Response]
+```
+
+1.  **Semantic Scoring**: Uses a cheap model to score task complexity (0.0–1.0).
+2.  **BCD (Budget-Constrained Decoding)**: If the powerful model is too expensive for your remaining budget, BAAR **automatically downgrades** to a cheaper one to ensure the task completes without an overage.
+3.  **Local Rejection**: If even the cheapest model exceeds the budget, the request is rejected **locally** with zero network cost.
+
+---
+
+## 🔬 Benchmarking Results
+
+To ensure frontier-grade quality, BAAR-Algo is validated on industry-standard datasets.
+
+| Dataset | Strategy | Accuracy % | Cost (USD) | Savings vs BIG |
+| :--- | :--- | :---: | :---: | :---: |
+| **MMLU** | ALWAYS-BIG | 100.0% | $0.0905 | - |
+| (Knowledge) | **BAAR-Algo** | **70.0%** | **$0.0050** | **93.3%** |
+| **GSM8K** | ALWAYS-BIG | 100.0% | $0.0905 | - |
+| (Math) | **BAAR-Algo** | **80.0%** | **$0.0050** | **93.3%** |
+| **HumanEval** | ALWAYS-BIG | 100.0% | $0.0105 | - |
+| (Coding) | **BAAR-Algo** | **100.0%** | **$0.0105** | **0.0%*** |
+
+*\*On HumanEval, BAAR correctly detects 100% complexity and uses the Big model, ensuring zero quality loss for critical code.*
+
+### Run the Benchmark Yourself (Free)
+```bash
+baar-bench --dataset all --mock
+```
+
+---
+
+## 📦 Installation
+
+```bash
+pip install baar-core
+```
+
+## ⚡ Quick Start
+
+```python
+from baar import BAARRouter
+
+# Set a hard $0.10 budget cap
+router = BAARRouter(budget=0.10)
+
+# This will be routed to gpt-4o-mini (Complexity ~0.1)
+response = router.chat("What is the capital of France?")
+
+# This will be routed to gpt-4o (Complexity ~0.9)
+code = router.chat("Write a complex matrix multiplication in CUDA.")
+```
+
+---
+
+## 🛡️ Resilience & Security
+
+BAAR is designed for **Financial Safety** (Anti-Denial of Wallet).
+
+| Attack Vector | BAAR Response | Proof |
+| :--- | :--- | :--- |
+| **Unbounded Consumption** | Zero-Call Rejection | Blocks request locally with **Zero** network calls. |
+| **Complexity Inflation** | Semantic Scoring | Ignores gibberish/padding intended to drain budget. |
+| **Sensitivity Toggling** | Tunable Threshold | Adjust `complexity_threshold` to match your quality needs. |
+
+Verify resilience locally:
+```bash
+baar-stress
+```
+
+---
+
+## 🛠️ Configuration
+
+```python
+router = BAARRouter(
+    budget=0.10,                    # Hard cap in USD
+    small_model="gpt-4o-mini",      # Cheap model
+    big_model="gpt-4o",             # Powerful model
+    complexity_threshold=0.65,      # 0–1: above this → use big model
+)
+```
+
+---
+
+## 📄 License & Research
+
+Distributed under the **MIT License**. See [LICENSE](https://github.com/orvi2014/Baar-Core/blob/main/LICENSE) for more information.
+
+For architectural details and mapping to the **OWASP LLM10** security framework, see [RESEARCH.md](https://github.com/orvi2014/Baar-Core/blob/main/RESEARCH.md).
+

baar_core-0.1.0/baar/__init__.py

@@ -0,0 +1,22 @@
+"""
+baar — Budget-Aware Agentic Routing.
+Public API for the BAAR-Algo project.
+"""
+
+from baar.router import BAARRouter, token_counter
+from baar.core.budget import BudgetExceeded, BudgetTracker
+from baar.core.router import Router, ModelTier, RoutingDecision
+from baar.core.models import StepResult, RoutingLog
+
+__version__ = "0.1.0"
+__all__ = [
+    "BAARRouter",
+    "token_counter",
+    "BudgetExceeded",
+    "BudgetTracker",
+    "Router",
+    "ModelTier",
+    "RoutingDecision",
+    "StepResult",
+    "RoutingLog",
+]

baar_core-0.1.0/baar/__main__.py

@@ -0,0 +1,16 @@
+"""
+baar/__main__.py — CLI entry point for 'python -m baar'.
+"""
+import sys
+from baar import __version__
+
+def main():
+    print(f"BAAR-Algo (baar-core) v{__version__}")
+    print("\nBudget-Aware Agentic Routing — Intelligent LLM Model Selection.")
+    print("\nUsage:")
+    print("  baar-bench   : Run the scientific validation suite")
+    print("  baar-stress  : Run the adversarial resilience suite")
+    print("\nSee README.md for more information.")
+
+if __name__ == "__main__":
+    main()

baar_core-0.1.0/baar/core/__init__.py

@@ -0,0 +1,3 @@
+"""
+baar.core — Internal core components (routing logic, models, budget).
+"""

baar_core-0.1.0/baar/core/budget.py

@@ -0,0 +1,153 @@
+"""
+Budget tracker — real token-based cost using LiteLLM pricing.
+This is the financial source of truth for the entire system.
+"""
+
+from dataclasses import dataclass, field
+from typing import Optional
+from litellm import completion_cost, cost_per_token
+
+
+class BudgetExceeded(Exception):
+    """Raised when a model call would exceed the remaining budget."""
+
+    def __init__(self, requested: float, remaining: float, model: str):
+        self.requested = requested
+        self.remaining = remaining
+        self.model = model
+        super().__init__(
+            f"Budget exceeded: model '{model}' would cost ~${requested:.6f} "
+            f"but only ${remaining:.6f} remains."
+        )
+
+
+@dataclass
+class SpendRecord:
+    step: int
+    model: str
+    prompt_tokens: int
+    completion_tokens: int
+    cost: float
+    cumulative_cost: float
+
+
+@dataclass
+class BudgetTracker:
+    """
+    Tracks real spend using LiteLLM's live pricing data.
+    Never uses hardcoded costs — always derives from actual token counts.
+    """
+
+    total_budget: float
+    _spent: float = field(default=0.0, init=False)
+    _records: list = field(default_factory=list, init=False)
+    _step: int = field(default=0, init=False)
+
+    @property
+    def spent(self) -> float:
+        return self._spent
+
+    @property
+    def remaining(self) -> float:
+        return max(0.0, self.total_budget - self._spent)
+
+    @property
+    def utilization(self) -> float:
+        """0.0 → 1.0 showing how much budget has been consumed."""
+        if self.total_budget <= 0:
+            return 1.0
+        return min(1.0, self._spent / self.total_budget)
+
+    def cost_from_response(self, response) -> float:
+        """
+        Extract real cost from a LiteLLM completion response.
+        Uses completion_cost() which reads live pricing from LiteLLM's
+        model_prices_and_context_window.json — no hardcoding.
+        """
+        try:
+            cost = completion_cost(completion_response=response)
+            return float(cost)
+        except Exception:
+            # Fallback: manual calc from usage if completion_cost fails
+            usage = getattr(response, "usage", None)
+            if usage:
+                model = response.model or "gpt-4o-mini"
+                try:
+                    in_cost, out_cost = cost_per_token(
+                        model=model,
+                        prompt_tokens=usage.prompt_tokens,
+                        completion_tokens=usage.completion_tokens,
+                    )
+                    return float(in_cost + out_cost)
+                except Exception:
+                    pass
+            return 0.0
+
+    def estimate_cost(self, model: str, prompt_tokens: int, completion_tokens: int = 200) -> float:
+        """
+        Pre-flight cost estimate before making a call.
+        Uses cost_per_token with estimated output token count.
+        """
+        try:
+            in_cost, out_cost = cost_per_token(
+                model=model,
+                prompt_tokens=prompt_tokens,
+                completion_tokens=completion_tokens,
+            )
+            return float(in_cost + out_cost)
+        except Exception:
+            return 0.0
+
+    def check_affordability(self, model: str, prompt_tokens: int) -> None:
+        """
+        Hard budget constraint (BCD — Budget-Constrained Decoding).
+        Raises BudgetExceeded before the call is ever made.
+        """
+        estimated = self.estimate_cost(model, prompt_tokens)
+        if estimated > self.remaining:
+            raise BudgetExceeded(
+                requested=estimated,
+                remaining=self.remaining,
+                model=model,
+            )
+
+    def record(self, response, model: str) -> SpendRecord:
+        """Record actual spend after a successful call."""
+        self._step += 1
+        cost = self.cost_from_response(response)
+        self._spent += cost
+
+        usage = getattr(response, "usage", None)
+        record = SpendRecord(
+            step=self._step,
+            model=model,
+            prompt_tokens=getattr(usage, "prompt_tokens", 0),
+            completion_tokens=getattr(usage, "completion_tokens", 0),
+            cost=cost,
+            cumulative_cost=self._spent,
+        )
+        self._records.append(record)
+        return record
+
+    @property
+    def records(self) -> list:
+        return list(self._records)
+
+    def summary(self) -> dict:
+        return {
+            "total_budget": self.total_budget,
+            "spent": round(self._spent, 8),
+            "remaining": round(self.remaining, 8),
+            "utilization_pct": round(self.utilization * 100, 2),
+            "steps": self._step,
+            "records": [
+                {
+                    "step": r.step,
+                    "model": r.model,
+                    "tokens": r.prompt_tokens + r.completion_tokens,
+                    "cost": round(r.cost, 8),
+                    "cumulative": round(r.cumulative_cost, 8),
+                }
+                for r in self._records
+            ],
+        }

baar_core-0.1.0/baar/core/models.py

@@ -0,0 +1,163 @@
+"""
+Data models for step results and routing logs.
+Every decision is recorded — this is what devs show in benchmarks.
+"""
+
+from dataclasses import dataclass, field
+from typing import Optional, List
+from baar.core.router import RoutingDecision, ModelTier
+
+
+@dataclass
+class StepResult:
+    """Result of a single routed LLM call."""
+    step_num: int
+    task: str
+    decision: RoutingDecision
+    response_text: str
+    cost: float
+    cumulative_cost: float
+    prompt_tokens: int
+    completion_tokens: int
+    latency_ms: float
+
+    @property
+    def model_used(self) -> str:
+        return self.decision.model
+
+    @property
+    def used_big(self) -> bool:
+        return self.decision.tier == ModelTier.BIG
+
+    def to_dict(self) -> dict:
+        return {
+            "step": self.step_num,
+            "task_preview": self.task[:80] + ("..." if len(self.task) > 80 else ""),
+            "model": self.model_used,
+            "tier": self.decision.tier.value,
+            "complexity_score": self.decision.complexity_score,
+            "confidence": self.decision.confidence,
+            "routing_reason": self.decision.reason,
+            "forced_by_budget": self.decision.forced_by_budget,
+            "prompt_tokens": self.prompt_tokens,
+            "completion_tokens": self.completion_tokens,
+            "cost_usd": round(self.cost, 8),
+            "cumulative_cost_usd": round(self.cumulative_cost, 8),
+            "latency_ms": round(self.latency_ms, 1),
+        }
+
+
+@dataclass
+class RoutingLog:
+    """
+    Full audit trail of a BAAR session.
+    This is what you show developers in the benchmark report.
+    """
+    budget: float
+    small_model: str
+    big_model: str
+    steps: List[StepResult] = field(default_factory=list)
+
+    def add(self, step: StepResult) -> None:
+        self.steps.append(step)
+
+    @property
+    def total_cost(self) -> float:
+        return sum(s.cost for s in self.steps)
+
+    @property
+    def total_steps(self) -> int:
+        return len(self.steps)
+
+    @property
+    def big_calls(self) -> int:
+        return sum(1 for s in self.steps if s.used_big)
+
+    @property
+    def small_calls(self) -> int:
+        return sum(1 for s in self.steps if not s.used_big)
+
+    @property
+    def budget_forced_downgrades(self) -> int:
+        return sum(1 for s in self.steps if s.decision.forced_by_budget)
+
+    @property
+    def always_big_cost(self) -> float:
+        """What this would have cost if we used big model for every step."""
+        return sum(
+            s.cost * (s.decision.complexity_score / max(0.01, s.decision.complexity_score))
+            if not s.used_big
+            else s.cost
+            for s in self.steps
+        )
+
+    def savings_vs_always_big(self) -> dict:
+        """
+        Calculate savings vs naive always-big strategy.
+        This is the benchmark number that matters.
+        """
+        # Estimate always-big cost: use ratio of big/small pricing
+        # gpt-4o is ~15x more expensive than gpt-4o-mini per token
+        estimated_always_big = sum(
+            s.cost * 15 if not s.used_big else s.cost
+            for s in self.steps
+        )
+        saved = estimated_always_big - self.total_cost
+        pct = (saved / estimated_always_big * 100) if estimated_always_big > 0 else 0
+
+        return {
+            "baar_cost": round(self.total_cost, 6),
+            "estimated_always_big_cost": round(estimated_always_big, 6),
+            "saved_usd": round(saved, 6),
+            "savings_pct": round(pct, 1),
+        }
+
+    def summary(self) -> dict:
+        savings = self.savings_vs_always_big()
+        return {
+            "budget_usd": self.budget,
+            "spent_usd": round(self.total_cost, 8),
+            "remaining_usd": round(self.budget - self.total_cost, 8),
+            "utilization_pct": round(self.total_cost / self.budget * 100, 2) if self.budget > 0 else 0,
+            "total_steps": self.total_steps,
+            "small_model_calls": self.small_calls,
+            "big_model_calls": self.big_calls,
+            "budget_forced_downgrades": self.budget_forced_downgrades,
+            "pct_routed_to_small": round(self.small_calls / max(1, self.total_steps) * 100, 1),
+            "savings_vs_always_big": savings,
+            "steps": [s.to_dict() for s in self.steps],
+        }
+
+    def print_report(self) -> None:
+        """Human-readable report — what devs share as screenshots."""
+        s = self.summary()
+        sav = s["savings_vs_always_big"]
+
+        print("\n" + "═" * 60)
+        print("  BAAR ROUTING REPORT")
+        print("═" * 60)
+        print(f"  Budget:        ${s['budget_usd']:.4f}")
+        print(f"  Spent:         ${s['spent_usd']:.6f}  ({s['utilization_pct']}% used)")
+        print(f"  Remaining:     ${s['remaining_usd']:.6f}")
+        print("─" * 60)
+        print(f"  Total steps:   {s['total_steps']}")
+        print(f"  → small model: {s['small_model_calls']} calls  ({s['pct_routed_to_small']}%)")
+        print(f"  → big model:   {s['big_model_calls']} calls")
+        print(f"  → budget forced downgrades: {s['budget_forced_downgrades']}")
+        print("─" * 60)
+        print(f"  BAAR cost:              ${sav['baar_cost']:.6f}")
+        print(f"  Always-big estimate:    ${sav['estimated_always_big_cost']:.6f}")
+        print(f"  Saved:                  ${sav['saved_usd']:.6f}  ({sav['savings_pct']}% cheaper)")
+        print("─" * 60)
+        print(f"  {'Step':<5} {'Model':<15} {'Complexity':<11} {'Cost':>10}  Reason")
+        print(f"  {'─'*4} {'─'*14} {'─'*10} {'─'*10}  {'─'*20}")
+        for step in s["steps"]:
+            forced = " [BUDGET]" if step["forced_by_budget"] else ""
+            print(
+                f"  {step['step']:<5} "
+                f"{step['model']:<15} "
+                f"{step['complexity_score']:<11.3f} "
+                f"${step['cost_usd']:>9.6f}  "
+                f"{step['routing_reason'][:30]}{forced}"
+            )
+        print("═" * 60 + "\n")