package agent
import (
"bytes"
"context"
"encoding/json"
"errors"
"os"
"path/filepath"
"strings"
"testing"
"github.com/johannSo/codey/internal/llm"
)
func TestCacheBreakpoints(t *testing.T) {
f := newFakeAPI(t, msg("end_turn", textBlock("hi")))
a := newTestAgent(t, f, t.TempDir(), &bytes.Buffer{})
if _, err := a.Run(context.Background(), "hello"); err != nil {
t.Fatalf("Run: %v", err)
}
req := f.requests[0]
if req.System[0].CacheControl == nil {
t.Error("the system prompt should carry a breakpoint: it and the tools never change")
}
last := req.Messages[len(req.Messages)-1]
if last.Content[len(last.Content)-1].CacheControl == nil {
t.Error("the end of the conversation should carry a rolling breakpoint")
}
raw := f.rawRequest(0)
if n := strings.Count(raw, `"cache_control"`); n != 2 {
t.Errorf("%d breakpoints in the body, want 2 (the limit is 4):\n%s", n, raw)
}
}
func TestNoCacheOption(t *testing.T) {
f := newFakeAPI(t, msg("end_turn", textBlock("hi")))
a := newTestAgent(t, f, t.TempDir(), &bytes.Buffer{})
a.opts.NoCache = true
if _, err := a.Run(context.Background(), "hello"); err != nil {
t.Fatalf("Run: %v", err)
}
if strings.Contains(f.rawRequest(0), "cache_control") {
t.Error("NoCache should send no breakpoints")
}
}
// Breakpoints must not mutate the stored history, or every turn would
// accumulate another one and blow past the four-breakpoint limit.
func TestBreakpointsDoNotLeakIntoHistory(t *testing.T) {
f := newFakeAPI(t,
msg("tool_use", toolUseBlock("tu_1", "boom", `{}`)),
msg("tool_use", toolUseBlock("tu_2", "boom", `{}`)),
msg("end_turn", textBlock("done")),
)
a := newTestAgent(t, f, t.TempDir(), &bytes.Buffer{})
if _, err := a.Run(context.Background(), "go"); err != nil {
t.Fatalf("Run: %v", err)
}
for i := range f.requests {
if n := strings.Count(f.rawRequest(i), `"cache_control"`); n != 2 {
t.Errorf("request %d has %d breakpoints, want 2", i, n)
}
}
for _, m := range a.State().History() {
for _, b := range m.Content {
if b.CacheControl != nil {
t.Error("stored history should stay free of breakpoints")
}
}
}
}
// mkHistory turns "uaua" into alternating user/assistant messages, so a test
// can say what shape of conversation it means in one string.
func mkHistory(roles string) []llm.Message {
var out []llm.Message
for _, r := range roles {
role := llm.RoleUser
if r == 'a' {
role = llm.RoleAssistant
}
out = append(out, llm.Message{Role: role, Content: []llm.ContentBlock{llm.TextBlock("x")}})
}
return out
}
func TestCompactionSplitLandsOnAnAssistantMessage(t *testing.T) {
tests := []struct {
name string
roles string
keep int
want int
}{
{name: "too short to compact", roles: "uaua", keep: keepRecentMessages, want: -1},
{name: "cuts at the first assistant past the midpoint", roles: "uauauauauaua", keep: keepRecentMessages, want: 7},
// The tail can end up one message shorter than the target when the
// boundary lands on a user message: correctness beats the constant.
{name: "skips forward past a user message", roles: "uauauauaua", keep: keepRecentMessages, want: 5},
// The smaller keep is what the floor uses: it folds conversations the
// normal split refuses to touch, because at 97% doing nothing is worse
// than keeping a short tail.
{name: "a short history the normal keep declines", roles: "uauaua", keep: keepUrgentMessages, want: 3},
{name: "urgently, four messages can still be cut", roles: "uaua", keep: keepUrgentMessages, want: 3},
{name: "nothing is foldable even urgently", roles: "ua", keep: keepUrgentMessages, want: -1},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
got := compactionSplit(mkHistory(tc.roles), tc.keep)
if got != tc.want {
t.Fatalf("compactionSplit = %d, want %d", got, tc.want)
}
if got >= 0 && mkHistory(tc.roles)[got].Role != llm.RoleAssistant {
t.Error("the kept tail must start with an assistant message, or its tool_results reference nothing")
}
})
}
}
func TestCompactionFoldsHistoryAndKeepsTheTask(t *testing.T) {
// Six tool-calling turns, then a compaction, then the answer.
var script []string
for i := 0; i < 6; i++ {
script = append(script, msgWithTokens("tool_use", 100, toolUseBlock("tu", "boom", `{}`)))
}
script = append(script, msgWithTokens("end_turn", 100, textBlock("all done")))
f := newFakeAPI(t, script...)
var logBuf bytes.Buffer
a := newTestAgent(t, f, t.TempDir(), &logBuf)
a.opts.ContextWindow = 1000 // 70% of 1000, and each fake turn reports 100
a.opts.CompactAt = 0.1
var compacted int
a.Observe = func(ev Event) {
if ev.Kind == EventCompact {
compacted++
}
}
if _, err := a.Run(context.Background(), "fix the failing test in loop.go"); err != nil {
t.Fatalf("Run: %v", err)
}
if compacted == 0 {
t.Fatal("expected a compaction")
}
history := a.State().History()
if history[0].Role != llm.RoleUser {
t.Fatal("history must start with a user message")
}
folded := history[0].Content[0].Text
for _, want := range []string{"[Earlier conversation, compacted]", "fix the failing test in loop.go", "the config loads from X not Y"} {
if !strings.Contains(folded, want) {
t.Errorf("folded message missing %q:\n%s", want, folded)
}
}
if history[1].Role != llm.RoleAssistant {
t.Errorf("message after the summary is %q, want assistant", history[1].Role)
}
if !strings.Contains(logBuf.String(), `"type":"compaction"`) {
t.Error("compaction should be logged; it is a cost and cache event")
}
// The summarization call must not be able to touch the repository.
for i, req := range f.requests {
if len(req.Tools) == 0 && len(req.Messages) > 0 {
if req.MaxTokens != 4096 {
t.Errorf("request %d looks like the compaction call but has max_tokens %d", i, req.MaxTokens)
}
}
}
}
// TestSummarizeCarriesSystemPrefixWhenSet guards the compaction bug: the
// summarization request is built by hand, outside (*Agent).request, so it is
// the one path that can silently omit the OAuth identity block. An omitted
// block does not 401 — it 429s, which the client retries three times before
// giving up, so a long OAuth session would die at the compaction threshold
// looking like a quota problem.
func TestSummarizeCarriesSystemPrefixWhenSet(t *testing.T) {
f := newFakeAPI(t)
a := newTestAgent(t, f, t.TempDir(), &bytes.Buffer{})
a.opts.SystemPrefix = ClaudeCodeIdentity
history := []llm.Message{{Role: llm.RoleUser, Content: []llm.ContentBlock{llm.TextBlock("hello")}}}
if _, err := a.summarize(context.Background(), history); err != nil {
t.Fatalf("summarize: %v", err)
}
if len(f.requests) != 1 {
t.Fatalf("expected 1 request, got %d", len(f.requests))
}
got := f.requests[0].System
if len(got) != 1 || got[0].Text != ClaudeCodeIdentity {
t.Errorf("System = %+v, want a single block with the Claude Code identity", got)
}
}
// TestSummarizeCarriesNoSystemWhenPrefixUnset is the other half: a session
// that never borrowed the Claude Code login must not gain a system block it
// never asked for.
func TestSummarizeCarriesNoSystemWhenPrefixUnset(t *testing.T) {
f := newFakeAPI(t)
a := newTestAgent(t, f, t.TempDir(), &bytes.Buffer{})
history := []llm.Message{{Role: llm.RoleUser, Content: []llm.ContentBlock{llm.TextBlock("hello")}}}
if _, err := a.summarize(context.Background(), history); err != nil {
t.Fatalf("summarize: %v", err)
}
if len(f.requests) != 1 {
t.Fatalf("expected 1 request, got %d", len(f.requests))
}
if got := f.requests[0].System; len(got) != 0 {
t.Errorf("System = %+v, want none when SystemPrefix is unset", got)
}
}
func TestStripTrailingToolUse(t *testing.T) {
msgs := []llm.Message{
{Role: llm.RoleUser, Content: []llm.ContentBlock{llm.TextBlock("go")}},
{Role: llm.RoleAssistant, Content: []llm.ContentBlock{{Type: llm.BlockToolUse, ID: "tu", Name: "x"}}},
}
if got := stripTrailingToolUse(msgs); len(got) != 1 {
t.Errorf("a dangling tool_use must be dropped, got %d messages", len(got))
}
keep := []llm.Message{
{Role: llm.RoleUser, Content: []llm.ContentBlock{llm.TextBlock("go")}},
{Role: llm.RoleAssistant, Content: []llm.ContentBlock{llm.TextBlock("done")}},
}
if got := stripTrailingToolUse(keep); len(got) != 2 {
t.Errorf("a text-only assistant turn should be kept, got %d", len(got))
}
}
func TestSupersedeStaleReads(t *testing.T) {
root := t.TempDir()
path := filepath.Join(root, "a.go")
os.WriteFile(path, []byte("package a\n\nconst X = 1\n"), 0o644)
f := newFakeAPI(t,
msg("tool_use", toolUseBlock("tu_1", "read_file", `{"path":"a.go"}`)),
msg("tool_use", toolUseBlock("tu_2", "read_file", `{"path":"a.go"}`)),
msg("tool_use", toolUseBlock("tu_3", "edit_file", `{"path":"a.go","old_str":"const X = 1","new_str":"const X = 2"}`)),
msg("end_turn", textBlock("done")),
)
var logBuf bytes.Buffer
a := newTestAgent(t, f, root, &logBuf)
if _, err := a.Run(context.Background(), "bump X"); err != nil {
t.Fatalf("Run: %v", err)
}
var superseded, intact int
for _, m := range a.State().History() {
for _, b := range m.Content {
if b.Type != llm.BlockToolResult {
continue
}
switch {
case strings.HasPrefix(b.Content, "[superseded:"):
superseded++
// Match the numbered read format, so the edit's own diff — which
// quotes the old line — is not counted as a surviving read.
case strings.Contains(b.Content, "\tconst X = 1"):
intact++
}
}
}
if superseded != 1 {
t.Errorf("%d results superseded, want 1 (the earlier of two reads)", superseded)
}
if intact != 1 {
t.Errorf("%d intact reads, want 1 (the most recent read stays)", intact)
}
if !strings.Contains(logBuf.String(), `"type":"supersede_reads"`) {
t.Error("superseding should be logged")
}
}
func TestSupersedeLeavesASingleReadAlone(t *testing.T) {
root := t.TempDir()
os.WriteFile(filepath.Join(root, "a.go"), []byte("package a\n\nconst X = 1\n"), 0o644)
f := newFakeAPI(t,
msg("tool_use", toolUseBlock("tu_1", "read_file", `{"path":"a.go"}`)),
msg("tool_use", toolUseBlock("tu_2", "edit_file", `{"path":"a.go","old_str":"const X = 1","new_str":"const X = 2"}`)),
msg("end_turn", textBlock("done")),
)
a := newTestAgent(t, f, root, &bytes.Buffer{})
if _, err := a.Run(context.Background(), "bump X"); err != nil {
t.Fatalf("Run: %v", err)
}
for _, m := range a.State().History() {
for _, b := range m.Content {
if strings.HasPrefix(b.Content, "[superseded:") {
t.Error("the only read of a file is still the current one; it must not be blanked")
}
}
}
}
func TestReadPathParsing(t *testing.T) {
if got := readPath(json.RawMessage(`{"path":"x/y.go","offset":3}`)); got != "x/y.go" {
t.Errorf("readPath = %q", got)
}
if got := readPath(json.RawMessage(`not json`)); got != "" {
t.Errorf("readPath = %q, want empty on malformed input", got)
}
}
// TestCompactionFloor covers the case the 70% rule cannot reach: a history too
// short for the normal split — a handful of enormous tool results — that has
// nevertheless filled the window. Below the floor the normal split declines and
// nothing happens; at the floor the smaller keep folds it anyway.
func TestCompactionFloor(t *testing.T) {
tests := []struct {
name string
inputTokens int
want bool
}{
{name: "past CompactAt but under the floor, the normal split declines", inputTokens: 800, want: false},
{name: "at the floor the smaller keep folds it", inputTokens: 980, want: true},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
f := newFakeAPI(t)
a := newTestAgent(t, f, t.TempDir(), &bytes.Buffer{})
a.opts.ContextWindow = 1000
// Six messages: more than keepUrgentMessages+2, fewer than
// keepRecentMessages+2, so the two keeps disagree about it.
a.state.Replace(mkHistory("uauaua"))
got, err := a.maybeCompact(context.Background(), tc.inputTokens)
if err != nil {
t.Fatalf("maybeCompact: %v", err)
}
if got != tc.want {
t.Fatalf("maybeCompact = %v, want %v", got, tc.want)
}
if !tc.want && len(f.requests) != 0 {
t.Errorf("declining to compact should cost no model call, got %d", len(f.requests))
}
})
}
}
// TestCompactionFloorWarnsWhenNothingIsFoldable is the case where the window is
// nearly full and there is genuinely nothing to fold. Saying so beats letting
// the next request hit the wall and surface as a bare API error.
func TestCompactionFloorWarnsWhenNothingIsFoldable(t *testing.T) {
f := newFakeAPI(t)
a := newTestAgent(t, f, t.TempDir(), &bytes.Buffer{})
a.opts.ContextWindow = 1000
a.state.Replace(mkHistory("ua")) // nothing either keep will cut
var notices []string
a.Observe = func(ev Event) {
if ev.Kind == EventNotice {
notices = append(notices, ev.Text)
}
}
got, err := a.maybeCompact(context.Background(), 980)
if err != nil {
t.Fatalf("maybeCompact: %v", err)
}
if got {
t.Fatal("there was nothing to fold; maybeCompact should report false")
}
if len(notices) != 1 {
t.Fatalf("%d notices, want 1 warning that the window is nearly full", len(notices))
}
if !strings.Contains(notices[0], "97%") {
t.Errorf("the warning should name the threshold it crossed: %q", notices[0])
}
if len(f.requests) != 0 {
t.Errorf("nothing to fold should cost no model call, got %d", len(f.requests))
}
}
// TestCompactionFloorNeverSitsBelowCompactAt: -compact-at above the floor would
// otherwise make every ordinary compaction take the aggressive keep and throw
// away the recent tail the model is still working from.
func TestCompactionFloorNeverSitsBelowCompactAt(t *testing.T) {
f := newFakeAPI(t)
a := newTestAgent(t, f, t.TempDir(), &bytes.Buffer{})
a.opts.ContextWindow = 1000
a.opts.CompactAt = 0.99
a.opts.CompactFloor = 0.5
a.state.Replace(mkHistory("uauaua"))
if got, err := a.maybeCompact(context.Background(), 600); err != nil || got {
t.Fatalf("maybeCompact = %v, %v; 600/1000 is under CompactAt, so nothing should happen", got, err)
}
}
// TestCompactFoldsOnDemand is /compact: no threshold involved, and the recent
// tail is kept exactly as an automatic compaction would keep it.
func TestCompactFoldsOnDemand(t *testing.T) {
f := newFakeAPI(t)
a := newTestAgent(t, f, t.TempDir(), &bytes.Buffer{})
a.state.Replace(mkHistory("uauauauauaua")) // 12 messages
var compacted int
a.Observe = func(ev Event) {
if ev.Kind == EventCompact {
compacted++
}
}
got, err := a.Compact(context.Background())
if err != nil {
t.Fatalf("Compact: %v", err)
}
if !got {
t.Fatal("Compact should report that it folded the conversation")
}
if compacted != 1 {
t.Errorf("%d compaction events, want 1", compacted)
}
history := a.State().History()
if n := len(history); n != 6 {
t.Fatalf("history has %d messages, want 6: the summary plus the kept tail", n)
}
if !strings.Contains(history[0].Content[0].Text, "[Earlier conversation, compacted]") {
t.Errorf("history should open with the folded summary, got %q", history[0].Content[0].Text)
}
if history[1].Role != llm.RoleAssistant {
t.Errorf("the kept tail starts with %q, want assistant", history[1].Role)
}
}
// TestCompactOnDemandDeclinesAShortConversation: /compact on a conversation
// with nothing worth folding should say so rather than spend a model call
// summarizing three messages.
func TestCompactOnDemandDeclinesAShortConversation(t *testing.T) {
f := newFakeAPI(t)
a := newTestAgent(t, f, t.TempDir(), &bytes.Buffer{})
a.state.Replace(mkHistory("uaua"))
got, err := a.Compact(context.Background())
if err != nil {
t.Fatalf("Compact: %v", err)
}
if got {
t.Error("Compact should report false when there is nothing to fold")
}
if len(f.requests) != 0 {
t.Errorf("declining should cost no model call, got %d", len(f.requests))
}
}
// With auto-compaction off Codey must not fold anything on its own, even
// well past the ordinary threshold.
func TestAutoCompactOffNeverFolds(t *testing.T) {
f := newFakeAPI(t)
a := newTestAgent(t, f, t.TempDir(), &bytes.Buffer{})
a.opts.ContextWindow = 1000
a.opts.NoAutoCompact = true
a.state.Replace(mkHistory("uauauauauaua"))
did, err := a.maybeCompact(context.Background(), 900) // 90%: past CompactAt
if err != nil {
t.Fatalf("maybeCompact: %v", err)
}
if did {
t.Error("auto-compaction is off; nothing should have been folded")
}
if len(f.requests) != 0 {
t.Errorf("no model call should have been made, got %d", len(f.requests))
}
if n := a.state.Len(); n != 12 {
t.Errorf("history has %d messages, want the original 12", n)
}
}
// Off, the floor stops the turn instead of folding: sending a request that
// cannot fit only trades a clear message for an opaque API error.
func TestAutoCompactOffStopsAtTheFloor(t *testing.T) {
f := newFakeAPI(t)
a := newTestAgent(t, f, t.TempDir(), &bytes.Buffer{})
a.opts.ContextWindow = 1000
a.opts.NoAutoCompact = true
a.state.Replace(mkHistory("uauauauauaua"))
_, err := a.maybeCompact(context.Background(), 980)
var full *ContextFullError
if !errors.As(err, &full) {
t.Fatalf("maybeCompact error = %v, want a *ContextFullError", err)
}
if full.Used != 980 || full.Window != 1000 {
t.Errorf("error carries %d of %d, want 980 of 1000", full.Used, full.Window)
}
if !strings.Contains(full.Error(), "98%") {
t.Errorf("the message should name how full the window is: %q", full.Error())
}
}
// The prompt must not join the history on a turn that never runs, or compacting
// and retrying would send it twice.
func TestAutoCompactOffRefusesBeforeTheHistoryGrows(t *testing.T) {
f := newFakeAPI(t)
a := newTestAgent(t, f, t.TempDir(), &bytes.Buffer{})
a.opts.ContextWindow = 1000
a.opts.NoAutoCompact = true
a.state.Replace(mkHistory("uaua"))
a.lastInputTokens = 980
_, err := a.Run(context.Background(), "carry on")
var full *ContextFullError
if !errors.As(err, &full) {
t.Fatalf("Run error = %v, want a *ContextFullError", err)
}
if n := a.state.Len(); n != 4 {
t.Errorf("history has %d messages, want the original 4: the refused prompt must not be kept", n)
}
if len(f.requests) != 0 {
t.Errorf("a refused turn should reach the API not at all, got %d requests", len(f.requests))
}
}
// /compact is the way out of a full window, so the setting that stops the
// automatic fold must not disable the manual one too.
func TestCompactWorksWithAutoCompactOff(t *testing.T) {
f := newFakeAPI(t)
a := newTestAgent(t, f, t.TempDir(), &bytes.Buffer{})
a.opts.ContextWindow = 1000
a.opts.NoAutoCompact = true
a.lastInputTokens = 980
a.state.Replace(mkHistory("uauauauauaua"))
did, err := a.Compact(context.Background())
if err != nil {
t.Fatalf("Compact: %v", err)
}
if !did {
t.Error("/compact must still fold when auto-compaction is off")
}
}
// Under the floor with auto-compaction off, an ordinary turn is untouched.
func TestAutoCompactOffLetsAnOrdinaryTurnThrough(t *testing.T) {
f := newFakeAPI(t, msg("end_turn", textBlock("fine")))
a := newTestAgent(t, f, t.TempDir(), &bytes.Buffer{})
a.opts.ContextWindow = 1000
a.opts.NoAutoCompact = true
a.lastInputTokens = 500
if _, err := a.Run(context.Background(), "carry on"); err != nil {
t.Fatalf("Run: %v", err)
}
}
// The dead end found by running it: auto-compaction off, four enormous
// messages, window full. The turn is refused, and if /compact also declined
// there would be nothing left but /clear — so past the floor the manual fold
// takes the same smaller tail the automatic one would have taken.
func TestCompactFoldsAShortHistoryWhenTheWindowIsFull(t *testing.T) {
f := newFakeAPI(t)
a := newTestAgent(t, f, t.TempDir(), &bytes.Buffer{})
a.opts.ContextWindow = 1000
a.opts.NoAutoCompact = true
a.lastInputTokens = 980
a.state.Replace(mkHistory("uaua"))
did, err := a.Compact(context.Background())
if err != nil {
t.Fatalf("Compact: %v", err)
}
if !did {
t.Fatal("/compact must fold when it is the only way out of a full window")
}
history := a.State().History()
if len(history) >= 4 {
t.Errorf("history is still %d messages; nothing was folded away", len(history))
}
if history[len(history)-1].Role != llm.RoleAssistant {
t.Error("the kept tail must still start and end on a valid boundary")
}
}
// Below the floor the same short conversation is left alone: folding three
// messages costs a model call and buys nothing.
func TestCompactStillDeclinesAShortHistoryWithRoomLeft(t *testing.T) {
f := newFakeAPI(t)
a := newTestAgent(t, f, t.TempDir(), &bytes.Buffer{})
a.opts.ContextWindow = 1000
a.lastInputTokens = 100
a.state.Replace(mkHistory("uaua"))
did, err := a.Compact(context.Background())
if err != nil {
t.Fatalf("Compact: %v", err)
}
if did {
t.Error("with the window nearly empty there is nothing worth folding")
}
if len(f.requests) != 0 {
t.Errorf("declining should cost no model call, got %d", len(f.requests))
}
}
// The wedge found by running it: /compact folded the history, but the recorded
// input size still described the conversation as it was before, so the next
// turn was refused on a number that had stopped being true — and no amount of
// compacting could ever clear it.
func TestCompactingUnwedgesAFullWindow(t *testing.T) {
f := newFakeAPI(t, msg("end_turn", textBlock("working again")))
a := newTestAgent(t, f, t.TempDir(), &bytes.Buffer{})
a.opts.ContextWindow = 1000
a.opts.NoAutoCompact = true
a.lastInputTokens = 980
a.state.Replace(mkHistory("uauauauauaua"))
if _, err := a.Run(context.Background(), "refused"); err == nil {
t.Fatal("the turn should be refused while the window is full")
}
if did, err := a.Compact(context.Background()); err != nil || !did {
t.Fatalf("Compact = %v, %v; want it to fold", did, err)
}
if _, err := a.Run(context.Background(), "and now?"); err != nil {
t.Fatalf("the turn after a compaction must go through, got %v", err)
}
}