X-Git-Url: https://git.giacomolli.uk/onechat/blobdiff_plain/4b9b22619008f0829b7f5a8685e7b1d2a9aeb6bb..add3cf6416e33c24331fd1e90e99284f44d2aae2:/compactor.go?ds=inline diff --git a/compactor.go b/compactor.go index 11497b8..2b23901 100644 --- a/compactor.go +++ b/compactor.go @@ -4,80 +4,92 @@ import ( "context" "errors" "fmt" - "slices" "strings" "unicode/utf8" ) -const ( - // compactionTries is the most calls for one node. - compactionTries = 5 +// compactorTries is the most calls for one node. +const compactorTries = 5 - // viewBlock is the number of view lines in one input part. - viewBlock = 4 -) +// compactorRuler shows the model the size limit of a line. Models cannot count +// bytes, and a sample line as the ruler gets its content copied. +var compactorRuler = strings.Repeat("-", nodeBytes) -// ruler shows the model the size limit of a line. Models cannot count bytes, -// and a sample line as the ruler gets its content copied. -var ruler = strings.Repeat("-", nodeBytes) +// newCompactor returns the compactor of an agent, which sends its calls through +// client with model. instructions gives the system prompt of the agent at each +// build. tools are the tools of that agent, so a build sends the same prompt +// and tools as its turns. +func newCompactor(client *ModelClient, instructions func() (string, error), model ModelConfig, tools []ModelTool, images *ImageStore) *Compactor { + return &Compactor{ + client: client, + model: model, + instructions: instructions, + tools: tools, + images: images, + } +} // Compactor builds the nodes of one agent with a model. A compaction is a call // like a turn, with the same system prompt and tools, so it reads them from the // prompt cache of the turns. The tools are never called. After them comes one -// user message with the compaction view up to the node and the task, in the -// parts that compactionParts gives. Only the last part holds the end of the -// view, so compactions whose views end at different lines begin with the same -// parts up to their last shared block. +// user message with the compaction view up to the node, its closing tag, a +// newline, and the task. // -// When the line is over nodeBytes, the next try sends the same view and task, -// plus a note with the size of the newest line and its cut at the limit. A try -// never sends the model's earlier reply or reasoning back, so every try has the -// same cached prefix and about the same size. After at most compactionTries -// tries, the shortest line is the node. A few bytes over the limit is fine, -// because the view measures the real sizes. A call that fails before any line -// fails the build, and the core tries it again at the next message. +// When the line is over nodeBytes, the next try sends the same message, plus +// one more user message with a note with the size of the newest line and its +// cut at the limit. Only the first call of an image leaf sends its pixels. A +// try never sends the model's earlier reply or reasoning back, so every try +// begins with the same view and task and has about the same size. After at most +// compactorTries tries, the shortest line is the node. A few bytes over the +// limit is fine, because the view measures the real sizes. A call that fails +// before any line fails the build, and the core tries it again at the next +// message. type Compactor struct { - client *Client + client *ModelClient model ModelConfig - instructions string - tools []Tool -} - -// newCompactor returns the compactor of the agent name, which sends its calls -// through client with model. -func newCompactor(client *Client, name string, model ModelConfig) *Compactor { - return &Compactor{ - client: client, - model: model, - instructions: prompt(name), - tools: agentTools(), - } + instructions func() (string, error) + tools []ModelTool + images *ImageStore } // Summarize returns the line of the node of task. func (c *Compactor) Summarize(ctx context.Context, task Task) (string, error) { - text, err := compactionTask(task) + text, err := compactorTask(task) if err != nil { return "", err } - first := compactionParts(task.Context, text) + instructions, err := c.instructions() + if err != nil { + return "", err + } + + source := task.Context + "\n" + text + parts, err := imageParts(c.images, source, task.Images) + if err != nil { + return "", fmt.Errorf("read compaction images: %w", err) + } + + first := []any{modelUserParts(parts)} + var lines []string + note := "" - for len(lines) < compactionTries { - parts := first + for len(lines) < compactorTries { + input := first if note != "" { - parts = append(slices.Clip(first), note) + input = []any{modelUserMessage(source), modelUserMessage(note)} } - var response Response - response, err = c.client.Create(ctx, Request{ + var response ModelResponse + + response, err = c.client.Create(ctx, ModelRequest{ Model: c.model.Model, Effort: c.model.Effort, - Instructions: c.instructions, + Instructions: instructions, Tools: c.tools, - Input: []any{userMessage(parts...)}, - Node: &nodeKey{task.Level, task.Index}, + Input: input, + Node: &NodeKey{task.Level, task.Index}, }) if err != nil { break @@ -94,41 +106,30 @@ func (c *Compactor) Summarize(ctx context.Context, task Task) (string, error) { break } - note = tooLong(line) + note = compactorTooLong(line) } if len(lines) == 0 { - return "", fmt.Errorf("compact node (%d, %d): %w", task.Level, task.Index, err) - } - - return shortest(lines), nil -} - -// compactionParts returns the input parts of a first try for the compaction -// view context and the task text: the opening tag, one part for each whole -// block of viewBlock lines, and then one part with the rest of the lines, the -// closing tag, a newline, and the task. Joined, the parts are the view, a -// newline, and the task. -func compactionParts(context, task string) []string { - lines := strings.SplitAfter(strings.TrimPrefix(context, "\n"), "\n") - whole := len(lines) - 1 - (len(lines)-1)%viewBlock - parts := []string{"\n"} - for n := 0; n < whole; n += viewBlock { - parts = append(parts, strings.Join(lines[n:n+viewBlock], "")) + return "", err } - return append(parts, strings.Join(lines[whole:], "")+"\n"+task) + return compactorShortest(lines), nil } -// compactionTask returns the task of a build, with its input. -func compactionTask(task Task) (string, error) { +// compactorTask returns the task of a build, with its input. +func compactorTask(task Task) (string, error) { if task.Level == 0 && len(task.Input) == 1 { - return fmt.Sprintf(`Compaction: compress message %d into one line of at most %d bytes + text := fmt.Sprintf(`Compaction: compress message %d into one line of at most %d bytes (about 70 words), the length of this ruler: %s %s -`, task.Index, nodeBytes, ruler, task.Input[0]), nil +`, task.Index, nodeBytes, compactorRuler, task.Input[0]) + if len(task.Images) > 0 { + text += "\nKeep each [image FILE] name and describe its kind, visible text, amounts, names, and context." + } + + return text, nil } if task.Level > 0 && len(task.Input) == 2 { @@ -143,24 +144,36 @@ of them from there too. %s %s -`, first, half, first+half, half, nodeBytes, ruler, first, nodeEnd(task.Level, task.Index)-1, task.Input[0], task.Input[1]), nil +`, first, half, first+half, half, nodeBytes, compactorRuler, first, nodeEnd(task.Level, task.Index)-1, task.Input[0], task.Input[1]), nil } return "", fmt.Errorf("node (%d, %d) has %d inputs", task.Level, task.Index, len(task.Input)) } -// tooLong returns the note for a line over nodeBytes: its size and its first -// nodeBytes bytes, which show the model where the limit cuts it. -func tooLong(line string) string { +// compactorTooLong returns the note for a line over nodeBytes: its size and its +// first nodeBytes bytes, which show the model where the limit cuts it. +func compactorTooLong(line string) string { return fmt.Sprintf(`Too long: your last line for this was %d bytes, over the %d-byte limit. Write the whole line again, cutting just enough of the least valuable items to fit before this cut: -%s| <- LIMIT`, len(line), nodeBytes, cutLine(line)) +%s| <- LIMIT`, len(line), nodeBytes, compactorCutLine(line)) } -// cutLine returns the first nodeBytes bytes of line, without a part of a -// character at the end. -func cutLine(line string) string { +// compactorShortest returns the first of the compactorShortest lines. +func compactorShortest(lines []string) string { + best := lines[0] + for _, line := range lines[1:] { + if len(line) < len(best) { + best = line + } + } + + return best +} + +// compactorCutLine returns the first nodeBytes bytes of line, without a part of +// a character at the end. +func compactorCutLine(line string) string { if len(line) <= nodeBytes { return line } @@ -172,15 +185,3 @@ func cutLine(line string) string { return cut } - -// shortest returns the first of the shortest lines. -func shortest(lines []string) string { - best := lines[0] - for _, line := range lines[1:] { - if len(line) < len(best) { - best = line - } - } - - return best -}