Merge pull request #9 from jhd3197/dev

Add cost tracking and pricing display for agent runs

Author: jhd3197

agentsite/api/app.py

@@ -52,6 +52,13 @@ async def lifespan(app: FastAPI):
     deps.agent_config_repo = deps.AgentConfigRepository(deps.db)
     deps.agent_run_repo = deps.AgentRunRepository(deps.db)
     deps.message_repo = deps.MessageRepository(deps.db)
+    # Backfill costs for runs recorded before cost tracking was added
+    try:
+        updated = await deps.agent_run_repo.backfill_costs()
+        if updated:
+            logger.info("Backfilled costs for %d agent runs", updated)
+    except Exception:
+        logger.debug("Cost backfill skipped", exc_info=True)
     logger.info("AgentSite started — data dir: %s", settings.data_dir)
     yield
     await deps.db.close()

agentsite/api/routes/agents.py

@@ -2,12 +2,16 @@
 
 from __future__ import annotations
 
+import logging
+
 from fastapi import APIRouter, Depends, HTTPException
 from pydantic import BaseModel
 
 from ...models import AgentConfig
 from ..deps import get_agent_config_repo, get_agent_run_repo
 
+logger = logging.getLogger("agentsite.api.agents")
+
 router = APIRouter(prefix="/api/agents", tags=["agents"])
 
 
@@ -75,3 +79,14 @@ async def get_daily_stats(
 ):
     """Get daily token aggregates for the last N days."""
     return await repo.get_daily_stats(days=days)
+
+
+@router.post("/runs/backfill-costs")
+async def backfill_costs(repo=Depends(get_agent_run_repo)):
+    """Recalculate costs for existing runs that have tokens but zero cost.
+
+    Uses Prompture's pricing engine to compute costs from stored token counts
+    and the project's model.
+    """
+    updated = await repo.backfill_costs()
+    return {"updated": updated}

agentsite/api/routes/models.py

@@ -29,6 +29,12 @@ async def list_models():
         logger.warning("Model discovery failed: %s", exc)
         enriched = []
 
+    # Try to import pricing helper
+    try:
+        from prompture.model_rates import get_model_rates
+    except ImportError:
+        get_model_rates = None
+
     # Group by provider
     groups: dict[str, list[dict]] = {}
     for entry in enriched:
@@ -38,6 +44,20 @@ async def list_models():
         # service to route to (e.g. openrouter/moonshotai/kimi-k2.5).
         model_id = f"{provider}/{raw_id}" if not raw_id.startswith(f"{provider}/") else raw_id
         caps = entry.get("capabilities") or {}
+
+        # Fetch pricing from models.dev cache (per 1M tokens)
+        pricing = None
+        if get_model_rates is not None:
+            try:
+                rates = get_model_rates(provider, raw_id)
+                if rates:
+                    pricing = {
+                        "input": rates.get("input"),
+                        "output": rates.get("output"),
+                    }
+            except Exception:
+                pass
+
         groups.setdefault(provider, []).append(
             {
                 "id": model_id,
@@ -50,6 +70,7 @@ async def list_models():
                     "supports_structured_output", False
                 ),
                 "is_reasoning": caps.get("is_reasoning", False),
+                "pricing": pricing,
             }
         )
 

agentsite/engine/pipeline.py

@@ -193,6 +193,11 @@ def _on_agent_complete(name: str, result: Any) -> None:
                     )
                     run.input_tokens = input_tokens
                     run.output_tokens = output_tokens
+                    run.cost = float(
+                        usage.get("total_cost", 0.0)
+                        or usage.get("cost", 0.0)
+                        or 0.0
+                    )
 
             # Capture developer output directly for fallback extraction
             if agent_key == "developer":
@@ -237,6 +242,7 @@ def _on_agent_complete(name: str, result: Any) -> None:
                 self._developer_reasoning = reasoning_text
 
             agent_model = self._agent_models.get(agent_key, "")
+            agent_cost = run.cost if run else 0.0
             self._emit(
                 "agent_complete",
                 agent=agent_key,
@@ -246,6 +252,7 @@ def _on_agent_complete(name: str, result: Any) -> None:
                     "duration_s": duration_s,
                     "input_tokens": input_tokens,
                     "output_tokens": output_tokens,
+                    "cost": agent_cost,
                     "tool_calls_count": len(tool_calls),
                     "model": agent_model,
                     "reasoning": reasoning_text,

agentsite/engine/reasoning_patch.py

@@ -1,6 +1,6 @@
 """Patch Prompture Conversation to preserve reasoning on assistant messages.
 
-Prompture 0.0.47 stores ``reasoning_content`` on assistant messages only in
+Prompture 0.0.49 stores ``reasoning_content`` on assistant messages only in
 the native tool-calling path.  For the simple ``ask()`` and ``ask_for_json()``
 paths, reasoning is stored on ``Conversation.last_reasoning`` but **not** on
 the message dicts in the history.

agentsite/storage/repository.py

@@ -505,13 +505,14 @@ async def get_stats(self, since: str | None = None) -> dict:
         }
 
     async def get_daily_stats(self, days: int = 30) -> list[dict]:
-        """Get daily token aggregates for the last N days."""
+        """Get daily token and cost aggregates for the last N days."""
         cursor = await self._db.conn.execute(
             """
             SELECT
                 DATE(started_at) as date,
                 SUM(input_tokens) as input_tokens,
-                SUM(output_tokens) as output_tokens
+                SUM(output_tokens) as output_tokens,
+                SUM(cost) as cost
             FROM agent_runs
             WHERE started_at >= DATE('now', ?)
             GROUP BY DATE(started_at)
@@ -525,10 +526,47 @@ async def get_daily_stats(self, days: int = 30) -> list[dict]:
                 "date": row["date"],
                 "input_tokens": row["input_tokens"] or 0,
                 "output_tokens": row["output_tokens"] or 0,
+                "cost": round(row["cost"] or 0.0, 4),
             }
             for row in rows
         ]
 
