Skip to content

The agent that turns websites into APIs!

feat: add health check & pricing computation

kalil032109a9e954535c
diff --git a/src/reverse_api/engineer.py b/src/reverse_api/engineer.py
index ef7744b..8204ecf 100644
--- a/src/reverse_api/engineer.py
+++ b/src/reverse_api/engineer.py
@@ -114,16 +114,15 @@ class ClaudeEngineer(BaseEngineer):
"cache_read_input_tokens", 0
)
- # Claude Sonnet 4.5 pricing per million tokens:
- # - Regular input: $3.00
- # - Cache creation: $3.75
- # - Cache read: $0.30
- # - Output: $15.00
- cost = (
- (input_tokens / 1_000_000 * 3.0)
- + (cache_creation_tokens / 1_000_000 * 3.75)
- + (cache_read_tokens / 1_000_000 * 0.30)
- + (output_tokens / 1_000_000 * 15.0)
+ # Calculate cost using shared pricing module
+ from .pricing import calculate_cost
+
+ cost = calculate_cost(
+ model_id=self.model,
+ input_tokens=input_tokens,
+ output_tokens=output_tokens,
+ cache_creation_tokens=cache_creation_tokens,
+ cache_read_tokens=cache_read_tokens,
)
self.usage_metadata["estimated_cost_usd"] = cost
diff --git a/src/reverse_api/opencode_engineer.py b/src/reverse_api/opencode_engineer.py
index d5087e2..be56746 100644
--- a/src/reverse_api/opencode_engineer.py
+++ b/src/reverse_api/opencode_engineer.py
@@ -65,6 +65,19 @@ class OpenCodeEngineer(BaseEngineer):
async with httpx.AsyncClient(
base_url=self.BASE_URL, timeout=600.0
) as client:
+ # Health check
+ try:
+ health_r = await client.get("/global/health")
+ health_r.raise_for_status()
+ health = health_r.json()
+ self.opencode_ui.health_check(health)
+ except Exception as e:
+ debug_log(f"Health check failed: {e}")
+ self.opencode_ui.error(
+ f"OpenCode server not responding. Is it running on {self.BASE_URL}?"
+ )
+ return None
+
# Create a new session
r = await client.post("/session", json={})
r.raise_for_status()
@@ -115,6 +128,31 @@ class OpenCodeEngineer(BaseEngineer):
# Success
script_path = str(self.scripts_dir / "api_client.py")
+
+ # Fetch actual provider and model used from session messages
+ try:
+ async with httpx.AsyncClient(
+ base_url=self.BASE_URL, timeout=10.0
+ ) as client:
+ messages_r = await client.get(
+ f"/session/{self._session_id}/message"
+ )
+ if messages_r.status_code == 200:
+ messages = messages_r.json()
+ # Find first assistant message with provider/model info
+ for msg in messages:
+ info = msg.get("info", {})
+ if info.get("role") == "assistant":
+ provider_id = info.get("providerID")
+ model_id = info.get("modelID")
+ if provider_id and model_id:
+ self.opencode_ui.model_info(provider_id, model_id)
+ break
+ except Exception as e:
+ debug_log(f"Failed to fetch session messages: {e}")
+
+ # Show session summary before success message
+ self.opencode_ui.session_summary(self.usage_metadata)
self.opencode_ui.success(script_path)
result_data: Dict[str, Any] = {
@@ -377,25 +415,47 @@ class OpenCodeEngineer(BaseEngineer):
elif part_type == "step-finish":
debug_log("Handling step-finish part")
# Extract usage stats
- cost = part.get("cost", 0)
+ api_cost = part.get("cost", 0)
tokens = part.get("tokens", {})
- self.opencode_ui.step_finish(cost, tokens)
+ input_tokens = tokens.get("input", 0)
+ output_tokens = tokens.get("output", 0)
+ reasoning_tokens = tokens.get("reasoning", 0)
+ cache = tokens.get("cache", {})
+ cache_read = cache.get("read", 0)
+ cache_write = cache.get("write", 0)
+
+ if api_cost == 0 and (input_tokens > 0 or output_tokens > 0):
+ from .pricing import calculate_cost
+
+ calculated_cost = calculate_cost(
+ model_id=self.opencode_model,
+ input_tokens=input_tokens,
+ output_tokens=output_tokens,
+ cache_creation_tokens=cache_write,
+ cache_read_tokens=cache_read,
+ reasoning_tokens=reasoning_tokens,
+ )
+ cost = calculated_cost
+ debug_log(f"API cost was 0, calculated locally: ${cost:.4f}")
+ else:
+ cost = api_cost
- # Update usage metadata
self.usage_metadata["input_tokens"] = self.usage_metadata.get(
"input_tokens", 0
- ) + tokens.get("input", 0)
+ ) + input_tokens
self.usage_metadata["output_tokens"] = self.usage_metadata.get(
"output_tokens", 0
- ) + tokens.get("output", 0)
- cache = tokens.get("cache", {})
+ ) + output_tokens
+ self.usage_metadata["reasoning_tokens"] = self.usage_metadata.get(
+ "reasoning_tokens", 0
+ ) + reasoning_tokens
self.usage_metadata["cache_read_tokens"] = self.usage_metadata.get(
"cache_read_tokens", 0
- ) + cache.get("read", 0)
+ ) + cache_read
self.usage_metadata["cache_creation_tokens"] = self.usage_metadata.get(
"cache_creation_tokens", 0
- ) + cache.get("write", 0)
+ ) + cache_write
self.usage_metadata["cost"] = self.usage_metadata.get("cost", 0) + cost
diff --git a/src/reverse_api/opencode_ui.py b/src/reverse_api/opencode_ui.py
index c26260f..0a175ca 100644
--- a/src/reverse_api/opencode_ui.py
+++ b/src/reverse_api/opencode_ui.py
@@ -46,10 +46,21 @@ class OpenCodeUI:
self.console.print(f" [dim]decoding starting...[/dim]")
self.console.print()
+ def health_check(self, health: Dict[str, Any]) -> None:
+ """Display server health status."""
+ version = health.get("version", "unknown")
+ self.console.print(f" [dim]server: OpenCode v{version}[/dim]")
+
def session_created(self, session_id: str) -> None:
"""Display session creation."""
self.console.print(f" [dim]session: {session_id[:16]}...[/dim]")
+ def model_info(self, provider: str, model: str) -> None:
+ """Display the actual provider and model being used."""
+ self.console.print(
+ f" [dim]using: {provider}/{model}[/dim]"
+ )
+
def start_streaming(self) -> None:
"""Start the live display for streaming updates."""
self._live = Live(
@@ -76,12 +87,6 @@ class OpenCodeUI:
display.append(f"{self._current_tool}", style="white")
display.append(" running...\n", style=THEME_DIM)
- # Show streaming text (last 200 chars)
- if self._current_text:
- text_preview = self._current_text[-200:].replace("\n", " ").strip()
- if len(self._current_text) > 200:
- text_preview = "..." + text_preview
- display.append(f" {text_preview}\n", style=THEME_DIM)
return display
@@ -131,13 +136,60 @@ class OpenCodeUI:
"""Display step completion with usage stats."""
input_tokens = tokens.get("input", 0)
output_tokens = tokens.get("output", 0)
+ reasoning_tokens = tokens.get("reasoning", 0)
cache = tokens.get("cache", {})
cache_read = cache.get("read", 0)
cache_write = cache.get("write", 0)
- self.console.print(
- f" [dim]step: {input_tokens:,}in/{output_tokens:,}out ${cost:.4f}[/dim]"
- )
+ token_parts = []
+ if input_tokens > 0:
+ token_parts.append(f"{input_tokens:,}in")
+ if output_tokens > 0:
+ token_parts.append(f"{output_tokens:,}out")
+ if reasoning_tokens > 0:
+ token_parts.append(f"{reasoning_tokens:,}rsn")
+ if cache_read > 0:
+ token_parts.append(f"{cache_read:,}cr")
+ if cache_write > 0:
+ token_parts.append(f"{cache_write:,}cw")
+
+ token_summary = "/".join(token_parts)
+
+ if cost > 0.001:
+ self.console.print(f" [dim]step: {token_summary} ${cost:.4f}[/dim]")
+ elif token_parts:
+ self.console.print(f" [dim]step: {token_summary}[/dim]")
+
+ def session_summary(self, usage_metadata: Dict[str, Any]) -> None:
+ """Display session usage summary."""
+ input_tokens = usage_metadata.get("input_tokens", 0)
+ output_tokens = usage_metadata.get("output_tokens", 0)
+ reasoning_tokens = usage_metadata.get("reasoning_tokens", 0)
+ cache_read = usage_metadata.get("cache_read_tokens", 0)
+ cache_write = usage_metadata.get("cache_creation_tokens", 0)
+ total_cost = usage_metadata.get("cost", 0)
+
+ if input_tokens > 0 or output_tokens > 0 or total_cost > 0:
+ self.console.print()
+ self.console.print(" [dim]Session Summary[/dim]")
+
+ if input_tokens > 0:
+ self.console.print(f" [dim] input: {input_tokens:,} tokens[/dim]")
+ if output_tokens > 0:
+ self.console.print(f" [dim] output: {output_tokens:,} tokens[/dim]")
+ if reasoning_tokens > 0:
+ self.console.print(
+ f" [dim] reasoning: {reasoning_tokens:,} tokens[/dim]"
+ )
+ if cache_write > 0:
+ self.console.print(
+ f" [dim] cache write: {cache_write:,} tokens[/dim]"
+ )
+ if cache_read > 0:
+ self.console.print(f" [dim] cache read: {cache_read:,} tokens[/dim]")
+
+ if total_cost > 0:
+ self.console.print(f" [dim] total cost: ${total_cost:.4f}[/dim]")
def session_status(self, status_type: str) -> None:
"""Update session status."""
@@ -185,18 +237,32 @@ class OpenCodeUI:
# Count by status
pending = sum(1 for t in todos if t.get("status") == "pending")
completed = sum(1 for t in todos if t.get("status") == "completed")
- in_progress = sum(1 for t in todos if t.get("status") == "in_progress")
+ in_progress_todos = [t for t in todos if t.get("status") == "in_progress"]
parts = []
- if in_progress:
- parts.append(f"{in_progress} active")
+ if in_progress_todos:
+ parts.append(f"{len(in_progress_todos)} active")
if pending:
parts.append(f"{pending} pending")
if completed:
parts.append(f"{completed} done")
status_str = ", ".join(parts) if parts else f"{len(todos)} items"
- self.console.print(f" [dim]tasks:[/dim] {status_str}")
+
+ # Show current task if there is one in progress
+ if in_progress_todos:
+ current_task = in_progress_todos[0]
+ task_content = current_task.get("activeForm") or current_task.get(
+ "content", ""
+ )
+ # Truncate if too long
+ if len(task_content) > 50:
+ task_content = task_content[:47] + "..."
+ self.console.print(
+ f" [dim]tasks:[/dim] {status_str} [dim]→ {task_content}[/dim]"
+ )
+ else:
+ self.console.print(f" [dim]tasks:[/dim] {status_str}")
def file_edited(self, file_path: str) -> None:
"""Display when a file is edited."""
diff --git a/uv.lock b/uv.lock
index a3e3632..698ce76 100644
--- a/uv.lock
+++ b/uv.lock
@@ -1849,7 +1849,7 @@ wheels = [
[[package]]
name = "reverse-api-engineer"
-version = "0.2.3"
+version = "0.2.7"
source = { editable = "." }
dependencies = [
{ name = "aiohttp" },