Lay out turn requests for the prompt cache

[onechat] / turn_test.go

diff --git a/turn_test.go b/turn_test.go
index 1b179406b72bb087fcfce2db11f39ccac1970006..b8c92dc260f22e95b04ffc0c82c68781cbb941bc 100644 (file)
--- a/turn_test.go
+++ b/turn_test.go
@@ -2,8 +2,10 @@ package main
 
 import (
        "context"
 
 import (
        "context"

+       "encoding/json"

        "errors"
        "net/http"
        "errors"
        "net/http"

+       "path/filepath"

        "strings"
        "sync"
        "testing"
        "strings"
        "sync"
        "testing"


@@ -70,10 +72,10 @@ func TestFirstRequestHoldsTheViewTheStateAndTheMessage(t *testing.T) {
        test.events.WaitFor(t, "idle", 1)
 
        require.Equal(t, []string{
        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.",
                "The new message.",

-       }, inputParts(t, server.Call(0)))
+       }, inputTexts(t, server.Call(0)))

 }
 
 func TestMessageDuringATurnJoinsTheNextRequest(t *testing.T) {
 }
 
 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())
 
        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{})
 }
 
 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)
 
        _, 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())
        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) {
 }
 
 func TestInterruptEndsTheTurn(t *testing.T) {


@@ -212,12 +214,82 @@ func TestFailedCallEndsTheTurnWithoutARetry(t *testing.T) {
        require.Contains(t, test.events.Last("error"), "HTTP 503")
 }
 
        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 {
 // 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".
 }
 
 // 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()
 
 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
 }
 
 // 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())
        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{
        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() {
        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
 }
 
        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",
 func reasoningItem(id, encrypted string) map[string]any {
        return map[string]any{
                "type":              "reasoning",