]> git.giacomolli.uk - onechat/blobdiff - turn_test.go
projects / onechat / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Bind external events to permanent agent IDs
[onechat] / turn_test.go
diff --git a/turn_test.go b/turn_test.go
index b8c92dc260f22e95b04ffc0c82c68781cbb941bc..3c6bb06aa1d244328442c1d8b643d02c0db22976 100644 (file)
--- a/turn_test.go
+++ b/turn_test.go
@@ -3,7 +3,6 @@ package main
 import (
        "context"
        "encoding/json"
 import (
        "context"
        "encoding/json"
-       "errors"
        "net/http"
        "path/filepath"
        "strings"
        "net/http"
        "path/filepath"
        "strings"
@@ -15,22 +14,22 @@ import (
 )
 
 func TestTurnRunsToolsUntilTheFinalAnswer(t *testing.T) {
 )
 
 func TestTurnRunsToolsUntilTheFinalAnswer(t *testing.T) {
-       server := newFakeResponses(t)
-       server.reply = func(w http.ResponseWriter, call fakeCall) {
+       server := newModelFake(t)
+       server.reply = func(w http.ResponseWriter, call ModelFakeCall) {
                if call.number == 0 {
                if call.number == 0 {
-                       writeEvents(w, completedEvent([]any{
-                               reasoningItem("rs_1", "opaque thought"),
-                               functionCallItem("fc_1", "call_1", "shell", `{"command":"echo hi"}`),
+                       modelWriteEvents(w, modelCompletedEvent([]any{
+                               turnReasoningItem("rs_1", "opaque thought"),
+                               modelFunctionCallItem("fc_1", "call_1", "shell", `{"command":"echo hi"}`),
                        }, 100, 0, 5))
 
                        return
                }
 
                        }, 100, 0, 5))
 
                        return
                }
 
-               writeEvents(w, completedEvent([]any{messageItem("It said hi.")}, 120, 100, 5))
+               modelWriteEvents(w, modelCompletedEvent([]any{modelMessageItem("It said hi.")}, 120, 100, 5))
        }
 
        }
 
-       test := newTestLoop(t, server)
-       _, err := test.loop.Submit("Run echo hi.")
+       test := newTestTurnLoop(t, server)
+       _, err := test.loop.Submit(terminalSource, "Run echo hi.")
        require.NoError(t, err)
        test.events.WaitFor(t, "idle", 1)
        require.Equal(t, 2, server.Calls())
        require.NoError(t, err)
        test.events.WaitFor(t, "idle", 1)
        require.Equal(t, 2, server.Calls())
@@ -58,16 +57,25 @@ func TestTurnRunsToolsUntilTheFinalAnswer(t *testing.T) {
                "echo: hi\n",
                "reply: It said hi.",
        }, test.Log(t))
                "echo: hi\n",
                "reply: It said hi.",
        }, test.Log(t))
+
        require.Equal(t, []string{"user", "busy", "tool", "echo", "reply", "idle"}, test.events.Kinds())
        require.Equal(t, []string{"user", "busy", "tool", "echo", "reply", "idle"}, test.events.Kinds())
