god-code 0.2.2__tar.gz → 0.3.0__tar.gz

{god_code-0.2.2 → god_code-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: god-code
-Version: 0.2.2
+Version: 0.3.0
 Summary: AI coding agent specialized for Godot game development
 Project-URL: Homepage, https://github.com/chuisiufai/god-code
 Project-URL: Repository, https://github.com/chuisiufai/god-code

{god_code-0.2.2 → god_code-0.3.0}/godot_agent/cli.py

@@ -195,7 +195,7 @@ def _run_setup_wizard() -> None:
     click.echo()
 
 
-_VERSION = "0.2.2"
+_VERSION = "0.3.0"
 
 
 def _check_update() -> None:
@@ -345,6 +345,7 @@ def chat(project: str = ".", config: str | None = None):
     cmd_table.add_row("/cd <path>", "change project directory")
     cmd_table.add_row("/info", "show project details")
     cmd_table.add_row("/status", "show model & auth")
+    cmd_table.add_row("/usage", "show token usage & cost")
     cmd_table.add_row("/save", "save session")
     cmd_table.add_row("/quit", "exit")
     console.print(cmd_table)
@@ -398,6 +399,20 @@ def chat(project: str = ".", config: str | None = None):
                         console.print(f"[yellow]  No project.godot in {project_root}[/]")
                     continue
 
+                if cmd == "/usage":
+                    sess = engine.session_usage
+                    cost = sess.cost_estimate(cfg.model)
+                    usage_table = Table(show_header=False, box=None, padding=(0, 1))
+                    usage_table.add_column(style="bold")
+                    usage_table.add_column()
+                    usage_table.add_row("Input tokens", f"{sess.prompt_tokens:,}")
+                    usage_table.add_row("Output tokens", f"{sess.completion_tokens:,}")
+                    usage_table.add_row("Total tokens", f"{sess.total_tokens:,}")
+                    usage_table.add_row("API calls", str(engine.session_api_calls))
+                    usage_table.add_row("Est. cost", f"${cost:.4f}")
+                    console.print(Panel(usage_table, title="Usage", border_style="blue"))
+                    continue
+
                 if cmd == "/status":
                     st = Table(show_header=False, box=None, padding=(0, 1))
                     st.add_column(style="bold")
@@ -446,12 +461,41 @@ def chat(project: str = ".", config: str | None = None):
                     border_style="cyan",
                     padding=(1, 2),
                 ))
+
+                # Show token usage
+                turn = engine.last_turn
+                sess = engine.session_usage
+                if turn:
+                    cost_turn = turn.usage.cost_estimate(cfg.model)
+                    cost_sess = sess.cost_estimate(cfg.model)
+                    tools_str = f"  tools: {', '.join(turn.tools_called)}" if turn.tools_called else ""
+                    console.print(
+                        f"  [dim]tokens: {turn.usage.total_tokens:,} "
+                        f"(in:{turn.usage.prompt_tokens:,} out:{turn.usage.completion_tokens:,}) "
+                        f"~${cost_turn:.4f}"
+                        f"{tools_str}[/]"
+                    )
+                    console.print(
+                        f"  [dim]session: {sess.total_tokens:,} tokens "
+                        f"| {engine.session_api_calls} API calls "
+                        f"| ~${cost_sess:.4f} total[/]"
+                    )
                 console.print()
         finally:
             await engine.close()
 
     asyncio.run(_loop())
-    console.print("[dim]Session ended.[/]")
+    # Session summary
+    sess = engine.session_usage
+    cost = sess.cost_estimate(cfg.model)
+    console.print()
+    console.print(Panel(
+        f"Tokens: {sess.total_tokens:,} (in:{sess.prompt_tokens:,} out:{sess.completion_tokens:,})\n"
+        f"API calls: {engine.session_api_calls}\n"
+        f"Estimated cost: ${cost:.4f}",
+        title="[dim]Session Summary[/]",
+        border_style="dim",
+    ))
 
 
 @main.command()

{god_code-0.2.2 → god_code-0.3.0}/godot_agent/llm/client.py

@@ -7,11 +7,42 @@ import httpx
 log = logging.getLogger(__name__)
 
 
