Make intentional error discards explicit

[onechat] / subagent_run_test.go

diff --git a/subagent_run_test.go b/subagent_run_test.go
index 5caf0d886ef3a6855ef142f1ed28ca41efec46f9..708b515745074ff889391970eda186b32cf6ed71 100644 (file)
--- a/subagent_run_test.go
+++ b/subagent_run_test.go
@@ -1,12 +1,15 @@
 package main
 
 import (
 package main
 
 import (

+       "context"

        "io"
        "io"

+       "log/slog"

        "net/http"
        "os"
        "path/filepath"
        "strconv"
        "strings"
        "net/http"
        "os"
        "path/filepath"
        "strconv"
        "strings"

+       "sync/atomic"

        "testing"
        "time"
 
        "testing"
        "time"
 


@@ -19,12 +22,15 @@ const subagentTestFullContext = `{"error": {"message": "Your input exceeds the c
 
 func TestSpawnRunsASubagentInTheBackground(t *testing.T) {
        server := newModelFake(t)
 
 func TestSpawnRunsASubagentInTheBackground(t *testing.T) {
        server := newModelFake(t)

+

        var test *TurnTestLoop
        var test *TurnTestLoop

+

        server.reply = func(w http.ResponseWriter, call ModelFakeCall) {
                last := subagentTestLastItem(call)
                switch {
                case subagentTestCall(call) && last["type"] == "function_call_output":
        server.reply = func(w http.ResponseWriter, call ModelFakeCall) {
                last := subagentTestLastItem(call)
                switch {
                case subagentTestCall(call) && last["type"] == "function_call_output":

-                       // The report comes after the reply of the turn of the spawn.
+                       // The report comes after the reply of the turn of the
+                       // spawn.

                        test.events.WaitFor(t, "reply", 1)
                        modelWriteEvents(w, modelCompletedEvent([]any{modelMessageItem("There are 3 files.")}, 100, 0, 5))
                case subagentTestCall(call):
                        test.events.WaitFor(t, "reply", 1)
                        modelWriteEvents(w, modelCompletedEvent([]any{modelMessageItem("There are 3 files.")}, 100, 0, 5))
                case subagentTestCall(call):


@@ -45,6 +51,7 @@ func TestSpawnRunsASubagentInTheBackground(t *testing.T) {
 
        name := test.events.Last("subagent")
        require.True(t, subagentNameValid(name), name)
 
        name := test.events.Last("subagent")
        require.True(t, subagentNameValid(name), name)

+

        work := filepath.Join(test.loop.runs.subagents.dir, name, "work")
        require.DirExists(t, work)
 
        work := filepath.Join(test.loop.runs.subagents.dir, name, "work")
        require.DirExists(t, work)
 


@@ -57,6 +64,7 @@ func TestSpawnRunsASubagentInTheBackground(t *testing.T) {
                "work: " + report,
                "reply: Noted.",
        }, test.Log(t))
                "work: " + report,
                "reply: Noted.",
        }, test.Log(t))

+

        require.Equal(t, Event{
                Kind:   "work",
                ID:     4,
        require.Equal(t, Event{
                Kind:   "work",
                ID:     4,


@@ -65,7 +73,10 @@ func TestSpawnRunsASubagentInTheBackground(t *testing.T) {
                Status: subagentFinished,
        }, test.events.LastEvent("work"))
 
                Status: subagentFinished,
        }, test.events.LastEvent("work"))
 

+       require.Equal(t, "<6>subagent started name="+name+"\n<6>subagent done name="+name+" after=0s\n", test.logs.String())
+

        var first, second *ModelFakeCall
        var first, second *ModelFakeCall

+

        for n := range server.Calls() {
                call := server.Call(n)
                if !subagentTestCall(call) {
        for n := range server.Calls() {
                call := server.Call(n)
                if !subagentTestCall(call) {


@@ -94,6 +105,7 @@ func TestSpawnRunsASubagentInTheBackground(t *testing.T) {
        require.Equal(t, instructions, first.body["instructions"])
 
        var tools []string
        require.Equal(t, instructions, first.body["instructions"])
 
        var tools []string

+

        for _, tool := range first.body["tools"].([]any) {
                tools = append(tools, tool.(map[string]any)["name"].(string))
        }
        for _, tool := range first.body["tools"].([]any) {
                tools = append(tools, tool.(map[string]any)["name"].(string))
        }


@@ -109,6 +121,7 @@ func TestSpawnRunsASubagentInTheBackground(t *testing.T) {
        require.Equal(t, "0|note: subagent\n\n1|user: Count the files.\n\n2|tool: shell {\"command\":\"pwd\"}\n\n3|echo: "+work+"\n\n\n4|reply: There are 3 files.", log)
 
        var agents []string
        require.Equal(t, "0|note: subagent\n\n1|user: Count the files.\n\n2|tool: shell {\"command\":\"pwd\"}\n\n3|echo: "+work+"\n\n\n4|reply: There are 3 files.", log)
 
        var agents []string

+

        for _, record := range modelReadUsage(t, test.usagePath) {
                agents = append(agents, record.Agent)
        }
        for _, record := range modelReadUsage(t, test.usagePath) {
                agents = append(agents, record.Agent)
        }


@@ -137,6 +150,7 @@ func TestReportJoinsTheNextRequestOfARunningTurn(t *testing.T) {
        require.NoError(t, err)
 
        <-arrived
        require.NoError(t, err)
 
        <-arrived

+

        report := subagentReport("GreenOtter", []string{"It is done."})
        test.loop.Report("GreenOtter", report, subagentFinished)
        close(release)
        report := subagentReport("GreenOtter", []string{"It is done."})
        test.loop.Report("GreenOtter", report, subagentFinished)
        close(release)


@@ -167,7 +181,11 @@ func TestFullContextGivesAFailedReport(t *testing.T) {
        server.reply = func(w http.ResponseWriter, call ModelFakeCall) {
                if subagentTestCall(call) {
                        w.WriteHeader(http.StatusBadRequest)
        server.reply = func(w http.ResponseWriter, call ModelFakeCall) {
                if subagentTestCall(call) {
                        w.WriteHeader(http.StatusBadRequest)

-                       _, _ = io.WriteString(w, subagentTestFullContext)
+
+                       _, err := io.WriteString(w, subagentTestFullContext)
+                       if err != nil {
+                               panic(err)
+                       }

 
                        return
                }
 
                        return
                }


@@ -182,10 +200,12 @@ func TestFullContextGivesAFailedReport(t *testing.T) {
 
        name := test.events.Last("subagent")
        require.Equal(t, []string{
 
        name := test.events.Last("subagent")
        require.Equal(t, []string{

-               "work: [" + name + "]\nfailed: model call: HTTP 400: " + subagentTestFullContext + "\n\nFull chat: zoom(\"" + name + "\")",
+               "work: [" + name + "]\nfailed: create model response: model call: HTTP 400: " + subagentTestFullContext + "\n\nFull chat: zoom(\"" + name + "\")",

                "reply: It failed.",
        }, test.Log(t))
                "reply: It failed.",
        }, test.Log(t))

+

        require.Equal(t, subagentFailed, test.events.LastEvent("work").Status)
        require.Equal(t, subagentFailed, test.events.LastEvent("work").Status)

+       require.Equal(t, "<6>subagent started name="+name+"\n<3>subagent failed name="+name+" after=0s: create model response: model call: HTTP 400: "+subagentTestFullContext+"\n", test.logs.String())

 }
 
 func TestSubagentHasItsOwnEffortAndNoSpawn(t *testing.T) {
 }
 
 func TestSubagentHasItsOwnEffortAndNoSpawn(t *testing.T) {


@@ -256,6 +276,7 @@ func TestTellReachesARunningSubagentBetweenItsToolCalls(t *testing.T) {
        require.NoError(t, err)
 
        <-arrived
        require.NoError(t, err)
 
        <-arrived

+

        name := test.events.Last("subagent")
        output, err := runs.Tell(t.Context(), name, "Use the second disk.")
        require.NoError(t, err)
        name := test.events.Last("subagent")
        output, err := runs.Tell(t.Context(), name, "Use the second disk.")
        require.NoError(t, err)


@@ -290,6 +311,7 @@ func TestTellAfterTheFinalAnswerStartsAnotherChain(t *testing.T) {
        require.NoError(t, err)
 
        <-arrived
        require.NoError(t, err)
 
        <-arrived

+

        name := test.events.Last("subagent")
        _, err = runs.Tell(t.Context(), name, "Count again.")
        require.NoError(t, err)
        name := test.events.Last("subagent")
        _, err = runs.Tell(t.Context(), name, "Count again.")
        require.NoError(t, err)


@@ -340,7 +362,7 @@ func TestTellToAFinishedSubagentGoesOnFromItsLog(t *testing.T) {
 
 func TestStopEndsASubagentAndItsCommand(t *testing.T) {
        server := newModelFake(t)
 
 func TestStopEndsASubagentAndItsCommand(t *testing.T) {
        server := newModelFake(t)

-       server.reply = func(w http.ResponseWriter, call ModelFakeCall) {
+       server.reply = func(w http.ResponseWriter, _ ModelFakeCall) {

                modelWriteEvents(w, modelCompletedEvent([]any{modelFunctionCallItem("fc_1", "call_1", "shell", `{"command":"touch started && sleep 30"}`)}, 100, 0, 5))
        }
 
                modelWriteEvents(w, modelCompletedEvent([]any{modelFunctionCallItem("fc_1", "call_1", "shell", `{"command":"touch started && sleep 30"}`)}, 100, 0, 5))
        }
 


@@ -369,7 +391,9 @@ func TestStopEndsASubagentAndItsCommand(t *testing.T) {
                "note: Stopped by the user: " + name + ".",
                "work: " + subagentReport(name, []string{"stopped"}),
        }, test.Log(t))
                "note: Stopped by the user: " + name + ".",
                "work: " + subagentReport(name, []string{"stopped"}),
        }, test.Log(t))

+

        require.Equal(t, subagentStopped, test.events.LastEvent("work").Status)
        require.Equal(t, subagentStopped, test.events.LastEvent("work").Status)

+       require.Equal(t, "<6>subagent started name="+name+"\n<6>subagent stopped name="+name+" after=0s\n", test.logs.String())

 
        log, err := subagent.Show()
        require.NoError(t, err)
 
        log, err := subagent.Show()
        require.NoError(t, err)


@@ -391,7 +415,7 @@ func TestCloseEndsTheSubagentsWithNoReport(t *testing.T) {
                close(release)
        })
 
                close(release)
        })
 

-       server.reply = func(w http.ResponseWriter, call ModelFakeCall) {
+       server.reply = func(_ http.ResponseWriter, _ ModelFakeCall) {

                close(arrived)
                <-release
        }
                close(arrived)
                <-release
        }


@@ -414,11 +438,100 @@ func TestCloseEndsTheSubagentsWithNoReport(t *testing.T) {
        require.Len(t, entries, 1)
 }
 
        require.Len(t, entries, 1)
 }
 

-// subagentTestCall tells if call is a call of a subagent.
-func subagentTestCall(call ModelFakeCall) bool {
-       instructions, _ := call.body["instructions"].(string)
+func TestRestartResumesTheCutSubagents(t *testing.T) {
+       server := newModelFake(t)
+       arrived := make(chan struct{}, 1)
+       release := make(chan struct{})
+       t.Cleanup(func() {
+               close(release)
+       })

 
 

-       return strings.HasPrefix(instructions, "You are a subagent")
+       var restarted atomic.Bool
+
+       server.reply = func(w http.ResponseWriter, call ModelFakeCall) {
+               switch {
+               case subagentTestCall(call) && !restarted.Load():
+                       arrived <- struct{}{}
+
+                       <-release
+               case subagentTestCall(call):
+                       modelWriteEvents(w, modelCompletedEvent([]any{modelMessageItem("Built.")}, 100, 0, 5))
+               default:
+                       modelWriteEvents(w, modelCompletedEvent([]any{modelMessageItem("Noted.")}, 100, 0, 5))
+               }
+       }
+
+       agent, err := openAgent(t.TempDir())
+       require.NoError(t, err)
+
+       first := &TurnEventRecorder{}
+       loop, _, stop := subagentTestStart(t, agent, server, first, discardLog())
+       _, err = loop.runs.Spawn(t.Context(), []string{"Build the project."}, nil)
+       require.NoError(t, err)
+
+       <-arrived
+
+       name := first.Last("subagent")
+
+       stop()
+       require.Zero(t, first.Count("work"))
+
+       data, err := os.ReadFile(filepath.Join(agent.dir, subagentWorkFileName))
+       require.NoError(t, err)
+       require.JSONEq(t, `{"running": ["`+name+`"]}`, string(data))
+
+       restarted.Store(true)
+
+       second := &TurnEventRecorder{}
+       loop, memory, stop := subagentTestStart(t, agent, server, second, discardLog())
+       defer stop()
+
+       second.WaitFor(t, "idle", 1)
+
+       note := "The daemon restarted, cutting " + name + "; nothing was lost: go on."
+       log := subagentTestChat(t, memory)
+       require.Equal(t, []string{
+               "note: " + note,
+               "work: " + subagentReport(name, []string{"Built."}),
+               "reply: Noted.",
+       }, log[len(log)-3:])
+
+       subagent, err := loop.runs.subagents.Get(t.Context(), name)
+       require.NoError(t, err)
+
+       text, err := subagent.Show()
+       require.NoError(t, err)
+       require.Equal(t, "0|note: subagent\n\n1|user: Build the project.\n\n2|user: "+note+"\n\n3|reply: Built.", text)
+
+       data, err = os.ReadFile(filepath.Join(agent.dir, subagentWorkFileName))
+       require.NoError(t, err)
+       require.JSONEq(t, `{"running": []}`, string(data))
+}
+
+func TestRestartReportsASubagentThatCannotGoOn(t *testing.T) {
+       server := newModelFake(t)
+       agent, err := openAgent(t.TempDir())
+       require.NoError(t, err)
+       require.NoError(t, os.WriteFile(filepath.Join(agent.dir, subagentWorkFileName), []byte(`{"running": ["BlueFox"]}`), 0o600))
+
+       events := &TurnEventRecorder{}
+       logs := &SyncBuffer{}
+       _, memory, stop := subagentTestStart(t, agent, server, events, daemonTestLogger(logs))
+       defer stop()
+
+       events.WaitFor(t, "idle", 1)
+       require.Equal(t, []string{
+               "note: The daemon restarted, cutting BlueFox; nothing was lost: go on.",
+               "work: " + subagentReport("BlueFox", []string{"failed: no agent BlueFox"}),
+               "reply: a line",
+       }, subagentTestChat(t, memory))
+
+       require.Equal(t, subagentFailed, events.LastEvent("work").Status)
+       require.Equal(t, "<3>subagent lost at restart name=BlueFox: no agent BlueFox\n", logs.String())
+
+       data, err := os.ReadFile(filepath.Join(agent.dir, subagentWorkFileName))
+       require.NoError(t, err)
+       require.JSONEq(t, `{"running": []}`, string(data))

 }
 
 // subagentTestLastItem returns the last input item of call.
 }
 
 // subagentTestLastItem returns the last input item of call.


@@ -428,11 +541,20 @@ func subagentTestLastItem(call ModelFakeCall) map[string]any {
        return input[len(input)-1].(map[string]any)
 }
 
        return input[len(input)-1].(map[string]any)
 }
 

-// subagentTestText returns the text of the user message item, or "" for
-// another item.
+// subagentTestCall tells if call is a call of a subagent.
+func subagentTestCall(call ModelFakeCall) bool {
+       instructions, _ := call.body["instructions"].(string)
+
+       return strings.HasPrefix(instructions, "You are a subagent")
+}
+
+// subagentTestText returns the text of the user message item, or "" for another
+// item.

 func subagentTestText(item map[string]any) string {
        content, _ := item["content"].([]any)
 func subagentTestText(item map[string]any) string {
        content, _ := item["content"].([]any)

+

        var text strings.Builder
        var text strings.Builder

+

        for _, part := range content {
                value, _ := part.(map[string]any)["text"].(string)
                text.WriteString(value)
        for _, part := range content {
                value, _ := part.(map[string]any)["text"].(string)
                text.WriteString(value)


@@ -440,3 +562,50 @@ func subagentTestText(item map[string]any) string {
 
        return text.String()
 }
 
        return text.String()
 }

+
+// subagentTestStart runs a loop of agent with its memory and subagents in the
+// agent directory, as the daemon does. The returned function stops the loop and
+// closes the files.
+func subagentTestStart(t *testing.T, agent *Agent, server *ModelFake, events *TurnEventRecorder, logger *slog.Logger) (*TurnLoop, *Memory, func()) {
+       t.Helper()
+
+       agent.config.Workdir = t.TempDir()
+       clock := newTestClock()
+       memory, err := openMemory(t.Context(), agent.dir, clock.Now, newFakeSummarizer(), discardLog())
+       require.NoError(t, err)
+
+       subagents := newSubagents(filepath.Join(agent.dir, subagentDirName), clock.Now, subagentNameRandom)
+       client := newModelClient(server.URL, ModelAPIKey(modelTestKey), agent.CacheKey(), filepath.Join(agent.dir, "usage.jsonl"))
+       whatsapp, _, _ := whatsappStartTest(t, t.TempDir(), clock)
+       loop, err := newTurnLoop(agent, memory, subagents, whatsapp, newTestSchedules(t, clock.Now), client, clock.Now, logger, events.Add)
+       require.NoError(t, err)
+
+       ctx, cancel := context.WithCancel(t.Context())
+       done := make(chan error)
+       go func() {
+               done <- loop.Run(ctx)
+       }()
+
+       return loop, memory, func() {
+               cancel()
+               require.ErrorIs(t, <-done, context.Canceled)
+               require.NoError(t, subagents.Close())
+               require.NoError(t, memory.Close())
+       }
+}
+
+// subagentTestChat returns each message of the chat in memory as "kind: text".
+func subagentTestChat(t *testing.T, memory *Memory) []string {
+       t.Helper()
+
+       var lines []string
+
+       for id := range memory.Len() {
+               message, err := memory.Message(id)
+               require.NoError(t, err)
+
+               lines = append(lines, message.Kind+": "+message.Text)
+       }
+
+       return lines
+}