+
+       var turns []string
+
+       for _, record := range modelReadUsage(t, test.usagePath) {
+               turns = append(turns, record.Turn)
+       }
+
+       require.Equal(t, []string{"first", "next"}, turns)
 }
 
 func TestFirstRequestHoldsTheViewTheStateAndTheMessage(t *testing.T) {
 }
 
 func TestFirstRequestHoldsTheViewTheStateAndTheMessage(t *testing.T) {
-       server := newFakeResponses(t)
-       test := newTestLoop(t, server)
+       server := newModelFake(t)
+       test := newTestTurnLoop(t, server)
        _, err := test.memory.Append("user", "an earlier message")
        require.NoError(t, err)
 
        _, err := test.memory.Append("user", "an earlier message")
        require.NoError(t, err)
 
-       _, err = test.loop.Submit("The new message.")
+       _, err = test.loop.Submit(terminalSource, "The new message.")
        require.NoError(t, err)
        test.events.WaitFor(t, "idle", 1)
 
        require.NoError(t, err)
        test.events.WaitFor(t, "idle", 1)
 
@@ -75,35 +83,37 @@ func TestFirstRequestHoldsTheViewTheStateAndTheMessage(t *testing.T) {
                "<chat>\n0+1|user: an earlier message\n",
                "</chat>\n\nNow: Thursday 2026-01-01 12:00 +00:00",
                "The new message.",
                "<chat>\n0+1|user: an earlier message\n",
                "</chat>\n\nNow: Thursday 2026-01-01 12:00 +00:00",
                "The new message.",
-       }, inputTexts(t, server.Call(0)))
+       }, turnInputTexts(t, server.Call(0)))
 }
 
 func TestMessageDuringATurnJoinsTheNextRequest(t *testing.T) {
 }
 
 func TestMessageDuringATurnJoinsTheNextRequest(t *testing.T) {
-       server := newFakeResponses(t)
+       server := newModelFake(t)
        arrived := make(chan struct{})
        release := make(chan struct{})
        arrived := make(chan struct{})
        release := make(chan struct{})
-       server.reply = func(w http.ResponseWriter, call fakeCall) {
+       server.reply = func(w http.ResponseWriter, call ModelFakeCall) {
                if call.number == 0 {
                        close(arrived)
                        <-release
                if call.number == 0 {
                        close(arrived)
                        <-release
-                       writeEvents(w, completedEvent([]any{functionCallItem("fc_1", "call_1", "date", `{"id":0}`)}, 100, 0, 5))
+                       modelWriteEvents(w, modelCompletedEvent([]any{modelFunctionCallItem("fc_1", "call_1", "date", `{"id":0}`)}, 100, 0, 5))
 
                        return
                }
 
 
                        return
                }
 
-               writeEvents(w, completedEvent([]any{messageItem("done")}, 100, 0, 5))
+               modelWriteEvents(w, modelCompletedEvent([]any{modelMessageItem("done")}, 100, 0, 5))
        }
 
        }
 
-       test := newTestLoop(t, server)
-       _, err := test.loop.Submit("first")
+       test := newTestTurnLoop(t, server)
+       _, err := test.loop.Submit(terminalSource, "first")
        require.NoError(t, err)
 
        <-arrived
        require.NoError(t, err)
 
        <-arrived
-       _, err = test.loop.Submit("second, during the turn")
+
+       _, err = test.loop.Submit(terminalSource, "second, during the turn")
        require.NoError(t, err)
        close(release)
 
        test.events.WaitFor(t, "idle", 1)
        require.NoError(t, err)
        close(release)
 
        test.events.WaitFor(t, "idle", 1)
+
        input := server.Call(1).body["input"].([]any)
        require.Equal(t, map[string]any{
                "role":    "user",
        input := server.Call(1).body["input"].([]any)
        require.Equal(t, map[string]any{
                "role":    "user",
@@ -116,45 +126,46 @@ func TestMessageDuringATurnJoinsTheNextRequest(t *testing.T) {
 }
 
 func TestMessageDuringTheFinalRequestStartsANewTurn(t *testing.T) {
 }
 
 func TestMessageDuringTheFinalRequestStartsANewTurn(t *testing.T) {
-       server := newFakeResponses(t)
+       server := newModelFake(t)
        arrived := make(chan struct{})
        release := make(chan struct{})
        arrived := make(chan struct{})
        release := make(chan struct{})
-       server.reply = func(w http.ResponseWriter, call fakeCall) {
+       server.reply = func(w http.ResponseWriter, call ModelFakeCall) {
                if call.number == 0 {
                        close(arrived)
                        <-release
                }
 
                if call.number == 0 {
                        close(arrived)
                        <-release
                }
 
-               writeEvents(w, completedEvent([]any{messageItem("answer")}, 100, 0, 5))
+               modelWriteEvents(w, modelCompletedEvent([]any{modelMessageItem("answer")}, 100, 0, 5))
        }
 
        }
 
-       test := newTestLoop(t, server)
-       _, err := test.loop.Submit("first")
+       test := newTestTurnLoop(t, server)
+       _, err := test.loop.Submit(terminalSource, "first")
        require.NoError(t, err)
 
        <-arrived
        require.NoError(t, err)
 
        <-arrived
-       _, err = test.loop.Submit("second")
+
+       _, err = test.loop.Submit(terminalSource, "second")
        require.NoError(t, err)
        close(release)
 
        test.events.WaitFor(t, "idle", 2)
        require.Equal(t, 2, server.Calls())
 
        require.NoError(t, err)
        close(release)
 
        test.events.WaitFor(t, "idle", 2)
        require.Equal(t, 2, server.Calls())
 
-       texts := inputTexts(t, server.Call(1))
+       texts := turnInputTexts(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) {
        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)
+       server := newModelFake(t)
        summarizer := newFakeSummarizer()
        summarizer.gate = make(chan struct{})
        summarizer := newFakeSummarizer()
        summarizer.gate = make(chan struct{})
-       test := newTestLoopWith(t, server, summarizer, false)
+       test := newTestTurnLoopWith(t, server, summarizer)
 
        _, 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)
 
-       _, err = test.loop.Submit("go on")
+       _, err = test.loop.Submit(terminalSource, "go on")
        require.NoError(t, err)
 
        time.Sleep(50 * time.Millisecond)
        require.NoError(t, err)
 
        time.Sleep(50 * time.Millisecond)
@@ -163,24 +174,24 @@ 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, inputTexts(t, server.Call(0))[0], pending)
+       require.NotContains(t, turnInputTexts(t, server.Call(0))[0], viewPending)
 }
 
 func TestInterruptEndsTheTurn(t *testing.T) {
 }
 
 func TestInterruptEndsTheTurn(t *testing.T) {
-       server := newFakeResponses(t)
+       server := newModelFake(t)
        arrived := make(chan struct{})
        release := make(chan struct{})
        arrived := make(chan struct{})
        release := make(chan struct{})
-       server.reply = func(w http.ResponseWriter, call fakeCall) {
+       server.reply = func(w http.ResponseWriter, call ModelFakeCall) {
                if call.number == 0 {
                        close(arrived)
                        <-release
                }
 
                if call.number == 0 {
                        close(arrived)
                        <-release
                }
 
-               writeEvents(w, completedEvent([]any{messageItem("answer")}, 100, 0, 5))
+               modelWriteEvents(w, modelCompletedEvent([]any{modelMessageItem("answer")}, 100, 0, 5))
        }
 
        }
 
-       test := newTestLoop(t, server)
-       _, err := test.loop.Submit("a long task")
+       test := newTestTurnLoop(t, server)
+       _, err := test.loop.Submit(terminalSource, "a long task")
        require.NoError(t, err)
 
        <-arrived
        require.NoError(t, err)
 
        <-arrived
@@ -192,39 +203,45 @@ func TestInterruptEndsTheTurn(t *testing.T) {
        require.Equal(t, []string{"user: a long task"}, test.Log(t))
        require.False(t, test.loop.Interrupt())
 
        require.Equal(t, []string{"user: a long task"}, test.Log(t))
        require.False(t, test.loop.Interrupt())
 
-       _, err = test.loop.Submit("again")
+       _, err = test.loop.Submit(terminalSource, "again")
        require.NoError(t, err)
        test.events.WaitFor(t, "idle", 2)
        require.Equal(t, "reply: answer", test.Log(t)[2])
        require.NoError(t, err)
        test.events.WaitFor(t, "idle", 2)
        require.Equal(t, "reply: answer", test.Log(t)[2])
+       require.Empty(t, test.logs.String())
 }
 
 func TestFailedCallEndsTheTurnWithoutARetry(t *testing.T) {
 }
 
 func TestFailedCallEndsTheTurnWithoutARetry(t *testing.T) {
-       server := newFakeResponses(t)
-       server.reply = func(w http.ResponseWriter, call fakeCall) {
+       server := newModelFake(t)
+       server.reply = func(w http.ResponseWriter, _ ModelFakeCall) {
                http.Error(w, "busy", http.StatusServiceUnavailable)
        }
 
                http.Error(w, "busy", http.StatusServiceUnavailable)
        }
 
-       test := newTestLoop(t, server)
-       _, err := test.loop.Submit("hello")
+       test := newTestTurnLoop(t, server)
+       _, err := test.loop.Submit(terminalSource, "hello")
        require.NoError(t, err)
        test.events.WaitFor(t, "idle", 1)
 
        time.Sleep(50 * time.Millisecond)
        require.Equal(t, 1, server.Calls())
        require.Contains(t, test.events.Last("error"), "HTTP 503")
        require.NoError(t, err)
        test.events.WaitFor(t, "idle", 1)
 
        time.Sleep(50 * time.Millisecond)
        require.Equal(t, 1, server.Calls())
        require.Contains(t, test.events.Last("error"), "HTTP 503")
+       require.Equal(t, 1, strings.Count(test.logs.String(), "\n"))
+       require.Contains(t, test.logs.String(), "<3>turn failed: ")
+       require.Contains(t, test.logs.String(), "HTTP 503")
+       require.NotContains(t, test.logs.String(), "hello")
 }
 
 func TestViewMessagesOnlyGrowBetweenTurns(t *testing.T) {
 }
 
 func TestViewMessagesOnlyGrowBetweenTurns(t *testing.T) {
-       server := newFakeResponses(t)
-       test := newTestLoop(t, server)
+       server := newModelFake(t)
+       test := newTestTurnLoop(t, server)
        for n, text := range []string{"one", "two", "three"} {
        for n, text := range []string{"one", "two", "three"} {
-               _, err := test.loop.Submit(text)
+               _, err := test.loop.Submit(terminalSource, 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.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.Len(t, first, 4)
        require.Len(t, second, 5)
        require.Equal(t, first[:2], second[:2])
@@ -234,69 +251,78 @@ func TestViewMessagesOnlyGrowBetweenTurns(t *testing.T) {
                "2+1|user: two\n3+1|reply: a line\n",
                "</chat>\n\nNow: Thursday 2026-01-01 12:00 +00:00",
                "three",
                "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)))
+       }, turnInputTexts(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
-               }
+// TurnTestLoop is a loop that runs in the background of a test, with its parts.
+type TurnTestLoop struct {
+       agent     *Agent
+       memory    *Memory
+       loop      *TurnLoop
+       events    *TurnEventRecorder
+       logs      *SyncBuffer
+       usagePath string
+}
 
 
-               writeEvents(w, completedEvent([]any{messageItem("answer")}, 100, 0, 5))
-       }
+// TurnEventRecorder keeps the events of a loop.
+type TurnEventRecorder struct {
+       mutex  sync.Mutex
+       events []Event
+}
+
+func newTestTurnLoop(t *testing.T, server *ModelFake) *TurnTestLoop {
+       t.Helper()
+
+       return newTestTurnLoopWith(t, server, newFakeSummarizer())
+}
+
+// newTestTurnLoopWith returns a running loop on a new agent whose builds use
+// summarizer and whose commands run in a temporary directory.
+func newTestTurnLoopWith(t *testing.T, server *ModelFake, summarizer Summarizer) *TurnTestLoop {
+       t.Helper()
 
 
-       test := newTestLoopWith(t, server, newFakeSummarizer(), true)
-       _, err := test.loop.Submit("one")
+       agent, err := openAgent(filepath.Join(t.TempDir(), "agent"))
        require.NoError(t, err)
        require.NoError(t, err)
-       require.Eventually(t, func() bool {
-               return server.Calls() == 2
-       }, 10*time.Second, time.Millisecond)
 
 
-       _, err = test.loop.Submit("two")
+       agent.config.Workdir = t.TempDir()
+       clock := newTestClock()
+       memory, err := openMemory(t.Context(), t.TempDir(), clock.Now, summarizer, discardLog())
        require.NoError(t, err)
        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)))
+       test := &TurnTestLoop{
+               agent:     agent,
+               memory:    memory,
+               events:    &TurnEventRecorder{},
+               logs:      &SyncBuffer{},
+               usagePath: filepath.Join(t.TempDir(), "usage.jsonl"),
+       }
 
 
-       // 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)])
+       client := newModelClient(server.URL, ModelAPIKey(modelTestKey), agent.CacheKey(), test.usagePath)
+       whatsapp, _, _ := whatsappStartTest(t, t.TempDir(), clock)
+       test.loop, err = newTurnLoop(agent, memory, newTestSubagents(t), whatsapp, newTestSchedules(t, clock.Now), client, clock.Now, daemonTestLogger(test.logs), test.events.Add)
+       require.NoError(t, err)
 
 
-       turns := []string{}
-       for _, record := range readUsage(t, test.usagePath) {
-               turns = append(turns, record.Turn)
-       }
+       ctx, cancel := context.WithCancel(t.Context())
+       done := make(chan error)
+       go func() {
+               done <- test.loop.Run(ctx)
+       }()
 
 
-       require.Equal(t, []string{"first", "warmup", "first", "warmup"}, turns)
-       require.Equal(t, []string{"user: one", "reply: answer", "user: two", "reply: answer"}, test.Log(t))
-}
+       t.Cleanup(func() {
+               cancel()
+               require.ErrorIs(t, <-done, context.Canceled)
+               require.NoError(t, memory.Close())
+       })
 
 
-// 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
-       usagePath string
+       return test
 }
 
 // Log returns the logged messages as "kind: text".
 }
 
 // Log returns the logged messages as "kind: text".
-func (l *testLoop) Log(t *testing.T) []string {
+func (l *TurnTestLoop) Log(t *testing.T) []string {
        t.Helper()
 
        var lines []string
        t.Helper()
 
        var lines []string
+
        for id := range l.memory.Len() {
                message, err := l.memory.Message(id)
                require.NoError(t, err)
        for id := range l.memory.Len() {
                message, err := l.memory.Message(id)
                require.NoError(t, err)
@@ -307,20 +333,16 @@ func (l *testLoop) Log(t *testing.T) []string {
        return lines
 }
 
        return lines
 }
 
-// eventRecorder keeps the events of a loop.
-type eventRecorder struct {
-       mutex  sync.Mutex
-       events []Event
-}
-
-func (r *eventRecorder) Add(event Event) {
-       r.mutex.Lock()
-       defer r.mutex.Unlock()
+// WaitFor waits until count events of kind came.
+func (r *TurnEventRecorder) WaitFor(t *testing.T, kind string, count int) {
+       t.Helper()
 
 
-       r.events = append(r.events, event)
+       require.Eventually(t, func() bool {
+               return r.Count(kind) >= count
+       }, 10*time.Second, time.Millisecond)
 }
 
 }
 
-func (r *eventRecorder) Kinds() []string {
+func (r *TurnEventRecorder) Kinds() []string {
        r.mutex.Lock()
        defer r.mutex.Unlock()
 
        r.mutex.Lock()
        defer r.mutex.Unlock()
 
@@ -332,7 +354,7 @@ func (r *eventRecorder) Kinds() []string {
        return kinds
 }
 
        return kinds
 }
 
-func (r *eventRecorder) Count(kind string) int {
+func (r *TurnEventRecorder) Count(kind string) int {
        count := 0
        for _, each := range r.Kinds() {
                if each == kind {
        count := 0
        for _, each := range r.Kinds() {
                if each == kind {
@@ -344,77 +366,42 @@ func (r *eventRecorder) Count(kind string) int {
 }
 
 // Last returns the text of the last event of kind.
 }
 
 // Last returns the text of the last event of kind.
-func (r *eventRecorder) Last(kind string) string {
+func (r *TurnEventRecorder) Last(kind string) string {
+       return r.LastEvent(kind).Text
+}
+
+func (r *TurnEventRecorder) Add(event Event) {
+       r.mutex.Lock()
+       defer r.mutex.Unlock()
+
+       r.events = append(r.events, event)
+}
+
+// LastEvent returns the last event of kind.
+func (r *TurnEventRecorder) LastEvent(kind string) Event {
        r.mutex.Lock()
        defer r.mutex.Unlock()
 
        for n := len(r.events) - 1; n >= 0; n-- {
                if r.events[n].Kind == kind {
        r.mutex.Lock()
        defer r.mutex.Unlock()
 
        for n := len(r.events) - 1; n >= 0; n-- {
                if r.events[n].Kind == kind {
-                       return r.events[n].Text
+                       return r.events[n]
                }
        }
 
                }
        }
 
-       return ""
-}
-
-// WaitFor waits until count events of kind came.
-func (r *eventRecorder) WaitFor(t *testing.T, kind string, count int) {
-       t.Helper()
-
-       require.Eventually(t, func() bool {
-               return r.Count(kind) >= count
-       }, 10*time.Second, time.Millisecond)
+       return Event{}
 }
 
 }
 
-func newTestLoop(t *testing.T, server *fakeResponses) *testLoop {
-       t.Helper()
-
-       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. 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())
-       require.NoError(t, err)
-
-       agent.config.Workdir = t.TempDir()
-       clock := newTestClock()
-       memory, err := openMemory(t.Context(), t.TempDir(), clock.Now, summarizer)
-       require.NoError(t, err)
-
-       test := &testLoop{
-               agent:     agent,
-               memory:    memory,
-               events:    &eventRecorder{},
-               usagePath: filepath.Join(t.TempDir(), "usage.jsonl"),
+func turnReasoningItem(id, encrypted string) map[string]any {
+       return map[string]any{
+               "type":              "reasoning",
+               "id":                id,
+               "encrypted_content": encrypted,
+               "summary":           []any{},
        }
        }
-
-       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() {
-               done <- test.loop.Run(ctx)
-       }()
-
-       t.Cleanup(func() {
-               cancel()
-               require.True(t, errors.Is(<-done, context.Canceled))
-               require.NoError(t, memory.Close())
-       })
-
-       return test
 }
 
 }
 
-// inputTexts returns the text of each user message of the input of call.
-func inputTexts(t *testing.T, call fakeCall) []string {
+// turnInputTexts returns the text of each user message of the input of call.
+func turnInputTexts(t *testing.T, call ModelFakeCall) []string {
        t.Helper()
 
        var body struct {
        t.Helper()
 
        var body struct {
@@ -429,12 +416,14 @@ func inputTexts(t *testing.T, call fakeCall) []string {
        require.NoError(t, json.Unmarshal(call.raw, &body))
 
        var texts []string
        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 _, item := range body.Input {
                if item.Role != "user" {
                        continue
                }
 
                var text strings.Builder
+
                for _, part := range item.Content {
                        text.WriteString(part.Text)
                }
                for _, part := range item.Content {
                        text.WriteString(part.Text)
                }
@@ -444,22 +433,3 @@ func inputTexts(t *testing.T, call fakeCall) []string {
 
        return texts
 }
 
        return texts
 }
-
-func reasoningItem(id, encrypted string) map[string]any {
-       return map[string]any{
-               "type":              "reasoning",
-               "id":                id,
-               "encrypted_content": encrypted,
-               "summary":           []any{},
-       }
-}
-
-func functionCallItem(id, callID, name, arguments string) map[string]any {
-       return map[string]any{
-               "type":      "function_call",
-               "id":        id,
-               "call_id":   callID,
-               "name":      name,
-               "arguments": arguments,
-       }
-}
Onechat