+@dataclass
+class TokenUsage:
+    prompt_tokens: int = 0
+    completion_tokens: int = 0
+    total_tokens: int = 0
+
+    def __add__(self, other: TokenUsage) -> TokenUsage:
+        return TokenUsage(
+            prompt_tokens=self.prompt_tokens + other.prompt_tokens,
+            completion_tokens=self.completion_tokens + other.completion_tokens,
+            total_tokens=self.total_tokens + other.total_tokens,
+        )
+
+    def cost_estimate(self, model: str = "") -> float:
+        """Estimate cost in USD based on model pricing."""
+        # Pricing per 1M tokens (input/output)
+        pricing = {
+            "gpt-5.4": (2.50, 10.00),
+            "gpt-4o": (2.50, 10.00),
+            "gpt-4o-mini": (0.15, 0.60),
+        }
+        inp_rate, out_rate = pricing.get(model, (2.50, 10.00))
+        return (self.prompt_tokens * inp_rate + self.completion_tokens * out_rate) / 1_000_000
+
+
 @dataclass
 class ToolCall:
     id: str
     name: str
-    arguments: str  # JSON string
+    arguments: str
+
+
+@dataclass
+class ChatResponse:
+    message: Message
+    usage: TokenUsage
 
 
 @dataclass
@@ -145,7 +176,14 @@ class LLMClient:
                 )
                 for tc in choice["tool_calls"]
             ]
-        return Message.assistant(content=choice.get("content"), tool_calls=tool_calls)
+        msg = Message.assistant(content=choice.get("content"), tool_calls=tool_calls)
+        usage_data = data.get("usage", {})
+        usage = TokenUsage(
+            prompt_tokens=usage_data.get("prompt_tokens", 0),
+            completion_tokens=usage_data.get("completion_tokens", 0),
+            total_tokens=usage_data.get("total_tokens", 0),
+        )
+        return ChatResponse(message=msg, usage=usage)
 
     async def close(self):
         await self._http.aclose()

{god_code-0.2.2 → god_code-0.3.0}/godot_agent/runtime/engine.py

@@ -4,8 +4,9 @@ from __future__ import annotations
 
 import json
 import logging
+from dataclasses import dataclass, field
 
-from godot_agent.llm.client import LLMClient, Message
+from godot_agent.llm.client import ChatResponse, LLMClient, Message, TokenUsage
 from godot_agent.runtime.context_manager import compact_messages, estimate_tokens
 from godot_agent.runtime.error_loop import format_validation_for_llm, validate_project
 from godot_agent.tools.registry import ToolRegistry
@@ -13,11 +14,17 @@ from godot_agent.tools.registry import ToolRegistry
 log = logging.getLogger(__name__)
 
 _COMPACT_THRESHOLD = 80000
-
-# Tools that modify files — trigger Godot validation after execution
 _FILE_MUTATING_TOOLS = {"write_file", "edit_file"}
 
 
