X-Git-Url: http://git.giacomolli.uk/onechat/blobdiff_plain/4b9b22619008f0829b7f5a8685e7b1d2a9aeb6bb..33aa709aa4e59e05ada6940a1c055f5e5646a418:/compactor.go?ds=inline diff --git a/compactor.go b/compactor.go index 11497b8..5e73cfa 100644 --- a/compactor.go +++ b/compactor.go @@ -4,80 +4,77 @@ 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, 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. +// user message with the compaction view up to the node 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 +// same cached prefix and 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) + view := task.Context + "\n" + text, err := compactorTask(task) if err != nil { return "", err } - first := compactionParts(task.Context, text) + instructions, err := c.instructions() + if err != nil { + return "", fmt.Errorf("compact node (%d, %d): %w", task.Level, task.Index, err) + } + var lines []string note := "" - for len(lines) < compactionTries { - parts := first + for len(lines) < compactorTries { + parts := []string{view, text} if note != "" { - parts = append(slices.Clip(first), note) + parts = append(parts, 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: []any{modelUserMessage(parts...)}, + Node: &NodeKey{task.Level, task.Index}, }) if err != nil { break @@ -94,41 +91,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 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 +124,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 +165,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 -}