v0.5.2 — Turn statistics (latency + token counts)

Each iteration header now shows real API-reported token usage and
wall-clock latency inline: [1,247 in · 342 out · 4.1s]

- parseResponse: extract usage.prompt_tokens + .completion_tokens
- CallResult: new InputTokens, OutputTokens fields
- Iteration: accepts latency + token stats, renders compact suffix
- Stats suppressed when API doesn't report usage (zero values -> hidden)
- No breaking changes to Run() or public API

Author: jkyberneees

internal/llm/client.go

@@ -87,8 +87,10 @@ type ThinkingConfig struct {
 
 // CallResult is the parsed response from /chat/completions.
 type CallResult struct {
-	Content   string     // assistant text
-	ToolCalls []ToolCall // tool calls requested by the model
+	Content      string     // assistant text
+	ToolCalls    []ToolCall // tool calls requested by the model
+	InputTokens  int        // prompt_tokens from API usage (0 = not reported)
+	OutputTokens int        // completion_tokens from API usage (0 = not reported)
 }
 
 // toolChoiceNone forces the model to not call tools.
@@ -155,6 +157,10 @@ func parseResponse(data []byte) (*CallResult, error) {
 				} `json:"tool_calls"`
 			} `json:"message"`
 		} `json:"choices"`
+		Usage *struct {
+			PromptTokens     int `json:"prompt_tokens"`
+			CompletionTokens int `json:"completion_tokens"`
+		} `json:"usage"`
 	}
 	if err := json.Unmarshal(data, &raw); err != nil {
 		return nil, fmt.Errorf("llm: parse response: %w (body: %s)", err, string(data))
@@ -167,6 +173,10 @@ func parseResponse(data []byte) (*CallResult, error) {
 	result := &CallResult{
 		Content: msg.Content,
 	}
+	if raw.Usage != nil {
+		result.InputTokens = raw.Usage.PromptTokens
+		result.OutputTokens = raw.Usage.CompletionTokens
+	}
 	for _, tc := range msg.ToolCalls {
 		result.ToolCalls = append(result.ToolCalls, ToolCall{
 			ID:   tc.ID,

internal/llm/client_test.go

@@ -521,3 +521,90 @@ func TestClient_Call_InvalidJSONResponse(t *testing.T) {
 		t.Fatal("expected error for invalid JSON response")
 	}
 }
+
+func TestParseResponse_WithUsage(t *testing.T) {
+	raw := `{
+		"choices": [{"message": {"content": "Hello"}}],
+		"usage": {"prompt_tokens": 452, "completion_tokens": 128, "total_tokens": 580}
+	}`
+
+	result, err := parseResponse([]byte(raw))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if result.InputTokens != 452 {
+		t.Errorf("InputTokens = %d, want 452", result.InputTokens)
+	}
+	if result.OutputTokens != 128 {
+		t.Errorf("OutputTokens = %d, want 128", result.OutputTokens)
+	}
+	if result.Content != "Hello" {
+		t.Errorf("Content = %q, want %q", result.Content, "Hello")
+	}
+}
+
+func TestParseResponse_WithoutUsage(t *testing.T) {
+	raw := `{
+		"choices": [{"message": {"content": "No usage"}}]
+	}`
+
+	result, err := parseResponse([]byte(raw))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if result.InputTokens != 0 {
+		t.Errorf("InputTokens = %d, want 0", result.InputTokens)
+	}
+	if result.OutputTokens != 0 {
+		t.Errorf("OutputTokens = %d, want 0", result.OutputTokens)
+	}
+}
+
+func TestParseResponse_UsageWithToolCalls(t *testing.T) {
+	raw := `{
+		"choices": [{
+			"message": {
+				"content": "Let me check.",
+				"tool_calls": [{
+					"id": "call_1",
+					"function": {"name": "shell", "arguments": "{\"cmd\":\"ls\"}"}
+				}]
+			}
+		}],
+		"usage": {"prompt_tokens": 1000, "completion_tokens": 50, "total_tokens": 1050}
+	}`
+
+	result, err := parseResponse([]byte(raw))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if result.InputTokens != 1000 {
+		t.Errorf("InputTokens = %d, want 1000", result.InputTokens)
+	}
+	if result.OutputTokens != 50 {
+		t.Errorf("OutputTokens = %d, want 50", result.OutputTokens)
+	}
+	if len(result.ToolCalls) != 1 {
+		t.Errorf("expected 1 tool call, got %d", len(result.ToolCalls))
+	}
+}
+
+func TestClient_Call_ReturnsUsage(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		w.Write([]byte(`{"choices":[{"message":{"content":"ok"}}],"usage":{"prompt_tokens":50,"completion_tokens":10,"total_tokens":60}}`))
+	}))
+	defer server.Close()
+
+	c := New(server.URL, "sk-test", "test-model", "", 0)
+	result, err := c.Call(context.Background(), []Message{{Role: "user", Content: "hi"}}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if result.InputTokens != 50 {
+		t.Errorf("InputTokens = %d, want 50", result.InputTokens)
+	}
+	if result.OutputTokens != 10 {
+		t.Errorf("OutputTokens = %d, want 10", result.OutputTokens)
+	}
+}

internal/loop/loop.go

@@ -5,6 +5,7 @@ import (
 	"context"
 	"fmt"
 	"strings"
+	"time"
 
 	"github.com/BackendStack21/kode/internal/llm"
 	"github.com/BackendStack21/kode/internal/render"
@@ -165,18 +166,25 @@ func (e *Engine) Run(ctx context.Context, task string) (string, error) {
 
 		// Render iteration header (1-indexed for humans)
 		if e.renderer != nil {
-			e.renderer.Iteration(i+1, e.maxIter)
+			e.renderer.Iteration(i+1, e.maxIter, 0, 0, 0)
 		}
 
 		// Trim context to stay within model's context window
 		messages = e.trimContext(messages, tools)
 
-		// THINK
+		// THINK (timed)
+		start := time.Now()
 		result, err := e.client.Call(ctx, messages, tools)
+		latency := time.Since(start)
 		if err != nil {
 			return "", fmt.Errorf("iteration %d: %w", i, err)
 		}
 
+		// Render turn statistics (re-draw iteration header with stats)
+		if e.renderer != nil {
+			e.renderer.Iteration(i+1, e.maxIter, latency, result.InputTokens, result.OutputTokens)
+		}
+
 		// No tool calls = final answer
 		if len(result.ToolCalls) == 0 {
 			if e.renderer != nil {

internal/render/render.go

@@ -21,6 +21,7 @@ import (
 	"io"
 	"os"
 	"strings"
+	"time"
 )
 
 // ── Events ────────────────────────────────────────────────────────────
@@ -129,8 +130,10 @@ func (r *Renderer) Start(task string) {
 	fmt.Fprintln(r.w)
 }
 
-// Iteration prints the cycle header.
-func (r *Renderer) Iteration(n, maxN int) {
+// Iteration prints the cycle header with optional turn statistics.
+// When latency > 0 or tokens are reported, a compact stats suffix
+// appears on the same line: [1,247 in · 342 out · 4.1s]
+func (r *Renderer) Iteration(n, maxN int, latency time.Duration, inTokens, outTokens int) {
 	if r.disable() {
 		return
 	}
@@ -140,9 +143,14 @@ func (r *Renderer) Iteration(n, maxN int) {
 	} else {
 		prefix = fmt.Sprintf("Iter %d/%d", n, maxN)
 	}
+	// Build stats suffix only when data is available
+	stats := ""
+	if inTokens > 0 || outTokens > 0 || latency > 0 {
+		stats = fmt.Sprintf("  [%d in · %d out · %.1fs]", inTokens, outTokens, latency.Seconds())
+	}
 	// Double-line rule framing
 	rule := strings.Repeat("═", 3)
-	line := fmt.Sprintf("%s %s %s", rule, prefix, rule)
+	line := fmt.Sprintf("%s %s %s%s", rule, prefix, rule, stats)
 	fmt.Fprintln(r.w)
 	fmt.Fprintln(r.w, r.style(blue, line))
 }

internal/render/render_test.go

@@ -5,6 +5,7 @@ import (
 	"errors"
 	"strings"
 	"testing"
+	"time"
 )
 
 func TestRenderer_Start(t *testing.T) {
@@ -43,7 +44,7 @@ func TestRenderer_Iteration(t *testing.T) {
 	var buf bytes.Buffer
 	r := New(&buf, true).WithModel("deepseek-chat")
 
-	r.Iteration(3, 90)
+	r.Iteration(3, 90, 0, 0, 0)
 
 	out := buf.String()
 	if !strings.Contains(out, "Iter 3/90") {
@@ -58,7 +59,7 @@ func TestRenderer_Iteration_NoModel(t *testing.T) {
 	var buf bytes.Buffer
 	r := New(&buf, true)
 
-	r.Iteration(1, 10)
+	r.Iteration(1, 10, 0, 0, 0)
 
 	out := buf.String()
 	if !strings.Contains(out, "Iter 1/10") {
@@ -260,7 +261,7 @@ func TestRenderer_NoColor(t *testing.T) {
 	var buf bytes.Buffer
 	r := New(&buf, false)
 
-	r.Iteration(1, 5)
+	r.Iteration(1, 5, 0, 0, 0)
 
 	out := buf.String()
 	if strings.Contains(out, "\033[") {
@@ -276,7 +277,7 @@ func TestRenderer_NilWriter(t *testing.T) {
 
 	// None of these should panic
 	r.Start("task")
-	r.Iteration(1, 5)
+	r.Iteration(1, 5, 0, 0, 0)
 	r.Thinking("hello")
 	r.ToolCall("shell", "{}")
 	r.ToolResult("output")
@@ -289,7 +290,7 @@ func TestRenderer_NilRenderer(t *testing.T) {
 
 	// None of these should panic on nil receiver
 	r.Start("task")
-	r.Iteration(1, 5)
+	r.Iteration(1, 5, 0, 0, 0)
 	r.Thinking("hello")
 	r.ToolCall("shell", "{}")
 	r.ToolResult("output")
@@ -303,11 +304,11 @@ func TestRenderer_FullCycle(t *testing.T) {
 
 	// Simulate one full session
 	r.Start("what files are here?")
-	r.Iteration(1, 90)
+	r.Iteration(1, 90, 0, 0, 0)
 	r.Thinking("I need to read the file to understand its contents.")
 	r.ToolCall("shell", `{"command": "cat main.go"}`)
 	r.ToolResult("package main\n\nimport \"fmt\"\n\nfunc main() {\n\tfmt.Println(\"hello\")\n}")
-	r.Iteration(2, 90)
+	r.Iteration(2, 90, 0, 0, 0)
 	r.FinalAnswer("The file contains a simple Go program that prints 'hello'.")
 
 	out := buf.String()
@@ -354,3 +355,61 @@ func TestEvent_String(t *testing.T) {
 		}
 	}
 }
+
+func TestRenderer_Iteration_WithStats(t *testing.T) {
+	var buf bytes.Buffer
+	r := New(&buf, true).WithModel("deepseek-v4-pro")
+
+	r.Iteration(3, 90, 5*time.Second, 1247, 342)
+
+	out := buf.String()
+	if !strings.Contains(out, "Iter 3/90") {
+		t.Errorf("missing iteration info: %q", out)
+	}
+	if !strings.Contains(out, "deepseek-v4-pro") {
+		t.Errorf("missing model name: %q", out)
+	}
+	if !strings.Contains(out, "1247 in") {
+		t.Errorf("missing input tokens: %q", out)
+	}
+	if !strings.Contains(out, "342 out") {
+		t.Errorf("missing output tokens: %q", out)
+	}
+	if !strings.Contains(out, "5.0s") {
+		t.Errorf("missing latency: %q", out)
+	}
+}
+
+func TestRenderer_Iteration_StatsSuppressedWhenZero(t *testing.T) {
+	var buf bytes.Buffer
+	r := New(&buf, true).WithModel("test")
+
+	r.Iteration(1, 10, 0, 0, 0)
+
+	out := buf.String()
+	// Check that the stats pattern (with "in ·") doesn't appear.
+	// Don't check for "[" which is part of ANSI escape codes.
+	if strings.Contains(out, "0 in") {
+		t.Errorf("stats should not appear when all values are zero: %q", out)
+	}
+}
+
+func TestRenderer_Iteration_WithoutModel(t *testing.T) {
+	var buf bytes.Buffer
+	r := New(&buf, true)
+
+	r.Iteration(1, 10, time.Second, 100, 50)
+
+	out := buf.String()
+	if !strings.Contains(out, "Iter 1/10") {
+		t.Errorf("missing iteration info: %q", out)
+	}
+	if !strings.Contains(out, "100 in") {
+		t.Errorf("missing input tokens: %q", out)
+	}
+}
+
+func TestRenderer_Iteration_NilSafe(t *testing.T) {
+	var r *Renderer
+	r.Iteration(1, 10, time.Second, 100, 50) // should not panic
+}