git.giacomolli.uk - onechat/blob - turn_test.go

   1 package main
   2
   3 import (
   4         "context"
   5         "encoding/json"
   6         "errors"
   7         "net/http"
   8         "path/filepath"
   9         "strings"
  10         "sync"
  11         "testing"
  12         "time"
  13
  14         "github.com/stretchr/testify/require"
  15 )
  16
  17 func TestTurnRunsToolsUntilTheFinalAnswer(t *testing.T) {
  18         server := newFakeResponses(t)
  19         server.reply = func(w http.ResponseWriter, call fakeCall) {
  20                 if call.number == 0 {
  21                         writeEvents(w, completedEvent([]any{
  22                                 reasoningItem("rs_1", "opaque thought"),
  23                                 functionCallItem("fc_1", "call_1", "shell", `{"command":"echo hi"}`),
  24                         }, 100, 0, 5))
  25
  26                         return
  27                 }
  28
  29                 writeEvents(w, completedEvent([]any{messageItem("It said hi.")}, 120, 100, 5))
  30         }
  31
  32         test := newTestLoop(t, server)
  33         _, err := test.loop.Submit(terminalSource, "Run echo hi.")
  34         require.NoError(t, err)
  35         test.events.WaitFor(t, "idle", 1)
  36         require.Equal(t, 2, server.Calls())
  37
  38         first := server.Call(0).body
  39         second := server.Call(1).body
  40         instructions, err := test.agent.Prompt()
  41         require.NoError(t, err)
  42         require.Equal(t, instructions, first["instructions"])
  43         require.Equal(t, test.agent.config.Model, first["model"])
  44
  45         // The second request begins with the whole first one.
  46         firstInput := first["input"].([]any)
  47         secondInput := second["input"].([]any)
  48         require.Equal(t, firstInput, secondInput[:len(firstInput)])
  49         require.Equal(t, []any{
  50                 map[string]any{"type": "reasoning", "encrypted_content": "opaque thought", "summary": []any{}},
  51                 map[string]any{"type": "function_call", "call_id": "call_1", "name": "shell", "arguments": `{"command":"echo hi"}`},
  52                 map[string]any{"type": "function_call_output", "call_id": "call_1", "output": "hi\n"},
  53         }, secondInput[len(firstInput):])
  54
  55         require.Equal(t, []string{
  56                 "user: Run echo hi.",
  57                 `tool: shell {"command":"echo hi"}`,
  58                 "echo: hi\n",
  59                 "reply: It said hi.",
  60         }, test.Log(t))
  61         require.Equal(t, []string{"user", "busy", "tool", "echo", "reply", "idle"}, test.events.Kinds())
  62
  63         var turns []string
  64         for _, record := range readUsage(t, test.usagePath) {
  65                 turns = append(turns, record.Turn)
  66         }
  67
  68         require.Equal(t, []string{"first", "next"}, turns)
  69 }
  70
  71 func TestFirstRequestHoldsTheViewTheStateAndTheMessage(t *testing.T) {
  72         server := newFakeResponses(t)
  73         test := newTestLoop(t, server)
  74         _, err := test.memory.Append("user", "an earlier message")
  75         require.NoError(t, err)
  76
  77         _, err = test.loop.Submit(terminalSource, "The new message.")
  78         require.NoError(t, err)
  79         test.events.WaitFor(t, "idle", 1)
  80
  81         require.Equal(t, []string{
  82                 "<chat>\n0+1|user: an earlier message\n",
  83                 "</chat>\n\nNow: Thursday 2026-01-01 12:00 +00:00",
  84                 "The new message.",
  85         }, inputTexts(t, server.Call(0)))
  86 }
  87
  88 func TestMessageDuringATurnJoinsTheNextRequest(t *testing.T) {
  89         server := newFakeResponses(t)
  90         arrived := make(chan struct{})
  91         release := make(chan struct{})
  92         server.reply = func(w http.ResponseWriter, call fakeCall) {
  93                 if call.number == 0 {
  94                         close(arrived)
  95                         <-release
  96                         writeEvents(w, completedEvent([]any{functionCallItem("fc_1", "call_1", "date", `{"id":0}`)}, 100, 0, 5))
  97
  98                         return
  99                 }
 100
 101                 writeEvents(w, completedEvent([]any{messageItem("done")}, 100, 0, 5))
 102         }
 103
 104         test := newTestLoop(t, server)
 105         _, err := test.loop.Submit(terminalSource, "first")
 106         require.NoError(t, err)
 107
 108         <-arrived
 109         _, err = test.loop.Submit(terminalSource, "second, during the turn")
 110         require.NoError(t, err)
 111         close(release)
 112
 113         test.events.WaitFor(t, "idle", 1)
 114         input := server.Call(1).body["input"].([]any)
 115         require.Equal(t, map[string]any{
 116                 "role":    "user",
 117                 "content": []any{map[string]any{"type": "input_text", "text": "second, during the turn"}},
 118         }, input[len(input)-1])
 119
 120         time.Sleep(50 * time.Millisecond)
 121         require.Equal(t, 2, server.Calls())
 122         require.Equal(t, 1, test.events.Count("busy"))
 123 }
 124
 125 func TestMessageDuringTheFinalRequestStartsANewTurn(t *testing.T) {
 126         server := newFakeResponses(t)
 127         arrived := make(chan struct{})
 128         release := make(chan struct{})
 129         server.reply = func(w http.ResponseWriter, call fakeCall) {
 130                 if call.number == 0 {
 131                         close(arrived)
 132                         <-release
 133                 }
 134
 135                 writeEvents(w, completedEvent([]any{messageItem("answer")}, 100, 0, 5))
 136         }
 137
 138         test := newTestLoop(t, server)
 139         _, err := test.loop.Submit(terminalSource, "first")
 140         require.NoError(t, err)
 141
 142         <-arrived
 143         _, err = test.loop.Submit(terminalSource, "second")
 144         require.NoError(t, err)
 145         close(release)
 146
 147         test.events.WaitFor(t, "idle", 2)
 148         require.Equal(t, 2, server.Calls())
 149
 150         texts := inputTexts(t, server.Call(1))
 151         require.Equal(t, "second", texts[len(texts)-1])
 152         require.Contains(t, strings.Join(texts, ""), "|reply: answer\n")
 153 }
 154
 155 func TestTurnWaitsForTheSummaries(t *testing.T) {
 156         server := newFakeResponses(t)
 157         summarizer := newFakeSummarizer()
 158         summarizer.gate = make(chan struct{})
 159         test := newTestLoopWith(t, server, summarizer)
 160
 161         _, err := test.memory.Append("echo", strings.Repeat("long output ", 100))
 162         require.NoError(t, err)
 163
 164         _, err = test.loop.Submit(terminalSource, "go on")
 165         require.NoError(t, err)
 166
 167         time.Sleep(50 * time.Millisecond)
 168         require.Equal(t, 0, server.Calls())
 169
 170         close(summarizer.gate)
 171         test.events.WaitFor(t, "idle", 1)
 172         require.Equal(t, 1, server.Calls())
 173         require.NotContains(t, inputTexts(t, server.Call(0))[0], pending)
 174 }
 175
 176 func TestInterruptEndsTheTurn(t *testing.T) {
 177         server := newFakeResponses(t)
 178         arrived := make(chan struct{})
 179         release := make(chan struct{})
 180         server.reply = func(w http.ResponseWriter, call fakeCall) {
 181                 if call.number == 0 {
 182                         close(arrived)
 183                         <-release
 184                 }
 185
 186                 writeEvents(w, completedEvent([]any{messageItem("answer")}, 100, 0, 5))
 187         }
 188
 189         test := newTestLoop(t, server)
 190         _, err := test.loop.Submit(terminalSource, "a long task")
 191         require.NoError(t, err)
 192
 193         <-arrived
 194         require.True(t, test.loop.Interrupt())
 195         test.events.WaitFor(t, "idle", 1)
 196         close(release)
 197
 198         require.Equal(t, "interrupted", test.events.Last("error"))
 199         require.Equal(t, []string{"user: a long task"}, test.Log(t))
 200         require.False(t, test.loop.Interrupt())
 201
 202         _, err = test.loop.Submit(terminalSource, "again")
 203         require.NoError(t, err)
 204         test.events.WaitFor(t, "idle", 2)
 205         require.Equal(t, "reply: answer", test.Log(t)[2])
 206 }
 207
 208 func TestFailedCallEndsTheTurnWithoutARetry(t *testing.T) {
 209         server := newFakeResponses(t)
 210         server.reply = func(w http.ResponseWriter, call fakeCall) {
 211                 http.Error(w, "busy", http.StatusServiceUnavailable)
 212         }
 213
 214         test := newTestLoop(t, server)
 215         _, err := test.loop.Submit(terminalSource, "hello")
 216         require.NoError(t, err)
 217         test.events.WaitFor(t, "idle", 1)
 218
 219         time.Sleep(50 * time.Millisecond)
 220         require.Equal(t, 1, server.Calls())
 221         require.Contains(t, test.events.Last("error"), "HTTP 503")
 222 }
 223
 224 func TestViewMessagesOnlyGrowBetweenTurns(t *testing.T) {
 225         server := newFakeResponses(t)
 226         test := newTestLoop(t, server)
 227         for n, text := range []string{"one", "two", "three"} {
 228                 _, err := test.loop.Submit(terminalSource, text)
 229                 require.NoError(t, err)
 230                 test.events.WaitFor(t, "idle", n+1)
 231         }
 232
 233         first := server.Call(1).body["input"].([]any)
 234         second := server.Call(2).body["input"].([]any)
 235         require.Len(t, first, 4)
 236         require.Len(t, second, 5)
 237         require.Equal(t, first[:2], second[:2])
 238         require.Equal(t, []string{
 239                 "<chat>\n",
 240                 "0+1|user: one\n1+1|reply: a line\n",
 241                 "2+1|user: two\n3+1|reply: a line\n",
 242                 "</chat>\n\nNow: Thursday 2026-01-01 12:00 +00:00",
 243                 "three",
 244         }, inputTexts(t, server.Call(2)))
 245 }
 246
 247 // testLoop is a loop that runs in the background of a test, with its parts.
 248 type testLoop struct {
 249         agent     *Agent
 250         memory    *Memory
 251         loop      *loop
 252         events    *eventRecorder
 253         usagePath string
 254 }
 255
 256 // Log returns the logged messages as "kind: text".
 257 func (l *testLoop) Log(t *testing.T) []string {
 258         t.Helper()
 259
 260         var lines []string
 261         for id := range l.memory.Len() {
 262                 message, err := l.memory.Message(id)
 263                 require.NoError(t, err)
 264
 265                 lines = append(lines, message.Kind+": "+message.Text)
 266         }
 267
 268         return lines
 269 }
 270
 271 // eventRecorder keeps the events of a loop.
 272 type eventRecorder struct {
 273         mutex  sync.Mutex
 274         events []Event
 275 }
 276
 277 func (r *eventRecorder) Add(event Event) {
 278         r.mutex.Lock()
 279         defer r.mutex.Unlock()
 280
 281         r.events = append(r.events, event)
 282 }
 283
 284 func (r *eventRecorder) Kinds() []string {
 285         r.mutex.Lock()
 286         defer r.mutex.Unlock()
 287
 288         kinds := make([]string, len(r.events))
 289         for n, event := range r.events {
 290                 kinds[n] = event.Kind
 291         }
 292
 293         return kinds
 294 }
 295
 296 func (r *eventRecorder) Count(kind string) int {
 297         count := 0
 298         for _, each := range r.Kinds() {
 299                 if each == kind {
 300                         count++
 301                 }
 302         }
 303
 304         return count
 305 }
 306
 307 // Last returns the text of the last event of kind.
 308 func (r *eventRecorder) Last(kind string) string {
 309         r.mutex.Lock()
 310         defer r.mutex.Unlock()
 311
 312         for n := len(r.events) - 1; n >= 0; n-- {
 313                 if r.events[n].Kind == kind {
 314                         return r.events[n].Text
 315                 }
 316         }
 317
 318         return ""
 319 }
 320
 321 // WaitFor waits until count events of kind came.
 322 func (r *eventRecorder) WaitFor(t *testing.T, kind string, count int) {
 323         t.Helper()
 324
 325         require.Eventually(t, func() bool {
 326                 return r.Count(kind) >= count
 327         }, 10*time.Second, time.Millisecond)
 328 }
 329
 330 func newTestLoop(t *testing.T, server *fakeResponses) *testLoop {
 331         t.Helper()
 332
 333         return newTestLoopWith(t, server, newFakeSummarizer())
 334 }
 335
 336 // newTestLoopWith returns a running loop on a new agent whose builds use
 337 // summarizer and whose commands run in a temporary directory.
 338 func newTestLoopWith(t *testing.T, server *fakeResponses, summarizer Summarizer) *testLoop {
 339         t.Helper()
 340
 341         agent, err := openAgent(t.TempDir())
 342         require.NoError(t, err)
 343
 344         agent.config.Workdir = t.TempDir()
 345         clock := newTestClock()
 346         memory, err := openMemory(t.Context(), t.TempDir(), clock.Now, summarizer)
 347         require.NoError(t, err)
 348
 349         test := &testLoop{
 350                 agent:     agent,
 351                 memory:    memory,
 352                 events:    &eventRecorder{},
 353                 usagePath: filepath.Join(t.TempDir(), "usage.jsonl"),
 354         }
 355
 356         client := newClient(server.URL, apiKey(testKey), agent.CacheKey(), test.usagePath)
 357         test.loop, err = newLoop(agent, memory, client, clock.Now, test.events.Add)
 358         require.NoError(t, err)
 359         ctx, cancel := context.WithCancel(t.Context())
 360         done := make(chan error)
 361         go func() {
 362                 done <- test.loop.Run(ctx)
 363         }()
 364
 365         t.Cleanup(func() {
 366                 cancel()
 367                 require.True(t, errors.Is(<-done, context.Canceled))
 368                 require.NoError(t, memory.Close())
 369         })
 370
 371         return test
 372 }
 373
 374 // inputTexts returns the text of each user message of the input of call.
 375 func inputTexts(t *testing.T, call fakeCall) []string {
 376         t.Helper()
 377
 378         var body struct {
 379                 Input []struct {
 380                         Role    string `json:"role"`
 381                         Content []struct {
 382                                 Text string `json:"text"`
 383                         } `json:"content"`
 384                 } `json:"input"`
 385         }
 386
 387         require.NoError(t, json.Unmarshal(call.raw, &body))
 388
 389         var texts []string
 390         for _, item := range body.Input {
 391                 if item.Role != "user" {
 392                         continue
 393                 }
 394
 395                 var text strings.Builder
 396                 for _, part := range item.Content {
 397                         text.WriteString(part.Text)
 398                 }
 399
 400                 texts = append(texts, text.String())
 401         }
 402
 403         return texts
 404 }
 405
 406 func reasoningItem(id, encrypted string) map[string]any {
 407         return map[string]any{
 408                 "type":              "reasoning",
 409                 "id":                id,
 410                 "encrypted_content": encrypted,
 411                 "summary":           []any{},
 412         }
 413 }
 414
 415 func functionCallItem(id, callID, name, arguments string) map[string]any {
 416         return map[string]any{
 417                 "type":      "function_call",
 418                 "id":        id,
 419                 "call_id":   callID,
 420                 "name":      name,
 421                 "arguments": arguments,
 422         }
 423 }