+    async def backfill_costs(self) -> int:
+        """Recalculate costs for runs with tokens but zero cost."""
+        cursor = await self._db.conn.execute(
+            """SELECT ar.id, ar.input_tokens, ar.output_tokens, p.model
+               FROM agent_runs ar
+               JOIN projects p ON ar.project_id = p.id
+               WHERE ar.cost = 0.0 AND (ar.input_tokens > 0 OR ar.output_tokens > 0)"""
+        )
+        rows = await cursor.fetchall()
+        if not rows:
+            return 0
+
+        try:
+            from prompture.drivers import get_driver_for_model
+
+            updated = 0
+            for row in rows:
+                model_str = row["model"] or ""
+                provider = model_str.split("/")[0] if "/" in model_str else ""
+                model_id = model_str.split("/", 1)[1] if "/" in model_str else model_str
+                try:
+                    drv = get_driver_for_model(model_str)
+                    cost = drv._calculate_cost(provider, model_id, row["input_tokens"], row["output_tokens"])
+                except Exception:
+                    cost = 0.0
+                if cost > 0:
+                    await self._db.conn.execute(
+                        "UPDATE agent_runs SET cost = ? WHERE id = ?",
+                        (round(cost, 6), row["id"]),
+                    )
+                    updated += 1
+            await self._db.conn.commit()
+            return updated
+        except ImportError:
+            return 0
+
     @staticmethod
     def _row_to_run(row: Any) -> AgentRun:
         return AgentRun(

frontend/src/components/builder/ProgressPipeline.jsx

@@ -48,6 +48,13 @@ const ALL_AGENTS = {
 
 const DEFAULT_ORDER = ["pm", "designer", "developer", "reviewer"];
 
+function formatCost(cost) {
+  if (!cost || cost === 0) return null;
+  if (cost < 0.001) return `$${cost.toFixed(6)}`;
+  if (cost < 0.01) return `$${cost.toFixed(4)}`;
+  return `$${cost.toFixed(3)}`;
+}
+
 function shortModelName(model) {
   if (!model) return null;
   // Extract last segment: "openrouter/moonshotai/kimi-k2.5" -> "kimi-k2.5"
@@ -115,9 +122,12 @@ export default function ProgressPipeline({ agents, pipelineAgents }) {
               {isComplete && agents[key]?.duration_s != null && (
                 <span
                   className="text-[10px] tabular-nums opacity-70"
-                  title={`${agents[key].input_tokens || 0} in / ${agents[key].output_tokens || 0} out tokens`}
+                  title={`${agents[key].input_tokens || 0} in / ${agents[key].output_tokens || 0} out tokens${agents[key].cost ? ` · ${formatCost(agents[key].cost)}` : ""}`}
                 >
                   {formatDuration(agents[key].duration_s)}
+                  {formatCost(agents[key]?.cost) && (
+                    <span className="ml-1 text-emerald-400/70">{formatCost(agents[key].cost)}</span>
+                  )}
                 </span>
               )}
             </div>

frontend/src/hooks/useGeneration.js

@@ -28,6 +28,7 @@ export default function useGeneration(projectId) {
             duration_s: msg.data?.duration_s,
             input_tokens: msg.data?.input_tokens,
             output_tokens: msg.data?.output_tokens,
+            cost: msg.data?.cost || 0,
             output_preview: msg.data?.output_preview || "",
             full_output: msg.data?.full_output || "",
             tool_calls_count: msg.data?.tool_calls_count || 0,

frontend/src/pages/ModelsPage.jsx

@@ -35,6 +35,13 @@ function formatNumber(n) {
   return n.toString();
 }
 
+function formatPrice(rate) {
+  if (rate == null) return "—";
+  if (rate === 0) return "free";
+  if (rate >= 1) return `$${rate.toFixed(2)}`;
+  return `$${rate.toFixed(4)}`.replace(/0+$/, "");
+}
+
 function CapBadge({ icon: Icon, label, active }) {
   if (!active) return null;
   return (
@@ -257,6 +264,26 @@ export default function ModelsPage() {
                               </p>
                             </div>
 
+                            {/* Pricing per 1M tokens */}
+                            <div className="hidden xl:block text-right shrink-0 w-28">
+                              <p className="text-[10px] text-slate-600">
+                                Price / 1M tok
+                              </p>
+                              {m.pricing ? (
+                                <p className="text-xs text-slate-400 font-mono">
+                                  <span className="text-emerald-400">
+                                    {formatPrice(m.pricing.input)}
+                                  </span>
+                                  <span className="text-slate-600 mx-0.5">/</span>
+                                  <span className="text-amber-400">
+                                    {formatPrice(m.pricing.output)}
+                                  </span>
+                                </p>
+                              ) : (
+                                <p className="text-xs text-slate-600">—</p>
+                              )}
+                            </div>
+
                             {/* Set as default */}
                             {!isDefault && (
                               <button

pyproject.toml

@@ -15,7 +15,7 @@ classifiers = [
     "Operating System :: OS Independent",
 ]
 dependencies = [
-    "prompture>=0.0.47",
+    "prompture>=0.0.49",
     "fastapi>=0.100",
     "uvicorn[standard]>=0.20",
     "aiosqlite>=0.19",