X-Git-Url: https://git.giacomolli.uk/onechat/blobdiff_plain/1e7f78e7b12d3881a6c345d191dfef6e42d9b01f..b473b56ebf00e6b4d6cf16664f93e1958fbe2080:/tools.go?ds=inline diff --git a/tools.go b/tools.go index af500ba..4c00350 100644 --- a/tools.go +++ b/tools.go @@ -49,11 +49,19 @@ type ToolChat interface { // the log as it happens: the call as a tool message, the result as an echo // message. The call is durable before its tool runs, so the log never misses an // action outside the agent. Commands and files run as the user in the working -// directory, with no sandbox. +// directory, with no sandbox. Zoom with a name reads the log of a subagent. The +// toolbox of the agent has the runs of its subagents for spawn and tell, the +// WhatsApp link for the WhatsApp tools, and the schedules for the schedule +// tools. The toolbox of a subagent has none of them, so these are unknown tools +// there. type Toolbox struct { - log ToolLog - chat ToolChat - workdir string + log ToolLog + chat ToolChat + subagents *Subagents + runs *SubagentRuns + whatsapp *WhatsApp + schedules *Schedules + workdir string } // Call logs the call of the tool name with its JSON arguments, makes the log @@ -63,12 +71,12 @@ type Toolbox struct { func (b *Toolbox) Call(ctx context.Context, name, arguments string) (string, error) { _, err := b.log.Append("tool", toolCallText(name, arguments)) if err != nil { - return "", err + return "", fmt.Errorf("append tool call: %w", err) } err = b.log.Flush(ctx) if err != nil && ctx.Err() == nil { - return "", err + return "", fmt.Errorf("flush tool call: %w", err) } output := "not run: the turn was interrupted" @@ -78,7 +86,7 @@ func (b *Toolbox) Call(ctx context.Context, name, arguments string) (string, err _, err = b.log.Append("echo", output) if err != nil { - return "", err + return "", fmt.Errorf("append tool result: %w", err) } return output, nil @@ -86,45 +94,126 @@ func (b *Toolbox) Call(ctx context.Context, name, arguments string) (string, err // run runs one tool and returns its output, or its error as text. func (b *Toolbox) run(ctx context.Context, name, arguments string) string { - var output string - var err error + var ( + output string + err error + ) + switch name { case "zoom": var args ToolZoomArguments + err = toolDecodeArguments(arguments, &args) - if err == nil { + switch { + case err != nil: + case args.Name != nil: + output, err = b.zoomAgent(ctx, *args.Name) + default: output, err = b.zoom(args.ID, args.N) } case "date": var args ToolDateArguments + err = toolDecodeArguments(arguments, &args) if err == nil { output, err = b.date(args.ID) } case "shell": var args ToolShellArguments + err = toolDecodeArguments(arguments, &args) if err == nil { output = b.shell(ctx, args.Command) } case "read": var args ToolPathArguments + err = toolDecodeArguments(arguments, &args) if err == nil { output, err = b.read(args.Path) } case "write": var args ToolWriteArguments + err = toolDecodeArguments(arguments, &args) if err == nil { output, err = b.write(args.Path, args.Text) } case "edit": var args ToolEditArguments + err = toolDecodeArguments(arguments, &args) if err == nil { output, err = b.edit(args.Path, args.Old, args.New) } + case "spawn": + var args ToolSpawnArguments + + err = toolDecodeArguments(arguments, &args) + switch { + case b.runs == nil: + err = fmt.Errorf("unknown tool %q", name) + case err == nil: + output, err = b.runs.Spawn(ctx, args.Tasks, args.Effort) + } + case "tell": + var args ToolTellArguments + + err = toolDecodeArguments(arguments, &args) + switch { + case b.runs == nil: + err = fmt.Errorf("unknown tool %q", name) + case err == nil: + output, err = b.runs.Tell(ctx, args.Name, args.Message) + } + case "whatsapp_find": + var args ToolWhatsAppFindArguments + + err = toolDecodeArguments(arguments, &args) + switch { + case b.whatsapp == nil: + err = fmt.Errorf("unknown tool %q", name) + case err == nil: + output, err = b.whatsapp.Find(ctx, args.Name) + } + case "whatsapp_send": + var args ToolWhatsAppSendArguments + + err = toolDecodeArguments(arguments, &args) + switch { + case b.whatsapp == nil: + err = fmt.Errorf("unknown tool %q", name) + case err == nil: + output, err = b.whatsapp.Send(ctx, args.ID, args.Chat, args.Text) + } + case "schedule_set": + var args ToolScheduleSetArguments + + err = toolDecodeArguments(arguments, &args) + switch { + case b.schedules == nil: + err = fmt.Errorf("unknown tool %q", name) + case err == nil: + output, err = b.schedules.Set(args.Text, args.At, args.Cron) + } + case "schedule_list": + err = toolDecodeArguments(arguments, &struct{}{}) + switch { + case b.schedules == nil: + err = fmt.Errorf("unknown tool %q", name) + case err == nil: + output = b.schedules.List() + } + case "schedule_remove": + var args ToolScheduleRemoveArguments + + err = toolDecodeArguments(arguments, &args) + switch { + case b.schedules == nil: + err = fmt.Errorf("unknown tool %q", name) + case err == nil: + output, err = b.schedules.Remove(args.ID) + } default: err = fmt.Errorf("unknown tool %q", name) } @@ -136,6 +225,16 @@ func (b *Toolbox) run(ctx context.Context, name, arguments string) string { return output } +// zoomAgent returns the whole log of the subagent name. +func (b *Toolbox) zoomAgent(ctx context.Context, name string) (string, error) { + subagent, err := b.subagents.Get(ctx, name) + if err != nil { + return "", err + } + + return subagent.Show() +} + // zoom returns message id whole for n = 1, or else the two lines under the line // id+n. func (b *Toolbox) zoom(id, n int) (string, error) { @@ -150,18 +249,20 @@ func (b *Toolbox) zoom(id, n int) (string, error) { if n == 1 { message, err := b.chat.Message(id) if err != nil { - return "", err + return "", fmt.Errorf("read zoom message: %w", err) } return leafSource(message), nil } level := bits.TrailingZeros(uint(n)) - 1 + var lines []string + for _, index := range []int{2 * id / n, 2*id/n + 1} { node, built, err := b.chat.Node(level, index) if err != nil { - return "", err + return "", fmt.Errorf("read zoom node: %w", err) } text := viewPending @@ -183,12 +284,12 @@ func (b *Toolbox) date(id int) (string, error) { message, err := b.chat.Message(id) if err != nil { - return "", err + return "", fmt.Errorf("read dated message: %w", err) } date, err := time.Parse(time.RFC3339Nano, message.Date) if err != nil { - return "", err + return "", fmt.Errorf("parse message date: %w", err) } return date.Local().Format("Monday 2006-01-02 15:04:05 -07:00"), nil @@ -214,7 +315,9 @@ func (b *Toolbox) shell(ctx context.Context, command string) string { err := cmd.Run() text := output.String() + var exit *exec.ExitError + switch { case ctx.Err() != nil: text += "\n[interrupted]" @@ -233,7 +336,7 @@ func (b *Toolbox) shell(ctx context.Context, command string) string { func (b *Toolbox) read(path string) (text string, err error) { file, err := os.Open(b.path(path)) if err != nil { - return "", err + return "", fmt.Errorf("open tool file: %w", err) } defer func() { @@ -243,7 +346,7 @@ func (b *Toolbox) read(path string) (text string, err error) { output := &ToolHeadTail{} _, err = io.Copy(output, file) if err != nil { - return "", err + return "", fmt.Errorf("read tool file: %w", err) } return output.String(), nil @@ -255,12 +358,12 @@ func (b *Toolbox) write(path, text string) (string, error) { path = b.path(path) err := os.MkdirAll(filepath.Dir(path), 0o755) if err != nil { - return "", err + return "", fmt.Errorf("create tool file directory: %w", err) } err = os.WriteFile(path, []byte(text), 0o644) if err != nil { - return "", err + return "", fmt.Errorf("write tool file: %w", err) } return fmt.Sprintf("wrote %d bytes to %s", len(text), path), nil @@ -272,7 +375,7 @@ func (b *Toolbox) edit(path, old, replacement string) (string, error) { path = b.path(path) data, err := os.ReadFile(path) if err != nil { - return "", err + return "", fmt.Errorf("read file to edit: %w", err) } if old == "" { @@ -286,12 +389,12 @@ func (b *Toolbox) edit(path, old, replacement string) (string, error) { info, err := os.Stat(path) if err != nil { - return "", err + return "", fmt.Errorf("read file mode: %w", err) } err = os.WriteFile(path, []byte(strings.Replace(string(data), old, replacement, 1)), info.Mode().Perm()) if err != nil { - return "", err + return "", fmt.Errorf("write edited file: %w", err) } return "edited " + path, nil @@ -307,10 +410,12 @@ func (b *Toolbox) path(path string) string { return filepath.Join(b.workdir, path) } -// ToolZoomArguments are the arguments of zoom. +// ToolZoomArguments are the arguments of zoom. A Name that is not nil names +// the subagent whose whole log zoom gives, and then ID and N are not used. type ToolZoomArguments struct { - ID int `json:"id"` - N int `json:"n"` + ID int `json:"id"` + N int `json:"n"` + Name *string `json:"name"` } // ToolDateArguments are the arguments of date. @@ -341,6 +446,44 @@ type ToolEditArguments struct { New string `json:"new"` } +// ToolSpawnArguments are the arguments of spawn. A nil Effort is the effort of +// the agent. +type ToolSpawnArguments struct { + Tasks []string `json:"tasks"` + Effort *string `json:"effort"` +} + +// ToolTellArguments are the arguments of tell. +type ToolTellArguments struct { + Name string `json:"name"` + Message string `json:"message"` +} + +// ToolWhatsAppFindArguments are the arguments of whatsapp_find. +type ToolWhatsAppFindArguments struct { + Name string `json:"name"` +} + +// ToolWhatsAppSendArguments are the arguments of whatsapp_send. +type ToolWhatsAppSendArguments struct { + ID string `json:"id"` + Chat string `json:"chat"` + Text string `json:"text"` +} + +// ToolScheduleSetArguments are the arguments of schedule_set. Exactly one of At +// and Cron is not nil. +type ToolScheduleSetArguments struct { + Text string `json:"text"` + At *string `json:"at"` + Cron *string `json:"cron"` +} + +// ToolScheduleRemoveArguments are the arguments of schedule_remove. +type ToolScheduleRemoveArguments struct { + ID int `json:"id"` +} + // ToolHeadTail keeps the first and the last toolClipBytes bytes written to it, // and counts the bytes between them that it drops. type ToolHeadTail struct { @@ -406,6 +549,7 @@ func toolClip(text string) string { func toolDecodeArguments(arguments string, args any) error { decoder := json.NewDecoder(strings.NewReader(arguments)) decoder.DisallowUnknownFields() + err := decoder.Decode(args) if err != nil { return fmt.Errorf("arguments: %w", err)