Name and order the daemon and socket code

[onechat] / turn_test.go

diff --git a/turn_test.go b/turn_test.go
index b8c92dc260f22e95b04ffc0c82c68781cbb941bc..c378469574dfa8d163e78d8c6ab3010a93fd866d 100644 (file)
--- a/turn_test.go
+++ b/turn_test.go
@@ -15,22 +15,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{
+                               modelReasoningItem("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)
        }
 
        test := newTestLoop(t, server)

-       _, err := test.loop.Submit("Run echo hi.")
+       _, 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())


@@ -59,15 +59,22 @@ func TestTurnRunsToolsUntilTheFinalAnswer(t *testing.T) {
                "reply: It said hi.",
        }, test.Log(t))
        require.Equal(t, []string{"user", "busy", "tool", "echo", "reply", "idle"}, test.events.Kinds())
                "reply: It said hi.",
        }, test.Log(t))
        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)
+       server := newModelFake(t)

        test := newTestLoop(t, server)
        _, err := test.memory.Append("user", "an earlier message")
        require.NoError(t, err)
 
        test := newTestLoop(t, server)
        _, 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)
 


@@ -79,27 +86,27 @@ func TestFirstRequestHoldsTheViewTheStateAndTheMessage(t *testing.T) {
 }
 
 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)
        }
 
        test := newTestLoop(t, server)

-       _, err := test.loop.Submit("first")
+       _, 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)
 
        require.NoError(t, err)
        close(release)
 


@@ -116,24 +123,24 @@ 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)
        }
 
        test := newTestLoop(t, server)

-       _, err := test.loop.Submit("first")
+       _, 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)
 
        require.NoError(t, err)
        close(release)
 


@@ -146,15 +153,15 @@ func TestMessageDuringTheFinalRequestStartsANewTurn(t *testing.T) {
 }
 
 func TestTurnWaitsForTheSummaries(t *testing.T) {
 }
 
 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 := newTestLoopWith(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)


@@ -167,20 +174,20 @@ func TestTurnWaitsForTheSummaries(t *testing.T) {
 }
 
 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)
        }
 
        test := newTestLoop(t, server)

-       _, err := test.loop.Submit("a long task")
+       _, err := test.loop.Submit(terminalSource, "a long task")

        require.NoError(t, err)
 
        <-arrived
        require.NoError(t, err)
 
        <-arrived


@@ -192,20 +199,20 @@ 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])
 }
 
 func TestFailedCallEndsTheTurnWithoutARetry(t *testing.T) {
        require.NoError(t, err)
        test.events.WaitFor(t, "idle", 2)
        require.Equal(t, "reply: answer", test.Log(t)[2])
 }
 
 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, call ModelFakeCall) {

                http.Error(w, "busy", http.StatusServiceUnavailable)
        }
 
        test := newTestLoop(t, server)
                http.Error(w, "busy", http.StatusServiceUnavailable)
        }
 
        test := newTestLoop(t, server)

-       _, err := test.loop.Submit("hello")
+       _, err := test.loop.Submit(terminalSource, "hello")

        require.NoError(t, err)
        test.events.WaitFor(t, "idle", 1)
 
        require.NoError(t, err)
        test.events.WaitFor(t, "idle", 1)
 


@@ -215,10 +222,10 @@ func TestFailedCallEndsTheTurnWithoutARetry(t *testing.T) {
 }
 
 func TestViewMessagesOnlyGrowBetweenTurns(t *testing.T) {
 }
 
 func TestViewMessagesOnlyGrowBetweenTurns(t *testing.T) {

-       server := newFakeResponses(t)
+       server := newModelFake(t)

        test := newTestLoop(t, server)
        for n, text := range []string{"one", "two", "three"} {
        test := newTestLoop(t, server)
        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)
        }
                require.NoError(t, err)
                test.events.WaitFor(t, "idle", n+1)
        }


@@ -237,52 +244,6 @@ func TestViewMessagesOnlyGrowBetweenTurns(t *testing.T) {
        }, inputTexts(t, server.Call(2)))
 }
 
        }, 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
 // testLoop is a loop that runs in the background of a test, with its parts.
 type testLoop struct {
        agent     *Agent


@@ -366,16 +327,15 @@ func (r *eventRecorder) WaitFor(t *testing.T, kind string, count int) {
        }, 10*time.Second, time.Millisecond)
 }
 
        }, 10*time.Second, time.Millisecond)
 }
 

-func newTestLoop(t *testing.T, server *fakeResponses) *testLoop {
+func newTestLoop(t *testing.T, server *ModelFake) *testLoop {

        t.Helper()
 
        t.Helper()
 

-       return newTestLoopWith(t, server, newFakeSummarizer(), false)
+       return newTestLoopWith(t, server, newFakeSummarizer())

 }
 
 // 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. warmUp turns the
-// warm-up on.
-func newTestLoopWith(t *testing.T, server *fakeResponses, summarizer Summarizer, warmUp bool) *testLoop {
+// summarizer and whose commands run in a temporary directory.
+func newTestLoopWith(t *testing.T, server *ModelFake, summarizer Summarizer) *testLoop {

        t.Helper()
 
        agent, err := openAgent(t.TempDir())
        t.Helper()
 
        agent, err := openAgent(t.TempDir())


@@ -393,11 +353,9 @@ func newTestLoopWith(t *testing.T, server *fakeResponses, summarizer Summarizer,
                usagePath: filepath.Join(t.TempDir(), "usage.jsonl"),
        }
 
                usagePath: filepath.Join(t.TempDir(), "usage.jsonl"),
        }
 

-       client := newClient(server.URL, apiKey(testKey), agent.CacheKey(), test.usagePath)
+       client := newModelClient(server.URL, ModelAPIKey(modelTestKey), agent.CacheKey(), test.usagePath)

        test.loop, err = newLoop(agent, memory, client, clock.Now, test.events.Add)
        require.NoError(t, err)
        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() {


@@ -414,7 +372,7 @@ func newTestLoopWith(t *testing.T, server *fakeResponses, summarizer Summarizer,
 }
 
 // inputTexts returns the text of each user message of the input of call.
 }
 
 // inputTexts returns the text of each user message of the input of call.

-func inputTexts(t *testing.T, call fakeCall) []string {
+func inputTexts(t *testing.T, call ModelFakeCall) []string {

        t.Helper()
 
        var body struct {
        t.Helper()
 
        var body struct {


@@ -444,22 +402,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,
-       }
-}