X-Git-Url: http://git.giacomolli.uk/onechat/blobdiff_plain/5da3ea038d1e9f9a2634d5ab137aef6989a3a789..e0ab6220b6fd35f7e92a04e4bf149940185713ab:/turn_test.go

diff --git a/turn_test.go b/turn_test.go
index 1b17940..b8c92dc 100644
--- a/turn_test.go
+++ b/turn_test.go
@@ -2,8 +2,10 @@ package main
 
 import (
 	"context"
+	"encoding/json"
 	"errors"
 	"net/http"
+	"path/filepath"
 	"strings"
 	"sync"
 	"testing"
@@ -70,10 +72,10 @@ func TestFirstRequestHoldsTheViewTheStateAndTheMessage(t *testing.T) {
 	test.events.WaitFor(t, "idle", 1)
 
 	require.Equal(t, []string{
-		"<chat>\n0+1|user: an earlier message\n</chat>\n",
-		"Now: Thursday 2026-01-01 12:00 +00:00\n",
+		"<chat>\n0+1|user: an earlier message\n",
+		"</chat>\n\nNow: Thursday 2026-01-01 12:00 +00:00",
 		"The new message.",
-	}, inputParts(t, server.Call(0)))
+	}, inputTexts(t, server.Call(0)))
 }
 
 func TestMessageDuringATurnJoinsTheNextRequest(t *testing.T) {
@@ -138,16 +140,16 @@ func TestMessageDuringTheFinalRequestStartsANewTurn(t *testing.T) {
 	test.events.WaitFor(t, "idle", 2)
 	require.Equal(t, 2, server.Calls())
 
-	parts := inputParts(t, server.Call(1))
-	require.Equal(t, "second", parts[len(parts)-1])
-	require.Contains(t, parts[0], "|reply: answer\n")
+	texts := inputTexts(t, server.Call(1))
+	require.Equal(t, "second", texts[len(texts)-1])
+	require.Contains(t, strings.Join(texts, ""), "|reply: answer\n")
 }
 
 func TestTurnWaitsForTheSummaries(t *testing.T) {
 	server := newFakeResponses(t)
 	summarizer := newFakeSummarizer()
 	summarizer.gate = make(chan struct{})
-	test := newTestLoopWith(t, server, summarizer)
+	test := newTestLoopWith(t, server, summarizer, false)
 
 	_, err := test.memory.Append("echo", strings.Repeat("long output ", 100))
 	require.NoError(t, err)
@@ -161,7 +163,7 @@ func TestTurnWaitsForTheSummaries(t *testing.T) {
 	close(summarizer.gate)
 	test.events.WaitFor(t, "idle", 1)
 	require.Equal(t, 1, server.Calls())
-	require.NotContains(t, inputParts(t, server.Call(0))[0], pending)
+	require.NotContains(t, inputTexts(t, server.Call(0))[0], pending)
 }
 
 func TestInterruptEndsTheTurn(t *testing.T) {
@@ -212,12 +214,82 @@ func TestFailedCallEndsTheTurnWithoutARetry(t *testing.T) {
 	require.Contains(t, test.events.Last("error"), "HTTP 503")
 }
 
+func TestViewMessagesOnlyGrowBetweenTurns(t *testing.T) {
+	server := newFakeResponses(t)
+	test := newTestLoop(t, server)
+	for n, text := range []string{"one", "two", "three"} {
+		_, err := test.loop.Submit(text)
+		require.NoError(t, err)
+		test.events.WaitFor(t, "idle", n+1)
+	}
+
+	first := server.Call(1).body["input"].([]any)
+	second := server.Call(2).body["input"].([]any)
+	require.Len(t, first, 4)
+	require.Len(t, second, 5)
+	require.Equal(t, first[:2], second[:2])
+	require.Equal(t, []string{
+		"<chat>\n",
+		"0+1|user: one\n1+1|reply: a line\n",
+		"2+1|user: two\n3+1|reply: a line\n",
+		"</chat>\n\nNow: Thursday 2026-01-01 12:00 +00:00",
+		"three",
+	}, inputTexts(t, server.Call(2)))
+}
+
+func TestWarmUpEndsWhereTheNextTurnReadsTheCache(t *testing.T) {
+	server := newFakeResponses(t)
+	server.reply = func(w http.ResponseWriter, call fakeCall) {
+		if call.number == 1 {
+			writeEvents(w, map[string]any{"type": "response.output_item.added", "item": reasoningItem("rs_1", "")})
+			return
+		}
+
+		writeEvents(w, completedEvent([]any{messageItem("answer")}, 100, 0, 5))
+	}
+
+	test := newTestLoopWith(t, server, newFakeSummarizer(), true)
+	_, err := test.loop.Submit("one")
+	require.NoError(t, err)
+	require.Eventually(t, func() bool {
+		return server.Calls() == 2
+	}, 10*time.Second, time.Millisecond)
+
+	_, err = test.loop.Submit("two")
+	require.NoError(t, err)
+	test.events.WaitFor(t, "idle", 2)
+	require.Eventually(t, func() bool {
+		return server.Calls() == 4
+	}, 10*time.Second, time.Millisecond)
+
+	warmUp := server.Call(1).body
+	require.Equal(t, server.Call(0).body["instructions"], warmUp["instructions"])
+	require.Equal(t, server.Call(0).body["tools"], warmUp["tools"])
+	require.Equal(t, []string{"<chat>\n", "0+1|user: one\n1+1|reply: answer\n"}, inputTexts(t, server.Call(1)))
+
+	// The next turn begins with the whole warm-up, so its message end after
+	// the view is the end of the warm-up entry.
+	warmInput := warmUp["input"].([]any)
+	turnInput := server.Call(2).body["input"].([]any)
+	require.Equal(t, warmInput, turnInput[:len(warmInput)])
+	require.Equal(t, "</chat>\n\nNow: Thursday 2026-01-01 12:00 +00:00", inputTexts(t, server.Call(2))[len(warmInput)])
+
+	turns := []string{}
+	for _, record := range readUsage(t, test.usagePath) {
+		turns = append(turns, record.Turn)
+	}
+
+	require.Equal(t, []string{"first", "warmup", "first", "warmup"}, turns)
+	require.Equal(t, []string{"user: one", "reply: answer", "user: two", "reply: answer"}, test.Log(t))
+}
+
 // testLoop is a loop that runs in the background of a test, with its parts.
 type testLoop struct {
-	agent  *Agent
-	memory *Memory
-	loop   *loop
-	events *eventRecorder
+	agent     *Agent
+	memory    *Memory
+	loop      *loop
+	events    *eventRecorder
+	usagePath string
 }
 
 // Log returns the logged messages as "kind: text".
@@ -297,12 +369,13 @@ func (r *eventRecorder) WaitFor(t *testing.T, kind string, count int) {
 func newTestLoop(t *testing.T, server *fakeResponses) *testLoop {
 	t.Helper()
 
-	return newTestLoopWith(t, server, newFakeSummarizer())
+	return newTestLoopWith(t, server, newFakeSummarizer(), false)
 }
 
 // newTestLoopWith returns a running loop on a new agent whose builds use
-// summarizer and whose commands run in a temporary directory.
-func newTestLoopWith(t *testing.T, server *fakeResponses, summarizer Summarizer) *testLoop {
+// summarizer and whose commands run in a temporary directory. warmUp turns the
+// warm-up on.
+func newTestLoopWith(t *testing.T, server *fakeResponses, summarizer Summarizer, warmUp bool) *testLoop {
 	t.Helper()
 
 	agent, err := openAgent(t.TempDir())
@@ -314,12 +387,17 @@ func newTestLoopWith(t *testing.T, server *fakeResponses, summarizer Summarizer)
 	require.NoError(t, err)
 
 	test := &testLoop{
-		agent:  agent,
-		memory: memory,
-		events: &eventRecorder{},
+		agent:     agent,
+		memory:    memory,
+		events:    &eventRecorder{},
+		usagePath: filepath.Join(t.TempDir(), "usage.jsonl"),
 	}
 
-	test.loop = newLoop(agent, memory, newTestClient(t, server), clock.Now, test.events.Add)
+	client := newClient(server.URL, apiKey(testKey), agent.CacheKey(), test.usagePath)
+	test.loop, err = newLoop(agent, memory, client, clock.Now, test.events.Add)
+	require.NoError(t, err)
+
+	test.loop.warmUp = warmUp
 	ctx, cancel := context.WithCancel(t.Context())
 	done := make(chan error)
 	go func() {
@@ -335,6 +413,38 @@ func newTestLoopWith(t *testing.T, server *fakeResponses, summarizer Summarizer)
 	return test
 }
 
+// inputTexts returns the text of each user message of the input of call.
+func inputTexts(t *testing.T, call fakeCall) []string {
+	t.Helper()
+
+	var body struct {
+		Input []struct {
+			Role    string `json:"role"`
+			Content []struct {
+				Text string `json:"text"`
+			} `json:"content"`
+		} `json:"input"`
+	}
+
+	require.NoError(t, json.Unmarshal(call.raw, &body))
+
+	var texts []string
+	for _, item := range body.Input {
+		if item.Role != "user" {
+			continue
+		}
+
+		var text strings.Builder
+		for _, part := range item.Content {
+			text.WriteString(part.Text)
+		}
+
+		texts = append(texts, text.String())
+	}
+
+	return texts
+}
+
 func reasoningItem(id, encrypted string) map[string]any {
 	return map[string]any{
 		"type":              "reasoning",