wall time and cost (#27)

* wall time and cost

* avoid overcounting

* Update src/agentopt/model_selection/base.py

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

---------

Co-authored-by: Wenyueh <norahua1996@outlook.com>
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

Author: 3 people

src/agentopt/model_selection/base.py

@@ -86,6 +86,11 @@ class SelectionResults(BaseModel):
     """Results from model selection."""
 
     results: List[ModelResult] = Field(default_factory=list)
+    selection_wall_time_seconds: Optional[float] = None
+    selection_cost: Optional[float] = Field(
+        default=None,
+        description="Total selection cost in USD.",
+    )
 
     def __iter__(self):
         return iter(self.results)
@@ -294,6 +299,16 @@ def row(
             )
         lines.append("")
 
+        # Selection overhead
+        parts = []
+        if self.selection_wall_time_seconds is not None:
+            parts.append(f"{self.selection_wall_time_seconds:.2f}s")
+        if self.selection_cost is not None:
+            parts.append(f"${self.selection_cost:.6f}")
+        if parts:
+            lines.append(f"{pad} Selection overhead: {', '.join(parts)}")
+            lines.append("")
+
         return "\n".join(lines)
 
     def print_summary(self) -> None:
@@ -667,11 +682,29 @@ def select_best(
         Returns:
             SelectionResults containing all model evaluation results.
         """
+        record_offset = len(self._tracker.get_records())
+        t0 = time.time()
         try:
-            return self._run_selection(parallel, max_concurrent)
+            result = self._run_selection(parallel, max_concurrent)
         finally:
             self._tracker.stop()
 
+        result.selection_wall_time_seconds = time.time() - t0
+
+        # Cost: only non-cached calls made during this run
+        input_tokens: Dict[str, int] = {}
+        output_tokens: Dict[str, int] = {}
+        for r in self._tracker.get_records()[record_offset:]:
+            if r.cached:
+                continue
+            input_tokens[r.model] = input_tokens.get(r.model, 0) + r.prompt_tokens
+            output_tokens[r.model] = output_tokens.get(r.model, 0) + r.completion_tokens
+        result.selection_cost = compute_price(
+            input_tokens, output_tokens, custom_prices=self._custom_prices,
+        )
+
+        return result
+
     @abstractmethod
     def _run_selection(
         self, parallel: bool = False, max_concurrent: int = 20,