+@dataclass
+class TurnStats:
+    """Stats for a single submit() call (may include multiple LLM round-trips)."""
+    usage: TokenUsage = field(default_factory=TokenUsage)
+    api_calls: int = 0
+    tools_called: list[str] = field(default_factory=list)
+
+
 class ConversationEngine:
     def __init__(
         self,
@@ -34,6 +41,10 @@ class ConversationEngine:
         self.messages: list[Message] = [Message.system(system_prompt)]
         self.project_path = project_path
         self.godot_path = godot_path
+        # Cumulative session stats
+        self.session_usage = TokenUsage()
+        self.session_api_calls = 0
+        self.last_turn: TurnStats | None = None
 
     async def _maybe_compact(self) -> None:
         total = sum(estimate_tokens(str(m.content or "")) for m in self.messages)
@@ -42,7 +53,6 @@ class ConversationEngine:
             self.messages = compact_messages(self.messages, keep_recent=8)
 
     async def _post_tool_validate(self, tool_names: set[str]) -> str | None:
-        """Run Godot validation after file-mutating tools. Returns error report or None."""
         if not self.project_path:
             return None
         if not tool_names & _FILE_MUTATING_TOOLS:
@@ -58,12 +68,23 @@ class ConversationEngine:
         return None
 
     async def _run_loop(self, tools: list[dict] | None) -> str:
+        turn = TurnStats()
+
         for _ in range(self.max_tool_rounds + 1):
             await self._maybe_compact()
-            response = await self.client.chat(self.messages, tools)
+            chat_resp: ChatResponse = await self.client.chat(self.messages, tools)
+            response = chat_resp.message
+
+            # Track usage
+            turn.usage = turn.usage + chat_resp.usage
+            turn.api_calls += 1
+            self.session_usage = self.session_usage + chat_resp.usage
+            self.session_api_calls += 1
+
             self.messages.append(response)
 
             if not response.tool_calls:
+                self.last_turn = turn
                 return response.content or ""
 
             tool_names_used: set[str] = set()
@@ -73,6 +94,7 @@ class ConversationEngine:
                 except json.JSONDecodeError:
                     args = {}
                 tool_names_used.add(tc.name)
+                turn.tools_called.append(tc.name)
                 result = await self.registry.execute(tc.name, args)
                 if result.error:
                     content = json.dumps({"error": result.error})
@@ -80,7 +102,6 @@ class ConversationEngine:
                     content = json.dumps(result.output.model_dump() if result.output else {})
                 self.messages.append(Message.tool_result(tool_call_id=tc.id, content=content))
 
-            # Auto-validate after file mutations
             validation_report = await self._post_tool_validate(tool_names_used)
             if validation_report:
                 self.messages.append(Message.user(
@@ -88,6 +109,7 @@ class ConversationEngine:
                     f"Fix the errors before proceeding."
                 ))
 
+        self.last_turn = turn
         return "Tool call limit reached. Please simplify the request."
 
     async def submit(self, user_input: str) -> str:

{god_code-0.2.2 → god_code-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "god-code"
-version = "0.2.2"
+version = "0.3.0"
 description = "AI coding agent specialized for Godot game development"
 requires-python = ">=3.9"
 license = {text = "GPL-3.0-or-later"}

{god_code-0.2.2 → god_code-0.3.0}/tests/runtime/test_engine.py

@@ -2,26 +2,28 @@ import pytest
 import json
 from unittest.mock import AsyncMock
 from godot_agent.runtime.engine import ConversationEngine
-from godot_agent.llm.client import Message, ToolCall, LLMClient
+from godot_agent.llm.client import Message, ToolCall, LLMClient, ChatResponse, TokenUsage
 from godot_agent.tools.registry import ToolRegistry
 from godot_agent.tools.base import BaseTool, ToolResult
 from pydantic import BaseModel
 
 
+def _resp(msg: Message) -> ChatResponse:
+    """Wrap a Message in a ChatResponse with dummy usage."""
+    return ChatResponse(message=msg, usage=TokenUsage(prompt_tokens=10, completion_tokens=5, total_tokens=15))
+
+
 class EchoInput(BaseModel):
     text: str
 
-
 class EchoOutput(BaseModel):
     reply: str
 
-
 class EchoTool(BaseTool):
     name = "echo"
     description = "Echo back"
     Input = EchoInput
     Output = EchoOutput
-
     async def execute(self, input):
         return ToolResult(output=EchoOutput(reply=f"echo: {input.text}"))
 
@@ -30,76 +32,48 @@ class TestConversationEngine:
     @pytest.mark.asyncio
     async def test_simple_text_response(self):
         mock_client = AsyncMock(spec=LLMClient)
-        mock_client.chat = AsyncMock(return_value=Message.assistant(content="Hello!"))
+        mock_client.chat = AsyncMock(return_value=_resp(Message.assistant(content="Hello!")))
         registry = ToolRegistry()
-        engine = ConversationEngine(
-            client=mock_client, registry=registry, system_prompt="You are helpful."
-        )
+        engine = ConversationEngine(client=mock_client, registry=registry, system_prompt="You are helpful.")
         response = await engine.submit("Hi")
         assert response == "Hello!"
-        assert len(engine.messages) == 3  # system + user + assistant
+        assert len(engine.messages) == 3
 
     @pytest.mark.asyncio
     async def test_tool_call_and_response(self):
         registry = ToolRegistry()
         registry.register(EchoTool())
-        call_msg = Message.assistant(
-            tool_calls=[
-                ToolCall(id="call_1", name="echo", arguments='{"text": "test"}')
-            ]
-        )
-        final_msg = Message.assistant(content="The echo said: echo: test")
+        call_msg = _resp(Message.assistant(tool_calls=[ToolCall(id="call_1", name="echo", arguments='{"text": "test"}')]))
+        final_msg = _resp(Message.assistant(content="The echo said: echo: test"))
         mock_client = AsyncMock(spec=LLMClient)
         mock_client.chat = AsyncMock(side_effect=[call_msg, final_msg])
-        engine = ConversationEngine(
-            client=mock_client, registry=registry, system_prompt="test"
-        )
+        engine = ConversationEngine(client=mock_client, registry=registry, system_prompt="test")
         response = await engine.submit("Echo something")
         assert "echo: test" in response
-        # system + user + assistant(tool) + tool_result + assistant(final)
         assert len(engine.messages) == 5
 
     @pytest.mark.asyncio
     async def test_max_turns_limit(self):
         registry = ToolRegistry()
         registry.register(EchoTool())
-        call_msg = Message.assistant(
-            tool_calls=[
-                ToolCall(id="call_1", name="echo", arguments='{"text": "loop"}')
-            ]
-        )
+        call_msg = _resp(Message.assistant(tool_calls=[ToolCall(id="call_1", name="echo", arguments='{"text": "loop"}')]))
         mock_client = AsyncMock(spec=LLMClient)
         mock_client.chat = AsyncMock(return_value=call_msg)
-        engine = ConversationEngine(
-            client=mock_client,
-            registry=registry,
-            system_prompt="test",
-            max_tool_rounds=3,
-        )
+        engine = ConversationEngine(client=mock_client, registry=registry, system_prompt="test", max_tool_rounds=3)
         response = await engine.submit("Loop forever")
-        # Should stop after max_tool_rounds + 1 iterations
         assert mock_client.chat.call_count == 4
 
     @pytest.mark.asyncio
     async def test_tool_error_forwarded(self):
-        """Tool execution errors are serialised as JSON error messages."""
         registry = ToolRegistry()
         registry.register(EchoTool())
-        # Malformed arguments will cause Input validation to fail
-        call_msg = Message.assistant(
-            tool_calls=[
-                ToolCall(id="call_err", name="echo", arguments='{"bad_key": 1}')
-            ]
-        )
-        final_msg = Message.assistant(content="Got an error from the tool.")
+        call_msg = _resp(Message.assistant(tool_calls=[ToolCall(id="call_err", name="echo", arguments='{"bad_key": 1}')]))
+        final_msg = _resp(Message.assistant(content="Got an error from the tool."))
         mock_client = AsyncMock(spec=LLMClient)
         mock_client.chat = AsyncMock(side_effect=[call_msg, final_msg])
-        engine = ConversationEngine(
-            client=mock_client, registry=registry, system_prompt="test"
-        )
+        engine = ConversationEngine(client=mock_client, registry=registry, system_prompt="test")
         response = await engine.submit("Break the tool")
         assert response == "Got an error from the tool."
-        # Verify the tool_result message contains an error key
         tool_result_msg = engine.messages[3]
         assert tool_result_msg.role == "tool"
         parsed = json.loads(tool_result_msg.content)
@@ -108,31 +82,35 @@ class TestConversationEngine:
     @pytest.mark.asyncio
     async def test_submit_with_images(self):
         mock_client = AsyncMock(spec=LLMClient)
-        mock_client.chat = AsyncMock(
-            return_value=Message.assistant(content="I see an image.")
-        )
+        mock_client.chat = AsyncMock(return_value=_resp(Message.assistant(content="I see an image.")))
         registry = ToolRegistry()
-        engine = ConversationEngine(
-            client=mock_client, registry=registry, system_prompt="Vision agent."
-        )
+        engine = ConversationEngine(client=mock_client, registry=registry, system_prompt="Vision agent.")
         response = await engine.submit_with_images("What is this?", ["base64data"])
         assert response == "I see an image."
         assert len(engine.messages) == 3
-        # The user message should contain image content blocks
-        user_msg = engine.messages[1]
-        assert isinstance(user_msg.content, list)
+        assert isinstance(engine.messages[1].content, list)
 
     @pytest.mark.asyncio
     async def test_empty_registry_passes_no_tools(self):
         mock_client = AsyncMock(spec=LLMClient)
-        mock_client.chat = AsyncMock(
-            return_value=Message.assistant(content="No tools here.")
-        )
+        mock_client.chat = AsyncMock(return_value=_resp(Message.assistant(content="No tools.")))
         registry = ToolRegistry()
-        engine = ConversationEngine(
-            client=mock_client, registry=registry, system_prompt="test"
-        )
+        engine = ConversationEngine(client=mock_client, registry=registry, system_prompt="test")
         await engine.submit("Hello")
-        # When registry is empty, tools param should be None
         call_args = mock_client.chat.call_args
         assert call_args[0][1] is None or call_args[1].get("tools") is None
+
+    @pytest.mark.asyncio
+    async def test_usage_tracking(self):
+        mock_client = AsyncMock(spec=LLMClient)
+        mock_client.chat = AsyncMock(return_value=ChatResponse(
+            message=Message.assistant(content="Done"),
+            usage=TokenUsage(prompt_tokens=100, completion_tokens=50, total_tokens=150),
+        ))
+        registry = ToolRegistry()
+        engine = ConversationEngine(client=mock_client, registry=registry, system_prompt="test")
+        await engine.submit("Test")
+        assert engine.session_usage.total_tokens == 150
+        assert engine.last_turn is not None
+        assert engine.last_turn.usage.total_tokens == 150
+        assert engine.session_api_calls == 1

{god_code-0.2.2 → god_code-0.3.0}/tests/test_e2e.py

@@ -12,7 +12,11 @@ from unittest.mock import AsyncMock
 
 import pytest
 
-from godot_agent.llm.client import LLMClient, Message, ToolCall
+from godot_agent.llm.client import LLMClient, Message, ToolCall, ChatResponse, TokenUsage
+
+
+def _resp(msg: Message) -> ChatResponse:
+    return ChatResponse(message=msg, usage=TokenUsage())
 from godot_agent.prompts.system import build_system_prompt
 from godot_agent.runtime.engine import ConversationEngine
 from godot_agent.tools.file_ops import EditFileTool, ReadFileTool, WriteFileTool
@@ -84,7 +88,7 @@ class TestE2EReadAndEdit:
         final = Message.assistant(content="Done! Changed speed from 100 to 200.")
 
         mock_client = AsyncMock(spec=LLMClient)
-        mock_client.chat = AsyncMock(side_effect=[read_call, edit_call, final])
+        mock_client.chat = AsyncMock(side_effect=[_resp(read_call), _resp(edit_call), _resp(final)])
 
         engine = _make_engine(godot_project, mock_client)
         result = await engine.submit("Change player speed to 200")
@@ -118,7 +122,7 @@ class TestE2ESearch:
         )
 
         mock_client = AsyncMock(spec=LLMClient)
-        mock_client.chat = AsyncMock(side_effect=[search_call, final])
+        mock_client.chat = AsyncMock(side_effect=[_resp(search_call), _resp(final)])
 
         engine = _make_engine(godot_project, mock_client)
         result = await engine.submit("Find where speed is defined")
@@ -148,7 +152,7 @@ class TestE2EWriteNewFile:
         final = Message.assistant(content="Created enemy.gd with 50 HP.")
 
         mock_client = AsyncMock(spec=LLMClient)
-        mock_client.chat = AsyncMock(side_effect=[write_call, final])
+        mock_client.chat = AsyncMock(side_effect=[_resp(write_call), _resp(final)])
 
         engine = _make_engine(godot_project, mock_client)
         result = await engine.submit("Create an enemy script")
@@ -189,7 +193,7 @@ class TestE2EMultiToolChain:
         )
 
         mock_client = AsyncMock(spec=LLMClient)
-        mock_client.chat = AsyncMock(side_effect=[glob_call, read_call, final])
+        mock_client.chat = AsyncMock(side_effect=[_resp(glob_call), _resp(read_call), _resp(final)])
 
         engine = _make_engine(godot_project, mock_client)
         result = await engine.submit("List all scripts and show me the player")