700 lines
29 KiB
Go
700 lines
29 KiB
Go
package executor
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/router-for-me/CLIProxyAPI/v7/internal/config"
|
|
"github.com/tidwall/gjson"
|
|
)
|
|
|
|
func TestEnsureCacheControl(t *testing.T) {
|
|
// Test case 1: System prompt as string
|
|
t.Run("String System Prompt", func(t *testing.T) {
|
|
input := []byte(`{"model": "claude-3-5-sonnet", "system": "This is a long system prompt", "messages": []}`)
|
|
output := ensureCacheControl(input)
|
|
|
|
res := gjson.GetBytes(output, "system.0.cache_control.type")
|
|
if res.String() != "ephemeral" {
|
|
t.Errorf("cache_control not found in system string. Output: %s", string(output))
|
|
}
|
|
})
|
|
|
|
// Test case 2: System prompt as array
|
|
t.Run("Array System Prompt", func(t *testing.T) {
|
|
input := []byte(`{"model": "claude-3-5-sonnet", "system": [{"type": "text", "text": "Part 1"}, {"type": "text", "text": "Part 2"}], "messages": []}`)
|
|
output := ensureCacheControl(input)
|
|
|
|
// cache_control should only be on the LAST element
|
|
res0 := gjson.GetBytes(output, "system.0.cache_control")
|
|
res1 := gjson.GetBytes(output, "system.1.cache_control.type")
|
|
|
|
if res0.Exists() {
|
|
t.Errorf("cache_control should NOT be on the first element")
|
|
}
|
|
if res1.String() != "ephemeral" {
|
|
t.Errorf("cache_control not found on last system element. Output: %s", string(output))
|
|
}
|
|
})
|
|
|
|
// Test case 3: Native Claude Code does not auto-stamp tools; system still caches.
|
|
t.Run("Tools Not Auto Cached", func(t *testing.T) {
|
|
input := []byte(`{
|
|
"model": "claude-3-5-sonnet",
|
|
"tools": [
|
|
{"name": "tool1", "description": "First tool", "input_schema": {"type": "object"}},
|
|
{"name": "tool2", "description": "Second tool", "input_schema": {"type": "object"}}
|
|
],
|
|
"system": "System prompt",
|
|
"messages": []
|
|
}`)
|
|
output := ensureCacheControl(input)
|
|
|
|
if gjson.GetBytes(output, "tools.0.cache_control").Exists() || gjson.GetBytes(output, "tools.1.cache_control").Exists() {
|
|
t.Errorf("default ensureCacheControl must not stamp tools[*].cache_control: %s", string(output))
|
|
}
|
|
|
|
systemCache := gjson.GetBytes(output, "system.0.cache_control")
|
|
if systemCache.Get("type").String() != "ephemeral" {
|
|
t.Errorf("cache_control not found in system. Output: %s", string(output))
|
|
}
|
|
// The native constructor spreads ttl in only when a ttl is selected, so the
|
|
// default breakpoint carries none. upgradeClaudeCacheControlTTL adds it later
|
|
// for the credentials native uses the 1h pool on.
|
|
if systemCache.Get("ttl").Exists() {
|
|
t.Errorf("default system cache_control must not carry ttl. Output: %s", string(output))
|
|
}
|
|
})
|
|
|
|
// Test case 4: Tools and system are INDEPENDENT breakpoints
|
|
// Per Anthropic docs: Up to 4 breakpoints allowed, tools and system are cached separately
|
|
t.Run("Independent Cache Breakpoints", func(t *testing.T) {
|
|
input := []byte(`{
|
|
"model": "claude-3-5-sonnet",
|
|
"tools": [
|
|
{"name": "tool1", "description": "First tool", "input_schema": {"type": "object"}, "cache_control": {"type": "ephemeral"}}
|
|
],
|
|
"system": [{"type": "text", "text": "System"}],
|
|
"messages": []
|
|
}`)
|
|
output := ensureCacheControl(input)
|
|
|
|
// Tool already has cache_control - should not be changed
|
|
tool0Cache := gjson.GetBytes(output, "tools.0.cache_control.type")
|
|
if tool0Cache.String() != "ephemeral" {
|
|
t.Errorf("existing cache_control was incorrectly removed")
|
|
}
|
|
|
|
// System SHOULD get cache_control because it is an INDEPENDENT breakpoint
|
|
// Tools and system are separate cache levels in the hierarchy
|
|
systemCache := gjson.GetBytes(output, "system.0.cache_control.type")
|
|
if systemCache.String() != "ephemeral" {
|
|
t.Errorf("system should have its own cache_control breakpoint (independent of tools)")
|
|
}
|
|
})
|
|
|
|
// Test case 5: tools without any system prompt. Native always sends a system
|
|
// prompt, so this shape only reaches CPA from OpenAI/Gemini translation where the
|
|
// caller supplied no system message. Without a tools breakpoint the sole marker
|
|
// would sit on the volatile final message and a stateless caller would rewrite
|
|
// the whole tools prefix on every request.
|
|
t.Run("Only Tools No System Falls Back To Tools Breakpoint", func(t *testing.T) {
|
|
input := []byte(`{
|
|
"model": "claude-3-5-sonnet",
|
|
"tools": [
|
|
{"name": "tool1", "description": "Tool", "input_schema": {"type": "object"}},
|
|
{"name": "tool2", "description": "Tool", "input_schema": {"type": "object"}}
|
|
],
|
|
"messages": [{"role": "user", "content": "Hi"}]
|
|
}`)
|
|
output := ensureCacheControl(input)
|
|
|
|
if gjson.GetBytes(output, "tools.0.cache_control").Exists() {
|
|
t.Errorf("only the last tool may host the fallback breakpoint: %s", string(output))
|
|
}
|
|
if got := gjson.GetBytes(output, "tools.1.cache_control.type").String(); got != "ephemeral" {
|
|
t.Errorf("missing tools fallback breakpoint when system is absent: %s", string(output))
|
|
}
|
|
if gjson.GetBytes(output, "tools.1.cache_control.ttl").Exists() {
|
|
t.Errorf("tools fallback breakpoint must not carry a default ttl: %s", string(output))
|
|
}
|
|
if got := gjson.GetBytes(output, "messages.0.content.0.cache_control.type").String(); got != "ephemeral" {
|
|
t.Errorf("rolling message breakpoint should still be present: %s", string(output))
|
|
}
|
|
})
|
|
|
|
t.Run("Empty System Still Falls Back To Tools", func(t *testing.T) {
|
|
for name, system := range map[string]string{
|
|
"empty array": `"system": [],`,
|
|
"empty string": `"system": "",`,
|
|
"blank string": `"system": " ",`,
|
|
} {
|
|
t.Run(name, func(t *testing.T) {
|
|
input := []byte(`{
|
|
"model": "claude-3-5-sonnet",
|
|
` + system + `
|
|
"tools": [{"name": "tool1", "description": "Tool", "input_schema": {"type": "object"}}],
|
|
"messages": [{"role": "user", "content": "Hi"}]
|
|
}`)
|
|
output := ensureCacheControl(input)
|
|
|
|
if got := gjson.GetBytes(output, "tools.0.cache_control.type").String(); got != "ephemeral" {
|
|
t.Errorf("an unusable system prompt must still yield a tools breakpoint: %s", string(output))
|
|
}
|
|
// Empty/blank string system must not be rewritten into a marked text
|
|
// block; that would double-stamp tools + a whitespace system host.
|
|
if bytes.Contains(output, []byte(`"text":""`)) || bytes.Contains(output, []byte(`"text":" "`)) {
|
|
t.Errorf("unusable string system must stay unconverted: %s", string(output))
|
|
}
|
|
if gjson.GetBytes(output, "system.0.cache_control").Exists() {
|
|
t.Errorf("unusable system must not receive its own breakpoint: %s", string(output))
|
|
}
|
|
if countCacheControls(output) != 2 {
|
|
t.Errorf("want tools+message breakpoints only, got %d in %s", countCacheControls(output), string(output))
|
|
}
|
|
})
|
|
}
|
|
})
|
|
|
|
// Test case 6: Many tools (Claude Code scenario) — default skips tools.
|
|
t.Run("Many Tools (Claude Code Scenario)", func(t *testing.T) {
|
|
// Simulate Claude Code with many tools
|
|
toolsJSON := `[`
|
|
for i := 0; i < 50; i++ {
|
|
if i > 0 {
|
|
toolsJSON += ","
|
|
}
|
|
toolsJSON += fmt.Sprintf(`{"name": "tool%d", "description": "Tool %d", "input_schema": {"type": "object"}}`, i, i)
|
|
}
|
|
toolsJSON += `]`
|
|
|
|
input := []byte(fmt.Sprintf(`{
|
|
"model": "claude-3-5-sonnet",
|
|
"tools": %s,
|
|
"system": [{"type": "text", "text": "You are Claude Code"}],
|
|
"messages": [{"role": "user", "content": "Hello"}]
|
|
}`, toolsJSON))
|
|
|
|
output := ensureCacheControl(input)
|
|
|
|
for i := 0; i < 50; i++ {
|
|
path := fmt.Sprintf("tools.%d.cache_control", i)
|
|
if gjson.GetBytes(output, path).Exists() {
|
|
t.Errorf("tool %d should NOT have cache_control under default ensure", i)
|
|
}
|
|
}
|
|
|
|
helperOut := injectToolsCacheControl(input)
|
|
if got := gjson.GetBytes(helperOut, "tools.49.cache_control.type").String(); got != "ephemeral" {
|
|
t.Errorf("injectToolsCacheControl should still mark last tool")
|
|
}
|
|
|
|
if got := gjson.GetBytes(output, "system.0.cache_control.type").String(); got != "ephemeral" {
|
|
t.Errorf("system should have cache_control, got %q", got)
|
|
}
|
|
if got := gjson.GetBytes(output, "messages.0.content.0.cache_control.type").String(); got != "ephemeral" {
|
|
t.Errorf("latest user should have cache_control, got %q", got)
|
|
}
|
|
})
|
|
|
|
// Test case 7: Empty tools array
|
|
t.Run("Empty Tools Array", func(t *testing.T) {
|
|
input := []byte(`{"model": "claude-3-5-sonnet", "tools": [], "system": "Test", "messages": []}`)
|
|
output := ensureCacheControl(input)
|
|
|
|
// System should still get cache_control
|
|
systemCache := gjson.GetBytes(output, "system.0.cache_control.type")
|
|
if systemCache.String() != "ephemeral" {
|
|
t.Errorf("system should have cache_control even with empty tools array")
|
|
}
|
|
})
|
|
|
|
// Test case 8: Messages caching follows native Claude Code (latest user turn).
|
|
t.Run("Messages Caching Latest User", func(t *testing.T) {
|
|
input := []byte(`{
|
|
"model": "claude-3-5-sonnet",
|
|
"messages": [
|
|
{"role": "user", "content": "First user"},
|
|
{"role": "assistant", "content": "Assistant reply"},
|
|
{"role": "user", "content": "Second user"},
|
|
{"role": "assistant", "content": "Assistant reply 2"},
|
|
{"role": "user", "content": "Third user"}
|
|
]
|
|
}`)
|
|
output := ensureCacheControl(input)
|
|
|
|
if got := gjson.GetBytes(output, "messages.4.content.0.cache_control.type").String(); got != "ephemeral" {
|
|
t.Errorf("cache_control.type on latest user = %q, want ephemeral. Output: %s", got, string(output))
|
|
}
|
|
if gjson.GetBytes(output, "messages.4.content.0.cache_control.ttl").Exists() {
|
|
t.Errorf("default rolling marker must not carry ttl. Output: %s", string(output))
|
|
}
|
|
if gjson.GetBytes(output, "messages.2.content.0.cache_control").Exists() {
|
|
t.Errorf("second-to-last user turn should NOT have cache_control; native Claude Code rolls onto the latest user")
|
|
}
|
|
})
|
|
|
|
// The native final-system special case is narrow: it requires non-empty STRING
|
|
// content and replaces it with a single freshly marked text block.
|
|
t.Run("Messages Caching Trailing System String", func(t *testing.T) {
|
|
input := []byte(`{
|
|
"model": "claude-3-5-sonnet",
|
|
"messages": [
|
|
{"role": "user", "content": "User"},
|
|
{"role": "assistant", "content": "Assistant"},
|
|
{"role": "system", "content": "Internal system"}
|
|
]
|
|
}`)
|
|
output := ensureCacheControl(input)
|
|
|
|
systemContent := gjson.GetBytes(output, "messages.2.content")
|
|
if !systemContent.IsArray() || len(systemContent.Array()) != 1 {
|
|
t.Fatalf("trailing string system was not replaced by a single text block: %s", output)
|
|
}
|
|
if got := systemContent.Get("0.text").String(); got != "Internal system" {
|
|
t.Fatalf("trailing system text = %q, want the original string: %s", got, output)
|
|
}
|
|
if got := systemContent.Get("0.cache_control.type").String(); got != "ephemeral" {
|
|
t.Fatalf("trailing string system did not take the native special case: %s", output)
|
|
}
|
|
if gjson.GetBytes(output, "messages.1.content.0.cache_control").Exists() {
|
|
t.Fatalf("preceding assistant must not also receive the rolling marker: %s", output)
|
|
}
|
|
})
|
|
|
|
// An array-content trailing system turn is NOT the native special case: native
|
|
// requires string content there, so the marker falls back to the last eligible
|
|
// user/assistant turn instead.
|
|
t.Run("Messages Caching Trailing System Array Falls Back", func(t *testing.T) {
|
|
input := []byte(`{
|
|
"model": "claude-3-5-sonnet",
|
|
"messages": [
|
|
{"role": "user", "content": "User"},
|
|
{"role": "assistant", "content": "Assistant"},
|
|
{"role": "system", "content": [{"type": "text", "text": "Internal 1"}, {"type": "text", "text": "Internal 2"}]}
|
|
]
|
|
}`)
|
|
output := ensureCacheControl(input)
|
|
|
|
if gjson.GetBytes(output, "messages.2.content.1.cache_control").Exists() {
|
|
t.Fatalf("array-content trailing system must not be marked; native requires string content: %s", output)
|
|
}
|
|
if got := gjson.GetBytes(output, "messages.1.content.0.cache_control.type").String(); got != "ephemeral" {
|
|
t.Fatalf("marker should fall back to the last eligible assistant turn: %s", output)
|
|
}
|
|
})
|
|
|
|
t.Run("Messages Caching Trailing Assistant Text", func(t *testing.T) {
|
|
input := []byte(`{
|
|
"messages": [
|
|
{"role": "user", "content": "User"},
|
|
{"role": "assistant", "content": "Assistant prefill"}
|
|
]
|
|
}`)
|
|
output := ensureCacheControl(input)
|
|
|
|
if got := gjson.GetBytes(output, "messages.1.content.0.cache_control.type").String(); got != "ephemeral" {
|
|
t.Fatalf("trailing assistant cache_control.type = %q, want ephemeral. Output: %s", got, output)
|
|
}
|
|
wantAssistant := []byte(`[{"type":"text","text":"Assistant prefill","cache_control":{"type":"ephemeral"}}]`)
|
|
if !bytes.Contains(output, wantAssistant) {
|
|
t.Fatalf("assistant string promotion does not match native order: %s", output)
|
|
}
|
|
if gjson.GetBytes(output, "messages.0.content.0.cache_control").Exists() {
|
|
t.Fatalf("preceding user must not receive an assistant rolling marker: %s", output)
|
|
}
|
|
})
|
|
|
|
t.Run("Messages Skip Trailing Assistant Thinking", func(t *testing.T) {
|
|
input := []byte(`{
|
|
"messages": [
|
|
{"role": "user", "content": "User"},
|
|
{"role": "system", "content": "Internal system"},
|
|
{"role": "assistant", "content": [
|
|
{"type": "text", "text": "Assistant"},
|
|
{"type": "thinking", "thinking": "Internal"}
|
|
]}
|
|
]
|
|
}`)
|
|
output := ensureCacheControl(input)
|
|
|
|
if got := gjson.GetBytes(output, "messages.0.content.0.cache_control.type").String(); got != "ephemeral" {
|
|
t.Fatalf("preceding user cache_control.type = %q, want fallback ephemeral. Output: %s", got, output)
|
|
}
|
|
if got := gjson.GetBytes(output, "messages.1.content"); got.Type != gjson.String {
|
|
t.Fatalf("internal system message was rewritten instead of skipped: %s", output)
|
|
}
|
|
if gjson.GetBytes(output, "messages.2.content.1.cache_control").Exists() {
|
|
t.Fatalf("assistant thinking block must not receive cache_control: %s", output)
|
|
}
|
|
})
|
|
|
|
// Test case 9: Cloaking first-user marker must not suppress latest-user rolling write.
|
|
t.Run("Messages Inject Despite Cloaking First User Marker", func(t *testing.T) {
|
|
input := []byte(`{
|
|
"model": "claude-3-5-sonnet",
|
|
"tools": [{"name": "Read", "description": "read", "input_schema": {"type": "object"}}],
|
|
"system": "You are helpful.",
|
|
"messages": [
|
|
{"role": "user", "content": [{"type": "text", "text": "currentDate"}, {"type": "text", "text": "First user", "cache_control": {"type": "ephemeral"}}]},
|
|
{"role": "assistant", "content": [{"type": "text", "text": "Assistant reply"}]},
|
|
{"role": "user", "content": [{"type": "text", "text": "Second user"}]},
|
|
{"role": "assistant", "content": [{"type": "text", "text": "Assistant reply 2"}]},
|
|
{"role": "user", "content": [{"type": "text", "text": "Third user"}]}
|
|
]
|
|
}`)
|
|
output := ensureCacheControl(input)
|
|
|
|
if got := gjson.GetBytes(output, "messages.0.content.1.cache_control.type").String(); got != "ephemeral" {
|
|
t.Errorf("cloaking first-user marker lost: %s", string(output))
|
|
}
|
|
if got := gjson.GetBytes(output, "messages.4.content.0.cache_control.type").String(); got != "ephemeral" {
|
|
t.Errorf("latest user missing rolling cache_control after cloaking marker. Output: %s", string(output))
|
|
}
|
|
if gjson.GetBytes(output, "tools.0.cache_control").Exists() {
|
|
t.Errorf("a payload with a system prompt must not stamp tools[*].cache_control: %s", string(output))
|
|
}
|
|
if got := gjson.GetBytes(output, "system.0.cache_control.type").String(); got != "ephemeral" {
|
|
t.Errorf("system should still receive independent cache_control. Output: %s", string(output))
|
|
}
|
|
})
|
|
|
|
// Test case 10: Existing marker on the latest user turn is preserved / not duplicated.
|
|
t.Run("Messages Skip When Latest User Already Has Cache Control", func(t *testing.T) {
|
|
input := []byte(`{
|
|
"model": "claude-3-5-sonnet",
|
|
"messages": [
|
|
{"role": "user", "content": [{"type": "text", "text": "First user"}]},
|
|
{"role": "assistant", "content": [{"type": "text", "text": "Assistant reply"}]},
|
|
{"role": "user", "content": [{"type": "text", "text": "Second user", "cache_control": {"type": "ephemeral", "ttl": "1h"}}]}
|
|
]
|
|
}`)
|
|
output := ensureCacheControl(input)
|
|
|
|
if got := gjson.GetBytes(output, "messages.2.content.0.cache_control.ttl").String(); got != "1h" {
|
|
t.Errorf("existing latest-user cache_control.ttl = %q, want 1h. Output: %s", got, string(output))
|
|
}
|
|
if gjson.GetBytes(output, "messages.0.content.0.cache_control").Exists() {
|
|
t.Errorf("should not invent an extra message breakpoint on the first user when latest already has one")
|
|
}
|
|
})
|
|
|
|
// Test case 11: Generated cache controls preserve native JSON property order.
|
|
t.Run("Native Cache Control Wire Order", func(t *testing.T) {
|
|
input := []byte(`{
|
|
"system": [{"type": "text", "text": "System"}],
|
|
"messages": [{"role": "user", "content": [{"type": "text", "text": "User"}]}]
|
|
}`)
|
|
output := ensureCacheControl(input)
|
|
want := []byte(`"cache_control":{"type":"ephemeral"}`)
|
|
if got := bytes.Count(output, want); got != 2 {
|
|
t.Fatalf("native cache_control wire shape count = %d, want 2. Output: %s", got, output)
|
|
}
|
|
|
|
upgraded := upgradeClaudeCacheControlTTL(output, claudeCacheControlTTL1h)
|
|
wantUpgraded := []byte(`"cache_control":{"type":"ephemeral","ttl":"1h"}`)
|
|
if got := bytes.Count(upgraded, wantUpgraded); got != 2 {
|
|
t.Fatalf("upgraded cache_control wire shape count = %d, want 2. Output: %s", got, upgraded)
|
|
}
|
|
if bytes.Contains(upgraded, []byte(`"cache_control":{"ttl":"1h","type":"ephemeral"}`)) {
|
|
t.Fatalf("cache_control keys emitted in non-native order: %s", upgraded)
|
|
}
|
|
})
|
|
|
|
t.Run("String Promotion Native Parent Order", func(t *testing.T) {
|
|
input := []byte(`{"system":"System <tag> &","messages":[{"role":"user","content":"User <tag> &"}]}`)
|
|
output := ensureCacheControl(input)
|
|
wantSystem := []byte(`"system":[{"type":"text","text":"System <tag> &","cache_control":{"type":"ephemeral"}}]`)
|
|
wantMessage := []byte(`"content":[{"type":"text","text":"User <tag> &","cache_control":{"type":"ephemeral"}}]`)
|
|
if !bytes.Contains(output, wantSystem) || !bytes.Contains(output, wantMessage) {
|
|
t.Fatalf("string promotion does not match native parent/key escaping order: %s", output)
|
|
}
|
|
if bytes.Contains(output, []byte(`\u003c`)) || bytes.Contains(output, []byte(`\u003e`)) || bytes.Contains(output, []byte(`\u0026`)) {
|
|
t.Fatalf("string promotion introduced HTML escaping: %s", output)
|
|
}
|
|
})
|
|
|
|
t.Run("Existing Global Scope Preserved", func(t *testing.T) {
|
|
input := []byte(`{"system":[{"type":"text","text":"Global","cache_control":{"type":"ephemeral","ttl":"1h","scope":"global"}}],"messages":[{"role":"user","content":"User"}]}`)
|
|
output := ensureCacheControl(input)
|
|
want := []byte(`"cache_control":{"type":"ephemeral","ttl":"1h","scope":"global"}`)
|
|
if !bytes.Contains(output, want) {
|
|
t.Fatalf("existing native global scope marker changed: %s", output)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestShouldEnsureCacheControl(t *testing.T) {
|
|
markerless := []byte(`{"messages":[{"role":"user","content":"x"}]}`)
|
|
withMarker := []byte(`{"messages":[{"role":"user","content":[{"type":"text","text":"x","cache_control":{"type":"ephemeral"}}]}]}`)
|
|
tests := []struct {
|
|
name string
|
|
payload []byte
|
|
cloaked bool
|
|
confirmedClaudeCode bool
|
|
want bool
|
|
}{
|
|
{name: "confirmed native markerless", payload: markerless, confirmedClaudeCode: true, want: false},
|
|
{name: "confirmed native with marker", payload: withMarker, confirmedClaudeCode: true, want: false},
|
|
{name: "cloaked with marker", payload: withMarker, cloaked: true, want: true},
|
|
{name: "unconfirmed markerless", payload: markerless, want: true},
|
|
{name: "unconfirmed with marker", payload: withMarker, want: false},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
if got := shouldEnsureCacheControl(tt.payload, tt.cloaked, tt.confirmedClaudeCode); got != tt.want {
|
|
t.Fatalf("shouldEnsureCacheControl() = %t, want %t", got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestInjectToolsCacheControlSkipsDeferredTools(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
input string
|
|
wantCacheIndex int
|
|
wantCacheTTL string
|
|
}{
|
|
{
|
|
name: "trailing deferred tool",
|
|
input: `{"tools":[
|
|
{"name":"resident","defer_loading":false},
|
|
{"name":"deferred","defer_loading":true}
|
|
]}`,
|
|
wantCacheIndex: 0,
|
|
},
|
|
{
|
|
name: "multiple trailing deferred tools",
|
|
input: `{"tools":[
|
|
{"name":"resident"},
|
|
{"name":"deferred_1","defer_loading":true},
|
|
{"name":"deferred_2","defer_loading":true}
|
|
]}`,
|
|
wantCacheIndex: 0,
|
|
},
|
|
{
|
|
name: "middle deferred tool",
|
|
input: `{"tools":[
|
|
{"name":"resident_1"},
|
|
{"name":"deferred","defer_loading":true},
|
|
{"name":"resident_2"}
|
|
]}`,
|
|
wantCacheIndex: 2,
|
|
},
|
|
{
|
|
name: "all tools deferred",
|
|
input: `{"tools":[
|
|
{"name":"deferred_1","defer_loading":true},
|
|
{"name":"deferred_2","defer_loading":true}
|
|
]}`,
|
|
wantCacheIndex: -1,
|
|
},
|
|
{
|
|
name: "existing cache control",
|
|
input: `{"tools":[
|
|
{"name":"resident_1","cache_control":{"type":"ephemeral","ttl":"1h"}},
|
|
{"name":"resident_2"}
|
|
]}`,
|
|
wantCacheIndex: 0,
|
|
wantCacheTTL: "1h",
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
output := injectToolsCacheControl([]byte(tt.input))
|
|
tools := gjson.GetBytes(output, "tools").Array()
|
|
cacheCount := 0
|
|
for index, tool := range tools {
|
|
cacheControl := tool.Get("cache_control")
|
|
if cacheControl.Exists() {
|
|
cacheCount++
|
|
if index != tt.wantCacheIndex {
|
|
t.Errorf("cache_control added to tool %d, want tool %d: %s", index, tt.wantCacheIndex, string(output))
|
|
}
|
|
}
|
|
if tool.Get("defer_loading").Bool() && cacheControl.Exists() {
|
|
t.Errorf("deferred tool %d must not have cache_control: %s", index, string(output))
|
|
}
|
|
}
|
|
|
|
wantCacheCount := 1
|
|
if tt.wantCacheIndex < 0 {
|
|
wantCacheCount = 0
|
|
}
|
|
if cacheCount != wantCacheCount {
|
|
t.Errorf("cache_control count = %d, want %d: %s", cacheCount, wantCacheCount, string(output))
|
|
}
|
|
if tt.wantCacheTTL != "" {
|
|
path := fmt.Sprintf("tools.%d.cache_control.ttl", tt.wantCacheIndex)
|
|
if got := gjson.GetBytes(output, path).String(); got != tt.wantCacheTTL {
|
|
t.Errorf("cache_control TTL = %q, want %q: %s", got, tt.wantCacheTTL, string(output))
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestCacheControlOrder verifies the correct order: tools -> system -> messages
|
|
func TestCacheControlOrder(t *testing.T) {
|
|
input := []byte(`{
|
|
"model": "claude-sonnet-4",
|
|
"tools": [
|
|
{"name": "Read", "description": "Read file", "input_schema": {"type": "object", "properties": {"path": {"type": "string"}}}},
|
|
{"name": "Write", "description": "Write file", "input_schema": {"type": "object", "properties": {"path": {"type": "string"}, "content": {"type": "string"}}}}
|
|
],
|
|
"system": [
|
|
{"type": "text", "text": "You are Claude Code, Anthropic's official CLI for Claude."},
|
|
{"type": "text", "text": "Additional instructions here..."}
|
|
],
|
|
"messages": [
|
|
{"role": "user", "content": "Hello"}
|
|
]
|
|
}`)
|
|
|
|
output := ensureCacheControl(input)
|
|
|
|
// Native default path does not stamp tools.
|
|
if gjson.GetBytes(output, "tools.0.cache_control").Exists() || gjson.GetBytes(output, "tools.1.cache_control").Exists() {
|
|
t.Error("default ensureCacheControl must not stamp tools[*].cache_control")
|
|
}
|
|
|
|
// Last system element has the default cache_control, which carries no ttl.
|
|
if gjson.GetBytes(output, "system.1.cache_control.type").String() != "ephemeral" {
|
|
t.Error("last system element should have cache_control")
|
|
}
|
|
if gjson.GetBytes(output, "system.1.cache_control.ttl").Exists() {
|
|
t.Error("default last system element must not carry a ttl")
|
|
}
|
|
if got := gjson.GetBytes(upgradeClaudeCacheControlTTL(output, claudeCacheControlTTL1h), "system.1.cache_control.ttl").String(); got != "1h" {
|
|
t.Errorf("upgraded last system element ttl = %q, want 1h", got)
|
|
}
|
|
|
|
// First system element has NO cache_control
|
|
if gjson.GetBytes(output, "system.0.cache_control").Exists() {
|
|
t.Error("first system element should NOT have cache_control")
|
|
}
|
|
}
|
|
|
|
// The native ttl helper only touches blocks that already carry a cache_control and
|
|
// have no ttl yet. It must never create a breakpoint, because placement is decided
|
|
// by ensureCacheControl before this step runs.
|
|
func TestUpgradeClaudeCacheControlTTL(t *testing.T) {
|
|
t.Run("Upgrades Only Existing Markers", func(t *testing.T) {
|
|
input := []byte(`{` +
|
|
`"tools":[{"name":"t","cache_control":{"type":"ephemeral"}},{"name":"u"}],` +
|
|
`"system":[{"type":"text","text":"s0"},{"type":"text","text":"s1","cache_control":{"type":"ephemeral"}}],` +
|
|
`"messages":[{"role":"user","content":[{"type":"text","text":"a"},{"type":"text","text":"b","cache_control":{"type":"ephemeral"}}]}]}`)
|
|
output := upgradeClaudeCacheControlTTL(input, claudeCacheControlTTL1h)
|
|
|
|
for _, path := range []string{"tools.0", "system.1", "messages.0.content.1"} {
|
|
if got := gjson.GetBytes(output, path+".cache_control.ttl").String(); got != "1h" {
|
|
t.Errorf("%s.cache_control.ttl = %q, want 1h. Output: %s", path, got, output)
|
|
}
|
|
}
|
|
for _, path := range []string{"tools.1", "system.0", "messages.0.content.0"} {
|
|
if gjson.GetBytes(output, path+".cache_control").Exists() {
|
|
t.Errorf("%s must not gain a cache_control: %s", path, output)
|
|
}
|
|
}
|
|
if got := countCacheControls(output); got != 3 {
|
|
t.Errorf("breakpoint count = %d, want the original 3", got)
|
|
}
|
|
})
|
|
|
|
t.Run("Preserves Caller TTL And Is Idempotent", func(t *testing.T) {
|
|
input := []byte(`{"system":[{"type":"text","text":"s","cache_control":{"type":"ephemeral","ttl":"5m"}}]}`)
|
|
output := upgradeClaudeCacheControlTTL(input, claudeCacheControlTTL1h)
|
|
if got := gjson.GetBytes(output, "system.0.cache_control.ttl").String(); got != "5m" {
|
|
t.Errorf("existing ttl = %q, want the caller's 5m to survive", got)
|
|
}
|
|
|
|
once := upgradeClaudeCacheControlTTL([]byte(`{"system":[{"type":"text","text":"s","cache_control":{"type":"ephemeral"}}]}`), claudeCacheControlTTL1h)
|
|
twice := upgradeClaudeCacheControlTTL(once, claudeCacheControlTTL1h)
|
|
if !bytes.Equal(once, twice) {
|
|
t.Errorf("upgrade is not idempotent: %s vs %s", once, twice)
|
|
}
|
|
})
|
|
|
|
t.Run("Keeps Native Key Order With Scope", func(t *testing.T) {
|
|
input := []byte(`{"system":[{"type":"text","text":"s","cache_control":{"type":"ephemeral","scope":"global"}}]}`)
|
|
output := upgradeClaudeCacheControlTTL(input, claudeCacheControlTTL1h)
|
|
want := []byte(`"cache_control":{"type":"ephemeral","ttl":"1h","scope":"global"}`)
|
|
if !bytes.Contains(output, want) {
|
|
t.Errorf("scope-bearing marker lost native {type, ttl, scope} order: %s", output)
|
|
}
|
|
})
|
|
|
|
t.Run("No TTL Is A No-op", func(t *testing.T) {
|
|
input := []byte(`{"system":[{"type":"text","text":"s","cache_control":{"type":"ephemeral"}}]}`)
|
|
if output := upgradeClaudeCacheControlTTL(input, ""); !bytes.Equal(output, input) {
|
|
t.Errorf("empty ttl must be a no-op: %s", output)
|
|
}
|
|
if output := upgradeClaudeCacheControlTTL([]byte(`not json`), claudeCacheControlTTL1h); string(output) != "not json" {
|
|
t.Errorf("invalid payload must be returned untouched: %s", output)
|
|
}
|
|
})
|
|
}
|
|
|
|
// End-to-end guard for #4855. Cloaking stamps the first real user block, and the
|
|
// old global `countCacheControls(body) == 0` gate then skipped every remaining
|
|
// section, freezing the rolling breakpoint on messages[0] for the whole
|
|
// conversation. Section-independent ensure has to keep that breakpoint advancing
|
|
// as the history grows, so a reintroduced global short-circuit fails here.
|
|
func TestClaudeExecutorCloakedRollingCacheBreakpointAdvances(t *testing.T) {
|
|
buildConversation := func(exchanges int) []byte {
|
|
messages := make([]string, 0, exchanges*2)
|
|
for i := 0; i < exchanges; i++ {
|
|
messages = append(messages,
|
|
fmt.Sprintf(`{"role":"user","content":"question number %d"}`, i),
|
|
fmt.Sprintf(`{"role":"assistant","content":"answer number %d"}`, i),
|
|
)
|
|
}
|
|
return []byte(`{"model":"claude-opus-5","max_tokens":100,` +
|
|
`"system":"You are a helpful assistant.",` +
|
|
`"messages":[` + strings.Join(messages, ",") + `]}`)
|
|
}
|
|
|
|
// lastMarkedMessage reports the highest message index carrying a breakpoint.
|
|
lastMarkedMessage := func(body []byte) int {
|
|
last := -1
|
|
gjson.GetBytes(body, "messages").ForEach(func(msgIdx, message gjson.Result) bool {
|
|
message.Get("content").ForEach(func(_, block gjson.Result) bool {
|
|
if block.Get("cache_control").Exists() {
|
|
last = int(msgIdx.Int())
|
|
}
|
|
return true
|
|
})
|
|
return true
|
|
})
|
|
return last
|
|
}
|
|
|
|
cfg := &config.Config{}
|
|
shortBody := executeClaudeContextManagementRequest(t, cfg, buildConversation(2), false)
|
|
longBody := executeClaudeContextManagementRequest(t, cfg, buildConversation(6), false)
|
|
|
|
shortMarked := lastMarkedMessage(shortBody)
|
|
longMarked := lastMarkedMessage(longBody)
|
|
if shortMarked <= 0 {
|
|
t.Fatalf("short conversation kept its only breakpoint at index %d: %s", shortMarked, shortBody)
|
|
}
|
|
if longMarked <= shortMarked {
|
|
t.Fatalf("rolling breakpoint did not advance with history: short=%d long=%d\n%s", shortMarked, longMarked, longBody)
|
|
}
|
|
// The rolling marker must land on the final turn, not an early frozen prefix.
|
|
if want := int(gjson.GetBytes(longBody, "messages.#").Int()) - 1; longMarked != want {
|
|
t.Fatalf("rolling breakpoint at message %d, want final message %d: %s", longMarked, want, longBody)
|
|
}
|
|
// Cloaking's own first-user marker must still be present alongside it.
|
|
if !gjson.GetBytes(longBody, "messages.0.content.1.cache_control").Exists() {
|
|
t.Fatalf("cloak first-user breakpoint lost: %s", longBody)
|
|
}
|
|
if total := countCacheControls(longBody); total > 4 {
|
|
t.Fatalf("cache_control count = %d, want at most 4: %s", total, longBody)
|
|
}
|
|
}
|