X-Git-Url: https://git.giacomolli.uk/onechat/blobdiff_plain/4b9b22619008f0829b7f5a8685e7b1d2a9aeb6bb..59e1537e1969f7c109084497287d729edbedba04:/compactor.go?ds=sidebyside diff --git a/compactor.go b/compactor.go index 11497b8..be17c15 100644 --- a/compactor.go +++ b/compactor.go @@ -9,75 +9,89 @@ import ( "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 -) +// compactorBlock is the number of view lines in one block message. +const compactorBlock = 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, so a build sends the same prompt as the turns of that time. +func newCompactor(client *ModelClient, instructions func() (string, error), model ModelConfig) *Compactor { + return &Compactor{ + client: client, + model: model, + instructions: instructions, + tools: promptTools(), + } +} // 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. +// prompt cache of the turns. The tools are never called. After them come the +// compaction view up to the node and the task, as the user messages that +// compactorTexts gives. Each whole block of compactorBlock view lines is its +// own message, and the last message holds the rest of the lines and the task. +// The backend reads a cache entry only at a message end of a request, so a +// compaction whose view begins with the same lines as an earlier one begins +// with the same block messages. // -// 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 messages, plus +// one more user message with 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 begins with the whole earlier try 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 } // 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 + } + + instructions, err := c.instructions() if err != nil { return "", err } - first := compactionParts(task.Context, text) + var first []any + + for _, message := range compactorTexts(task.Context, text) { + first = append(first, modelUserMessage(message)) + } + 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 = append(slices.Clip(first), 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 +108,25 @@ 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 (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]), nil } if task.Level > 0 && len(task.Input) == 2 { @@ -143,24 +141,57 @@ 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 { +// compactorTexts returns the texts of the user messages of a first try for the +// compaction view and the task text. Each whole block of compactorBlock lines, +// counted from the first line of the view, is one message. The last message +// holds the rest of the lines, the closing tag, a newline, and the task. The +// first message starts with the opening tag. Joined, the texts are the view, a +// newline, and the task. +func compactorTexts(view, task string) []string { + body := strings.TrimSuffix(strings.TrimPrefix(view, "\n"), "") + lines := strings.SplitAfter(body, "\n") + lines = lines[:len(lines)-1] + whole := len(lines) - len(lines)%compactorBlock + + var texts []string + + for n := 0; n < whole; n += compactorBlock { + texts = append(texts, viewMessage(n == 0, lines[n:n+compactorBlock])) + } + + return append(texts, viewMessage(whole == 0, lines[whole:])+"\n"+task) +} + +// 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 +203,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 -}