feat(costs): add default OpenAI price table (4o-mini, 4o/4.1); fallback estimation only when usage tokens missing; docs updated

Author: haasonsaas

Dockerfile

@@ -35,14 +35,197 @@ USER appuser
 
 EXPOSE 8000
 HEALTHCHECK --interval=30s --timeout=5s --start-period=10s --retries=3 \
-  CMD python - <<'PY' || exit 1
-import json, sys, urllib.request
-try:
-    with urllib.request.urlopen('http://127.0.0.1:8000/openapi.json', timeout=3) as r:
-        sys.exit(0 if r.status==200 else 1)
-except Exception:
-    sys.exit(1)
-PY
+  CMD python -c "import sys,urllib.request;\
+    
+    
+    import contextlib;\
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    url='http://127.0.0.1:8000/healthz';\
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    with contextlib.ExitStack() as s: r=s.enter_context(urllib.request.urlopen(url, timeout=3)); sys.exit(0 if r.status==200 else 1)" 
 
 CMD ["uvicorn", "micro_agent.server:app", "--host", "0.0.0.0", "--port", "8000"]
-

README.md

@@ -138,13 +138,16 @@ Code references (discoverability)
 Notes: For this small dataset, demos neither help nor hurt. For larger flows, compile demos from your real tasks.
 
 ### Cost & Tokens
-- The agent aggregates token counts and cost (when available). If provider usage isn’t exposed, it estimates tokens from prompts/outputs and computes cost using env prices.
+- The agent aggregates token counts and cost. If provider usage isn’t exposed, it estimates tokens from prompts/outputs and computes cost using prices.
 - Set env prices for OpenAI models (USD per 1K tokens):
 ```bash
 export OPENAI_INPUT_PRICE_PER_1K=0.005  # example
 export OPENAI_OUTPUT_PRICE_PER_1K=0.015 # example
 ```
-The eval script will include `avg_cost_usd`. Defaults to 0 if prices aren’t set.
+Defaults: for OpenAI models, built‑in prices are used if env isn’t set (best‑effort):
+- gpt-4o-mini: $0.00015 in / $0.0006 out per 1K tokens
+- gpt-4o (and 4.1): $0.005 in / $0.015 out per 1K tokens
+You can override via the env vars above. Evals print `avg_cost_usd`.
 
 ## Optimize (Teleprompting)
 - Compile optimized few-shot demos for the OpenAI `PlanWithTools` planner and save to JSON:

micro_agent/agent.py

@@ -196,20 +196,20 @@ def _accumulate_usage(input_text: str = "", output_text: str = ""):
                 # Accumulate usage from DSPy prediction (OpenAI path)
                 try:
                     usage = pred.get_lm_usage() or {}
+                    in_tok = int(usage.get('input_tokens', 0) or 0)
+                    out_tok = int(usage.get('output_tokens', 0) or 0)
                     total_cost += float(usage.get('cost', 0.0) or 0.0)
-                    total_in_tokens += int(usage.get('input_tokens', 0) or 0)
-                    total_out_tokens += int(usage.get('output_tokens', 0) or 0)
-                except Exception:
-                    pass
-                # Heuristic fallback: estimate using a reconstructed prompt & result
-                try:
-                    approx_prompt = self._decision_prompt(
-                        question=question,
-                        state_json=json.dumps(state, ensure_ascii=False),
-                        tools_json=json.dumps(self._tool_list, ensure_ascii=False),
-                    )
-                    approx_out = getattr(pred, 'final', None) or (str(getattr(pred, 'tool_calls', '')))
-                    _accumulate_usage(approx_prompt, approx_out)
+                    total_in_tokens += in_tok
+                    total_out_tokens += out_tok
+                    # Only if usage tokens are both zero, use heuristic fallback
+                    if in_tok == 0 and out_tok == 0:
+                        approx_prompt = self._decision_prompt(
+                            question=question,
+                            state_json=json.dumps(state, ensure_ascii=False),
+                            tools_json=json.dumps(self._tool_list, ensure_ascii=False),
+                        )
+                        approx_out = getattr(pred, 'final', None) or (str(getattr(pred, 'tool_calls', '')))
+                        _accumulate_usage(approx_prompt, approx_out)
                 except Exception:
                     pass
 

micro_agent/costs.py

@@ -26,15 +26,40 @@ def estimate_tokens(text: str, model: str = "gpt-4o-mini") -> int:
     except Exception:
         return max(1, len(text) // 4)
 
+_OPENAI_DEFAULTS = {
+    # Prices per 1K tokens (USD) — see https://platform.openai.com/docs/pricing
+    # These defaults are best-effort and may drift. Override via env vars to be exact.
+    "gpt-4o-mini": (0.00015, 0.0006),  # $0.15 / $0.60 per 1M
+    "gpt-4o": (0.005, 0.015),          # $5 / $15 per 1M
+    "gpt-4.1": (0.005, 0.015),         # typical parity with 4o
+}
+
+def _normalize(model: str) -> str:
+    if not model:
+        return ""
+    m = model.lower()
+    # Strip provider prefix like 'openai/' if present
+    if "/" in m:
+        m = m.split("/", 1)[1]
+    return m
+
 def get_prices_per_1k(model: str, provider: str) -> Tuple[float, float]:
-    # Allow env overrides; default to 0 to avoid misleading values.
-    in_price = float(os.getenv("OPENAI_INPUT_PRICE_PER_1K", "0") or 0)
-    out_price = float(os.getenv("OPENAI_OUTPUT_PRICE_PER_1K", "0") or 0)
-    if provider != "openai":
-        return 0.0, 0.0
-    return in_price, out_price
+    # Allow env overrides; when set, they win.
+    env_in = os.getenv("OPENAI_INPUT_PRICE_PER_1K")
+    env_out = os.getenv("OPENAI_OUTPUT_PRICE_PER_1K")
+    if provider == "openai":
+        if env_in is not None and env_out is not None:
+            try:
+                return float(env_in or 0), float(env_out or 0)
+            except Exception:
+                pass
+        key = _normalize(model)
+        # Match by prefix to handle variants like gpt-4o-mini-2024-xx-xx
+        for base, prices in _OPENAI_DEFAULTS.items():
+            if key.startswith(base):
+                return prices
+    return 0.0, 0.0
 
 def estimate_cost_usd(input_tokens: int, output_tokens: int, model: str, provider: str) -> float:
     in_price_1k, out_price_1k = get_prices_per_1k(model, provider)
     return (input_tokens / 1000.0) * in_price_1k + (output_tokens / 1000.0) * out_price_1k
-

opt/plan_demos.json

@@ -1,43 +1,4 @@
 [
-  {
-    "question": "What time is it right now? Use UTC.",
-    "state": "[]",
-    "tool_calls": [
-      {
-        "name": "now",
-        "args": {
-          "timezone": "utc"
-        }
-      }
-    ],
-    "final": null
-  },
-  {
-    "question": "What time is it right now? Use UTC.",
-    "state": "[]",
-    "tool_calls": [
-      {
-        "name": "now",
-        "args": {
-          "timezone": "utc"
-        }
-      }
-    ],
-    "final": null
-  },
-  {
-    "question": "What time is it right now? Use UTC.",
-    "state": "[]",
-    "tool_calls": [
-      {
-        "name": "now",
-        "args": {
-          "timezone": "utc"
-        }
-      }
-    ],
-    "final": null
-  },
   {
     "question": "What time is it right now? Use UTC.",
     "state": "[]",