package gateway import ( "strings" "testing" ) func TestCompressionConfigForModelReservesPromptAndOutputBudget(t *testing.T) { details := ModelDetails{ContextWindow: 16384, MaxOutputTokens: 2048} cfg, err := CompressionConfigForModel(details, 1024) if err != nil { t.Fatalf("CompressionConfigForModel() error = %v", err) } if got, want := cfg.MaxPromptTokens, 13312; got != want { t.Fatalf("MaxPromptTokens = %d, want %d", got, want) } if got, want := cfg.ContextWindow, 16384; got != want { t.Fatalf("ContextWindow = %d, want %d", got, want) } } func TestCompressionConfigForModelUsesCompatibilityFallbackWithoutMetadata(t *testing.T) { cfg, err := CompressionConfigForModel(ModelDetails{Ref: "provider/model"}, 1024) if err != nil { t.Fatalf("CompressionConfigForModel() error = %v", err) } if cfg.MaxPromptTokens != 126976 { t.Fatalf("MaxPromptTokens = %d, want compatibility budget", cfg.MaxPromptTokens) } } func TestCompressionConfigForModelRejectsOverReservedBudget(t *testing.T) { _, err := CompressionConfigForModel(ModelDetails{Ref: "provider/model", ContextWindow: 4096, MaxOutputTokens: 2048}, 2048) if err == nil { t.Fatal("CompressionConfigForModel() error = nil, want over-reserved-budget error") } } func TestCompressHistoryHonorsPromptBudget(t *testing.T) { cfg := DefaultCompressionConfig() cfg.MaxPromptTokens = 1000 cfg.ProtectFirst = 1 cfg.ProtectLast = 2 msgs := makeMessages(40, 300) view := CompressHistory(msgs, cfg) if !view.WasCompressed { t.Fatal("expected compression") } if view.TokensAfter > cfg.MaxPromptTokens { t.Fatalf("TokensAfter = %d, want <= %d", view.TokensAfter, cfg.MaxPromptTokens) } } func TestCompressHistoryThresholdNotExceeded(t *testing.T) { cfg := DefaultCompressionConfig() cfg.ContextWindow = 1000000 // huge window msgs := makeMessages(100, 500) // ~12,500 estimated tokens view := CompressHistory(msgs, cfg) if view.WasCompressed { t.Error("should not compress below threshold") } if len(view.Messages) != len(msgs) { t.Errorf("expected %d messages, got %d", len(msgs), len(view.Messages)) } } func TestCompressHistoryTruncatesMiddle(t *testing.T) { cfg := DefaultCompressionConfig() cfg.ContextWindow = 10000 // small window forces compression cfg.Threshold = 0.1 cfg.ProtectFirst = 3 cfg.ProtectLast = 5 msgs := makeMessages(50, 200) // ~2,500 estimated tokens view := CompressHistory(msgs, cfg) if !view.WasCompressed { t.Fatal("should have compressed") } if view.TokensAfter >= view.TokensBefore { t.Errorf("tokens after (%d) should be less than before (%d)", view.TokensAfter, view.TokensBefore) } // Structure: first 3 + system summary + last 5 = 9 messages. if len(view.Messages) != 9 { t.Errorf("expected 9 messages (3 + summary + 5), got %d", len(view.Messages)) } // First 3 should be unchanged. for i := range 3 { if view.Messages[i].Content != msgs[i].Content { t.Errorf("first message %d changed", i) } } // Summary marker should be a system message. summary := view.Messages[3] if summary.Role != "system" { t.Errorf("summary role = %q, want system", summary.Role) } if !strings.Contains(summary.Content, "messages removed") { t.Errorf("summary should mention messages removed: %q", summary.Content) } // Last 5 should be the tail. for i := range 5 { got := view.Messages[4+i].Content want := msgs[len(msgs)-5+i].Content if got != want { t.Errorf("tail message %d: got %q, want %q", i, got, want) } } } func TestCompressHistorySmallConversationStillHonorsPromptBudget(t *testing.T) { cfg := DefaultCompressionConfig() cfg.MaxPromptTokens = 100 cfg.ProtectFirst = 3 cfg.ProtectLast = 20 msgs := makeMessages(4, 200) view := CompressHistory(msgs, cfg) if !view.WasCompressed { t.Fatal("expected compression") } if view.TokensAfter > cfg.MaxPromptTokens { t.Fatalf("TokensAfter = %d, want <= %d", view.TokensAfter, cfg.MaxPromptTokens) } } func TestCompressHistorySmallConversation(t *testing.T) { cfg := DefaultCompressionConfig() // Only 15 messages — protect 3+20 requires at least 23, so // this small conversation should not compress. msgs := makeMessages(15, 100) view := CompressHistory(msgs, cfg) if view.WasCompressed { t.Error("small conversation should not compress") } } func TestCompressHistoryDisabled(t *testing.T) { cfg := DefaultCompressionConfig() cfg.Enabled = false cfg.ContextWindow = 100 // tiny window msgs := makeMessages(100, 200) view := CompressHistory(msgs, cfg) if view.WasCompressed { t.Error("disabled compression should not trigger") } } func TestCompressHistoryZeroWindow(t *testing.T) { cfg := DefaultCompressionConfig() cfg.ContextWindow = 0 // disabled msgs := makeMessages(100, 200) view := CompressHistory(msgs, cfg) if view.WasCompressed { t.Error("zero context window should skip compression") } } func TestTokenEstimate(t *testing.T) { tests := []struct { input string want int }{ {"", 0}, {"four", 1}, // 4 chars / 4 = 1 {"hello world", 2}, // 11 chars / 4 = 2 {"12345678", 2}, // 8 chars / 4 = 2 {"你好世界", 4}, // non-ASCII runes reserve one token each {"🙂🙂", 2}, // emoji must not be byte-divided to zero {strings.Repeat("x", 100), 25}, } for _, tt := range tests { got := tokenEstimate(tt.input) if got != tt.want { t.Errorf("tokenEstimate(%q) = %d, want %d", tt.input, got, tt.want) } } } func TestEstimateTotal(t *testing.T) { msgs := []CompressedMessage{ {Role: "user", Content: "hello"}, // 5 → 1 {Role: "assistant", Content: "world!"}, // 6 → 1 } got := estimateTotal(msgs) if got != 2 { t.Errorf("estimateTotal = %d, want 2", got) } } func TestSummariseTruncated(t *testing.T) { cfg := DefaultCompressionConfig() msgs := []CompressedMessage{ {Role: "user", Content: "first message"}, {Role: "assistant", Content: "reply one"}, {Role: "user", Content: "second message"}, {Role: "assistant", Content: "reply two"}, } summary := summariseTruncated(msgs, cfg) if !strings.Contains(summary, "4 messages removed") { t.Errorf("summary should mention count: %q", summary) } if !strings.Contains(summary, "2 user turns") { t.Errorf("summary should mention user turns: %q", summary) } if !strings.Contains(summary, "2 assistant turns") { t.Errorf("summary should mention assistant turns: %q", summary) } } func TestSummariseTruncatedEmpty(t *testing.T) { cfg := DefaultCompressionConfig() summary := summariseTruncated(nil, cfg) if summary != cfg.SummaryMarker { t.Errorf("empty summary = %q, want marker", summary) } } func TestDefaultCompressionConfig(t *testing.T) { cfg := DefaultCompressionConfig() if !cfg.Enabled { t.Error("default should be enabled") } if cfg.Threshold != 0.5 { t.Errorf("Threshold = %v, want 0.5", cfg.Threshold) } if cfg.ContextWindow != 128000 { t.Errorf("ContextWindow = %d, want 128000", cfg.ContextWindow) } if cfg.ProtectFirst != 3 { t.Errorf("ProtectFirst = %d, want 3", cfg.ProtectFirst) } if cfg.ProtectLast != 20 { t.Errorf("ProtectLast = %d, want 20", cfg.ProtectLast) } } func TestCompressHistoryProtectClamp(t *testing.T) { cfg := DefaultCompressionConfig() cfg.ContextWindow = 1000 cfg.Threshold = 0.01 // compress with tiny window cfg.ProtectFirst = 10 cfg.ProtectLast = 10 // Only 15 messages total: protect 10+10=20 would overflow. msgs := makeMessages(15, 200) view := CompressHistory(msgs, cfg) if view.WasCompressed { // If it did compress, first and last should be properly clamped. if len(view.Messages) >= len(msgs) { t.Errorf("compressed %d messages should be fewer than %d", len(view.Messages), len(msgs)) } } } func TestTruncate(t *testing.T) { if got := truncate("hello", 10); got != "hello" { t.Errorf("short string: %q", got) } if got := truncate("hello world this is long", 10); len(got) > 10+3 { t.Errorf("long string too long: %q (%d)", got, len(got)) } } // makeMessages creates n alternating user/assistant messages, each // contentLen characters long. func makeMessages(n, contentLen int) []CompressedMessage { out := make([]CompressedMessage, n) for i := range n { role := "user" if i%2 == 1 { role = "assistant" } out[i] = CompressedMessage{ Role: role, Content: strings.Repeat("x", contentLen) + " msg " + itoa(i), } } return out } func itoa(n int) string { if n == 0 { return "0" } var digits []byte for n > 0 { digits = append([]byte{byte('0' + n%10)}, digits...) n /= 10 } return string(digits) }