X-Git-Url: https://git.giacomolli.uk/onechat/blobdiff_plain/80e348724041a694002fc38f57e8868b9b9a2be9..4a42f7f208cbfead335eba9ebe615b35b1742130:/subagent_run.go?ds=sidebyside diff --git a/subagent_run.go b/subagent_run.go index 3df12ce..ca45976 100644 --- a/subagent_run.go +++ b/subagent_run.go @@ -53,8 +53,8 @@ var errSubagentClosed = errors.New("the daemon stops, so no subagent starts") // work.json in the directory of the agent holds the names of the running // subagents. Each start and each end of a run writes it whole, but Close does // not, so after a stop of the daemon it names the runs that the stop cut, and -// Resume goes on with them. The logs alone cannot tell this, because a stop -// can cut a run just after its final reply. +// Resume goes on with them. The logs alone cannot tell this, because a stop can +// cut a run just after its final reply. // // Spawn and Tell split the view with the layout of the agent, which has no // lock. They are tools, so they run in the goroutine of the turns, as each @@ -132,7 +132,7 @@ func (r *SubagentRuns) Spawn(ctx context.Context, tasks []string, effort *string view, err := r.layout.Split(r.memory.ViewLines(nil)) if err != nil { - return "", err + return "", fmt.Errorf("split worker view: %w", err) } names := make([]string, 0, len(tasks)) @@ -143,7 +143,7 @@ func (r *SubagentRuns) Spawn(ctx context.Context, tasks []string, effort *string } if err != nil { - return "", err + return "", fmt.Errorf("create worker: %w", err) } names = append(names, name) @@ -152,173 +152,24 @@ func (r *SubagentRuns) Spawn(ctx context.Context, tasks []string, effort *string return "Started " + strings.Join(names, ", ") + ". Each one's report will reach you as a message when it finishes.", nil } -// Tell sends message to the subagent name. A running subagent reads it between -// its tool calls, and its report answers it. A finished subagent goes on from -// its log with a new run, with the view of now and the effort of its note. -func (r *SubagentRuns) Tell(ctx context.Context, name, message string) (string, error) { - r.mutex.Lock() - - run, found := r.running[name] - if found { - defer r.mutex.Unlock() - - told, err := run.subagent.Append("user", message) - if err != nil { - return "", err - } - - run.pending = append(run.pending, told) - - return "Sent. " + name + " reads it between its tool calls, and its report answers it.", nil - } - - closed := r.closed - r.mutex.Unlock() - - if closed { - return "", errSubagentClosed - } - - subagent, err := r.subagents.Get(ctx, name) - if err != nil { - return "", err - } - - effort, err := r.effort(subagent) - if err != nil { - return "", err - } - - err = r.memory.Settle(ctx) - if err != nil { - return "", fmt.Errorf("wait for the summaries: %w", err) - } - - view, err := r.layout.Split(r.memory.ViewLines(nil)) - if err != nil { - return "", err - } - - _, err = subagent.Append("user", message) - if err == nil { - err = subagent.Flush(ctx) - } - - if err != nil { - return "", err - } - - err = r.start(ctx, &SubagentRun{ - subagent: subagent, - view: view, - effort: effort, - }) - if err != nil { - return "", err - } - - return "Sent. " + name + "'s reply will reach you as a message.", nil -} - -// Stop ends the run of the subagent name and tells if it ran. The chat gets the -// note "Stopped by the user: NAME." under the mutex, so the note comes before -// the report of the run. -func (r *SubagentRuns) Stop(name string) (bool, error) { - r.mutex.Lock() - defer r.mutex.Unlock() - - run, found := r.running[name] - if !found { - return false, nil - } - - err := r.note("Stopped by the user: " + name + ".") - if err != nil { - return true, err - } - - run.stopped = true - run.cancel() - - return true, nil -} - -// Resume goes on with the runs that a stop of the daemon cut, as work.json -// names them. The chat gets the note "The daemon restarted, cutting NAMES; -// nothing was lost: go on.", and each cut subagent gets the same text as a -// message of Tell. A subagent that cannot go on gets a failed report. -func (r *SubagentRuns) Resume(ctx context.Context) error { - names, err := r.load() - if err != nil || len(names) == 0 { - return err - } - - text := "The daemon restarted, cutting " + strings.Join(names, ", ") + "; nothing was lost: go on." - err = r.note(text) - if err != nil { - return err - } - - for _, name := range names { - _, err = r.Tell(ctx, name, text) - if err != nil { - r.logger.Error("subagent lost at restart", "name", name, "err", err) - r.report(name, subagentReport(name, []string{"failed: " + err.Error()}), subagentFailed) - } - } - - // A subagent that cannot go on does not run, so work.json no longer - // names it, and the next start does not try it again. - r.mutex.Lock() - defer r.mutex.Unlock() - - return r.save() -} - -// Snapshot locks the run state, memory, and subagent logs while snapshot reads -// the agent files. The lock order agrees with Stop, which logs under the run -// lock. -func (r *SubagentRuns) Snapshot(ctx context.Context, snapshot func() error) error { - r.mutex.Lock() - defer r.mutex.Unlock() - - return r.memory.Snapshot(ctx, func() error { - return r.subagents.Snapshot(ctx, snapshot) - }) -} - -// Close ends every run and waits for them. No subagent starts after Close. -func (r *SubagentRuns) Close() { - r.mutex.Lock() - - r.closed = true - for _, run := range r.running { - run.cancel() - } - - r.mutex.Unlock() - - r.workers.Wait() -} - // create makes a new subagent with its note, its task, and its work directory, // and starts its run. func (r *SubagentRuns) create(ctx context.Context, note, task string, view []string, effort string) (string, error) { subagent, err := r.subagents.Create(ctx) if err != nil { - return "", err + return "", fmt.Errorf("create worker log: %w", err) } for _, message := range [][2]string{{"note", note}, {"user", task}} { _, err = subagent.Append(message[0], message[1]) if err != nil { - return "", err + return "", fmt.Errorf("append worker message: %w", err) } } err = subagent.Flush(ctx) if err != nil { - return "", err + return "", fmt.Errorf("flush worker log: %w", err) } err = os.MkdirAll(subagent.WorkDir(), 0o700) @@ -326,31 +177,16 @@ func (r *SubagentRuns) create(ctx context.Context, note, task string, view []str return "", fmt.Errorf("create work directory: %w", err) } - return subagent.name, r.start(ctx, &SubagentRun{ + err = r.start(ctx, &SubagentRun{ subagent: subagent, view: view, effort: effort, }) -} - -// effort returns the effort of subagent from the note at the start of its log: -// the effort of the agent, or the effort that the note names. -func (r *SubagentRuns) effort(subagent *Subagent) (string, error) { - note, err := subagent.First() if err != nil { - return "", err - } - - effort, own := strings.CutPrefix(note.Text, subagentNote+subagentNoteEffort) - switch { - case note.Kind != "note": - case own: - return effort, nil - case note.Text == subagentNote: - return r.agent.config.Effort, nil + return subagent.name, fmt.Errorf("start created worker: %w", err) } - return "", fmt.Errorf("the log of %s does not start with a subagent note", subagent.name) + return subagent.name, nil } // start runs run in the background and logs its start. Its context keeps the @@ -379,7 +215,7 @@ func (r *SubagentRuns) start(ctx context.Context, run *SubagentRun) error { r.mutex.Unlock() run.cancel() - return err + return fmt.Errorf("save running workers: %w", err) } r.workers.Add(1) @@ -397,29 +233,8 @@ func (r *SubagentRuns) start(ctx context.Context, run *SubagentRun) error { return nil } -// load reads the names of work.json. A missing file names none. -func (r *SubagentRuns) load() ([]string, error) { - data, err := os.ReadFile(r.workPath()) - if errors.Is(err, os.ErrNotExist) { - return nil, nil - } - - if err != nil { - return nil, fmt.Errorf("read running subagents: %w", err) - } - - var file SubagentWorkFile - - err = json.Unmarshal(data, &file) - if err != nil { - return nil, fmt.Errorf("decode running subagents: %w", err) - } - - return file.Running, nil -} - -// save writes the names of the running subagents to work.json. The caller -// holds the mutex. +// save writes the names of the running subagents to work.json. The caller holds +// the mutex. func (r *SubagentRuns) save() error { file := SubagentWorkFile{ Running: append([]string{}, slices.Sorted(maps.Keys(r.running))...), @@ -438,10 +253,6 @@ func (r *SubagentRuns) save() error { return nil } -func (r *SubagentRuns) workPath() string { - return filepath.Join(r.agent.dir, subagentWorkFileName) -} - // run runs the chains of run and reports and logs its end with the length of // the run, unless Close ended it. A chain follows while messages wait after the // final answer of the chain before it, and no chain failed. A chain that Stop @@ -515,16 +326,20 @@ func (r *SubagentRuns) run(ctx context.Context, run *SubagentRun) { r.report(run.subagent.name, subagentReport(run.subagent.name, replies), status) } +func (r *SubagentRuns) workPath() string { + return filepath.Join(r.agent.dir, subagentWorkFileName) +} + // chain runs one request chain of run and returns its final answer. func (r *SubagentRuns) chain(ctx context.Context, run *SubagentRun) (string, error) { instructions, err := r.agent.SubagentPrompt() if err != nil { - return "", err + return "", fmt.Errorf("read worker instructions: %w", err) } log, err := run.subagent.Show() if err != nil { - return "", err + return "", fmt.Errorf("read worker log: %w", err) } input := make([]any, 0, len(run.view)+2) @@ -555,11 +370,16 @@ func (r *SubagentRuns) chain(ctx context.Context, run *SubagentRun) (string, err }, } - return chain.Run(ctx, input) + text, err := chain.Run(ctx, input) + if err != nil { + return text, fmt.Errorf("run worker chain: %w", err) + } + + return text, nil } -// take returns the messages of Tell that wait for a request of run, and -// removes them. +// take returns the messages of Tell that wait for a request of run, and removes +// them. func (r *SubagentRuns) take(run *SubagentRun) []Message { r.mutex.Lock() defer r.mutex.Unlock() @@ -570,6 +390,205 @@ func (r *SubagentRuns) take(run *SubagentRun) []Message { return messages } +// Stop ends the run of the subagent name and tells if it ran. The chat gets the +// note "Stopped by the user: NAME." under the mutex, so the note comes before +// the report of the run. +func (r *SubagentRuns) Stop(name string) (bool, error) { + r.mutex.Lock() + defer r.mutex.Unlock() + + run, found := r.running[name] + if !found { + return false, nil + } + + err := r.note("Stopped by the user: " + name + ".") + if err != nil { + return true, err + } + + run.stopped = true + run.cancel() + + return true, nil +} + +// Resume goes on with the runs that a stop of the daemon cut, as work.json +// names them. The chat gets the note "The daemon restarted, cutting NAMES; +// nothing was lost: go on.", and each cut subagent gets the same text as a +// message of Tell. A subagent that cannot go on gets a failed report. +func (r *SubagentRuns) Resume(ctx context.Context) error { + names, err := r.load() + if err != nil || len(names) == 0 { + if err != nil { + return fmt.Errorf("load interrupted workers: %w", err) + } + + return nil + } + + text := "The daemon restarted, cutting " + strings.Join(names, ", ") + "; nothing was lost: go on." + err = r.note(text) + if err != nil { + return fmt.Errorf("record interrupted workers: %w", err) + } + + for _, name := range names { + _, err = r.Tell(ctx, name, text) + if err != nil { + r.logger.Error("subagent lost at restart", "name", name, "err", err) + r.report(name, subagentReport(name, []string{"failed: " + err.Error()}), subagentFailed) + } + } + + // A subagent that cannot go on does not run, so work.json no longer + // names it, and the next start does not try it again. + r.mutex.Lock() + defer r.mutex.Unlock() + + err = r.save() + if err != nil { + return fmt.Errorf("save resumed workers: %w", err) + } + + return nil +} + +// load reads the names of work.json. A missing file names none. +func (r *SubagentRuns) load() ([]string, error) { + data, err := os.ReadFile(r.workPath()) + if errors.Is(err, os.ErrNotExist) { + return nil, nil + } + + if err != nil { + return nil, fmt.Errorf("read running subagents: %w", err) + } + + var file SubagentWorkFile + + err = json.Unmarshal(data, &file) + if err != nil { + return nil, fmt.Errorf("decode running subagents: %w", err) + } + + return file.Running, nil +} + +// Tell sends message to the subagent name. A running subagent reads it between +// its tool calls, and its report answers it. A finished subagent goes on from +// its log with a new run, with the view of now and the effort of its note. +func (r *SubagentRuns) Tell(ctx context.Context, name, message string) (string, error) { + r.mutex.Lock() + + run, found := r.running[name] + if found { + defer r.mutex.Unlock() + + told, err := run.subagent.Append("user", message) + if err != nil { + return "", fmt.Errorf("append running worker message: %w", err) + } + + run.pending = append(run.pending, told) + + return "Sent. " + name + " reads it between its tool calls, and its report answers it.", nil + } + + closed := r.closed + r.mutex.Unlock() + + if closed { + return "", errSubagentClosed + } + + subagent, err := r.subagents.Get(ctx, name) + if err != nil { + return "", fmt.Errorf("open worker log: %w", err) + } + + effort, err := r.effort(subagent) + if err != nil { + return "", fmt.Errorf("read worker effort: %w", err) + } + + err = r.memory.Settle(ctx) + if err != nil { + return "", fmt.Errorf("wait for the summaries: %w", err) + } + + view, err := r.layout.Split(r.memory.ViewLines(nil)) + if err != nil { + return "", fmt.Errorf("split worker view: %w", err) + } + + _, err = subagent.Append("user", message) + if err == nil { + err = subagent.Flush(ctx) + } + + if err != nil { + return "", fmt.Errorf("save worker message: %w", err) + } + + err = r.start(ctx, &SubagentRun{ + subagent: subagent, + view: view, + effort: effort, + }) + if err != nil { + return "", fmt.Errorf("start told worker: %w", err) + } + + return "Sent. " + name + "'s reply will reach you as a message.", nil +} + +// effort returns the effort of subagent from the note at the start of its log: +// the effort of the agent, or the effort that the note names. +func (r *SubagentRuns) effort(subagent *Subagent) (string, error) { + note, err := subagent.First() + if err != nil { + return "", fmt.Errorf("read worker note: %w", err) + } + + effort, own := strings.CutPrefix(note.Text, subagentNote+subagentNoteEffort) + switch { + case note.Kind != "note": + case own: + return effort, nil + case note.Text == subagentNote: + return r.agent.config.Effort, nil + } + + return "", fmt.Errorf("the log of %s does not start with a subagent note", subagent.name) +} + +// Snapshot locks the run state, memory, and subagent logs while snapshot reads +// the agent files. The lock order agrees with Stop, which logs under the run +// lock. +func (r *SubagentRuns) Snapshot(ctx context.Context, snapshot func() error) error { + r.mutex.Lock() + defer r.mutex.Unlock() + + return r.memory.Snapshot(ctx, func() error { + return r.subagents.Snapshot(ctx, snapshot) + }) +} + +// Close ends every run and waits for them. No subagent starts after Close. +func (r *SubagentRuns) Close() { + r.mutex.Lock() + + r.closed = true + for _, run := range r.running { + run.cancel() + } + + r.mutex.Unlock() + + r.workers.Wait() +} + // subagentReport returns the report of the subagent name with its replies: the // name in brackets, a new line, the replies, and the zoom that gives its whole // chat.