mirror of
https://github.com/router-for-me/CLIProxyAPI.git
synced 2026-02-02 20:40:52 +08:00
test(thinking): remove legacy unit and integration tests
This commit is contained in:
hkfires
@@ -1,144 +0,0 @@
|
|||||||
// Package thinking provides unified thinking configuration processing logic.
|
|
||||||
package thinking
|
|
||||||
|
|
||||||
import (
|
|
||||||
"testing"
|
|
||||||
|
|
||||||
"github.com/router-for-me/CLIProxyAPI/v6/internal/registry"
|
|
||||||
"github.com/tidwall/gjson"
|
|
||||||
)
|
|
||||||
|
|
||||||
// setupTestModels registers test models in the global registry for testing.
|
|
||||||
// This is required because ApplyThinking now looks up models by name.
|
|
||||||
func setupTestModels(t *testing.T) func() {
|
|
||||||
t.Helper()
|
|
||||||
reg := registry.GetGlobalRegistry()
|
|
||||||
|
|
||||||
// Register test models via RegisterClient (the correct API)
|
|
||||||
clientID := "test-thinking-client"
|
|
||||||
testModels := []*registry.ModelInfo{
|
|
||||||
{ID: "test-thinking-model", Thinking: ®istry.ThinkingSupport{Min: 1, Max: 10}},
|
|
||||||
{ID: "test-no-thinking", Type: "gemini"},
|
|
||||||
{ID: "gpt-5.2-test", Thinking: ®istry.ThinkingSupport{Min: 128, Max: 32768, Levels: []string{"low", "medium", "high"}}},
|
|
||||||
}
|
|
||||||
|
|
||||||
reg.RegisterClient(clientID, "test", testModels)
|
|
||||||
|
|
||||||
// Return cleanup function
|
|
||||||
return func() {
|
|
||||||
reg.UnregisterClient(clientID)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestApplyThinkingPassthrough(t *testing.T) {
|
|
||||||
cleanup := setupTestModels(t)
|
|
||||||
defer cleanup()
|
|
||||||
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
body string
|
|
||||||
model string
|
|
||||||
provider string
|
|
||||||
}{
|
|
||||||
{"unknown provider", `{"a":1}`, "test-thinking-model", "unknown"},
|
|
||||||
{"unknown model", `{"a":1}`, "nonexistent-model", "gemini"},
|
|
||||||
{"nil thinking support", `{"a":1}`, "test-no-thinking", "gemini"},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
got, err := ApplyThinking([]byte(tt.body), tt.model, tt.provider)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("ApplyThinking() error = %v", err)
|
|
||||||
}
|
|
||||||
if string(got) != tt.body {
|
|
||||||
t.Fatalf("ApplyThinking() = %s, want %s", string(got), tt.body)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestApplyThinkingValidationError(t *testing.T) {
|
|
||||||
cleanup := setupTestModels(t)
|
|
||||||
defer cleanup()
|
|
||||||
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
body string
|
|
||||||
model string
|
|
||||||
provider string
|
|
||||||
}{
|
|
||||||
{"unsupported level", `{"reasoning_effort":"ultra"}`, "gpt-5.2-test", "openai"},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
got, err := ApplyThinking([]byte(tt.body), tt.model, tt.provider)
|
|
||||||
if err == nil {
|
|
||||||
t.Fatalf("ApplyThinking() error = nil, want error")
|
|
||||||
}
|
|
||||||
// On validation error, ApplyThinking returns original body (defensive programming)
|
|
||||||
if string(got) != tt.body {
|
|
||||||
t.Fatalf("ApplyThinking() body = %s, want original body %s", string(got), tt.body)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestApplyThinkingSuffixPriority(t *testing.T) {
|
|
||||||
cleanup := setupTestModels(t)
|
|
||||||
defer cleanup()
|
|
||||||
|
|
||||||
// Register a model that supports thinking with budget
|
|
||||||
reg := registry.GetGlobalRegistry()
|
|
||||||
suffixClientID := "test-suffix-client"
|
|
||||||
testModels := []*registry.ModelInfo{
|
|
||||||
{
|
|
||||||
ID: "gemini-2.5-pro-suffix-test",
|
|
||||||
Thinking: ®istry.ThinkingSupport{Min: 128, Max: 32768, ZeroAllowed: true},
|
|
||||||
},
|
|
||||||
}
|
|
||||||
reg.RegisterClient(suffixClientID, "gemini", testModels)
|
|
||||||
defer reg.UnregisterClient(suffixClientID)
|
|
||||||
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
body string
|
|
||||||
model string
|
|
||||||
provider string
|
|
||||||
checkPath string
|
|
||||||
expectedValue int
|
|
||||||
}{
|
|
||||||
{
|
|
||||||
"suffix overrides body config",
|
|
||||||
`{"generationConfig":{"thinkingConfig":{"thinkingBudget":1000}}}`,
|
|
||||||
"gemini-2.5-pro-suffix-test(8192)",
|
|
||||||
"gemini",
|
|
||||||
"generationConfig.thinkingConfig.thinkingBudget",
|
|
||||||
8192,
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"suffix none disables thinking",
|
|
||||||
`{"generationConfig":{"thinkingConfig":{"thinkingBudget":1000}}}`,
|
|
||||||
"gemini-2.5-pro-suffix-test(none)",
|
|
||||||
"gemini",
|
|
||||||
"generationConfig.thinkingConfig.thinkingBudget",
|
|
||||||
0,
|
|
||||||
},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
got, err := ApplyThinking([]byte(tt.body), tt.model, tt.provider)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("ApplyThinking() error = %v", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Use gjson to check the value
|
|
||||||
result := int(gjson.GetBytes(got, tt.checkPath).Int())
|
|
||||||
if result != tt.expectedValue {
|
|
||||||
t.Fatalf("ApplyThinking() %s = %v, want %v", tt.checkPath, result, tt.expectedValue)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,501 +0,0 @@
|
|||||||
// Package thinking_test provides external tests for the thinking package.
|
|
||||||
package thinking_test
|
|
||||||
|
|
||||||
import (
|
|
||||||
"testing"
|
|
||||||
|
|
||||||
"github.com/router-for-me/CLIProxyAPI/v6/internal/registry"
|
|
||||||
"github.com/router-for-me/CLIProxyAPI/v6/internal/thinking"
|
|
||||||
"github.com/tidwall/gjson"
|
|
||||||
|
|
||||||
_ "github.com/router-for-me/CLIProxyAPI/v6/internal/thinking/provider/claude"
|
|
||||||
_ "github.com/router-for-me/CLIProxyAPI/v6/internal/thinking/provider/gemini"
|
|
||||||
_ "github.com/router-for-me/CLIProxyAPI/v6/internal/thinking/provider/geminicli"
|
|
||||||
_ "github.com/router-for-me/CLIProxyAPI/v6/internal/thinking/provider/iflow"
|
|
||||||
_ "github.com/router-for-me/CLIProxyAPI/v6/internal/thinking/provider/openai"
|
|
||||||
)
|
|
||||||
|
|
||||||
// registerTestModels sets up test models in the registry and returns a cleanup function.
|
|
||||||
func registerTestModels(t *testing.T) func() {
|
|
||||||
t.Helper()
|
|
||||||
reg := registry.GetGlobalRegistry()
|
|
||||||
|
|
||||||
testModels := []*registry.ModelInfo{
|
|
||||||
geminiBudgetModel(),
|
|
||||||
geminiLevelModel(),
|
|
||||||
claudeBudgetModel(),
|
|
||||||
openAILevelModel(),
|
|
||||||
iFlowModel(),
|
|
||||||
{ID: "claude-3"},
|
|
||||||
{ID: "gemini-2.5-pro-strip"},
|
|
||||||
{ID: "glm-4.6-strip"},
|
|
||||||
}
|
|
||||||
|
|
||||||
clientID := "test-thinking-models"
|
|
||||||
reg.RegisterClient(clientID, "test", testModels)
|
|
||||||
|
|
||||||
return func() {
|
|
||||||
reg.UnregisterClient(clientID)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestApplyThinking tests the main ApplyThinking entry point.
|
|
||||||
//
|
|
||||||
// ApplyThinking is the unified entry point for applying thinking configuration.
|
|
||||||
// It routes to the appropriate provider-specific applier based on model.
|
|
||||||
//
|
|
||||||
// Depends on: Epic 10 Story 10-2 (apply-thinking main entry)
|
|
||||||
func TestApplyThinking(t *testing.T) {
|
|
||||||
cleanup := registerTestModels(t)
|
|
||||||
defer cleanup()
|
|
||||||
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
body string
|
|
||||||
model string
|
|
||||||
provider string
|
|
||||||
check string
|
|
||||||
}{
|
|
||||||
{"gemini budget", `{"generationConfig":{"thinkingConfig":{"thinkingBudget":8192}}}`, "gemini-2.5-pro-test", "gemini", "geminiBudget"},
|
|
||||||
{"gemini level", `{"generationConfig":{"thinkingConfig":{"thinkingLevel":"high"}}}`, "gemini-3-pro-preview-test", "gemini", "geminiLevel"},
|
|
||||||
{"gemini-cli budget", `{"request":{"generationConfig":{"thinkingConfig":{"thinkingBudget":8192}}}}`, "gemini-2.5-pro-test", "gemini-cli", "geminiCliBudget"},
|
|
||||||
{"antigravity budget", `{"request":{"generationConfig":{"thinkingConfig":{"thinkingBudget":8192}}}}`, "gemini-2.5-pro-test", "antigravity", "geminiCliBudget"},
|
|
||||||
{"claude budget", `{"thinking":{"budget_tokens":16384}}`, "claude-sonnet-4-5-test", "claude", "claudeBudget"},
|
|
||||||
{"claude enabled type auto", `{"thinking":{"type":"enabled"}}`, "claude-sonnet-4-5-test", "claude", "claudeAuto"},
|
|
||||||
{"openai level", `{"reasoning_effort":"high"}`, "gpt-5.2-test", "openai", "openaiLevel"},
|
|
||||||
{"iflow enable", `{"chat_template_kwargs":{"enable_thinking":true}}`, "glm-4.6-test", "iflow", "iflowEnable"},
|
|
||||||
{"unknown provider passthrough", `{"a":1}`, "gemini-2.5-pro-test", "unknown", "passthrough"},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
got, err := thinking.ApplyThinking([]byte(tt.body), tt.model, tt.provider)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("ApplyThinking() error = %v", err)
|
|
||||||
}
|
|
||||||
assertApplyThinkingCheck(t, tt.check, tt.body, got)
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestApplyThinkingErrors(t *testing.T) {
|
|
||||||
cleanup := registerTestModels(t)
|
|
||||||
defer cleanup()
|
|
||||||
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
body string
|
|
||||||
model string
|
|
||||||
provider string
|
|
||||||
}{
|
|
||||||
{"unsupported level openai", `{"reasoning_effort":"ultra"}`, "gpt-5.2-test", "openai"},
|
|
||||||
{"unsupported level gemini", `{"generationConfig":{"thinkingConfig":{"thinkingLevel":"ultra"}}}`, "gemini-3-pro-preview-test", "gemini"},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
got, err := thinking.ApplyThinking([]byte(tt.body), tt.model, tt.provider)
|
|
||||||
if err == nil {
|
|
||||||
t.Fatalf("ApplyThinking() error = nil, want error")
|
|
||||||
}
|
|
||||||
// On validation error, ApplyThinking returns original body (defensive programming)
|
|
||||||
if string(got) != tt.body {
|
|
||||||
t.Fatalf("ApplyThinking() body = %s, want original body %s", string(got), tt.body)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestApplyThinkingStripOnUnsupportedModel(t *testing.T) {
|
|
||||||
cleanup := registerTestModels(t)
|
|
||||||
defer cleanup()
|
|
||||||
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
body string
|
|
||||||
model string
|
|
||||||
provider string
|
|
||||||
stripped []string
|
|
||||||
preserved []string
|
|
||||||
}{
|
|
||||||
{"claude strip", `{"thinking":{"budget_tokens":8192},"model":"claude-3"}`, "claude-3", "claude", []string{"thinking"}, []string{"model"}},
|
|
||||||
{"gemini strip", `{"generationConfig":{"thinkingConfig":{"thinkingBudget":8192},"temperature":0.7}}`, "gemini-2.5-pro-strip", "gemini", []string{"generationConfig.thinkingConfig"}, []string{"generationConfig.temperature"}},
|
|
||||||
{"iflow strip", `{"chat_template_kwargs":{"enable_thinking":true,"clear_thinking":false,"other":"value"}}`, "glm-4.6-strip", "iflow", []string{"chat_template_kwargs.enable_thinking", "chat_template_kwargs.clear_thinking"}, []string{"chat_template_kwargs.other"}},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
got, err := thinking.ApplyThinking([]byte(tt.body), tt.model, tt.provider)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("ApplyThinking() error = %v", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, path := range tt.stripped {
|
|
||||||
if gjson.GetBytes(got, path).Exists() {
|
|
||||||
t.Fatalf("expected %s to be stripped, got %s", path, string(got))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
for _, path := range tt.preserved {
|
|
||||||
if !gjson.GetBytes(got, path).Exists() {
|
|
||||||
t.Fatalf("expected %s to be preserved, got %s", path, string(got))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestIsUserDefinedModel(t *testing.T) {
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
modelInfo *registry.ModelInfo
|
|
||||||
want bool
|
|
||||||
}{
|
|
||||||
{"nil modelInfo", nil, true},
|
|
||||||
{"not user-defined no flag", ®istry.ModelInfo{ID: "test"}, false},
|
|
||||||
{"not user-defined with type", ®istry.ModelInfo{ID: "test", Type: "openai"}, false},
|
|
||||||
{"user-defined with flag", ®istry.ModelInfo{ID: "test", Type: "openai", UserDefined: true}, true},
|
|
||||||
{"user-defined flag only", ®istry.ModelInfo{ID: "test", UserDefined: true}, true},
|
|
||||||
{"has thinking not user-defined", ®istry.ModelInfo{ID: "test", Type: "openai", Thinking: ®istry.ThinkingSupport{Min: 1024}}, false},
|
|
||||||
{"has thinking with user-defined flag", ®istry.ModelInfo{ID: "test", Type: "openai", Thinking: ®istry.ThinkingSupport{Min: 1024}, UserDefined: true}, true},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
if got := thinking.IsUserDefinedModel(tt.modelInfo); got != tt.want {
|
|
||||||
t.Fatalf("IsUserDefinedModel() = %v, want %v", got, tt.want)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestApplyThinking_UserDefinedModel(t *testing.T) {
|
|
||||||
// Register user-defined test models
|
|
||||||
reg := registry.GetGlobalRegistry()
|
|
||||||
userDefinedModels := []*registry.ModelInfo{
|
|
||||||
{ID: "custom-gpt", Type: "openai", UserDefined: true},
|
|
||||||
{ID: "or-claude", Type: "openai", UserDefined: true},
|
|
||||||
{ID: "custom-gemini", Type: "gemini", UserDefined: true},
|
|
||||||
{ID: "vertex-flash", Type: "gemini", UserDefined: true},
|
|
||||||
{ID: "cli-gemini", Type: "gemini", UserDefined: true},
|
|
||||||
{ID: "ag-gemini", Type: "gemini", UserDefined: true},
|
|
||||||
{ID: "custom-claude", Type: "claude", UserDefined: true},
|
|
||||||
{ID: "unknown"},
|
|
||||||
}
|
|
||||||
clientID := "test-user-defined-models"
|
|
||||||
reg.RegisterClient(clientID, "test", userDefinedModels)
|
|
||||||
defer reg.UnregisterClient(clientID)
|
|
||||||
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
body string
|
|
||||||
model string
|
|
||||||
provider string
|
|
||||||
check string
|
|
||||||
}{
|
|
||||||
{
|
|
||||||
"openai user-defined with reasoning_effort",
|
|
||||||
`{"model":"custom-gpt","reasoning_effort":"high"}`,
|
|
||||||
"custom-gpt",
|
|
||||||
"openai",
|
|
||||||
"openaiCompatible",
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"openai-compatibility model with reasoning_effort",
|
|
||||||
`{"model":"or-claude","reasoning_effort":"high"}`,
|
|
||||||
"or-claude",
|
|
||||||
"openai",
|
|
||||||
"openaiCompatible",
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"gemini user-defined with thinkingBudget",
|
|
||||||
`{"model":"custom-gemini","generationConfig":{"thinkingConfig":{"thinkingBudget":8192}}}`,
|
|
||||||
"custom-gemini",
|
|
||||||
"gemini",
|
|
||||||
"geminiCompatibleBudget",
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"vertex user-defined with thinkingBudget",
|
|
||||||
`{"model":"vertex-flash","generationConfig":{"thinkingConfig":{"thinkingBudget":16384}}}`,
|
|
||||||
"vertex-flash",
|
|
||||||
"gemini",
|
|
||||||
"geminiCompatibleBudget16384",
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"gemini-cli user-defined with thinkingBudget",
|
|
||||||
`{"model":"cli-gemini","request":{"generationConfig":{"thinkingConfig":{"thinkingBudget":8192}}}}`,
|
|
||||||
"cli-gemini",
|
|
||||||
"gemini-cli",
|
|
||||||
"geminiCliCompatibleBudget",
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"antigravity user-defined with thinkingBudget",
|
|
||||||
`{"model":"ag-gemini","request":{"generationConfig":{"thinkingConfig":{"thinkingBudget":8192}}}}`,
|
|
||||||
"ag-gemini",
|
|
||||||
"antigravity",
|
|
||||||
"geminiCliCompatibleBudget",
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"claude user-defined with thinking",
|
|
||||||
`{"model":"custom-claude","thinking":{"type":"enabled","budget_tokens":8192}}`,
|
|
||||||
"custom-claude",
|
|
||||||
"claude",
|
|
||||||
"claudeCompatibleBudget",
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"user-defined model no config",
|
|
||||||
`{"model":"custom-gpt","messages":[]}`,
|
|
||||||
"custom-gpt",
|
|
||||||
"openai",
|
|
||||||
"passthrough",
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"non-user-defined model strips config",
|
|
||||||
`{"model":"unknown","reasoning_effort":"high"}`,
|
|
||||||
"unknown",
|
|
||||||
"openai",
|
|
||||||
"stripReasoning",
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"user-defined model unknown provider",
|
|
||||||
`{"model":"custom-gpt","reasoning_effort":"high"}`,
|
|
||||||
"custom-gpt",
|
|
||||||
"unknown",
|
|
||||||
"passthrough",
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"unknown model passthrough",
|
|
||||||
`{"model":"nonexistent","reasoning_effort":"high"}`,
|
|
||||||
"nonexistent",
|
|
||||||
"openai",
|
|
||||||
"passthrough",
|
|
||||||
},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
got, err := thinking.ApplyThinking([]byte(tt.body), tt.model, tt.provider)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("ApplyThinking() error = %v", err)
|
|
||||||
}
|
|
||||||
assertCompatibleModelCheck(t, tt.check, tt.body, got)
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestApplyThinkingSuffixPriority tests suffix priority over body config.
|
|
||||||
func TestApplyThinkingSuffixPriority(t *testing.T) {
|
|
||||||
// Register test model
|
|
||||||
reg := registry.GetGlobalRegistry()
|
|
||||||
testModels := []*registry.ModelInfo{
|
|
||||||
{
|
|
||||||
ID: "gemini-suffix-test",
|
|
||||||
Thinking: ®istry.ThinkingSupport{Min: 128, Max: 32768, ZeroAllowed: true},
|
|
||||||
},
|
|
||||||
}
|
|
||||||
clientID := "test-suffix-priority"
|
|
||||||
reg.RegisterClient(clientID, "gemini", testModels)
|
|
||||||
defer reg.UnregisterClient(clientID)
|
|
||||||
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
body string
|
|
||||||
model string
|
|
||||||
provider string
|
|
||||||
checkPath string
|
|
||||||
expectedValue int
|
|
||||||
}{
|
|
||||||
{
|
|
||||||
"suffix overrides body budget",
|
|
||||||
`{"generationConfig":{"thinkingConfig":{"thinkingBudget":1000}}}`,
|
|
||||||
"gemini-suffix-test(8192)",
|
|
||||||
"gemini",
|
|
||||||
"generationConfig.thinkingConfig.thinkingBudget",
|
|
||||||
8192,
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"suffix none sets budget to 0",
|
|
||||||
`{"generationConfig":{"thinkingConfig":{"thinkingBudget":1000}}}`,
|
|
||||||
"gemini-suffix-test(none)",
|
|
||||||
"gemini",
|
|
||||||
"generationConfig.thinkingConfig.thinkingBudget",
|
|
||||||
0,
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"no suffix uses body config",
|
|
||||||
`{"generationConfig":{"thinkingConfig":{"thinkingBudget":5000}}}`,
|
|
||||||
"gemini-suffix-test",
|
|
||||||
"gemini",
|
|
||||||
"generationConfig.thinkingConfig.thinkingBudget",
|
|
||||||
5000,
|
|
||||||
},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
got, err := thinking.ApplyThinking([]byte(tt.body), tt.model, tt.provider)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("ApplyThinking() error = %v", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
result := int(gjson.GetBytes(got, tt.checkPath).Int())
|
|
||||||
if result != tt.expectedValue {
|
|
||||||
t.Fatalf("ApplyThinking() %s = %v, want %v\nbody: %s", tt.checkPath, result, tt.expectedValue, string(got))
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func assertApplyThinkingCheck(t *testing.T, checkName, input string, body []byte) {
|
|
||||||
t.Helper()
|
|
||||||
|
|
||||||
switch checkName {
|
|
||||||
case "geminiBudget":
|
|
||||||
assertJSONInt(t, body, "generationConfig.thinkingConfig.thinkingBudget", 8192)
|
|
||||||
assertJSONBool(t, body, "generationConfig.thinkingConfig.includeThoughts", true)
|
|
||||||
case "geminiLevel":
|
|
||||||
assertJSONString(t, body, "generationConfig.thinkingConfig.thinkingLevel", "high")
|
|
||||||
assertJSONBool(t, body, "generationConfig.thinkingConfig.includeThoughts", true)
|
|
||||||
case "geminiCliBudget":
|
|
||||||
assertJSONInt(t, body, "request.generationConfig.thinkingConfig.thinkingBudget", 8192)
|
|
||||||
assertJSONBool(t, body, "request.generationConfig.thinkingConfig.includeThoughts", true)
|
|
||||||
case "claudeBudget":
|
|
||||||
assertJSONString(t, body, "thinking.type", "enabled")
|
|
||||||
assertJSONInt(t, body, "thinking.budget_tokens", 16384)
|
|
||||||
case "claudeAuto":
|
|
||||||
// When type=enabled without budget, auto mode is applied using mid-range budget
|
|
||||||
assertJSONString(t, body, "thinking.type", "enabled")
|
|
||||||
// Budget should be mid-range: (1024 + 128000) / 2 = 64512
|
|
||||||
assertJSONInt(t, body, "thinking.budget_tokens", 64512)
|
|
||||||
case "openaiLevel":
|
|
||||||
assertJSONString(t, body, "reasoning_effort", "high")
|
|
||||||
case "iflowEnable":
|
|
||||||
assertJSONBool(t, body, "chat_template_kwargs.enable_thinking", true)
|
|
||||||
assertJSONBool(t, body, "chat_template_kwargs.clear_thinking", false)
|
|
||||||
case "passthrough":
|
|
||||||
if string(body) != input {
|
|
||||||
t.Fatalf("ApplyThinking() = %s, want %s", string(body), input)
|
|
||||||
}
|
|
||||||
default:
|
|
||||||
t.Fatalf("unknown check: %s", checkName)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func assertCompatibleModelCheck(t *testing.T, checkName, input string, body []byte) {
|
|
||||||
t.Helper()
|
|
||||||
|
|
||||||
switch checkName {
|
|
||||||
case "openaiCompatible":
|
|
||||||
assertJSONString(t, body, "reasoning_effort", "high")
|
|
||||||
case "geminiCompatibleBudget":
|
|
||||||
assertJSONInt(t, body, "generationConfig.thinkingConfig.thinkingBudget", 8192)
|
|
||||||
assertJSONBool(t, body, "generationConfig.thinkingConfig.includeThoughts", true)
|
|
||||||
case "geminiCompatibleBudget16384":
|
|
||||||
assertJSONInt(t, body, "generationConfig.thinkingConfig.thinkingBudget", 16384)
|
|
||||||
assertJSONBool(t, body, "generationConfig.thinkingConfig.includeThoughts", true)
|
|
||||||
case "geminiCliCompatibleBudget":
|
|
||||||
assertJSONInt(t, body, "request.generationConfig.thinkingConfig.thinkingBudget", 8192)
|
|
||||||
assertJSONBool(t, body, "request.generationConfig.thinkingConfig.includeThoughts", true)
|
|
||||||
case "claudeCompatibleBudget":
|
|
||||||
assertJSONString(t, body, "thinking.type", "enabled")
|
|
||||||
assertJSONInt(t, body, "thinking.budget_tokens", 8192)
|
|
||||||
case "stripReasoning":
|
|
||||||
if gjson.GetBytes(body, "reasoning_effort").Exists() {
|
|
||||||
t.Fatalf("expected reasoning_effort to be stripped, got %s", string(body))
|
|
||||||
}
|
|
||||||
case "passthrough":
|
|
||||||
if string(body) != input {
|
|
||||||
t.Fatalf("ApplyThinking() = %s, want %s", string(body), input)
|
|
||||||
}
|
|
||||||
default:
|
|
||||||
t.Fatalf("unknown check: %s", checkName)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func assertJSONString(t *testing.T, body []byte, path, want string) {
|
|
||||||
t.Helper()
|
|
||||||
value := gjson.GetBytes(body, path)
|
|
||||||
if !value.Exists() {
|
|
||||||
t.Fatalf("expected %s to exist", path)
|
|
||||||
}
|
|
||||||
if value.String() != want {
|
|
||||||
t.Fatalf("value at %s = %s, want %s", path, value.String(), want)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func assertJSONInt(t *testing.T, body []byte, path string, want int) {
|
|
||||||
t.Helper()
|
|
||||||
value := gjson.GetBytes(body, path)
|
|
||||||
if !value.Exists() {
|
|
||||||
t.Fatalf("expected %s to exist", path)
|
|
||||||
}
|
|
||||||
if int(value.Int()) != want {
|
|
||||||
t.Fatalf("value at %s = %d, want %d", path, value.Int(), want)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func assertJSONBool(t *testing.T, body []byte, path string, want bool) {
|
|
||||||
t.Helper()
|
|
||||||
value := gjson.GetBytes(body, path)
|
|
||||||
if !value.Exists() {
|
|
||||||
t.Fatalf("expected %s to exist", path)
|
|
||||||
}
|
|
||||||
if value.Bool() != want {
|
|
||||||
t.Fatalf("value at %s = %t, want %t", path, value.Bool(), want)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func geminiBudgetModel() *registry.ModelInfo {
|
|
||||||
return ®istry.ModelInfo{
|
|
||||||
ID: "gemini-2.5-pro-test",
|
|
||||||
Thinking: ®istry.ThinkingSupport{
|
|
||||||
Min: 128,
|
|
||||||
Max: 32768,
|
|
||||||
ZeroAllowed: true,
|
|
||||||
},
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func geminiLevelModel() *registry.ModelInfo {
|
|
||||||
return ®istry.ModelInfo{
|
|
||||||
ID: "gemini-3-pro-preview-test",
|
|
||||||
Thinking: ®istry.ThinkingSupport{
|
|
||||||
Min: 128,
|
|
||||||
Max: 32768,
|
|
||||||
Levels: []string{"minimal", "low", "medium", "high"},
|
|
||||||
},
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func claudeBudgetModel() *registry.ModelInfo {
|
|
||||||
return ®istry.ModelInfo{
|
|
||||||
ID: "claude-sonnet-4-5-test",
|
|
||||||
Thinking: ®istry.ThinkingSupport{
|
|
||||||
Min: 1024,
|
|
||||||
Max: 128000,
|
|
||||||
ZeroAllowed: true,
|
|
||||||
},
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func openAILevelModel() *registry.ModelInfo {
|
|
||||||
return ®istry.ModelInfo{
|
|
||||||
ID: "gpt-5.2-test",
|
|
||||||
Thinking: ®istry.ThinkingSupport{
|
|
||||||
Min: 128,
|
|
||||||
Max: 32768,
|
|
||||||
ZeroAllowed: true,
|
|
||||||
Levels: []string{"low", "medium", "high"},
|
|
||||||
},
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func iFlowModel() *registry.ModelInfo {
|
|
||||||
return ®istry.ModelInfo{
|
|
||||||
ID: "glm-4.6-test",
|
|
||||||
Thinking: ®istry.ThinkingSupport{
|
|
||||||
Min: 1,
|
|
||||||
Max: 10,
|
|
||||||
ZeroAllowed: true,
|
|
||||||
},
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,277 +0,0 @@
|
|||||||
// Package thinking provides unified thinking configuration processing logic.
|
|
||||||
package thinking
|
|
||||||
|
|
||||||
import (
|
|
||||||
"testing"
|
|
||||||
|
|
||||||
"github.com/router-for-me/CLIProxyAPI/v6/internal/registry"
|
|
||||||
)
|
|
||||||
|
|
||||||
// TestConvertLevelToBudget tests the ConvertLevelToBudget function.
|
|
||||||
//
|
|
||||||
// ConvertLevelToBudget converts a thinking level to a budget value.
|
|
||||||
// This is a semantic conversion - it does NOT apply clamping.
|
|
||||||
//
|
|
||||||
// Level → Budget mapping:
|
|
||||||
// - none → 0
|
|
||||||
// - auto → -1
|
|
||||||
// - minimal → 512
|
|
||||||
// - low → 1024
|
|
||||||
// - medium → 8192
|
|
||||||
// - high → 24576
|
|
||||||
// - xhigh → 32768
|
|
||||||
func TestConvertLevelToBudget(t *testing.T) {
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
level string
|
|
||||||
want int
|
|
||||||
wantOK bool
|
|
||||||
}{
|
|
||||||
// Standard levels
|
|
||||||
{"none", "none", 0, true},
|
|
||||||
{"auto", "auto", -1, true},
|
|
||||||
{"minimal", "minimal", 512, true},
|
|
||||||
{"low", "low", 1024, true},
|
|
||||||
{"medium", "medium", 8192, true},
|
|
||||||
{"high", "high", 24576, true},
|
|
||||||
{"xhigh", "xhigh", 32768, true},
|
|
||||||
|
|
||||||
// Case insensitive
|
|
||||||
{"case insensitive HIGH", "HIGH", 24576, true},
|
|
||||||
{"case insensitive High", "High", 24576, true},
|
|
||||||
{"case insensitive NONE", "NONE", 0, true},
|
|
||||||
{"case insensitive Auto", "Auto", -1, true},
|
|
||||||
|
|
||||||
// Invalid levels
|
|
||||||
{"invalid ultra", "ultra", 0, false},
|
|
||||||
{"invalid maximum", "maximum", 0, false},
|
|
||||||
{"empty string", "", 0, false},
|
|
||||||
{"whitespace", " ", 0, false},
|
|
||||||
{"numeric string", "1000", 0, false},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
budget, ok := ConvertLevelToBudget(tt.level)
|
|
||||||
if ok != tt.wantOK {
|
|
||||||
t.Errorf("ConvertLevelToBudget(%q) ok = %v, want %v", tt.level, ok, tt.wantOK)
|
|
||||||
}
|
|
||||||
if budget != tt.want {
|
|
||||||
t.Errorf("ConvertLevelToBudget(%q) = %d, want %d", tt.level, budget, tt.want)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestConvertBudgetToLevel tests the ConvertBudgetToLevel function.
|
|
||||||
//
|
|
||||||
// ConvertBudgetToLevel converts a budget value to the nearest level.
|
|
||||||
// Uses threshold-based mapping for range conversion.
|
|
||||||
//
|
|
||||||
// Budget → Level thresholds:
|
|
||||||
// - -1 → auto
|
|
||||||
// - 0 → none
|
|
||||||
// - 1-512 → minimal
|
|
||||||
// - 513-1024 → low
|
|
||||||
// - 1025-8192 → medium
|
|
||||||
// - 8193-24576 → high
|
|
||||||
// - 24577+ → xhigh
|
|
||||||
//
|
|
||||||
// Depends on: Epic 4 Story 4-2 (budget to level conversion)
|
|
||||||
func TestConvertBudgetToLevel(t *testing.T) {
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
budget int
|
|
||||||
want string
|
|
||||||
wantOK bool
|
|
||||||
}{
|
|
||||||
// Special values
|
|
||||||
{"auto", -1, "auto", true},
|
|
||||||
{"none", 0, "none", true},
|
|
||||||
|
|
||||||
// Invalid negative values
|
|
||||||
{"invalid negative -2", -2, "", false},
|
|
||||||
{"invalid negative -100", -100, "", false},
|
|
||||||
{"invalid negative extreme", -999999, "", false},
|
|
||||||
|
|
||||||
// Minimal range (1-512)
|
|
||||||
{"minimal min", 1, "minimal", true},
|
|
||||||
{"minimal mid", 256, "minimal", true},
|
|
||||||
{"minimal max", 512, "minimal", true},
|
|
||||||
|
|
||||||
// Low range (513-1024)
|
|
||||||
{"low start", 513, "low", true},
|
|
||||||
{"low boundary", 1024, "low", true},
|
|
||||||
|
|
||||||
// Medium range (1025-8192)
|
|
||||||
{"medium start", 1025, "medium", true},
|
|
||||||
{"medium mid", 4096, "medium", true},
|
|
||||||
{"medium boundary", 8192, "medium", true},
|
|
||||||
|
|
||||||
// High range (8193-24576)
|
|
||||||
{"high start", 8193, "high", true},
|
|
||||||
{"high mid", 16384, "high", true},
|
|
||||||
{"high boundary", 24576, "high", true},
|
|
||||||
|
|
||||||
// XHigh range (24577+)
|
|
||||||
{"xhigh start", 24577, "xhigh", true},
|
|
||||||
{"xhigh mid", 32768, "xhigh", true},
|
|
||||||
{"xhigh large", 100000, "xhigh", true},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
level, ok := ConvertBudgetToLevel(tt.budget)
|
|
||||||
if ok != tt.wantOK {
|
|
||||||
t.Errorf("ConvertBudgetToLevel(%d) ok = %v, want %v", tt.budget, ok, tt.wantOK)
|
|
||||||
}
|
|
||||||
if level != tt.want {
|
|
||||||
t.Errorf("ConvertBudgetToLevel(%d) = %q, want %q", tt.budget, level, tt.want)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestConvertMixedFormat tests mixed format handling.
|
|
||||||
//
|
|
||||||
// Tests scenarios where both level and budget might be present,
|
|
||||||
// or where format conversion requires special handling.
|
|
||||||
//
|
|
||||||
// Depends on: Epic 4 Story 4-3 (mixed format handling)
|
|
||||||
func TestConvertMixedFormat(t *testing.T) {
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
inputBudget int
|
|
||||||
inputLevel string
|
|
||||||
wantMode ThinkingMode
|
|
||||||
wantBudget int
|
|
||||||
wantLevel ThinkingLevel
|
|
||||||
}{
|
|
||||||
// Level takes precedence when both present
|
|
||||||
{"level and budget - level wins", 8192, "high", ModeLevel, 0, LevelHigh},
|
|
||||||
{"level and zero budget", 0, "high", ModeLevel, 0, LevelHigh},
|
|
||||||
|
|
||||||
// Budget only
|
|
||||||
{"budget only", 16384, "", ModeBudget, 16384, ""},
|
|
||||||
|
|
||||||
// Level only
|
|
||||||
{"level only", 0, "medium", ModeLevel, 0, LevelMedium},
|
|
||||||
|
|
||||||
// Neither (default)
|
|
||||||
{"neither", 0, "", ModeNone, 0, ""},
|
|
||||||
|
|
||||||
// Special values
|
|
||||||
{"auto level", 0, "auto", ModeAuto, -1, LevelAuto},
|
|
||||||
{"none level", 0, "none", ModeNone, 0, LevelNone},
|
|
||||||
{"auto budget", -1, "", ModeAuto, -1, ""},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
got := normalizeMixedConfig(tt.inputBudget, tt.inputLevel)
|
|
||||||
if got.Mode != tt.wantMode {
|
|
||||||
t.Errorf("normalizeMixedConfig(%d, %q) Mode = %v, want %v", tt.inputBudget, tt.inputLevel, got.Mode, tt.wantMode)
|
|
||||||
}
|
|
||||||
if got.Budget != tt.wantBudget {
|
|
||||||
t.Errorf("normalizeMixedConfig(%d, %q) Budget = %d, want %d", tt.inputBudget, tt.inputLevel, got.Budget, tt.wantBudget)
|
|
||||||
}
|
|
||||||
if got.Level != tt.wantLevel {
|
|
||||||
t.Errorf("normalizeMixedConfig(%d, %q) Level = %q, want %q", tt.inputBudget, tt.inputLevel, got.Level, tt.wantLevel)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestNormalizeForModel tests model-aware format normalization.
|
|
||||||
func TestNormalizeForModel(t *testing.T) {
|
|
||||||
budgetOnlyModel := ®istry.ModelInfo{
|
|
||||||
Thinking: ®istry.ThinkingSupport{
|
|
||||||
Min: 1024,
|
|
||||||
Max: 128000,
|
|
||||||
},
|
|
||||||
}
|
|
||||||
levelOnlyModel := ®istry.ModelInfo{
|
|
||||||
Thinking: ®istry.ThinkingSupport{
|
|
||||||
Levels: []string{"low", "medium", "high"},
|
|
||||||
},
|
|
||||||
}
|
|
||||||
hybridModel := ®istry.ModelInfo{
|
|
||||||
Thinking: ®istry.ThinkingSupport{
|
|
||||||
Min: 128,
|
|
||||||
Max: 32768,
|
|
||||||
Levels: []string{"minimal", "low", "medium", "high"},
|
|
||||||
},
|
|
||||||
}
|
|
||||||
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
config ThinkingConfig
|
|
||||||
model *registry.ModelInfo
|
|
||||||
want ThinkingConfig
|
|
||||||
wantErr bool
|
|
||||||
}{
|
|
||||||
{"budget-only keeps budget", ThinkingConfig{Mode: ModeBudget, Budget: 8192}, budgetOnlyModel, ThinkingConfig{Mode: ModeBudget, Budget: 8192}, false},
|
|
||||||
{"budget-only converts level", ThinkingConfig{Mode: ModeLevel, Level: LevelHigh}, budgetOnlyModel, ThinkingConfig{Mode: ModeBudget, Budget: 24576}, false},
|
|
||||||
{"level-only converts budget", ThinkingConfig{Mode: ModeBudget, Budget: 8192}, levelOnlyModel, ThinkingConfig{Mode: ModeLevel, Level: LevelMedium}, false},
|
|
||||||
{"level-only keeps level", ThinkingConfig{Mode: ModeLevel, Level: LevelLow}, levelOnlyModel, ThinkingConfig{Mode: ModeLevel, Level: LevelLow}, false},
|
|
||||||
{"hybrid keeps budget", ThinkingConfig{Mode: ModeBudget, Budget: 16384}, hybridModel, ThinkingConfig{Mode: ModeBudget, Budget: 16384}, false},
|
|
||||||
{"hybrid keeps level", ThinkingConfig{Mode: ModeLevel, Level: LevelMinimal}, hybridModel, ThinkingConfig{Mode: ModeLevel, Level: LevelMinimal}, false},
|
|
||||||
{"auto passthrough", ThinkingConfig{Mode: ModeAuto, Budget: -1}, levelOnlyModel, ThinkingConfig{Mode: ModeAuto, Budget: -1}, false},
|
|
||||||
{"none passthrough", ThinkingConfig{Mode: ModeNone, Budget: 0}, budgetOnlyModel, ThinkingConfig{Mode: ModeNone, Budget: 0}, false},
|
|
||||||
{"invalid level", ThinkingConfig{Mode: ModeLevel, Level: "ultra"}, budgetOnlyModel, ThinkingConfig{}, true},
|
|
||||||
{"invalid budget", ThinkingConfig{Mode: ModeBudget, Budget: -2}, levelOnlyModel, ThinkingConfig{}, true},
|
|
||||||
{"nil modelInfo passthrough budget", ThinkingConfig{Mode: ModeBudget, Budget: 8192}, nil, ThinkingConfig{Mode: ModeBudget, Budget: 8192}, false},
|
|
||||||
{"nil modelInfo passthrough level", ThinkingConfig{Mode: ModeLevel, Level: LevelHigh}, nil, ThinkingConfig{Mode: ModeLevel, Level: LevelHigh}, false},
|
|
||||||
{"nil thinking degrades to none", ThinkingConfig{Mode: ModeBudget, Budget: 4096}, ®istry.ModelInfo{}, ThinkingConfig{Mode: ModeNone, Budget: 0}, false},
|
|
||||||
{"nil thinking level degrades to none", ThinkingConfig{Mode: ModeLevel, Level: LevelHigh}, ®istry.ModelInfo{}, ThinkingConfig{Mode: ModeNone, Budget: 0}, false},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
got, err := NormalizeForModel(&tt.config, tt.model)
|
|
||||||
if (err != nil) != tt.wantErr {
|
|
||||||
t.Fatalf("NormalizeForModel(%+v) error = %v, wantErr %v", tt.config, err, tt.wantErr)
|
|
||||||
}
|
|
||||||
if tt.wantErr {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
if got == nil {
|
|
||||||
t.Fatalf("NormalizeForModel(%+v) returned nil config", tt.config)
|
|
||||||
}
|
|
||||||
if got.Mode != tt.want.Mode {
|
|
||||||
t.Errorf("NormalizeForModel(%+v) Mode = %v, want %v", tt.config, got.Mode, tt.want.Mode)
|
|
||||||
}
|
|
||||||
if got.Budget != tt.want.Budget {
|
|
||||||
t.Errorf("NormalizeForModel(%+v) Budget = %d, want %d", tt.config, got.Budget, tt.want.Budget)
|
|
||||||
}
|
|
||||||
if got.Level != tt.want.Level {
|
|
||||||
t.Errorf("NormalizeForModel(%+v) Level = %q, want %q", tt.config, got.Level, tt.want.Level)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestLevelToBudgetRoundTrip tests level → budget → level round trip.
|
|
||||||
//
|
|
||||||
// Verifies that converting level to budget and back produces consistent results.
|
|
||||||
//
|
|
||||||
// Depends on: Epic 4 Story 4-1, 4-2
|
|
||||||
func TestLevelToBudgetRoundTrip(t *testing.T) {
|
|
||||||
levels := []string{"none", "auto", "minimal", "low", "medium", "high", "xhigh"}
|
|
||||||
|
|
||||||
for _, level := range levels {
|
|
||||||
t.Run(level, func(t *testing.T) {
|
|
||||||
budget, ok := ConvertLevelToBudget(level)
|
|
||||||
if !ok {
|
|
||||||
t.Fatalf("ConvertLevelToBudget(%q) returned ok=false", level)
|
|
||||||
}
|
|
||||||
resultLevel, ok := ConvertBudgetToLevel(budget)
|
|
||||||
if !ok {
|
|
||||||
t.Fatalf("ConvertBudgetToLevel(%d) returned ok=false", budget)
|
|
||||||
}
|
|
||||||
if resultLevel != level {
|
|
||||||
t.Errorf("round trip: %q → %d → %q, want %q", level, budget, resultLevel, level)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,34 +0,0 @@
|
|||||||
// Package thinking provides unified thinking configuration processing logic.
|
|
||||||
package thinking
|
|
||||||
|
|
||||||
import "testing"
|
|
||||||
|
|
||||||
// TestThinkingErrorError tests the Error() method of ThinkingError.
|
|
||||||
//
|
|
||||||
// Error() returns the message directly without code prefix.
|
|
||||||
// Use Code field for programmatic error handling.
|
|
||||||
func TestThinkingErrorError(t *testing.T) {
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
err *ThinkingError
|
|
||||||
wantMsg string
|
|
||||||
wantCode ErrorCode
|
|
||||||
}{
|
|
||||||
{"invalid suffix format", NewThinkingError(ErrInvalidSuffix, "invalid suffix format: model(abc"), "invalid suffix format: model(abc", ErrInvalidSuffix},
|
|
||||||
{"unknown level", NewThinkingError(ErrUnknownLevel, "unknown level: ultra"), "unknown level: ultra", ErrUnknownLevel},
|
|
||||||
{"level not supported", NewThinkingError(ErrLevelNotSupported, "level \"xhigh\" not supported, valid levels: low, medium, high"), "level \"xhigh\" not supported, valid levels: low, medium, high", ErrLevelNotSupported},
|
|
||||||
{"thinking not supported", NewThinkingErrorWithModel(ErrThinkingNotSupported, "thinking not supported for this model", "claude-haiku"), "thinking not supported for this model", ErrThinkingNotSupported},
|
|
||||||
{"provider mismatch", NewThinkingError(ErrProviderMismatch, "provider mismatch: expected claude, got gemini"), "provider mismatch: expected claude, got gemini", ErrProviderMismatch},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
if got := tt.err.Error(); got != tt.wantMsg {
|
|
||||||
t.Errorf("Error() = %q, want %q", got, tt.wantMsg)
|
|
||||||
}
|
|
||||||
if tt.err.Code != tt.wantCode {
|
|
||||||
t.Errorf("Code = %q, want %q", tt.err.Code, tt.wantCode)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,42 +0,0 @@
|
|||||||
// Package thinking provides unified thinking configuration processing logic.
|
|
||||||
package thinking
|
|
||||||
|
|
||||||
import "testing"
|
|
||||||
|
|
||||||
func TestExtractThinkingConfig(t *testing.T) {
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
body string
|
|
||||||
provider string
|
|
||||||
want ThinkingConfig
|
|
||||||
}{
|
|
||||||
{"claude budget", `{"thinking":{"budget_tokens":16384}}`, "claude", ThinkingConfig{Mode: ModeBudget, Budget: 16384}},
|
|
||||||
{"claude disabled type", `{"thinking":{"type":"disabled"}}`, "claude", ThinkingConfig{Mode: ModeNone, Budget: 0}},
|
|
||||||
{"claude auto budget", `{"thinking":{"budget_tokens":-1}}`, "claude", ThinkingConfig{Mode: ModeAuto, Budget: -1}},
|
|
||||||
{"claude enabled type without budget", `{"thinking":{"type":"enabled"}}`, "claude", ThinkingConfig{Mode: ModeAuto, Budget: -1}},
|
|
||||||
{"claude enabled type with budget", `{"thinking":{"type":"enabled","budget_tokens":8192}}`, "claude", ThinkingConfig{Mode: ModeBudget, Budget: 8192}},
|
|
||||||
{"claude disabled type overrides budget", `{"thinking":{"type":"disabled","budget_tokens":8192}}`, "claude", ThinkingConfig{Mode: ModeNone, Budget: 0}},
|
|
||||||
{"gemini budget", `{"generationConfig":{"thinkingConfig":{"thinkingBudget":8192}}}`, "gemini", ThinkingConfig{Mode: ModeBudget, Budget: 8192}},
|
|
||||||
{"gemini level", `{"generationConfig":{"thinkingConfig":{"thinkingLevel":"high"}}}`, "gemini", ThinkingConfig{Mode: ModeLevel, Level: LevelHigh}},
|
|
||||||
{"gemini cli auto", `{"request":{"generationConfig":{"thinkingConfig":{"thinkingLevel":"auto"}}}}`, "gemini-cli", ThinkingConfig{Mode: ModeAuto, Budget: -1}},
|
|
||||||
{"openai level", `{"reasoning_effort":"medium"}`, "openai", ThinkingConfig{Mode: ModeLevel, Level: LevelMedium}},
|
|
||||||
{"openai none", `{"reasoning_effort":"none"}`, "openai", ThinkingConfig{Mode: ModeNone, Budget: 0}},
|
|
||||||
{"codex effort high", `{"reasoning":{"effort":"high"}}`, "codex", ThinkingConfig{Mode: ModeLevel, Level: LevelHigh}},
|
|
||||||
{"codex effort none", `{"reasoning":{"effort":"none"}}`, "codex", ThinkingConfig{Mode: ModeNone, Budget: 0}},
|
|
||||||
{"iflow enable", `{"chat_template_kwargs":{"enable_thinking":true}}`, "iflow", ThinkingConfig{Mode: ModeBudget, Budget: 1}},
|
|
||||||
{"iflow disable", `{"reasoning_split":false}`, "iflow", ThinkingConfig{Mode: ModeNone, Budget: 0}},
|
|
||||||
{"unknown provider", `{"thinking":{"budget_tokens":123}}`, "unknown", ThinkingConfig{}},
|
|
||||||
{"invalid json", `{"thinking":`, "claude", ThinkingConfig{}},
|
|
||||||
{"empty body", "", "claude", ThinkingConfig{}},
|
|
||||||
{"no config", `{}`, "gemini", ThinkingConfig{}},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
got := extractThinkingConfig([]byte(tt.body), tt.provider)
|
|
||||||
if got != tt.want {
|
|
||||||
t.Fatalf("extractThinkingConfig() = %+v, want %+v", got, tt.want)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,288 +0,0 @@
|
|||||||
// Package claude implements thinking configuration for Claude models.
|
|
||||||
package claude
|
|
||||||
|
|
||||||
import (
|
|
||||||
"testing"
|
|
||||||
|
|
||||||
"github.com/router-for-me/CLIProxyAPI/v6/internal/registry"
|
|
||||||
"github.com/router-for-me/CLIProxyAPI/v6/internal/thinking"
|
|
||||||
"github.com/tidwall/gjson"
|
|
||||||
)
|
|
||||||
|
|
||||||
// =============================================================================
|
|
||||||
// Unit Tests: Applier Creation and Interface
|
|
||||||
// =============================================================================
|
|
||||||
|
|
||||||
func TestNewApplier(t *testing.T) {
|
|
||||||
applier := NewApplier()
|
|
||||||
if applier == nil {
|
|
||||||
t.Fatal("NewApplier() returned nil")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestApplierImplementsInterface(t *testing.T) {
|
|
||||||
var _ thinking.ProviderApplier = (*Applier)(nil)
|
|
||||||
}
|
|
||||||
|
|
||||||
// =============================================================================
|
|
||||||
// Unit Tests: Budget and Disable Logic (Pre-validated Config)
|
|
||||||
// =============================================================================
|
|
||||||
|
|
||||||
// TestClaudeApplyBudgetAndNone tests budget values and disable modes.
|
|
||||||
// NOTE: These tests assume config has been pre-validated by ValidateConfig.
|
|
||||||
// Apply trusts the input and does not perform clamping.
|
|
||||||
func TestClaudeApplyBudgetAndNone(t *testing.T) {
|
|
||||||
applier := NewApplier()
|
|
||||||
modelInfo := buildClaudeModelInfo()
|
|
||||||
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
config thinking.ThinkingConfig
|
|
||||||
wantType string
|
|
||||||
wantBudget int
|
|
||||||
wantBudgetOK bool
|
|
||||||
}{
|
|
||||||
// Valid pre-validated budget values
|
|
||||||
{"budget 16k", thinking.ThinkingConfig{Mode: thinking.ModeBudget, Budget: 16384}, "enabled", 16384, true},
|
|
||||||
{"budget min", thinking.ThinkingConfig{Mode: thinking.ModeBudget, Budget: 1024}, "enabled", 1024, true},
|
|
||||||
{"budget max", thinking.ThinkingConfig{Mode: thinking.ModeBudget, Budget: 128000}, "enabled", 128000, true},
|
|
||||||
{"budget mid", thinking.ThinkingConfig{Mode: thinking.ModeBudget, Budget: 50000}, "enabled", 50000, true},
|
|
||||||
// Disable cases
|
|
||||||
{"budget zero disables", thinking.ThinkingConfig{Mode: thinking.ModeBudget, Budget: 0}, "disabled", 0, false},
|
|
||||||
{"mode none disables", thinking.ThinkingConfig{Mode: thinking.ModeNone, Budget: 0}, "disabled", 0, false},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
result, err := applier.Apply([]byte(`{}`), tt.config, modelInfo)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Apply() error = %v", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
thinkingType := gjson.GetBytes(result, "thinking.type").String()
|
|
||||||
if thinkingType != tt.wantType {
|
|
||||||
t.Fatalf("thinking.type = %q, want %q", thinkingType, tt.wantType)
|
|
||||||
}
|
|
||||||
|
|
||||||
budgetValue := gjson.GetBytes(result, "thinking.budget_tokens")
|
|
||||||
if budgetValue.Exists() != tt.wantBudgetOK {
|
|
||||||
t.Fatalf("thinking.budget_tokens exists = %v, want %v", budgetValue.Exists(), tt.wantBudgetOK)
|
|
||||||
}
|
|
||||||
if tt.wantBudgetOK {
|
|
||||||
if got := int(budgetValue.Int()); got != tt.wantBudget {
|
|
||||||
t.Fatalf("thinking.budget_tokens = %d, want %d", got, tt.wantBudget)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestClaudeApplyPassthroughBudget tests that Apply trusts pre-validated budget values.
|
|
||||||
// It does NOT perform clamping - that's ValidateConfig's responsibility.
|
|
||||||
func TestClaudeApplyPassthroughBudget(t *testing.T) {
|
|
||||||
applier := NewApplier()
|
|
||||||
modelInfo := buildClaudeModelInfo()
|
|
||||||
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
config thinking.ThinkingConfig
|
|
||||||
wantBudget int
|
|
||||||
}{
|
|
||||||
// Apply should pass through the budget value as-is
|
|
||||||
// (ValidateConfig would have clamped these, but Apply trusts the input)
|
|
||||||
{"passes through any budget", thinking.ThinkingConfig{Mode: thinking.ModeBudget, Budget: 500}, 500},
|
|
||||||
{"passes through large budget", thinking.ThinkingConfig{Mode: thinking.ModeBudget, Budget: 200000}, 200000},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
result, err := applier.Apply([]byte(`{}`), tt.config, modelInfo)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Apply() error = %v", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
if got := int(gjson.GetBytes(result, "thinking.budget_tokens").Int()); got != tt.wantBudget {
|
|
||||||
t.Fatalf("thinking.budget_tokens = %d, want %d (passthrough)", got, tt.wantBudget)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// =============================================================================
|
|
||||||
// Unit Tests: Mode Passthrough (Strict Layering)
|
|
||||||
// =============================================================================
|
|
||||||
|
|
||||||
// TestClaudeApplyModePassthrough tests that non-Budget/None modes pass through unchanged.
|
|
||||||
// Apply expects ValidateConfig to have already converted Level/Auto to Budget.
|
|
||||||
func TestClaudeApplyModePassthrough(t *testing.T) {
|
|
||||||
applier := NewApplier()
|
|
||||||
modelInfo := buildClaudeModelInfo()
|
|
||||||
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
config thinking.ThinkingConfig
|
|
||||||
body string
|
|
||||||
}{
|
|
||||||
{"ModeLevel passes through", thinking.ThinkingConfig{Mode: thinking.ModeLevel, Level: "high"}, `{"model":"test"}`},
|
|
||||||
{"ModeAuto passes through", thinking.ThinkingConfig{Mode: thinking.ModeAuto, Budget: -1}, `{"model":"test"}`},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
result, err := applier.Apply([]byte(tt.body), tt.config, modelInfo)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Apply() error = %v", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Should return body unchanged
|
|
||||||
if string(result) != tt.body {
|
|
||||||
t.Fatalf("Apply() = %s, want %s (passthrough)", string(result), tt.body)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// =============================================================================
|
|
||||||
// Unit Tests: Output Format
|
|
||||||
// =============================================================================
|
|
||||||
|
|
||||||
// TestClaudeApplyOutputFormat tests the exact JSON output format.
|
|
||||||
//
|
|
||||||
// Claude expects:
|
|
||||||
//
|
|
||||||
// {
|
|
||||||
// "thinking": {
|
|
||||||
// "type": "enabled",
|
|
||||||
// "budget_tokens": 16384
|
|
||||||
// }
|
|
||||||
// }
|
|
||||||
func TestClaudeApplyOutputFormat(t *testing.T) {
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
config thinking.ThinkingConfig
|
|
||||||
wantJSON string
|
|
||||||
}{
|
|
||||||
{
|
|
||||||
"enabled with budget",
|
|
||||||
thinking.ThinkingConfig{Mode: thinking.ModeBudget, Budget: 16384},
|
|
||||||
`{"thinking":{"type":"enabled","budget_tokens":16384}}`,
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"disabled",
|
|
||||||
thinking.ThinkingConfig{Mode: thinking.ModeNone, Budget: 0},
|
|
||||||
`{"thinking":{"type":"disabled"}}`,
|
|
||||||
},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
applier := NewApplier()
|
|
||||||
modelInfo := buildClaudeModelInfo()
|
|
||||||
|
|
||||||
result, err := applier.Apply([]byte(`{}`), tt.config, modelInfo)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Apply() error = %v", err)
|
|
||||||
}
|
|
||||||
if string(result) != tt.wantJSON {
|
|
||||||
t.Fatalf("Apply() = %s, want %s", result, tt.wantJSON)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// =============================================================================
|
|
||||||
// Unit Tests: Body Merging
|
|
||||||
// =============================================================================
|
|
||||||
|
|
||||||
// TestClaudeApplyWithExistingBody tests applying config to existing request body.
|
|
||||||
func TestClaudeApplyWithExistingBody(t *testing.T) {
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
body string
|
|
||||||
config thinking.ThinkingConfig
|
|
||||||
wantBody string
|
|
||||||
}{
|
|
||||||
{
|
|
||||||
"add to empty body",
|
|
||||||
`{}`,
|
|
||||||
thinking.ThinkingConfig{Mode: thinking.ModeBudget, Budget: 16384},
|
|
||||||
`{"thinking":{"type":"enabled","budget_tokens":16384}}`,
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"preserve existing fields",
|
|
||||||
`{"model":"claude-sonnet-4-5","messages":[]}`,
|
|
||||||
thinking.ThinkingConfig{Mode: thinking.ModeBudget, Budget: 8192},
|
|
||||||
`{"model":"claude-sonnet-4-5","messages":[],"thinking":{"type":"enabled","budget_tokens":8192}}`,
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"override existing thinking",
|
|
||||||
`{"thinking":{"type":"enabled","budget_tokens":1000}}`,
|
|
||||||
thinking.ThinkingConfig{Mode: thinking.ModeBudget, Budget: 16384},
|
|
||||||
`{"thinking":{"type":"enabled","budget_tokens":16384}}`,
|
|
||||||
},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
applier := NewApplier()
|
|
||||||
modelInfo := buildClaudeModelInfo()
|
|
||||||
|
|
||||||
result, err := applier.Apply([]byte(tt.body), tt.config, modelInfo)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Apply() error = %v", err)
|
|
||||||
}
|
|
||||||
if string(result) != tt.wantBody {
|
|
||||||
t.Fatalf("Apply() = %s, want %s", result, tt.wantBody)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestClaudeApplyWithNilBody tests handling of nil/empty body.
|
|
||||||
func TestClaudeApplyWithNilBody(t *testing.T) {
|
|
||||||
applier := NewApplier()
|
|
||||||
modelInfo := buildClaudeModelInfo()
|
|
||||||
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
body []byte
|
|
||||||
wantBudget int
|
|
||||||
}{
|
|
||||||
{"nil body", nil, 16384},
|
|
||||||
{"empty body", []byte{}, 16384},
|
|
||||||
{"empty object", []byte(`{}`), 16384},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
config := thinking.ThinkingConfig{Mode: thinking.ModeBudget, Budget: 16384}
|
|
||||||
result, err := applier.Apply(tt.body, config, modelInfo)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Apply() error = %v", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
if got := gjson.GetBytes(result, "thinking.type").String(); got != "enabled" {
|
|
||||||
t.Fatalf("thinking.type = %q, want %q", got, "enabled")
|
|
||||||
}
|
|
||||||
if got := int(gjson.GetBytes(result, "thinking.budget_tokens").Int()); got != tt.wantBudget {
|
|
||||||
t.Fatalf("thinking.budget_tokens = %d, want %d", got, tt.wantBudget)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// =============================================================================
|
|
||||||
// Helper Functions
|
|
||||||
// =============================================================================
|
|
||||||
|
|
||||||
func buildClaudeModelInfo() *registry.ModelInfo {
|
|
||||||
return ®istry.ModelInfo{
|
|
||||||
ID: "claude-sonnet-4-5",
|
|
||||||
Thinking: ®istry.ThinkingSupport{
|
|
||||||
Min: 1024,
|
|
||||||
Max: 128000,
|
|
||||||
ZeroAllowed: true,
|
|
||||||
DynamicAllowed: false,
|
|
||||||
},
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,519 +0,0 @@
|
|||||||
// Package gemini implements thinking configuration for Gemini models.
|
|
||||||
package gemini
|
|
||||||
|
|
||||||
import (
|
|
||||||
"testing"
|
|
||||||
|
|
||||||
"github.com/router-for-me/CLIProxyAPI/v6/internal/registry"
|
|
||||||
"github.com/router-for-me/CLIProxyAPI/v6/internal/thinking"
|
|
||||||
"github.com/tidwall/gjson"
|
|
||||||
)
|
|
||||||
|
|
||||||
func TestNewApplier(t *testing.T) {
|
|
||||||
applier := NewApplier()
|
|
||||||
if applier == nil {
|
|
||||||
t.Fatal("NewApplier() returned nil")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// parseConfigFromSuffix parses a raw suffix into a ThinkingConfig.
|
|
||||||
// This helper reduces code duplication in end-to-end tests (L1 fix).
|
|
||||||
func parseConfigFromSuffix(rawSuffix string) (thinking.ThinkingConfig, bool) {
|
|
||||||
if budget, ok := thinking.ParseNumericSuffix(rawSuffix); ok {
|
|
||||||
return thinking.ThinkingConfig{Mode: thinking.ModeBudget, Budget: budget}, true
|
|
||||||
}
|
|
||||||
if level, ok := thinking.ParseLevelSuffix(rawSuffix); ok {
|
|
||||||
return thinking.ThinkingConfig{Mode: thinking.ModeLevel, Level: level}, true
|
|
||||||
}
|
|
||||||
if mode, ok := thinking.ParseSpecialSuffix(rawSuffix); ok {
|
|
||||||
config := thinking.ThinkingConfig{Mode: mode}
|
|
||||||
if mode == thinking.ModeAuto {
|
|
||||||
config.Budget = -1
|
|
||||||
}
|
|
||||||
return config, true
|
|
||||||
}
|
|
||||||
return thinking.ThinkingConfig{}, false
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestApplierImplementsInterface(t *testing.T) {
|
|
||||||
// Compile-time check: if Applier doesn't implement the interface, this won't compile
|
|
||||||
var _ thinking.ProviderApplier = (*Applier)(nil)
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestGeminiApply tests the Gemini thinking applier.
|
|
||||||
//
|
|
||||||
// Gemini-specific behavior:
|
|
||||||
// - Gemini 2.5: thinkingBudget format (numeric)
|
|
||||||
// - Gemini 3.x: thinkingLevel format (string)
|
|
||||||
// - Flash series: ZeroAllowed=true
|
|
||||||
// - Pro series: ZeroAllowed=false, Min=128
|
|
||||||
// - CRITICAL: When budget=0/none, set includeThoughts=false
|
|
||||||
//
|
|
||||||
// Depends on: Epic 7 Story 7-2, 7-3
|
|
||||||
func TestGeminiApply(t *testing.T) {
|
|
||||||
applier := NewApplier()
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
model string
|
|
||||||
config thinking.ThinkingConfig
|
|
||||||
wantField string
|
|
||||||
wantValue interface{}
|
|
||||||
wantIncludeThoughts bool // CRITICAL: includeThoughts field
|
|
||||||
}{
|
|
||||||
// Gemini 2.5 Flash (ZeroAllowed=true)
|
|
||||||
{"flash budget 8k", "gemini-2.5-flash", thinking.ThinkingConfig{Mode: thinking.ModeBudget, Budget: 8192}, "thinkingBudget", 8192, true},
|
|
||||||
{"flash zero", "gemini-2.5-flash", thinking.ThinkingConfig{Mode: thinking.ModeBudget, Budget: 0}, "thinkingBudget", 0, false},
|
|
||||||
{"flash none", "gemini-2.5-flash", thinking.ThinkingConfig{Mode: thinking.ModeNone, Budget: 0}, "thinkingBudget", 0, false},
|
|
||||||
|
|
||||||
// Gemini 2.5 Pro (ZeroAllowed=false, Min=128)
|
|
||||||
{"pro budget 8k", "gemini-2.5-pro", thinking.ThinkingConfig{Mode: thinking.ModeBudget, Budget: 8192}, "thinkingBudget", 8192, true},
|
|
||||||
{"pro zero - clamp", "gemini-2.5-pro", thinking.ThinkingConfig{Mode: thinking.ModeBudget, Budget: 0}, "thinkingBudget", 128, false},
|
|
||||||
{"pro none - clamp", "gemini-2.5-pro", thinking.ThinkingConfig{Mode: thinking.ModeNone, Budget: 0}, "thinkingBudget", 128, false},
|
|
||||||
{"pro below min", "gemini-2.5-pro", thinking.ThinkingConfig{Mode: thinking.ModeBudget, Budget: 50}, "thinkingBudget", 128, true},
|
|
||||||
{"pro above max", "gemini-2.5-pro", thinking.ThinkingConfig{Mode: thinking.ModeBudget, Budget: 50000}, "thinkingBudget", 32768, true},
|
|
||||||
{"pro auto", "gemini-2.5-pro", thinking.ThinkingConfig{Mode: thinking.ModeAuto, Budget: -1}, "thinkingBudget", -1, true},
|
|
||||||
|
|
||||||
// Gemini 3 Pro (Level mode, ZeroAllowed=false)
|
|
||||||
{"g3-pro high", "gemini-3-pro-preview", thinking.ThinkingConfig{Mode: thinking.ModeLevel, Level: thinking.LevelHigh}, "thinkingLevel", "high", true},
|
|
||||||
{"g3-pro low", "gemini-3-pro-preview", thinking.ThinkingConfig{Mode: thinking.ModeLevel, Level: thinking.LevelLow}, "thinkingLevel", "low", true},
|
|
||||||
{"g3-pro auto", "gemini-3-pro-preview", thinking.ThinkingConfig{Mode: thinking.ModeAuto, Budget: -1}, "thinkingBudget", -1, true},
|
|
||||||
|
|
||||||
// Gemini 3 Flash (Level mode, minimal is lowest)
|
|
||||||
{"g3-flash high", "gemini-3-flash-preview", thinking.ThinkingConfig{Mode: thinking.ModeLevel, Level: thinking.LevelHigh}, "thinkingLevel", "high", true},
|
|
||||||
{"g3-flash medium", "gemini-3-flash-preview", thinking.ThinkingConfig{Mode: thinking.ModeLevel, Level: thinking.LevelMedium}, "thinkingLevel", "medium", true},
|
|
||||||
{"g3-flash minimal", "gemini-3-flash-preview", thinking.ThinkingConfig{Mode: thinking.ModeLevel, Level: thinking.LevelMinimal}, "thinkingLevel", "minimal", true},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
modelInfo := buildGeminiModelInfo(tt.model)
|
|
||||||
normalized, err := thinking.ValidateConfig(tt.config, modelInfo.Thinking)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("ValidateConfig() error = %v", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
result, err := applier.Apply([]byte(`{}`), *normalized, modelInfo)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Apply() error = %v", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
gotField := gjson.GetBytes(result, "generationConfig.thinkingConfig."+tt.wantField)
|
|
||||||
switch want := tt.wantValue.(type) {
|
|
||||||
case int:
|
|
||||||
if int(gotField.Int()) != want {
|
|
||||||
t.Fatalf("%s = %d, want %d", tt.wantField, gotField.Int(), want)
|
|
||||||
}
|
|
||||||
case string:
|
|
||||||
if gotField.String() != want {
|
|
||||||
t.Fatalf("%s = %q, want %q", tt.wantField, gotField.String(), want)
|
|
||||||
}
|
|
||||||
case bool:
|
|
||||||
if gotField.Bool() != want {
|
|
||||||
t.Fatalf("%s = %v, want %v", tt.wantField, gotField.Bool(), want)
|
|
||||||
}
|
|
||||||
default:
|
|
||||||
t.Fatalf("unsupported wantValue type %T", tt.wantValue)
|
|
||||||
}
|
|
||||||
|
|
||||||
gotIncludeThoughts := gjson.GetBytes(result, "generationConfig.thinkingConfig.includeThoughts").Bool()
|
|
||||||
if gotIncludeThoughts != tt.wantIncludeThoughts {
|
|
||||||
t.Fatalf("includeThoughts = %v, want %v", gotIncludeThoughts, tt.wantIncludeThoughts)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestGeminiApplyEndToEndBudgetZero tests suffix parsing + validation + apply for budget=0.
|
|
||||||
//
|
|
||||||
// This test covers the complete flow from suffix parsing to Apply output:
|
|
||||||
// - AC#1: ModeBudget+Budget=0 → ModeNone conversion
|
|
||||||
// - AC#3: Gemini 3 ModeNone+Budget>0 → includeThoughts=false + thinkingLevel=low
|
|
||||||
// - AC#4: Gemini 2.5 Pro (0) → clamped to 128 + includeThoughts=false
|
|
||||||
func TestGeminiApplyEndToEndBudgetZero(t *testing.T) {
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
model string
|
|
||||||
wantModel string
|
|
||||||
wantField string // "thinkingBudget" or "thinkingLevel"
|
|
||||||
wantValue interface{}
|
|
||||||
wantIncludeThoughts bool
|
|
||||||
}{
|
|
||||||
// AC#4: Gemini 2.5 Pro - Budget format
|
|
||||||
{"gemini-25-pro zero", "gemini-2.5-pro(0)", "gemini-2.5-pro", "thinkingBudget", 128, false},
|
|
||||||
// AC#3: Gemini 3 Pro - Level format, ModeNone clamped to Budget=128, uses lowest level
|
|
||||||
{"gemini-3-pro zero", "gemini-3-pro-preview(0)", "gemini-3-pro-preview", "thinkingLevel", "low", false},
|
|
||||||
{"gemini-3-pro none", "gemini-3-pro-preview(none)", "gemini-3-pro-preview", "thinkingLevel", "low", false},
|
|
||||||
// Gemini 3 Flash - Level format, lowest level is "minimal"
|
|
||||||
{"gemini-3-flash zero", "gemini-3-flash-preview(0)", "gemini-3-flash-preview", "thinkingLevel", "minimal", false},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
suffix := thinking.ParseSuffix(tt.model)
|
|
||||||
if !suffix.HasSuffix {
|
|
||||||
t.Fatalf("ParseSuffix(%q) HasSuffix = false, want true", tt.model)
|
|
||||||
}
|
|
||||||
if suffix.ModelName != tt.wantModel {
|
|
||||||
t.Fatalf("ParseSuffix(%q) ModelName = %q, want %q", tt.model, suffix.ModelName, tt.wantModel)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Parse suffix value using helper function (L1 fix)
|
|
||||||
config, ok := parseConfigFromSuffix(suffix.RawSuffix)
|
|
||||||
if !ok {
|
|
||||||
t.Fatalf("ParseSuffix(%q) RawSuffix = %q is not a valid suffix", tt.model, suffix.RawSuffix)
|
|
||||||
}
|
|
||||||
|
|
||||||
modelInfo := buildGeminiModelInfo(suffix.ModelName)
|
|
||||||
normalized, err := thinking.ValidateConfig(config, modelInfo.Thinking)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("ValidateConfig() error = %v", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
applier := NewApplier()
|
|
||||||
result, err := applier.Apply([]byte(`{}`), *normalized, modelInfo)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Apply() error = %v", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Verify the output field value
|
|
||||||
gotField := gjson.GetBytes(result, "generationConfig.thinkingConfig."+tt.wantField)
|
|
||||||
switch want := tt.wantValue.(type) {
|
|
||||||
case int:
|
|
||||||
if int(gotField.Int()) != want {
|
|
||||||
t.Fatalf("%s = %d, want %d", tt.wantField, gotField.Int(), want)
|
|
||||||
}
|
|
||||||
case string:
|
|
||||||
if gotField.String() != want {
|
|
||||||
t.Fatalf("%s = %q, want %q", tt.wantField, gotField.String(), want)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
gotIncludeThoughts := gjson.GetBytes(result, "generationConfig.thinkingConfig.includeThoughts").Bool()
|
|
||||||
if gotIncludeThoughts != tt.wantIncludeThoughts {
|
|
||||||
t.Fatalf("includeThoughts = %v, want %v", gotIncludeThoughts, tt.wantIncludeThoughts)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestGeminiApplyEndToEndAuto tests auto mode through both suffix parsing and direct config.
|
|
||||||
//
|
|
||||||
// This test covers:
|
|
||||||
// - AC#2: Gemini 2.5 auto uses thinkingBudget=-1
|
|
||||||
// - AC#3: Gemini 3 auto uses thinkingBudget=-1 (not thinkingLevel)
|
|
||||||
// - Suffix parsing path: (auto) and (-1) suffixes
|
|
||||||
// - Direct config path: ModeLevel + Level=auto → ModeAuto conversion
|
|
||||||
func TestGeminiApplyEndToEndAuto(t *testing.T) {
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
model string // model name (with suffix for parsing, or plain for direct config)
|
|
||||||
directConfig *thinking.ThinkingConfig // if not nil, use direct config instead of suffix parsing
|
|
||||||
wantField string
|
|
||||||
wantValue int
|
|
||||||
wantIncludeThoughts bool
|
|
||||||
}{
|
|
||||||
// Suffix parsing path - Budget-only model (Gemini 2.5)
|
|
||||||
{"suffix auto g25", "gemini-2.5-pro(auto)", nil, "thinkingBudget", -1, true},
|
|
||||||
{"suffix -1 g25", "gemini-2.5-pro(-1)", nil, "thinkingBudget", -1, true},
|
|
||||||
// Suffix parsing path - Hybrid model (Gemini 3)
|
|
||||||
{"suffix auto g3", "gemini-3-pro-preview(auto)", nil, "thinkingBudget", -1, true},
|
|
||||||
{"suffix -1 g3", "gemini-3-pro-preview(-1)", nil, "thinkingBudget", -1, true},
|
|
||||||
// Direct config path - Level=auto → ModeAuto conversion
|
|
||||||
{"direct level=auto g25", "gemini-2.5-pro", &thinking.ThinkingConfig{Mode: thinking.ModeLevel, Level: thinking.LevelAuto}, "thinkingBudget", -1, true},
|
|
||||||
{"direct level=auto g3", "gemini-3-pro-preview", &thinking.ThinkingConfig{Mode: thinking.ModeLevel, Level: thinking.LevelAuto}, "thinkingBudget", -1, true},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
var config thinking.ThinkingConfig
|
|
||||||
var modelName string
|
|
||||||
|
|
||||||
if tt.directConfig != nil {
|
|
||||||
// Direct config path
|
|
||||||
config = *tt.directConfig
|
|
||||||
modelName = tt.model
|
|
||||||
} else {
|
|
||||||
// Suffix parsing path
|
|
||||||
suffix := thinking.ParseSuffix(tt.model)
|
|
||||||
if !suffix.HasSuffix {
|
|
||||||
t.Fatalf("ParseSuffix(%q) HasSuffix = false", tt.model)
|
|
||||||
}
|
|
||||||
modelName = suffix.ModelName
|
|
||||||
var ok bool
|
|
||||||
config, ok = parseConfigFromSuffix(suffix.RawSuffix)
|
|
||||||
if !ok {
|
|
||||||
t.Fatalf("parseConfigFromSuffix(%q) failed", suffix.RawSuffix)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
modelInfo := buildGeminiModelInfo(modelName)
|
|
||||||
normalized, err := thinking.ValidateConfig(config, modelInfo.Thinking)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("ValidateConfig() error = %v", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Verify ModeAuto after validation
|
|
||||||
if normalized.Mode != thinking.ModeAuto {
|
|
||||||
t.Fatalf("ValidateConfig() Mode = %v, want ModeAuto", normalized.Mode)
|
|
||||||
}
|
|
||||||
|
|
||||||
applier := NewApplier()
|
|
||||||
result, err := applier.Apply([]byte(`{}`), *normalized, modelInfo)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Apply() error = %v", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
gotField := gjson.GetBytes(result, "generationConfig.thinkingConfig."+tt.wantField)
|
|
||||||
if int(gotField.Int()) != tt.wantValue {
|
|
||||||
t.Fatalf("%s = %d, want %d", tt.wantField, gotField.Int(), tt.wantValue)
|
|
||||||
}
|
|
||||||
|
|
||||||
gotIncludeThoughts := gjson.GetBytes(result, "generationConfig.thinkingConfig.includeThoughts").Bool()
|
|
||||||
if gotIncludeThoughts != tt.wantIncludeThoughts {
|
|
||||||
t.Fatalf("includeThoughts = %v, want %v", gotIncludeThoughts, tt.wantIncludeThoughts)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestGeminiApplyInvalidBody(t *testing.T) {
|
|
||||||
applier := NewApplier()
|
|
||||||
modelInfo := buildGeminiModelInfo("gemini-2.5-flash")
|
|
||||||
config := thinking.ThinkingConfig{Mode: thinking.ModeBudget, Budget: 8192}
|
|
||||||
normalized, err := thinking.ValidateConfig(config, modelInfo.Thinking)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("ValidateConfig() error = %v", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
body []byte
|
|
||||||
}{
|
|
||||||
{"nil body", nil},
|
|
||||||
{"empty body", []byte{}},
|
|
||||||
{"invalid json", []byte("{\"not json\"")},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
result, err := applier.Apply(tt.body, *normalized, modelInfo)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Apply() error = %v", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
gotBudget := int(gjson.GetBytes(result, "generationConfig.thinkingConfig.thinkingBudget").Int())
|
|
||||||
if gotBudget != 8192 {
|
|
||||||
t.Fatalf("thinkingBudget = %d, want %d", gotBudget, 8192)
|
|
||||||
}
|
|
||||||
|
|
||||||
gotIncludeThoughts := gjson.GetBytes(result, "generationConfig.thinkingConfig.includeThoughts").Bool()
|
|
||||||
if !gotIncludeThoughts {
|
|
||||||
t.Fatalf("includeThoughts = %v, want %v", gotIncludeThoughts, true)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestGeminiApplyConflictingFields tests that conflicting fields are removed.
|
|
||||||
//
|
|
||||||
// When applying Budget format, any existing thinkingLevel should be removed.
|
|
||||||
// When applying Level format, any existing thinkingBudget should be removed.
|
|
||||||
func TestGeminiApplyConflictingFields(t *testing.T) {
|
|
||||||
applier := NewApplier()
|
|
||||||
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
model string
|
|
||||||
config thinking.ThinkingConfig
|
|
||||||
existingBody string
|
|
||||||
wantField string // expected field to exist
|
|
||||||
wantNoField string // expected field to NOT exist
|
|
||||||
}{
|
|
||||||
// Budget format should remove existing thinkingLevel
|
|
||||||
{
|
|
||||||
"budget removes level",
|
|
||||||
"gemini-2.5-pro",
|
|
||||||
thinking.ThinkingConfig{Mode: thinking.ModeBudget, Budget: 8192},
|
|
||||||
`{"generationConfig":{"thinkingConfig":{"thinkingLevel":"high"}}}`,
|
|
||||||
"thinkingBudget",
|
|
||||||
"thinkingLevel",
|
|
||||||
},
|
|
||||||
// Level format should remove existing thinkingBudget
|
|
||||||
{
|
|
||||||
"level removes budget",
|
|
||||||
"gemini-3-pro-preview",
|
|
||||||
thinking.ThinkingConfig{Mode: thinking.ModeLevel, Level: thinking.LevelHigh},
|
|
||||||
`{"generationConfig":{"thinkingConfig":{"thinkingBudget":8192}}}`,
|
|
||||||
"thinkingLevel",
|
|
||||||
"thinkingBudget",
|
|
||||||
},
|
|
||||||
// ModeAuto uses budget format, should remove thinkingLevel
|
|
||||||
{
|
|
||||||
"auto removes level",
|
|
||||||
"gemini-3-pro-preview",
|
|
||||||
thinking.ThinkingConfig{Mode: thinking.ModeAuto, Budget: -1},
|
|
||||||
`{"generationConfig":{"thinkingConfig":{"thinkingLevel":"high"}}}`,
|
|
||||||
"thinkingBudget",
|
|
||||||
"thinkingLevel",
|
|
||||||
},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
modelInfo := buildGeminiModelInfo(tt.model)
|
|
||||||
result, err := applier.Apply([]byte(tt.existingBody), tt.config, modelInfo)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Apply() error = %v", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Verify expected field exists
|
|
||||||
wantPath := "generationConfig.thinkingConfig." + tt.wantField
|
|
||||||
if !gjson.GetBytes(result, wantPath).Exists() {
|
|
||||||
t.Fatalf("%s should exist in result: %s", tt.wantField, string(result))
|
|
||||||
}
|
|
||||||
|
|
||||||
// Verify conflicting field was removed
|
|
||||||
noPath := "generationConfig.thinkingConfig." + tt.wantNoField
|
|
||||||
if gjson.GetBytes(result, noPath).Exists() {
|
|
||||||
t.Fatalf("%s should NOT exist in result: %s", tt.wantNoField, string(result))
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestGeminiApplyThinkingNotSupported tests passthrough handling when modelInfo.Thinking is nil.
|
|
||||||
func TestGeminiApplyThinkingNotSupported(t *testing.T) {
|
|
||||||
applier := NewApplier()
|
|
||||||
config := thinking.ThinkingConfig{Mode: thinking.ModeBudget, Budget: 8192}
|
|
||||||
body := []byte(`{"generationConfig":{"thinkingConfig":{"thinkingBudget":8192}}}`)
|
|
||||||
|
|
||||||
// Model with nil Thinking support
|
|
||||||
modelInfo := ®istry.ModelInfo{ID: "gemini-unknown", Thinking: nil}
|
|
||||||
|
|
||||||
got, err := applier.Apply(body, config, modelInfo)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Apply() expected nil error for nil Thinking, got %v", err)
|
|
||||||
}
|
|
||||||
if string(got) != string(body) {
|
|
||||||
t.Fatalf("expected body unchanged, got %s", string(got))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func buildGeminiModelInfo(modelID string) *registry.ModelInfo {
|
|
||||||
support := ®istry.ThinkingSupport{}
|
|
||||||
switch modelID {
|
|
||||||
case "gemini-2.5-pro":
|
|
||||||
support.Min = 128
|
|
||||||
support.Max = 32768
|
|
||||||
support.ZeroAllowed = false
|
|
||||||
support.DynamicAllowed = true
|
|
||||||
case "gemini-2.5-flash", "gemini-2.5-flash-lite":
|
|
||||||
support.Min = 0
|
|
||||||
support.Max = 24576
|
|
||||||
support.ZeroAllowed = true
|
|
||||||
support.DynamicAllowed = true
|
|
||||||
case "gemini-3-pro-preview":
|
|
||||||
support.Min = 128
|
|
||||||
support.Max = 32768
|
|
||||||
support.ZeroAllowed = false
|
|
||||||
support.DynamicAllowed = true
|
|
||||||
support.Levels = []string{"low", "high"}
|
|
||||||
case "gemini-3-flash-preview":
|
|
||||||
support.Min = 128
|
|
||||||
support.Max = 32768
|
|
||||||
support.ZeroAllowed = false
|
|
||||||
support.DynamicAllowed = true
|
|
||||||
support.Levels = []string{"minimal", "low", "medium", "high"}
|
|
||||||
default:
|
|
||||||
// Unknown model - return nil Thinking to trigger error path
|
|
||||||
return ®istry.ModelInfo{ID: modelID, Thinking: nil}
|
|
||||||
}
|
|
||||||
return ®istry.ModelInfo{
|
|
||||||
ID: modelID,
|
|
||||||
Thinking: support,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestGeminiApplyNilModelInfo tests Apply behavior when modelInfo is nil.
|
|
||||||
// Coverage: apply.go:56-58 (H1)
|
|
||||||
func TestGeminiApplyNilModelInfo(t *testing.T) {
|
|
||||||
applier := NewApplier()
|
|
||||||
config := thinking.ThinkingConfig{Mode: thinking.ModeBudget, Budget: 8192}
|
|
||||||
body := []byte(`{"existing": "data"}`)
|
|
||||||
|
|
||||||
result, err := applier.Apply(body, config, nil)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Apply() with nil modelInfo should not error, got: %v", err)
|
|
||||||
}
|
|
||||||
// nil modelInfo now applies compatible config
|
|
||||||
if !gjson.GetBytes(result, "generationConfig.thinkingConfig.thinkingBudget").Exists() {
|
|
||||||
t.Fatalf("Apply() with nil modelInfo should apply thinking config, got: %s", result)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestGeminiApplyEmptyModelID tests Apply when modelID is empty.
|
|
||||||
// Coverage: apply.go:61-63 (H2)
|
|
||||||
func TestGeminiApplyEmptyModelID(t *testing.T) {
|
|
||||||
applier := NewApplier()
|
|
||||||
config := thinking.ThinkingConfig{Mode: thinking.ModeBudget, Budget: 8192}
|
|
||||||
modelInfo := ®istry.ModelInfo{ID: "", Thinking: nil}
|
|
||||||
body := []byte(`{"generationConfig":{"thinkingConfig":{"thinkingBudget":8192}}}`)
|
|
||||||
|
|
||||||
got, err := applier.Apply(body, config, modelInfo)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Apply() expected nil error, got %v", err)
|
|
||||||
}
|
|
||||||
if string(got) != string(body) {
|
|
||||||
t.Fatalf("expected body unchanged, got %s", string(got))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestGeminiApplyModeBudgetWithLevels tests that ModeBudget is applied with budget format
|
|
||||||
// even for models with Levels. The Apply layer handles ModeBudget by applying thinkingBudget.
|
|
||||||
// Coverage: apply.go:88-90
|
|
||||||
func TestGeminiApplyModeBudgetWithLevels(t *testing.T) {
|
|
||||||
applier := NewApplier()
|
|
||||||
modelInfo := buildGeminiModelInfo("gemini-3-flash-preview")
|
|
||||||
config := thinking.ThinkingConfig{Mode: thinking.ModeBudget, Budget: 8192}
|
|
||||||
body := []byte(`{"existing": "data"}`)
|
|
||||||
|
|
||||||
result, err := applier.Apply(body, config, modelInfo)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Apply() error = %v", err)
|
|
||||||
}
|
|
||||||
// ModeBudget applies budget format
|
|
||||||
budget := gjson.GetBytes(result, "generationConfig.thinkingConfig.thinkingBudget").Int()
|
|
||||||
if budget != 8192 {
|
|
||||||
t.Fatalf("Apply() expected thinkingBudget=8192, got: %d", budget)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestGeminiApplyUnsupportedMode tests behavior with unsupported Mode types.
|
|
||||||
// Coverage: apply.go:67-69 and 97-98 (H5, L2)
|
|
||||||
func TestGeminiApplyUnsupportedMode(t *testing.T) {
|
|
||||||
applier := NewApplier()
|
|
||||||
body := []byte(`{"existing": "data"}`)
|
|
||||||
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
model string
|
|
||||||
config thinking.ThinkingConfig
|
|
||||||
}{
|
|
||||||
{"unknown mode with budget model", "gemini-2.5-pro", thinking.ThinkingConfig{Mode: thinking.ThinkingMode(99), Budget: 8192}},
|
|
||||||
{"unknown mode with level model", "gemini-3-pro-preview", thinking.ThinkingConfig{Mode: thinking.ThinkingMode(99), Level: thinking.LevelHigh}},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
modelInfo := buildGeminiModelInfo(tt.model)
|
|
||||||
result, err := applier.Apply(body, tt.config, modelInfo)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Apply() error = %v", err)
|
|
||||||
}
|
|
||||||
// Unsupported modes return original body unchanged
|
|
||||||
if string(result) != string(body) {
|
|
||||||
t.Fatalf("Apply() with unsupported mode should return original body, got: %s", result)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,375 +0,0 @@
|
|||||||
// Package geminicli implements thinking configuration for Gemini CLI API format.
|
|
||||||
package geminicli
|
|
||||||
|
|
||||||
import (
|
|
||||||
"testing"
|
|
||||||
|
|
||||||
"github.com/router-for-me/CLIProxyAPI/v6/internal/registry"
|
|
||||||
"github.com/router-for-me/CLIProxyAPI/v6/internal/thinking"
|
|
||||||
"github.com/tidwall/gjson"
|
|
||||||
)
|
|
||||||
|
|
||||||
func TestNewApplier(t *testing.T) {
|
|
||||||
applier := NewApplier()
|
|
||||||
if applier == nil {
|
|
||||||
t.Fatal("NewApplier() returned nil")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestApplierImplementsInterface(t *testing.T) {
|
|
||||||
// Compile-time check: if Applier doesn't implement the interface, this won't compile
|
|
||||||
var _ thinking.ProviderApplier = (*Applier)(nil)
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestGeminiCLIApply tests the Gemini CLI thinking applier.
|
|
||||||
//
|
|
||||||
// Gemini CLI uses request.generationConfig.thinkingConfig.* path.
|
|
||||||
// Behavior mirrors Gemini applier but with different JSON path prefix.
|
|
||||||
func TestGeminiCLIApply(t *testing.T) {
|
|
||||||
applier := NewApplier()
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
model string
|
|
||||||
config thinking.ThinkingConfig
|
|
||||||
wantField string
|
|
||||||
wantValue interface{}
|
|
||||||
wantIncludeThoughts bool
|
|
||||||
}{
|
|
||||||
// Budget mode (no Levels)
|
|
||||||
{"budget 8k", "gemini-cli-budget", thinking.ThinkingConfig{Mode: thinking.ModeBudget, Budget: 8192}, "thinkingBudget", 8192, true},
|
|
||||||
{"budget zero", "gemini-cli-budget", thinking.ThinkingConfig{Mode: thinking.ModeBudget, Budget: 0}, "thinkingBudget", 0, false},
|
|
||||||
{"none mode", "gemini-cli-budget", thinking.ThinkingConfig{Mode: thinking.ModeNone, Budget: 0}, "thinkingBudget", 0, false},
|
|
||||||
{"auto mode", "gemini-cli-budget", thinking.ThinkingConfig{Mode: thinking.ModeAuto, Budget: -1}, "thinkingBudget", -1, true},
|
|
||||||
|
|
||||||
// Level mode (has Levels)
|
|
||||||
{"level high", "gemini-cli-level", thinking.ThinkingConfig{Mode: thinking.ModeLevel, Level: thinking.LevelHigh}, "thinkingLevel", "high", true},
|
|
||||||
{"level low", "gemini-cli-level", thinking.ThinkingConfig{Mode: thinking.ModeLevel, Level: thinking.LevelLow}, "thinkingLevel", "low", true},
|
|
||||||
{"level minimal", "gemini-cli-level", thinking.ThinkingConfig{Mode: thinking.ModeLevel, Level: thinking.LevelMinimal}, "thinkingLevel", "minimal", true},
|
|
||||||
// ModeAuto with Levels model still uses thinkingBudget=-1
|
|
||||||
{"auto with levels", "gemini-cli-level", thinking.ThinkingConfig{Mode: thinking.ModeAuto, Budget: -1}, "thinkingBudget", -1, true},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
modelInfo := buildGeminiCLIModelInfo(tt.model)
|
|
||||||
result, err := applier.Apply([]byte(`{}`), tt.config, modelInfo)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Apply() error = %v", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
gotField := gjson.GetBytes(result, "request.generationConfig.thinkingConfig."+tt.wantField)
|
|
||||||
switch want := tt.wantValue.(type) {
|
|
||||||
case int:
|
|
||||||
if int(gotField.Int()) != want {
|
|
||||||
t.Fatalf("%s = %d, want %d", tt.wantField, gotField.Int(), want)
|
|
||||||
}
|
|
||||||
case string:
|
|
||||||
if gotField.String() != want {
|
|
||||||
t.Fatalf("%s = %q, want %q", tt.wantField, gotField.String(), want)
|
|
||||||
}
|
|
||||||
case bool:
|
|
||||||
if gotField.Bool() != want {
|
|
||||||
t.Fatalf("%s = %v, want %v", tt.wantField, gotField.Bool(), want)
|
|
||||||
}
|
|
||||||
default:
|
|
||||||
t.Fatalf("unsupported wantValue type %T", tt.wantValue)
|
|
||||||
}
|
|
||||||
|
|
||||||
gotIncludeThoughts := gjson.GetBytes(result, "request.generationConfig.thinkingConfig.includeThoughts").Bool()
|
|
||||||
if gotIncludeThoughts != tt.wantIncludeThoughts {
|
|
||||||
t.Fatalf("includeThoughts = %v, want %v", gotIncludeThoughts, tt.wantIncludeThoughts)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestGeminiCLIApplyModeNoneWithLevel tests ModeNone with Level model.
|
|
||||||
// When ModeNone is used with a model that has Levels, includeThoughts should be false.
|
|
||||||
func TestGeminiCLIApplyModeNoneWithLevel(t *testing.T) {
|
|
||||||
applier := NewApplier()
|
|
||||||
modelInfo := buildGeminiCLIModelInfo("gemini-cli-level")
|
|
||||||
config := thinking.ThinkingConfig{Mode: thinking.ModeNone, Level: thinking.LevelLow}
|
|
||||||
|
|
||||||
result, err := applier.Apply([]byte(`{}`), config, modelInfo)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Apply() error = %v", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
gotIncludeThoughts := gjson.GetBytes(result, "request.generationConfig.thinkingConfig.includeThoughts").Bool()
|
|
||||||
if gotIncludeThoughts != false {
|
|
||||||
t.Fatalf("includeThoughts = %v, want %v", gotIncludeThoughts, false)
|
|
||||||
}
|
|
||||||
|
|
||||||
gotLevel := gjson.GetBytes(result, "request.generationConfig.thinkingConfig.thinkingLevel").String()
|
|
||||||
if gotLevel != "low" {
|
|
||||||
t.Fatalf("thinkingLevel = %q, want %q", gotLevel, "low")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestGeminiCLIApplyInvalidBody tests Apply behavior with invalid body inputs.
|
|
||||||
func TestGeminiCLIApplyInvalidBody(t *testing.T) {
|
|
||||||
applier := NewApplier()
|
|
||||||
modelInfo := buildGeminiCLIModelInfo("gemini-cli-budget")
|
|
||||||
config := thinking.ThinkingConfig{Mode: thinking.ModeBudget, Budget: 8192}
|
|
||||||
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
body []byte
|
|
||||||
}{
|
|
||||||
{"nil body", nil},
|
|
||||||
{"empty body", []byte{}},
|
|
||||||
{"invalid json", []byte("{\"not json\"")},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
result, err := applier.Apply(tt.body, config, modelInfo)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Apply() error = %v", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
gotBudget := int(gjson.GetBytes(result, "request.generationConfig.thinkingConfig.thinkingBudget").Int())
|
|
||||||
if gotBudget != 8192 {
|
|
||||||
t.Fatalf("thinkingBudget = %d, want %d", gotBudget, 8192)
|
|
||||||
}
|
|
||||||
|
|
||||||
gotIncludeThoughts := gjson.GetBytes(result, "request.generationConfig.thinkingConfig.includeThoughts").Bool()
|
|
||||||
if !gotIncludeThoughts {
|
|
||||||
t.Fatalf("includeThoughts = %v, want %v", gotIncludeThoughts, true)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestGeminiCLIApplyConflictingFields tests that conflicting fields are removed.
|
|
||||||
//
|
|
||||||
// When applying Budget format, any existing thinkingLevel should be removed.
|
|
||||||
// When applying Level format, any existing thinkingBudget should be removed.
|
|
||||||
func TestGeminiCLIApplyConflictingFields(t *testing.T) {
|
|
||||||
applier := NewApplier()
|
|
||||||
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
model string
|
|
||||||
config thinking.ThinkingConfig
|
|
||||||
existingBody string
|
|
||||||
wantField string // expected field to exist
|
|
||||||
wantNoField string // expected field to NOT exist
|
|
||||||
}{
|
|
||||||
// Budget format should remove existing thinkingLevel
|
|
||||||
{
|
|
||||||
"budget removes level",
|
|
||||||
"gemini-cli-budget",
|
|
||||||
thinking.ThinkingConfig{Mode: thinking.ModeBudget, Budget: 8192},
|
|
||||||
`{"request":{"generationConfig":{"thinkingConfig":{"thinkingLevel":"high"}}}}`,
|
|
||||||
"thinkingBudget",
|
|
||||||
"thinkingLevel",
|
|
||||||
},
|
|
||||||
// Level format should remove existing thinkingBudget
|
|
||||||
{
|
|
||||||
"level removes budget",
|
|
||||||
"gemini-cli-level",
|
|
||||||
thinking.ThinkingConfig{Mode: thinking.ModeLevel, Level: thinking.LevelHigh},
|
|
||||||
`{"request":{"generationConfig":{"thinkingConfig":{"thinkingBudget":8192}}}}`,
|
|
||||||
"thinkingLevel",
|
|
||||||
"thinkingBudget",
|
|
||||||
},
|
|
||||||
// ModeAuto uses budget format, should remove thinkingLevel
|
|
||||||
{
|
|
||||||
"auto removes level",
|
|
||||||
"gemini-cli-level",
|
|
||||||
thinking.ThinkingConfig{Mode: thinking.ModeAuto, Budget: -1},
|
|
||||||
`{"request":{"generationConfig":{"thinkingConfig":{"thinkingLevel":"high"}}}}`,
|
|
||||||
"thinkingBudget",
|
|
||||||
"thinkingLevel",
|
|
||||||
},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
modelInfo := buildGeminiCLIModelInfo(tt.model)
|
|
||||||
result, err := applier.Apply([]byte(tt.existingBody), tt.config, modelInfo)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Apply() error = %v", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Verify expected field exists
|
|
||||||
wantPath := "request.generationConfig.thinkingConfig." + tt.wantField
|
|
||||||
if !gjson.GetBytes(result, wantPath).Exists() {
|
|
||||||
t.Fatalf("%s should exist in result: %s", tt.wantField, string(result))
|
|
||||||
}
|
|
||||||
|
|
||||||
// Verify conflicting field was removed
|
|
||||||
noPath := "request.generationConfig.thinkingConfig." + tt.wantNoField
|
|
||||||
if gjson.GetBytes(result, noPath).Exists() {
|
|
||||||
t.Fatalf("%s should NOT exist in result: %s", tt.wantNoField, string(result))
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestGeminiCLIApplyThinkingNotSupported tests passthrough handling when modelInfo.Thinking is nil.
|
|
||||||
func TestGeminiCLIApplyThinkingNotSupported(t *testing.T) {
|
|
||||||
applier := NewApplier()
|
|
||||||
config := thinking.ThinkingConfig{Mode: thinking.ModeBudget, Budget: 8192}
|
|
||||||
body := []byte(`{"request":{"generationConfig":{"thinkingConfig":{"thinkingBudget":8192}}}}`)
|
|
||||||
|
|
||||||
// Model with nil Thinking support
|
|
||||||
modelInfo := ®istry.ModelInfo{ID: "gemini-cli-unknown", Thinking: nil}
|
|
||||||
|
|
||||||
got, err := applier.Apply(body, config, modelInfo)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Apply() expected nil error for nil Thinking, got %v", err)
|
|
||||||
}
|
|
||||||
if string(got) != string(body) {
|
|
||||||
t.Fatalf("expected body unchanged, got %s", string(got))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestGeminiCLIApplyNilModelInfo tests Apply behavior when modelInfo is nil.
|
|
||||||
func TestGeminiCLIApplyNilModelInfo(t *testing.T) {
|
|
||||||
applier := NewApplier()
|
|
||||||
config := thinking.ThinkingConfig{Mode: thinking.ModeBudget, Budget: 8192}
|
|
||||||
body := []byte(`{"existing": "data"}`)
|
|
||||||
|
|
||||||
result, err := applier.Apply(body, config, nil)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Apply() with nil modelInfo should not error, got: %v", err)
|
|
||||||
}
|
|
||||||
// nil modelInfo now applies compatible config
|
|
||||||
if !gjson.GetBytes(result, "request.generationConfig.thinkingConfig.thinkingBudget").Exists() {
|
|
||||||
t.Fatalf("Apply() with nil modelInfo should apply thinking config, got: %s", result)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestGeminiCLIApplyEmptyModelID tests Apply when modelID is empty.
|
|
||||||
func TestGeminiCLIApplyEmptyModelID(t *testing.T) {
|
|
||||||
applier := NewApplier()
|
|
||||||
config := thinking.ThinkingConfig{Mode: thinking.ModeBudget, Budget: 8192}
|
|
||||||
modelInfo := ®istry.ModelInfo{ID: "", Thinking: nil}
|
|
||||||
body := []byte(`{"request":{"generationConfig":{"thinkingConfig":{"thinkingBudget":8192}}}}`)
|
|
||||||
|
|
||||||
got, err := applier.Apply(body, config, modelInfo)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Apply() expected nil error, got %v", err)
|
|
||||||
}
|
|
||||||
if string(got) != string(body) {
|
|
||||||
t.Fatalf("expected body unchanged, got %s", string(got))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestGeminiCLIApplyModeBudgetWithLevels tests that ModeBudget with Levels model passes through.
|
|
||||||
// Apply layer doesn't convert - upper layer should handle Budget→Level conversion.
|
|
||||||
func TestGeminiCLIApplyModeBudgetWithLevels(t *testing.T) {
|
|
||||||
applier := NewApplier()
|
|
||||||
modelInfo := buildGeminiCLIModelInfo("gemini-cli-level")
|
|
||||||
config := thinking.ThinkingConfig{Mode: thinking.ModeBudget, Budget: 8192}
|
|
||||||
body := []byte(`{"existing": "data"}`)
|
|
||||||
|
|
||||||
result, err := applier.Apply(body, config, modelInfo)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Apply() error = %v", err)
|
|
||||||
}
|
|
||||||
// ModeBudget applies budget format directly without conversion to levels
|
|
||||||
if !gjson.GetBytes(result, "request.generationConfig.thinkingConfig.thinkingBudget").Exists() {
|
|
||||||
t.Fatalf("Apply() ModeBudget should apply budget format, got: %s", result)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestGeminiCLIApplyUnsupportedMode tests behavior with unsupported Mode types.
|
|
||||||
func TestGeminiCLIApplyUnsupportedMode(t *testing.T) {
|
|
||||||
applier := NewApplier()
|
|
||||||
body := []byte(`{"existing": "data"}`)
|
|
||||||
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
model string
|
|
||||||
config thinking.ThinkingConfig
|
|
||||||
}{
|
|
||||||
{"unknown mode with budget model", "gemini-cli-budget", thinking.ThinkingConfig{Mode: thinking.ThinkingMode(99), Budget: 8192}},
|
|
||||||
{"unknown mode with level model", "gemini-cli-level", thinking.ThinkingConfig{Mode: thinking.ThinkingMode(99), Level: thinking.LevelHigh}},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
modelInfo := buildGeminiCLIModelInfo(tt.model)
|
|
||||||
result, err := applier.Apply(body, tt.config, modelInfo)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Apply() error = %v", err)
|
|
||||||
}
|
|
||||||
// Unsupported modes return original body unchanged
|
|
||||||
if string(result) != string(body) {
|
|
||||||
t.Fatalf("Apply() with unsupported mode should return original body, got: %s", result)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestAntigravityUsesGeminiCLIFormat tests that antigravity provider uses gemini-cli format.
|
|
||||||
// Antigravity is registered with the same applier as gemini-cli.
|
|
||||||
func TestAntigravityUsesGeminiCLIFormat(t *testing.T) {
|
|
||||||
applier := NewApplier()
|
|
||||||
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
config thinking.ThinkingConfig
|
|
||||||
modelInfo *registry.ModelInfo
|
|
||||||
wantField string
|
|
||||||
}{
|
|
||||||
{
|
|
||||||
"claude model budget",
|
|
||||||
thinking.ThinkingConfig{Mode: thinking.ModeBudget, Budget: 16384},
|
|
||||||
®istry.ModelInfo{ID: "gemini-claude-sonnet-4-5-thinking", Thinking: ®istry.ThinkingSupport{Min: 1024, Max: 200000}},
|
|
||||||
"request.generationConfig.thinkingConfig.thinkingBudget",
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"opus model budget",
|
|
||||||
thinking.ThinkingConfig{Mode: thinking.ModeBudget, Budget: 32768},
|
|
||||||
®istry.ModelInfo{ID: "gemini-claude-opus-4-5-thinking", Thinking: ®istry.ThinkingSupport{Min: 1024, Max: 200000}},
|
|
||||||
"request.generationConfig.thinkingConfig.thinkingBudget",
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"model with levels",
|
|
||||||
thinking.ThinkingConfig{Mode: thinking.ModeLevel, Level: thinking.LevelHigh},
|
|
||||||
®istry.ModelInfo{ID: "some-model-with-levels", Thinking: ®istry.ThinkingSupport{Min: 1024, Max: 200000, Levels: []string{"low", "high"}}},
|
|
||||||
"request.generationConfig.thinkingConfig.thinkingLevel",
|
|
||||||
},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
got, err := applier.Apply([]byte(`{}`), tt.config, tt.modelInfo)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Apply() error = %v", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
if !gjson.GetBytes(got, tt.wantField).Exists() {
|
|
||||||
t.Fatalf("expected field %s in output: %s", tt.wantField, string(got))
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func buildGeminiCLIModelInfo(modelID string) *registry.ModelInfo {
|
|
||||||
support := ®istry.ThinkingSupport{}
|
|
||||||
switch modelID {
|
|
||||||
case "gemini-cli-budget":
|
|
||||||
support.Min = 0
|
|
||||||
support.Max = 32768
|
|
||||||
support.ZeroAllowed = true
|
|
||||||
support.DynamicAllowed = true
|
|
||||||
case "gemini-cli-level":
|
|
||||||
support.Min = 128
|
|
||||||
support.Max = 32768
|
|
||||||
support.ZeroAllowed = false
|
|
||||||
support.DynamicAllowed = true
|
|
||||||
support.Levels = []string{"minimal", "low", "medium", "high"}
|
|
||||||
default:
|
|
||||||
// Unknown model - return nil Thinking to trigger error path
|
|
||||||
return ®istry.ModelInfo{ID: modelID, Thinking: nil}
|
|
||||||
}
|
|
||||||
return ®istry.ModelInfo{
|
|
||||||
ID: modelID,
|
|
||||||
Thinking: support,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,318 +0,0 @@
|
|||||||
// Package iflow implements thinking configuration for iFlow models (GLM, MiniMax).
|
|
||||||
package iflow
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bytes"
|
|
||||||
"testing"
|
|
||||||
|
|
||||||
"github.com/router-for-me/CLIProxyAPI/v6/internal/registry"
|
|
||||||
"github.com/router-for-me/CLIProxyAPI/v6/internal/thinking"
|
|
||||||
"github.com/tidwall/gjson"
|
|
||||||
)
|
|
||||||
|
|
||||||
func TestNewApplier(t *testing.T) {
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
}{
|
|
||||||
{"default"},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
applier := NewApplier()
|
|
||||||
if applier == nil {
|
|
||||||
t.Fatalf("expected non-nil applier")
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestApplierImplementsInterface(t *testing.T) {
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
applier thinking.ProviderApplier
|
|
||||||
}{
|
|
||||||
{"default", NewApplier()},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
if tt.applier == nil {
|
|
||||||
t.Fatalf("expected thinking.ProviderApplier implementation")
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestApplyNilModelInfo(t *testing.T) {
|
|
||||||
applier := NewApplier()
|
|
||||||
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
body []byte
|
|
||||||
}{
|
|
||||||
{"nil body", nil},
|
|
||||||
{"empty body", []byte{}},
|
|
||||||
{"json body", []byte(`{"model":"glm-4.6"}`)},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
got, err := applier.Apply(tt.body, thinking.ThinkingConfig{}, nil)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("expected nil error, got %v", err)
|
|
||||||
}
|
|
||||||
if !bytes.Equal(got, tt.body) {
|
|
||||||
t.Fatalf("expected body unchanged, got %s", string(got))
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestApplyMissingThinkingSupport(t *testing.T) {
|
|
||||||
applier := NewApplier()
|
|
||||||
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
modelID string
|
|
||||||
}{
|
|
||||||
{"model id", "glm-4.6"},
|
|
||||||
{"empty model id", ""},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
modelInfo := ®istry.ModelInfo{ID: tt.modelID}
|
|
||||||
body := []byte(`{"model":"` + tt.modelID + `"}`)
|
|
||||||
got, err := applier.Apply(body, thinking.ThinkingConfig{}, modelInfo)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("expected nil error, got %v", err)
|
|
||||||
}
|
|
||||||
if string(got) != string(body) {
|
|
||||||
t.Fatalf("expected body unchanged, got %s", string(got))
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestConfigToBoolean(t *testing.T) {
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
config thinking.ThinkingConfig
|
|
||||||
want bool
|
|
||||||
}{
|
|
||||||
{"mode none", thinking.ThinkingConfig{Mode: thinking.ModeNone}, false},
|
|
||||||
{"mode auto", thinking.ThinkingConfig{Mode: thinking.ModeAuto}, true},
|
|
||||||
{"budget zero", thinking.ThinkingConfig{Mode: thinking.ModeBudget, Budget: 0}, false},
|
|
||||||
{"budget positive", thinking.ThinkingConfig{Mode: thinking.ModeBudget, Budget: 1000}, true},
|
|
||||||
{"level none", thinking.ThinkingConfig{Mode: thinking.ModeLevel, Level: thinking.LevelNone}, false},
|
|
||||||
{"level minimal", thinking.ThinkingConfig{Mode: thinking.ModeLevel, Level: thinking.LevelMinimal}, true},
|
|
||||||
{"level low", thinking.ThinkingConfig{Mode: thinking.ModeLevel, Level: thinking.LevelLow}, true},
|
|
||||||
{"level medium", thinking.ThinkingConfig{Mode: thinking.ModeLevel, Level: thinking.LevelMedium}, true},
|
|
||||||
{"level high", thinking.ThinkingConfig{Mode: thinking.ModeLevel, Level: thinking.LevelHigh}, true},
|
|
||||||
{"level xhigh", thinking.ThinkingConfig{Mode: thinking.ModeLevel, Level: thinking.LevelXHigh}, true},
|
|
||||||
{"zero value config", thinking.ThinkingConfig{}, false},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
if got := configToBoolean(tt.config); got != tt.want {
|
|
||||||
t.Fatalf("configToBoolean(%+v) = %v, want %v", tt.config, got, tt.want)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestApplyGLM(t *testing.T) {
|
|
||||||
applier := NewApplier()
|
|
||||||
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
modelID string
|
|
||||||
body []byte
|
|
||||||
config thinking.ThinkingConfig
|
|
||||||
wantEnable bool
|
|
||||||
wantPreserve string
|
|
||||||
}{
|
|
||||||
{"mode none", "glm-4.6", []byte(`{}`), thinking.ThinkingConfig{Mode: thinking.ModeNone}, false, ""},
|
|
||||||
{"level none", "glm-4.7", []byte(`{}`), thinking.ThinkingConfig{Mode: thinking.ModeLevel, Level: thinking.LevelNone}, false, ""},
|
|
||||||
{"mode auto", "glm-4.6", []byte(`{}`), thinking.ThinkingConfig{Mode: thinking.ModeAuto}, true, ""},
|
|
||||||
{"level minimal", "glm-4.6", []byte(`{}`), thinking.ThinkingConfig{Mode: thinking.ModeLevel, Level: thinking.LevelMinimal}, true, ""},
|
|
||||||
{"level low", "glm-4.7", []byte(`{}`), thinking.ThinkingConfig{Mode: thinking.ModeLevel, Level: thinking.LevelLow}, true, ""},
|
|
||||||
{"level medium", "glm-4.6", []byte(`{}`), thinking.ThinkingConfig{Mode: thinking.ModeLevel, Level: thinking.LevelMedium}, true, ""},
|
|
||||||
{"level high", "GLM-4.6", []byte(`{}`), thinking.ThinkingConfig{Mode: thinking.ModeLevel, Level: thinking.LevelHigh}, true, ""},
|
|
||||||
{"level xhigh", "glm-z1-preview", []byte(`{}`), thinking.ThinkingConfig{Mode: thinking.ModeLevel, Level: thinking.LevelXHigh}, true, ""},
|
|
||||||
{"budget zero", "glm-4.6", []byte(`{}`), thinking.ThinkingConfig{Mode: thinking.ModeBudget, Budget: 0}, false, ""},
|
|
||||||
{"budget 1000", "glm-4.6", []byte(`{}`), thinking.ThinkingConfig{Mode: thinking.ModeBudget, Budget: 1000}, true, ""},
|
|
||||||
{"preserve fields", "glm-4.6", []byte(`{"model":"glm-4.6","extra":{"keep":true}}`), thinking.ThinkingConfig{Mode: thinking.ModeAuto}, true, "glm-4.6"},
|
|
||||||
{"empty body", "glm-4.6", nil, thinking.ThinkingConfig{Mode: thinking.ModeAuto}, true, ""},
|
|
||||||
{"malformed json", "glm-4.6", []byte(`{invalid`), thinking.ThinkingConfig{Mode: thinking.ModeAuto}, true, ""},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
modelInfo := ®istry.ModelInfo{
|
|
||||||
ID: tt.modelID,
|
|
||||||
Thinking: ®istry.ThinkingSupport{},
|
|
||||||
}
|
|
||||||
got, err := applier.Apply(tt.body, tt.config, modelInfo)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Apply() error = %v", err)
|
|
||||||
}
|
|
||||||
if !gjson.ValidBytes(got) {
|
|
||||||
t.Fatalf("expected valid JSON, got %s", string(got))
|
|
||||||
}
|
|
||||||
|
|
||||||
enableResult := gjson.GetBytes(got, "chat_template_kwargs.enable_thinking")
|
|
||||||
if !enableResult.Exists() {
|
|
||||||
t.Fatalf("enable_thinking missing")
|
|
||||||
}
|
|
||||||
gotEnable := enableResult.Bool()
|
|
||||||
if gotEnable != tt.wantEnable {
|
|
||||||
t.Fatalf("enable_thinking = %v, want %v", gotEnable, tt.wantEnable)
|
|
||||||
}
|
|
||||||
|
|
||||||
// clear_thinking only set when enable_thinking=true
|
|
||||||
clearResult := gjson.GetBytes(got, "chat_template_kwargs.clear_thinking")
|
|
||||||
if tt.wantEnable {
|
|
||||||
if !clearResult.Exists() {
|
|
||||||
t.Fatalf("clear_thinking missing when enable_thinking=true")
|
|
||||||
}
|
|
||||||
if clearResult.Bool() {
|
|
||||||
t.Fatalf("clear_thinking = %v, want false", clearResult.Bool())
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
if clearResult.Exists() {
|
|
||||||
t.Fatalf("clear_thinking should not exist when enable_thinking=false")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if tt.wantPreserve != "" {
|
|
||||||
gotModel := gjson.GetBytes(got, "model").String()
|
|
||||||
if gotModel != tt.wantPreserve {
|
|
||||||
t.Fatalf("model = %q, want %q", gotModel, tt.wantPreserve)
|
|
||||||
}
|
|
||||||
if !gjson.GetBytes(got, "extra.keep").Bool() {
|
|
||||||
t.Fatalf("expected extra.keep preserved")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestApplyMiniMax(t *testing.T) {
|
|
||||||
applier := NewApplier()
|
|
||||||
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
modelID string
|
|
||||||
body []byte
|
|
||||||
config thinking.ThinkingConfig
|
|
||||||
wantSplit bool
|
|
||||||
wantModel string
|
|
||||||
wantKeep bool
|
|
||||||
}{
|
|
||||||
{"mode none", "minimax-m2", []byte(`{}`), thinking.ThinkingConfig{Mode: thinking.ModeNone}, false, "", false},
|
|
||||||
{"level none", "minimax-m2.1", []byte(`{}`), thinking.ThinkingConfig{Mode: thinking.ModeLevel, Level: thinking.LevelNone}, false, "", false},
|
|
||||||
{"mode auto", "minimax-m2", []byte(`{}`), thinking.ThinkingConfig{Mode: thinking.ModeAuto}, true, "", false},
|
|
||||||
{"level high", "MINIMAX-M2", []byte(`{}`), thinking.ThinkingConfig{Mode: thinking.ModeLevel, Level: thinking.LevelHigh}, true, "", false},
|
|
||||||
{"level low", "minimax-m2.1", []byte(`{}`), thinking.ThinkingConfig{Mode: thinking.ModeLevel, Level: thinking.LevelLow}, true, "", false},
|
|
||||||
{"level minimal", "minimax-m2", []byte(`{}`), thinking.ThinkingConfig{Mode: thinking.ModeLevel, Level: thinking.LevelMinimal}, true, "", false},
|
|
||||||
{"level medium", "minimax-m2", []byte(`{}`), thinking.ThinkingConfig{Mode: thinking.ModeLevel, Level: thinking.LevelMedium}, true, "", false},
|
|
||||||
{"level xhigh", "minimax-m2", []byte(`{}`), thinking.ThinkingConfig{Mode: thinking.ModeLevel, Level: thinking.LevelXHigh}, true, "", false},
|
|
||||||
{"budget zero", "minimax-m2", []byte(`{}`), thinking.ThinkingConfig{Mode: thinking.ModeBudget, Budget: 0}, false, "", false},
|
|
||||||
{"budget 1000", "minimax-m2.1", []byte(`{}`), thinking.ThinkingConfig{Mode: thinking.ModeBudget, Budget: 1000}, true, "", false},
|
|
||||||
{"unknown level", "minimax-m2", []byte(`{}`), thinking.ThinkingConfig{Mode: thinking.ModeLevel, Level: "unknown"}, true, "", false},
|
|
||||||
{"preserve fields", "minimax-m2", []byte(`{"model":"minimax-m2","extra":{"keep":true}}`), thinking.ThinkingConfig{Mode: thinking.ModeAuto}, true, "minimax-m2", true},
|
|
||||||
{"empty body", "minimax-m2", nil, thinking.ThinkingConfig{Mode: thinking.ModeAuto}, true, "", false},
|
|
||||||
{"malformed json", "minimax-m2", []byte(`{invalid`), thinking.ThinkingConfig{Mode: thinking.ModeAuto}, true, "", false},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
modelInfo := ®istry.ModelInfo{
|
|
||||||
ID: tt.modelID,
|
|
||||||
Thinking: ®istry.ThinkingSupport{},
|
|
||||||
}
|
|
||||||
got, err := applier.Apply(tt.body, tt.config, modelInfo)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Apply() error = %v", err)
|
|
||||||
}
|
|
||||||
if !gjson.ValidBytes(got) {
|
|
||||||
t.Fatalf("expected valid JSON, got %s", string(got))
|
|
||||||
}
|
|
||||||
|
|
||||||
splitResult := gjson.GetBytes(got, "reasoning_split")
|
|
||||||
if !splitResult.Exists() {
|
|
||||||
t.Fatalf("reasoning_split missing")
|
|
||||||
}
|
|
||||||
// Verify JSON type is boolean, not string
|
|
||||||
if splitResult.Type != gjson.True && splitResult.Type != gjson.False {
|
|
||||||
t.Fatalf("reasoning_split should be boolean, got type %v", splitResult.Type)
|
|
||||||
}
|
|
||||||
gotSplit := splitResult.Bool()
|
|
||||||
if gotSplit != tt.wantSplit {
|
|
||||||
t.Fatalf("reasoning_split = %v, want %v", gotSplit, tt.wantSplit)
|
|
||||||
}
|
|
||||||
|
|
||||||
if tt.wantModel != "" {
|
|
||||||
gotModel := gjson.GetBytes(got, "model").String()
|
|
||||||
if gotModel != tt.wantModel {
|
|
||||||
t.Fatalf("model = %q, want %q", gotModel, tt.wantModel)
|
|
||||||
}
|
|
||||||
if tt.wantKeep && !gjson.GetBytes(got, "extra.keep").Bool() {
|
|
||||||
t.Fatalf("expected extra.keep preserved")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestIsGLMModel tests the GLM model detection.
|
|
||||||
//
|
|
||||||
// Depends on: Epic 9 Story 9-1
|
|
||||||
func TestIsGLMModel(t *testing.T) {
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
model string
|
|
||||||
wantGLM bool
|
|
||||||
}{
|
|
||||||
{"glm-4.6", "glm-4.6", true},
|
|
||||||
{"glm-z1-preview", "glm-z1-preview", true},
|
|
||||||
{"glm uppercase", "GLM-4.7", true},
|
|
||||||
{"minimax-01", "minimax-01", false},
|
|
||||||
{"gpt-5.2", "gpt-5.2", false},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
if got := isGLMModel(tt.model); got != tt.wantGLM {
|
|
||||||
t.Fatalf("isGLMModel(%q) = %v, want %v", tt.model, got, tt.wantGLM)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestIsMiniMaxModel tests the MiniMax model detection.
|
|
||||||
//
|
|
||||||
// Depends on: Epic 9 Story 9-1
|
|
||||||
func TestIsMiniMaxModel(t *testing.T) {
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
model string
|
|
||||||
wantMiniMax bool
|
|
||||||
}{
|
|
||||||
{"minimax-01", "minimax-01", true},
|
|
||||||
{"minimax uppercase", "MINIMAX-M2", true},
|
|
||||||
{"glm-4.6", "glm-4.6", false},
|
|
||||||
{"gpt-5.2", "gpt-5.2", false},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
if got := isMiniMaxModel(tt.model); got != tt.wantMiniMax {
|
|
||||||
t.Fatalf("isMiniMaxModel(%q) = %v, want %v", tt.model, got, tt.wantMiniMax)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,336 +0,0 @@
|
|||||||
// Package openai implements thinking configuration for OpenAI/Codex models.
|
|
||||||
package openai
|
|
||||||
|
|
||||||
import (
|
|
||||||
"testing"
|
|
||||||
|
|
||||||
"github.com/router-for-me/CLIProxyAPI/v6/internal/registry"
|
|
||||||
"github.com/router-for-me/CLIProxyAPI/v6/internal/thinking"
|
|
||||||
"github.com/tidwall/gjson"
|
|
||||||
)
|
|
||||||
|
|
||||||
func buildOpenAIModelInfo(modelID string) *registry.ModelInfo {
|
|
||||||
info := registry.LookupStaticModelInfo(modelID)
|
|
||||||
if info != nil {
|
|
||||||
return info
|
|
||||||
}
|
|
||||||
// Fallback with complete ThinkingSupport matching real OpenAI model capabilities
|
|
||||||
return ®istry.ModelInfo{
|
|
||||||
ID: modelID,
|
|
||||||
Thinking: ®istry.ThinkingSupport{
|
|
||||||
Min: 1024,
|
|
||||||
Max: 32768,
|
|
||||||
ZeroAllowed: true,
|
|
||||||
Levels: []string{"none", "low", "medium", "high", "xhigh"},
|
|
||||||
},
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestNewApplier(t *testing.T) {
|
|
||||||
applier := NewApplier()
|
|
||||||
if applier == nil {
|
|
||||||
t.Fatalf("expected non-nil applier")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestApplierImplementsInterface(t *testing.T) {
|
|
||||||
_, ok := interface{}(NewApplier()).(thinking.ProviderApplier)
|
|
||||||
if !ok {
|
|
||||||
t.Fatalf("expected Applier to implement thinking.ProviderApplier")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestApplyNilModelInfo(t *testing.T) {
|
|
||||||
applier := NewApplier()
|
|
||||||
body := []byte(`{"model":"gpt-5.2"}`)
|
|
||||||
config := thinking.ThinkingConfig{Mode: thinking.ModeLevel, Level: thinking.LevelHigh}
|
|
||||||
got, err := applier.Apply(body, config, nil)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("expected nil error, got %v", err)
|
|
||||||
}
|
|
||||||
// nil modelInfo now applies compatible config
|
|
||||||
if !gjson.GetBytes(got, "reasoning_effort").Exists() {
|
|
||||||
t.Fatalf("expected reasoning_effort applied, got %s", string(got))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestApplyMissingThinkingSupport(t *testing.T) {
|
|
||||||
applier := NewApplier()
|
|
||||||
modelInfo := ®istry.ModelInfo{ID: "gpt-5.2"}
|
|
||||||
body := []byte(`{"model":"gpt-5.2"}`)
|
|
||||||
got, err := applier.Apply(body, thinking.ThinkingConfig{}, modelInfo)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("expected nil error, got %v", err)
|
|
||||||
}
|
|
||||||
if string(got) != string(body) {
|
|
||||||
t.Fatalf("expected body unchanged, got %s", string(got))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestApplyLevel tests Apply with ModeLevel (unit test, no ValidateConfig).
|
|
||||||
func TestApplyLevel(t *testing.T) {
|
|
||||||
applier := NewApplier()
|
|
||||||
modelInfo := buildOpenAIModelInfo("gpt-5.2")
|
|
||||||
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
level thinking.ThinkingLevel
|
|
||||||
want string
|
|
||||||
}{
|
|
||||||
{"high", thinking.LevelHigh, "high"},
|
|
||||||
{"medium", thinking.LevelMedium, "medium"},
|
|
||||||
{"low", thinking.LevelLow, "low"},
|
|
||||||
{"xhigh", thinking.LevelXHigh, "xhigh"},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
result, err := applier.Apply([]byte(`{}`), thinking.ThinkingConfig{Mode: thinking.ModeLevel, Level: tt.level}, modelInfo)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Apply() error = %v", err)
|
|
||||||
}
|
|
||||||
if got := gjson.GetBytes(result, "reasoning_effort").String(); got != tt.want {
|
|
||||||
t.Fatalf("reasoning_effort = %q, want %q", got, tt.want)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestApplyModeNone tests Apply with ModeNone (unit test).
|
|
||||||
func TestApplyModeNone(t *testing.T) {
|
|
||||||
applier := NewApplier()
|
|
||||||
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
config thinking.ThinkingConfig
|
|
||||||
modelInfo *registry.ModelInfo
|
|
||||||
want string
|
|
||||||
}{
|
|
||||||
{"zero allowed", thinking.ThinkingConfig{Mode: thinking.ModeNone, Budget: 0}, ®istry.ModelInfo{ID: "gpt-5.2", Thinking: ®istry.ThinkingSupport{ZeroAllowed: true, Levels: []string{"none", "low"}}}, "none"},
|
|
||||||
{"clamped to level", thinking.ThinkingConfig{Mode: thinking.ModeNone, Budget: 128, Level: thinking.LevelLow}, ®istry.ModelInfo{ID: "gpt-5", Thinking: ®istry.ThinkingSupport{Levels: []string{"minimal", "low"}}}, "low"},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
result, err := applier.Apply([]byte(`{}`), tt.config, tt.modelInfo)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Apply() error = %v", err)
|
|
||||||
}
|
|
||||||
if got := gjson.GetBytes(result, "reasoning_effort").String(); got != tt.want {
|
|
||||||
t.Fatalf("reasoning_effort = %q, want %q", got, tt.want)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestApplyPassthrough tests that unsupported modes pass through unchanged.
|
|
||||||
func TestApplyPassthrough(t *testing.T) {
|
|
||||||
applier := NewApplier()
|
|
||||||
modelInfo := buildOpenAIModelInfo("gpt-5.2")
|
|
||||||
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
config thinking.ThinkingConfig
|
|
||||||
}{
|
|
||||||
{"mode auto", thinking.ThinkingConfig{Mode: thinking.ModeAuto}},
|
|
||||||
{"mode budget", thinking.ThinkingConfig{Mode: thinking.ModeBudget, Budget: 8192}},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
body := []byte(`{"model":"gpt-5.2"}`)
|
|
||||||
result, err := applier.Apply(body, tt.config, modelInfo)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Apply() error = %v", err)
|
|
||||||
}
|
|
||||||
if string(result) != string(body) {
|
|
||||||
t.Fatalf("Apply() result = %s, want %s", string(result), string(body))
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestApplyInvalidBody tests Apply with invalid body input.
|
|
||||||
func TestApplyInvalidBody(t *testing.T) {
|
|
||||||
applier := NewApplier()
|
|
||||||
modelInfo := buildOpenAIModelInfo("gpt-5.2")
|
|
||||||
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
body []byte
|
|
||||||
}{
|
|
||||||
{"nil body", nil},
|
|
||||||
{"empty body", []byte{}},
|
|
||||||
{"invalid json", []byte(`{"not json"`)},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
result, err := applier.Apply(tt.body, thinking.ThinkingConfig{Mode: thinking.ModeLevel, Level: thinking.LevelHigh}, modelInfo)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Apply() error = %v", err)
|
|
||||||
}
|
|
||||||
if !gjson.ValidBytes(result) {
|
|
||||||
t.Fatalf("Apply() result is not valid JSON: %s", string(result))
|
|
||||||
}
|
|
||||||
if got := gjson.GetBytes(result, "reasoning_effort").String(); got != "high" {
|
|
||||||
t.Fatalf("reasoning_effort = %q, want %q", got, "high")
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestApplyPreservesFields tests that existing body fields are preserved.
|
|
||||||
func TestApplyPreservesFields(t *testing.T) {
|
|
||||||
applier := NewApplier()
|
|
||||||
modelInfo := buildOpenAIModelInfo("gpt-5.2")
|
|
||||||
|
|
||||||
body := []byte(`{"model":"gpt-5.2","messages":[]}`)
|
|
||||||
result, err := applier.Apply(body, thinking.ThinkingConfig{Mode: thinking.ModeLevel, Level: thinking.LevelLow}, modelInfo)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Apply() error = %v", err)
|
|
||||||
}
|
|
||||||
if got := gjson.GetBytes(result, "model").String(); got != "gpt-5.2" {
|
|
||||||
t.Fatalf("model = %q, want %q", got, "gpt-5.2")
|
|
||||||
}
|
|
||||||
if !gjson.GetBytes(result, "messages").Exists() {
|
|
||||||
t.Fatalf("messages missing from result: %s", string(result))
|
|
||||||
}
|
|
||||||
if got := gjson.GetBytes(result, "reasoning_effort").String(); got != "low" {
|
|
||||||
t.Fatalf("reasoning_effort = %q, want %q", got, "low")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestHasLevel tests the hasLevel helper function.
|
|
||||||
func TestHasLevel(t *testing.T) {
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
levels []string
|
|
||||||
target string
|
|
||||||
want bool
|
|
||||||
}{
|
|
||||||
{"exact match", []string{"low", "medium", "high"}, "medium", true},
|
|
||||||
{"case insensitive", []string{"low", "medium", "high"}, "MEDIUM", true},
|
|
||||||
{"with spaces", []string{"low", " medium ", "high"}, "medium", true},
|
|
||||||
{"not found", []string{"low", "medium", "high"}, "xhigh", false},
|
|
||||||
{"empty levels", []string{}, "medium", false},
|
|
||||||
{"none level", []string{"none", "low", "medium"}, "none", true},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
if got := hasLevel(tt.levels, tt.target); got != tt.want {
|
|
||||||
t.Fatalf("hasLevel(%v, %q) = %v, want %v", tt.levels, tt.target, got, tt.want)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// --- End-to-End Tests (ValidateConfig → Apply) ---
|
|
||||||
|
|
||||||
// TestE2EApply tests the full flow: ValidateConfig → Apply.
|
|
||||||
func TestE2EApply(t *testing.T) {
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
model string
|
|
||||||
config thinking.ThinkingConfig
|
|
||||||
want string
|
|
||||||
}{
|
|
||||||
{"level high", "gpt-5.2", thinking.ThinkingConfig{Mode: thinking.ModeLevel, Level: thinking.LevelHigh}, "high"},
|
|
||||||
{"level medium", "gpt-5.2", thinking.ThinkingConfig{Mode: thinking.ModeLevel, Level: thinking.LevelMedium}, "medium"},
|
|
||||||
{"level low", "gpt-5.2", thinking.ThinkingConfig{Mode: thinking.ModeLevel, Level: thinking.LevelLow}, "low"},
|
|
||||||
{"level xhigh", "gpt-5.2", thinking.ThinkingConfig{Mode: thinking.ModeLevel, Level: thinking.LevelXHigh}, "xhigh"},
|
|
||||||
{"mode none", "gpt-5.2", thinking.ThinkingConfig{Mode: thinking.ModeNone, Budget: 0}, "none"},
|
|
||||||
{"budget to level", "gpt-5.2", thinking.ThinkingConfig{Mode: thinking.ModeBudget, Budget: 8192}, "medium"},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
modelInfo := buildOpenAIModelInfo(tt.model)
|
|
||||||
normalized, err := thinking.ValidateConfig(tt.config, modelInfo.Thinking)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("ValidateConfig() error = %v", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
applier := NewApplier()
|
|
||||||
result, err := applier.Apply([]byte(`{}`), *normalized, modelInfo)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Apply() error = %v", err)
|
|
||||||
}
|
|
||||||
if got := gjson.GetBytes(result, "reasoning_effort").String(); got != tt.want {
|
|
||||||
t.Fatalf("reasoning_effort = %q, want %q", got, tt.want)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestE2EApplyOutputFormat tests the full flow with exact JSON output verification.
|
|
||||||
func TestE2EApplyOutputFormat(t *testing.T) {
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
model string
|
|
||||||
config thinking.ThinkingConfig
|
|
||||||
wantJSON string
|
|
||||||
}{
|
|
||||||
{"level high", "gpt-5.2", thinking.ThinkingConfig{Mode: thinking.ModeLevel, Level: thinking.LevelHigh}, `{"reasoning_effort":"high"}`},
|
|
||||||
{"level none", "gpt-5.2", thinking.ThinkingConfig{Mode: thinking.ModeNone, Budget: 0}, `{"reasoning_effort":"none"}`},
|
|
||||||
{"budget converted", "gpt-5.2", thinking.ThinkingConfig{Mode: thinking.ModeBudget, Budget: 8192}, `{"reasoning_effort":"medium"}`},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
modelInfo := buildOpenAIModelInfo(tt.model)
|
|
||||||
normalized, err := thinking.ValidateConfig(tt.config, modelInfo.Thinking)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("ValidateConfig() error = %v", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
applier := NewApplier()
|
|
||||||
result, err := applier.Apply([]byte(`{}`), *normalized, modelInfo)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Apply() error = %v", err)
|
|
||||||
}
|
|
||||||
if string(result) != tt.wantJSON {
|
|
||||||
t.Fatalf("Apply() result = %s, want %s", string(result), tt.wantJSON)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestE2EApplyWithExistingBody tests the full flow with existing body fields.
|
|
||||||
func TestE2EApplyWithExistingBody(t *testing.T) {
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
body string
|
|
||||||
config thinking.ThinkingConfig
|
|
||||||
wantEffort string
|
|
||||||
wantModel string
|
|
||||||
}{
|
|
||||||
{"empty body", `{}`, thinking.ThinkingConfig{Mode: thinking.ModeLevel, Level: thinking.LevelHigh}, "high", ""},
|
|
||||||
{"preserve fields", `{"model":"gpt-5.2","messages":[]}`, thinking.ThinkingConfig{Mode: thinking.ModeLevel, Level: thinking.LevelMedium}, "medium", "gpt-5.2"},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
modelInfo := buildOpenAIModelInfo("gpt-5.2")
|
|
||||||
normalized, err := thinking.ValidateConfig(tt.config, modelInfo.Thinking)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("ValidateConfig() error = %v", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
applier := NewApplier()
|
|
||||||
result, err := applier.Apply([]byte(tt.body), *normalized, modelInfo)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Apply() error = %v", err)
|
|
||||||
}
|
|
||||||
if got := gjson.GetBytes(result, "reasoning_effort").String(); got != tt.wantEffort {
|
|
||||||
t.Fatalf("reasoning_effort = %q, want %q", got, tt.wantEffort)
|
|
||||||
}
|
|
||||||
if tt.wantModel != "" {
|
|
||||||
if got := gjson.GetBytes(result, "model").String(); got != tt.wantModel {
|
|
||||||
t.Fatalf("model = %q, want %q", got, tt.wantModel)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,51 +0,0 @@
|
|||||||
// Package thinking_test provides external tests for the thinking package.
|
|
||||||
//
|
|
||||||
// This file uses package thinking_test (external) to allow importing provider
|
|
||||||
// subpackages, which triggers their init() functions to register appliers.
|
|
||||||
// This avoids import cycles that would occur if thinking package imported providers directly.
|
|
||||||
package thinking_test
|
|
||||||
|
|
||||||
import (
|
|
||||||
"testing"
|
|
||||||
|
|
||||||
"github.com/router-for-me/CLIProxyAPI/v6/internal/thinking"
|
|
||||||
|
|
||||||
// Blank imports to trigger provider init() registration
|
|
||||||
_ "github.com/router-for-me/CLIProxyAPI/v6/internal/thinking/provider/claude"
|
|
||||||
_ "github.com/router-for-me/CLIProxyAPI/v6/internal/thinking/provider/gemini"
|
|
||||||
_ "github.com/router-for-me/CLIProxyAPI/v6/internal/thinking/provider/geminicli"
|
|
||||||
_ "github.com/router-for-me/CLIProxyAPI/v6/internal/thinking/provider/iflow"
|
|
||||||
_ "github.com/router-for-me/CLIProxyAPI/v6/internal/thinking/provider/openai"
|
|
||||||
)
|
|
||||||
|
|
||||||
func TestProviderAppliersBasic(t *testing.T) {
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
provider string
|
|
||||||
wantNil bool
|
|
||||||
}{
|
|
||||||
{"gemini provider", "gemini", false},
|
|
||||||
{"gemini-cli provider", "gemini-cli", false},
|
|
||||||
{"claude provider", "claude", false},
|
|
||||||
{"openai provider", "openai", false},
|
|
||||||
{"iflow provider", "iflow", false},
|
|
||||||
{"antigravity provider", "antigravity", false},
|
|
||||||
{"unknown provider", "unknown", true},
|
|
||||||
{"empty provider", "", true},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
got := thinking.GetProviderApplier(tt.provider)
|
|
||||||
if tt.wantNil {
|
|
||||||
if got != nil {
|
|
||||||
t.Fatalf("GetProviderApplier(%q) = %T, want nil", tt.provider, got)
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
if got == nil {
|
|
||||||
t.Fatalf("GetProviderApplier(%q) = nil, want non-nil", tt.provider)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,66 +0,0 @@
|
|||||||
// Package thinking_test provides tests for thinking config stripping.
|
|
||||||
package thinking_test
|
|
||||||
|
|
||||||
import (
|
|
||||||
"testing"
|
|
||||||
|
|
||||||
"github.com/router-for-me/CLIProxyAPI/v6/internal/thinking"
|
|
||||||
"github.com/tidwall/gjson"
|
|
||||||
)
|
|
||||||
|
|
||||||
func TestStripThinkingConfig(t *testing.T) {
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
body string
|
|
||||||
provider string
|
|
||||||
stripped []string
|
|
||||||
preserved []string
|
|
||||||
}{
|
|
||||||
{"claude thinking", `{"thinking":{"budget_tokens":8192},"model":"claude-3"}`, "claude", []string{"thinking"}, []string{"model"}},
|
|
||||||
{"gemini thinkingConfig", `{"generationConfig":{"thinkingConfig":{"thinkingBudget":8192},"temperature":0.7}}`, "gemini", []string{"generationConfig.thinkingConfig"}, []string{"generationConfig.temperature"}},
|
|
||||||
{"gemini-cli thinkingConfig", `{"request":{"generationConfig":{"thinkingConfig":{"thinkingBudget":8192},"temperature":0.7}}}`, "gemini-cli", []string{"request.generationConfig.thinkingConfig"}, []string{"request.generationConfig.temperature"}},
|
|
||||||
{"antigravity thinkingConfig", `{"request":{"generationConfig":{"thinkingConfig":{"thinkingBudget":4096},"maxTokens":1024}}}`, "antigravity", []string{"request.generationConfig.thinkingConfig"}, []string{"request.generationConfig.maxTokens"}},
|
|
||||||
{"openai reasoning_effort", `{"reasoning_effort":"high","model":"gpt-5"}`, "openai", []string{"reasoning_effort"}, []string{"model"}},
|
|
||||||
{"iflow glm", `{"chat_template_kwargs":{"enable_thinking":true,"clear_thinking":false,"other":"value"}}`, "iflow", []string{"chat_template_kwargs.enable_thinking", "chat_template_kwargs.clear_thinking"}, []string{"chat_template_kwargs.other"}},
|
|
||||||
{"iflow minimax", `{"reasoning_split":true,"model":"minimax"}`, "iflow", []string{"reasoning_split"}, []string{"model"}},
|
|
||||||
{"iflow both formats", `{"chat_template_kwargs":{"enable_thinking":true,"clear_thinking":false},"reasoning_split":true,"model":"mixed"}`, "iflow", []string{"chat_template_kwargs.enable_thinking", "chat_template_kwargs.clear_thinking", "reasoning_split"}, []string{"model"}},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
got := thinking.StripThinkingConfig([]byte(tt.body), tt.provider)
|
|
||||||
|
|
||||||
for _, path := range tt.stripped {
|
|
||||||
if gjson.GetBytes(got, path).Exists() {
|
|
||||||
t.Fatalf("expected %s to be stripped, got %s", path, string(got))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
for _, path := range tt.preserved {
|
|
||||||
if !gjson.GetBytes(got, path).Exists() {
|
|
||||||
t.Fatalf("expected %s to be preserved, got %s", path, string(got))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestStripThinkingConfigPassthrough(t *testing.T) {
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
body string
|
|
||||||
provider string
|
|
||||||
}{
|
|
||||||
{"empty body", ``, "claude"},
|
|
||||||
{"invalid json", `{not valid`, "claude"},
|
|
||||||
{"unknown provider", `{"thinking":{"budget_tokens":8192}}`, "unknown"},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
got := thinking.StripThinkingConfig([]byte(tt.body), tt.provider)
|
|
||||||
if string(got) != tt.body {
|
|
||||||
t.Fatalf("StripThinkingConfig() = %s, want passthrough %s", string(got), tt.body)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,313 +0,0 @@
|
|||||||
// Package thinking provides unified thinking configuration processing.
|
|
||||||
package thinking
|
|
||||||
|
|
||||||
import (
|
|
||||||
"strings"
|
|
||||||
"testing"
|
|
||||||
)
|
|
||||||
|
|
||||||
// TestParseSuffix tests the ParseSuffix function.
|
|
||||||
//
|
|
||||||
// ParseSuffix extracts thinking suffix from model name.
|
|
||||||
// Format: model-name(value) where value is the raw suffix content.
|
|
||||||
// This function only extracts; interpretation is done by other functions.
|
|
||||||
func TestParseSuffix(t *testing.T) {
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
model string
|
|
||||||
wantModel string
|
|
||||||
wantSuffix bool
|
|
||||||
wantRaw string
|
|
||||||
}{
|
|
||||||
{"no suffix", "claude-sonnet-4-5", "claude-sonnet-4-5", false, ""},
|
|
||||||
{"numeric suffix", "model(1000)", "model", true, "1000"},
|
|
||||||
{"level suffix", "gpt-5(high)", "gpt-5", true, "high"},
|
|
||||||
{"auto suffix", "gemini-2.5-pro(auto)", "gemini-2.5-pro", true, "auto"},
|
|
||||||
{"none suffix", "model(none)", "model", true, "none"},
|
|
||||||
{"complex model name", "gemini-2.5-flash-lite(8192)", "gemini-2.5-flash-lite", true, "8192"},
|
|
||||||
{"alias with suffix", "g25p(1000)", "g25p", true, "1000"},
|
|
||||||
{"empty suffix", "model()", "model", true, ""},
|
|
||||||
{"nested parens", "model(a(b))", "model(a", true, "b)"},
|
|
||||||
{"no model name", "(1000)", "", true, "1000"},
|
|
||||||
{"unmatched open", "model(", "model(", false, ""},
|
|
||||||
{"unmatched close", "model)", "model)", false, ""},
|
|
||||||
{"paren not at end", "model(1000)extra", "model(1000)extra", false, ""},
|
|
||||||
{"empty string", "", "", false, ""},
|
|
||||||
{"large budget", "claude-opus(128000)", "claude-opus", true, "128000"},
|
|
||||||
{"xhigh level", "gpt-5.2(xhigh)", "gpt-5.2", true, "xhigh"},
|
|
||||||
{"minimal level", "model(minimal)", "model", true, "minimal"},
|
|
||||||
{"medium level", "model(medium)", "model", true, "medium"},
|
|
||||||
{"low level", "model(low)", "model", true, "low"},
|
|
||||||
}
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
got := ParseSuffix(tt.model)
|
|
||||||
if got.ModelName != tt.wantModel {
|
|
||||||
t.Errorf("ModelName = %q, want %q", got.ModelName, tt.wantModel)
|
|
||||||
}
|
|
||||||
if got.HasSuffix != tt.wantSuffix {
|
|
||||||
t.Errorf("HasSuffix = %v, want %v", got.HasSuffix, tt.wantSuffix)
|
|
||||||
}
|
|
||||||
if got.RawSuffix != tt.wantRaw {
|
|
||||||
t.Errorf("RawSuffix = %q, want %q", got.RawSuffix, tt.wantRaw)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestParseSuffixWithError tests invalid suffix error reporting.
|
|
||||||
func TestParseSuffixWithError(t *testing.T) {
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
model string
|
|
||||||
wantHasSuffix bool
|
|
||||||
}{
|
|
||||||
{"missing close paren", "model(abc", false},
|
|
||||||
{"unmatched close paren", "model)", false},
|
|
||||||
{"paren not at end", "model(1000)extra", false},
|
|
||||||
{"no suffix", "gpt-5", false},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
got, err := ParseSuffixWithError(tt.model)
|
|
||||||
if tt.name == "no suffix" {
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("ParseSuffixWithError(%q) error = %v, want nil", tt.model, err)
|
|
||||||
}
|
|
||||||
if got.HasSuffix != tt.wantHasSuffix {
|
|
||||||
t.Errorf("HasSuffix = %v, want %v", got.HasSuffix, tt.wantHasSuffix)
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
if err == nil {
|
|
||||||
t.Fatalf("ParseSuffixWithError(%q) error = nil, want error", tt.model)
|
|
||||||
}
|
|
||||||
thinkingErr, ok := err.(*ThinkingError)
|
|
||||||
if !ok {
|
|
||||||
t.Fatalf("ParseSuffixWithError(%q) error type = %T, want *ThinkingError", tt.model, err)
|
|
||||||
}
|
|
||||||
if thinkingErr.Code != ErrInvalidSuffix {
|
|
||||||
t.Errorf("error code = %v, want %v", thinkingErr.Code, ErrInvalidSuffix)
|
|
||||||
}
|
|
||||||
if !strings.Contains(thinkingErr.Message, tt.model) {
|
|
||||||
t.Errorf("message %q does not include input %q", thinkingErr.Message, tt.model)
|
|
||||||
}
|
|
||||||
if got.HasSuffix != tt.wantHasSuffix {
|
|
||||||
t.Errorf("HasSuffix = %v, want %v", got.HasSuffix, tt.wantHasSuffix)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestParseSuffixNumeric tests numeric suffix parsing.
|
|
||||||
//
|
|
||||||
// ParseNumericSuffix parses raw suffix content as integer budget.
|
|
||||||
// Only non-negative integers are valid. Negative numbers return ok=false.
|
|
||||||
func TestParseSuffixNumeric(t *testing.T) {
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
rawSuffix string
|
|
||||||
wantBudget int
|
|
||||||
wantOK bool
|
|
||||||
}{
|
|
||||||
{"small budget", "512", 512, true},
|
|
||||||
{"standard budget", "8192", 8192, true},
|
|
||||||
{"large budget", "100000", 100000, true},
|
|
||||||
{"max int32", "2147483647", 2147483647, true},
|
|
||||||
{"max int64", "9223372036854775807", 9223372036854775807, true},
|
|
||||||
{"zero", "0", 0, true},
|
|
||||||
{"negative one", "-1", 0, false},
|
|
||||||
{"negative", "-100", 0, false},
|
|
||||||
{"int64 overflow", "9223372036854775808", 0, false},
|
|
||||||
{"large overflow", "99999999999999999999", 0, false},
|
|
||||||
{"not a number", "abc", 0, false},
|
|
||||||
{"level string", "high", 0, false},
|
|
||||||
{"float", "1.5", 0, false},
|
|
||||||
{"empty", "", 0, false},
|
|
||||||
{"leading zero", "08192", 8192, true},
|
|
||||||
{"whitespace", " 8192 ", 0, false},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
budget, ok := ParseNumericSuffix(tt.rawSuffix)
|
|
||||||
if budget != tt.wantBudget {
|
|
||||||
t.Errorf("budget = %d, want %d", budget, tt.wantBudget)
|
|
||||||
}
|
|
||||||
if ok != tt.wantOK {
|
|
||||||
t.Errorf("ok = %v, want %v", ok, tt.wantOK)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestParseSuffixLevel tests level suffix parsing.
|
|
||||||
//
|
|
||||||
// ParseLevelSuffix parses raw suffix content as discrete thinking level.
|
|
||||||
// Only effort levels (minimal, low, medium, high, xhigh) are valid.
|
|
||||||
// Special values (none, auto) return ok=false - use ParseSpecialSuffix instead.
|
|
||||||
func TestParseSuffixLevel(t *testing.T) {
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
rawSuffix string
|
|
||||||
wantLevel ThinkingLevel
|
|
||||||
wantOK bool
|
|
||||||
}{
|
|
||||||
{"minimal", "minimal", LevelMinimal, true},
|
|
||||||
{"low", "low", LevelLow, true},
|
|
||||||
{"medium", "medium", LevelMedium, true},
|
|
||||||
{"high", "high", LevelHigh, true},
|
|
||||||
{"xhigh", "xhigh", LevelXHigh, true},
|
|
||||||
{"case HIGH", "HIGH", LevelHigh, true},
|
|
||||||
{"case High", "High", LevelHigh, true},
|
|
||||||
{"case hIgH", "hIgH", LevelHigh, true},
|
|
||||||
{"case MINIMAL", "MINIMAL", LevelMinimal, true},
|
|
||||||
{"case XHigh", "XHigh", LevelXHigh, true},
|
|
||||||
{"none special", "none", "", false},
|
|
||||||
{"auto special", "auto", "", false},
|
|
||||||
{"unknown ultra", "ultra", "", false},
|
|
||||||
{"unknown maximum", "maximum", "", false},
|
|
||||||
{"unknown invalid", "invalid", "", false},
|
|
||||||
{"numeric", "8192", "", false},
|
|
||||||
{"numeric zero", "0", "", false},
|
|
||||||
{"empty", "", "", false},
|
|
||||||
{"whitespace", " high ", "", false},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
level, ok := ParseLevelSuffix(tt.rawSuffix)
|
|
||||||
if level != tt.wantLevel {
|
|
||||||
t.Errorf("level = %q, want %q", level, tt.wantLevel)
|
|
||||||
}
|
|
||||||
if ok != tt.wantOK {
|
|
||||||
t.Errorf("ok = %v, want %v", ok, tt.wantOK)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestParseSuffixSpecialValues tests special value suffix parsing.
|
|
||||||
//
|
|
||||||
// Depends on: Epic 3 Story 3-4 (special value suffix parsing)
|
|
||||||
func TestParseSuffixSpecialValues(t *testing.T) {
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
rawSuffix string
|
|
||||||
wantMode ThinkingMode
|
|
||||||
wantOK bool
|
|
||||||
}{
|
|
||||||
{"none", "none", ModeNone, true},
|
|
||||||
{"auto", "auto", ModeAuto, true},
|
|
||||||
{"negative one", "-1", ModeAuto, true},
|
|
||||||
{"case NONE", "NONE", ModeNone, true},
|
|
||||||
{"case Auto", "Auto", ModeAuto, true},
|
|
||||||
{"case aUtO", "aUtO", ModeAuto, true},
|
|
||||||
{"case NoNe", "NoNe", ModeNone, true},
|
|
||||||
{"empty", "", ModeBudget, false},
|
|
||||||
{"level high", "high", ModeBudget, false},
|
|
||||||
{"numeric", "8192", ModeBudget, false},
|
|
||||||
{"negative other", "-2", ModeBudget, false},
|
|
||||||
{"whitespace", " none ", ModeBudget, false},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
mode, ok := ParseSpecialSuffix(tt.rawSuffix)
|
|
||||||
if mode != tt.wantMode {
|
|
||||||
t.Errorf("mode = %q, want %q", mode, tt.wantMode)
|
|
||||||
}
|
|
||||||
if ok != tt.wantOK {
|
|
||||||
t.Errorf("ok = %v, want %v", ok, tt.wantOK)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestParseSuffixAliasFormats tests alias model suffix parsing.
|
|
||||||
//
|
|
||||||
// This test validates that short model aliases (e.g., g25p, cs45) work correctly
|
|
||||||
// with all suffix types. Alias-to-canonical-model mapping is caller's responsibility.
|
|
||||||
func TestParseSuffixAliasFormats(t *testing.T) {
|
|
||||||
tests := []struct {
|
|
||||||
name string // test case description
|
|
||||||
model string // input model string with optional suffix
|
|
||||||
wantName string // expected ModelName after parsing
|
|
||||||
wantSuffix bool // expected HasSuffix value
|
|
||||||
wantRaw string // expected RawSuffix value
|
|
||||||
checkBudget bool // if true, verify ParseNumericSuffix result
|
|
||||||
wantBudget int // expected budget (only when checkBudget=true)
|
|
||||||
checkLevel bool // if true, verify ParseLevelSuffix result
|
|
||||||
wantLevel ThinkingLevel // expected level (only when checkLevel=true)
|
|
||||||
checkMode bool // if true, verify ParseSpecialSuffix result
|
|
||||||
wantMode ThinkingMode // expected mode (only when checkMode=true)
|
|
||||||
}{
|
|
||||||
// Alias + numeric suffix
|
|
||||||
{"alias numeric g25p", "g25p(1000)", "g25p", true, "1000", true, 1000, false, "", false, 0},
|
|
||||||
{"alias numeric cs45", "cs45(16384)", "cs45", true, "16384", true, 16384, false, "", false, 0},
|
|
||||||
{"alias numeric g3f", "g3f(8192)", "g3f", true, "8192", true, 8192, false, "", false, 0},
|
|
||||||
// Alias + level suffix
|
|
||||||
{"alias level gpt52", "gpt52(high)", "gpt52", true, "high", false, 0, true, LevelHigh, false, 0},
|
|
||||||
{"alias level g25f", "g25f(medium)", "g25f", true, "medium", false, 0, true, LevelMedium, false, 0},
|
|
||||||
{"alias level cs4", "cs4(low)", "cs4", true, "low", false, 0, true, LevelLow, false, 0},
|
|
||||||
// Alias + special suffix
|
|
||||||
{"alias auto g3f", "g3f(auto)", "g3f", true, "auto", false, 0, false, "", true, ModeAuto},
|
|
||||||
{"alias none claude", "claude(none)", "claude", true, "none", false, 0, false, "", true, ModeNone},
|
|
||||||
{"alias -1 g25p", "g25p(-1)", "g25p", true, "-1", false, 0, false, "", true, ModeAuto},
|
|
||||||
// Single char alias
|
|
||||||
{"single char c", "c(1024)", "c", true, "1024", true, 1024, false, "", false, 0},
|
|
||||||
{"single char g", "g(high)", "g", true, "high", false, 0, true, LevelHigh, false, 0},
|
|
||||||
// Alias containing numbers
|
|
||||||
{"alias with num gpt5", "gpt5(medium)", "gpt5", true, "medium", false, 0, true, LevelMedium, false, 0},
|
|
||||||
{"alias with num g25", "g25(1000)", "g25", true, "1000", true, 1000, false, "", false, 0},
|
|
||||||
// Edge cases
|
|
||||||
{"no suffix", "g25p", "g25p", false, "", false, 0, false, "", false, 0},
|
|
||||||
{"empty alias", "(1000)", "", true, "1000", true, 1000, false, "", false, 0},
|
|
||||||
{"hyphen alias", "g-25-p(1000)", "g-25-p", true, "1000", true, 1000, false, "", false, 0},
|
|
||||||
{"underscore alias", "g_25_p(high)", "g_25_p", true, "high", false, 0, true, LevelHigh, false, 0},
|
|
||||||
{"nested parens", "g25p(test)(1000)", "g25p(test)", true, "1000", true, 1000, false, "", false, 0},
|
|
||||||
}
|
|
||||||
|
|
||||||
// ParseSuffix only extracts alias and suffix; mapping to canonical model is caller responsibility.
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
result := ParseSuffix(tt.model)
|
|
||||||
|
|
||||||
if result.ModelName != tt.wantName {
|
|
||||||
t.Errorf("ParseSuffix(%q).ModelName = %q, want %q", tt.model, result.ModelName, tt.wantName)
|
|
||||||
}
|
|
||||||
if result.HasSuffix != tt.wantSuffix {
|
|
||||||
t.Errorf("ParseSuffix(%q).HasSuffix = %v, want %v", tt.model, result.HasSuffix, tt.wantSuffix)
|
|
||||||
}
|
|
||||||
if result.RawSuffix != tt.wantRaw {
|
|
||||||
t.Errorf("ParseSuffix(%q).RawSuffix = %q, want %q", tt.model, result.RawSuffix, tt.wantRaw)
|
|
||||||
}
|
|
||||||
|
|
||||||
if result.HasSuffix {
|
|
||||||
if tt.checkBudget {
|
|
||||||
budget, ok := ParseNumericSuffix(result.RawSuffix)
|
|
||||||
if !ok || budget != tt.wantBudget {
|
|
||||||
t.Errorf("ParseNumericSuffix(%q) = (%d, %v), want (%d, true)",
|
|
||||||
result.RawSuffix, budget, ok, tt.wantBudget)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if tt.checkLevel {
|
|
||||||
level, ok := ParseLevelSuffix(result.RawSuffix)
|
|
||||||
if !ok || level != tt.wantLevel {
|
|
||||||
t.Errorf("ParseLevelSuffix(%q) = (%q, %v), want (%q, true)",
|
|
||||||
result.RawSuffix, level, ok, tt.wantLevel)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if tt.checkMode {
|
|
||||||
mode, ok := ParseSpecialSuffix(result.RawSuffix)
|
|
||||||
if !ok || mode != tt.wantMode {
|
|
||||||
t.Errorf("ParseSpecialSuffix(%q) = (%v, %v), want (%v, true)",
|
|
||||||
result.RawSuffix, mode, ok, tt.wantMode)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,349 +0,0 @@
|
|||||||
// Package thinking provides unified thinking configuration processing logic.
|
|
||||||
package thinking
|
|
||||||
|
|
||||||
import (
|
|
||||||
"strings"
|
|
||||||
"testing"
|
|
||||||
"unicode"
|
|
||||||
"unicode/utf8"
|
|
||||||
|
|
||||||
"github.com/router-for-me/CLIProxyAPI/v6/internal/registry"
|
|
||||||
log "github.com/sirupsen/logrus"
|
|
||||||
logtest "github.com/sirupsen/logrus/hooks/test"
|
|
||||||
)
|
|
||||||
|
|
||||||
// TestClampBudget tests the ClampBudget function.
|
|
||||||
//
|
|
||||||
// ClampBudget applies range constraints to a budget value:
|
|
||||||
// - budget < Min → clamp to Min (with Debug log)
|
|
||||||
// - budget > Max → clamp to Max (with Debug log)
|
|
||||||
// - Auto value (-1) passes through unchanged
|
|
||||||
func TestClampBudget(t *testing.T) {
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
value int
|
|
||||||
min int
|
|
||||||
max int
|
|
||||||
want int
|
|
||||||
}{
|
|
||||||
// Within range - no clamping
|
|
||||||
{"within range", 8192, 128, 32768, 8192},
|
|
||||||
{"at min", 128, 128, 32768, 128},
|
|
||||||
{"at max", 32768, 128, 32768, 32768},
|
|
||||||
|
|
||||||
// Below min - clamp to min
|
|
||||||
{"below min", 100, 128, 32768, 128},
|
|
||||||
|
|
||||||
// Above max - clamp to max
|
|
||||||
{"above max", 50000, 128, 32768, 32768},
|
|
||||||
|
|
||||||
// Edge cases
|
|
||||||
{"min equals max", 5000, 5000, 5000, 5000},
|
|
||||||
{"zero min zero value", 0, 0, 100, 0},
|
|
||||||
|
|
||||||
// Auto value (-1) - passes through
|
|
||||||
{"auto value", -1, 128, 32768, -1},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
got := ClampBudget(tt.value, tt.min, tt.max)
|
|
||||||
if got != tt.want {
|
|
||||||
t.Errorf("ClampBudget(%d, %d, %d) = %d, want %d",
|
|
||||||
tt.value, tt.min, tt.max, got, tt.want)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestZeroAllowedBoundaryHandling tests ZeroAllowed=false edge cases.
|
|
||||||
//
|
|
||||||
// When ZeroAllowed=false and user requests 0, clamp to Min + log Warn.
|
|
||||||
func TestZeroAllowedBoundaryHandling(t *testing.T) {
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
value int
|
|
||||||
min int
|
|
||||||
max int
|
|
||||||
zeroAllowed bool
|
|
||||||
want int
|
|
||||||
}{
|
|
||||||
// ZeroAllowed=true: 0 stays 0
|
|
||||||
{"zero allowed - keep zero", 0, 128, 32768, true, 0},
|
|
||||||
|
|
||||||
// ZeroAllowed=false: 0 clamps to min
|
|
||||||
{"zero not allowed - clamp to min", 0, 128, 32768, false, 128},
|
|
||||||
|
|
||||||
// ZeroAllowed=false but non-zero value: normal clamping
|
|
||||||
{"zero not allowed - positive value", 8192, 1024, 100000, false, 8192},
|
|
||||||
|
|
||||||
// Auto value (-1) always passes through
|
|
||||||
{"auto value", -1, 128, 32768, false, -1},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
got := ClampBudgetWithZeroCheck(tt.value, tt.min, tt.max, tt.zeroAllowed)
|
|
||||||
if got != tt.want {
|
|
||||||
t.Errorf("ClampBudgetWithZeroCheck(%d, %d, %d, %v) = %d, want %d",
|
|
||||||
tt.value, tt.min, tt.max, tt.zeroAllowed, got, tt.want)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestValidateConfigFramework verifies the ValidateConfig function framework.
|
|
||||||
// This test is merged into TestValidateConfig for consolidation.
|
|
||||||
|
|
||||||
// TestValidateConfigNotSupported verifies nil support handling.
|
|
||||||
// This test is merged into TestValidateConfig for consolidation.
|
|
||||||
|
|
||||||
// TestValidateConfigConversion verifies mode conversion based on capability.
|
|
||||||
// This test is merged into TestValidateConfig for consolidation.
|
|
||||||
|
|
||||||
// TestValidateConfigLevelSupport verifies level list validation.
|
|
||||||
// This test is merged into TestValidateConfig for consolidation.
|
|
||||||
|
|
||||||
// TestValidateConfigClamping verifies budget clamping behavior.
|
|
||||||
// This test is merged into TestValidateConfig for consolidation.
|
|
||||||
|
|
||||||
// TestValidateConfig is the comprehensive test for ValidateConfig function.
|
|
||||||
//
|
|
||||||
// ValidateConfig checks if a ThinkingConfig is valid for a given model.
|
|
||||||
// This test covers all validation scenarios including:
|
|
||||||
// - Framework basics (nil support with ModeNone)
|
|
||||||
// - Error cases (thinking not supported, level not supported, dynamic not allowed)
|
|
||||||
// - Mode conversion (budget-only, level-only, hybrid)
|
|
||||||
// - Budget clamping (to max, to min)
|
|
||||||
// - ZeroAllowed boundary handling (ModeNone with ZeroAllowed=false)
|
|
||||||
// - DynamicAllowed validation
|
|
||||||
//
|
|
||||||
// Depends on: Epic 5 Story 5-3 (config validity validation)
|
|
||||||
func TestValidateConfig(t *testing.T) {
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
config ThinkingConfig
|
|
||||||
support *registry.ThinkingSupport
|
|
||||||
wantMode ThinkingMode
|
|
||||||
wantBudget int
|
|
||||||
wantLevel ThinkingLevel
|
|
||||||
wantErr bool
|
|
||||||
wantCode ErrorCode
|
|
||||||
}{
|
|
||||||
// Framework basics
|
|
||||||
{"nil support mode none", ThinkingConfig{Mode: ModeNone, Budget: 0}, nil, ModeNone, 0, "", false, ""},
|
|
||||||
|
|
||||||
// Valid configs - no conversion needed
|
|
||||||
{"budget-only keeps budget", ThinkingConfig{Mode: ModeBudget, Budget: 8192}, ®istry.ThinkingSupport{Min: 1024, Max: 100000}, ModeBudget, 8192, "", false, ""},
|
|
||||||
|
|
||||||
// Auto-conversion: Level → Budget
|
|
||||||
{"budget-only converts level", ThinkingConfig{Mode: ModeLevel, Level: LevelHigh}, ®istry.ThinkingSupport{Min: 1024, Max: 100000}, ModeBudget, 24576, "", false, ""},
|
|
||||||
|
|
||||||
// Auto-conversion: Budget → Level
|
|
||||||
{"level-only converts budget", ThinkingConfig{Mode: ModeBudget, Budget: 5000}, ®istry.ThinkingSupport{Levels: []string{"low", "medium", "high"}}, ModeLevel, 0, LevelMedium, false, ""},
|
|
||||||
|
|
||||||
// Hybrid preserves original format
|
|
||||||
{"hybrid preserves level", ThinkingConfig{Mode: ModeLevel, Level: LevelLow}, ®istry.ThinkingSupport{Min: 128, Max: 32768, Levels: []string{"low", "high"}}, ModeLevel, 0, LevelLow, false, ""},
|
|
||||||
|
|
||||||
// Budget clamping
|
|
||||||
{"budget clamped to max", ThinkingConfig{Mode: ModeBudget, Budget: 200000}, ®istry.ThinkingSupport{Min: 1024, Max: 100000}, ModeBudget, 100000, "", false, ""},
|
|
||||||
{"budget clamped to min", ThinkingConfig{Mode: ModeBudget, Budget: 100}, ®istry.ThinkingSupport{Min: 1024, Max: 100000}, ModeBudget, 1024, "", false, ""},
|
|
||||||
|
|
||||||
// Error: thinking not supported
|
|
||||||
{"thinking not supported", ThinkingConfig{Mode: ModeBudget, Budget: 8192}, nil, 0, 0, "", true, ErrThinkingNotSupported},
|
|
||||||
|
|
||||||
// Error: level not in list
|
|
||||||
{"level not supported", ThinkingConfig{Mode: ModeLevel, Level: LevelXHigh}, ®istry.ThinkingSupport{Levels: []string{"low", "medium", "high"}}, 0, 0, "", true, ErrLevelNotSupported},
|
|
||||||
|
|
||||||
// Level case-insensitive
|
|
||||||
{"level supported case-insensitive", ThinkingConfig{Mode: ModeLevel, Level: ThinkingLevel("HIGH")}, ®istry.ThinkingSupport{Levels: []string{"low", "medium", "high"}}, ModeLevel, 0, ThinkingLevel("HIGH"), false, ""},
|
|
||||||
|
|
||||||
// ModeAuto with DynamicAllowed
|
|
||||||
{"auto with dynamic allowed", ThinkingConfig{Mode: ModeAuto, Budget: -1}, ®istry.ThinkingSupport{Min: 128, Max: 32768, DynamicAllowed: true}, ModeAuto, -1, "", false, ""},
|
|
||||||
|
|
||||||
// ModeAuto with DynamicAllowed=false - converts to mid-range (M3)
|
|
||||||
{"auto with dynamic not allowed", ThinkingConfig{Mode: ModeAuto, Budget: -1}, ®istry.ThinkingSupport{Min: 128, Max: 32768, DynamicAllowed: false}, ModeBudget, 16448, "", false, ""},
|
|
||||||
|
|
||||||
// ModeNone with ZeroAllowed=true - stays as ModeNone
|
|
||||||
{"mode none with zero allowed", ThinkingConfig{Mode: ModeNone, Budget: 0}, ®istry.ThinkingSupport{Min: 1024, Max: 100000, ZeroAllowed: true}, ModeNone, 0, "", false, ""},
|
|
||||||
|
|
||||||
// Budget=0 converts to ModeNone before clamping (M1)
|
|
||||||
{"budget zero converts to none", ThinkingConfig{Mode: ModeBudget, Budget: 0}, ®istry.ThinkingSupport{Min: 128, Max: 32768, ZeroAllowed: false}, ModeNone, 128, "", false, ""},
|
|
||||||
|
|
||||||
// Level=none converts to ModeNone before clamping, then Level set to lowest
|
|
||||||
{"level none converts to none", ThinkingConfig{Mode: ModeLevel, Level: LevelNone}, ®istry.ThinkingSupport{Min: 128, Max: 32768, Levels: []string{"low", "high"}, ZeroAllowed: false}, ModeNone, 128, ThinkingLevel("low"), false, ""},
|
|
||||||
{"level auto converts to auto", ThinkingConfig{Mode: ModeLevel, Level: LevelAuto}, ®istry.ThinkingSupport{Min: 128, Max: 32768, Levels: []string{"low", "high"}, DynamicAllowed: true}, ModeAuto, -1, "", false, ""},
|
|
||||||
// M1: Level=auto with DynamicAllowed=false - converts to mid-range budget
|
|
||||||
{"level auto with dynamic not allowed", ThinkingConfig{Mode: ModeLevel, Level: LevelAuto}, ®istry.ThinkingSupport{Min: 128, Max: 32768, Levels: []string{"low", "high"}, DynamicAllowed: false}, ModeBudget, 16448, "", false, ""},
|
|
||||||
// M2: Level=auto on Budget-only model (no Levels)
|
|
||||||
{"level auto on budget-only model", ThinkingConfig{Mode: ModeLevel, Level: LevelAuto}, ®istry.ThinkingSupport{Min: 128, Max: 32768, DynamicAllowed: true}, ModeAuto, -1, "", false, ""},
|
|
||||||
|
|
||||||
// ModeNone with ZeroAllowed=false - clamps to min but preserves ModeNone (M1)
|
|
||||||
{"mode none with zero not allowed - preserve mode", ThinkingConfig{Mode: ModeNone, Budget: 0}, ®istry.ThinkingSupport{Min: 1024, Max: 100000, ZeroAllowed: false}, ModeNone, 1024, "", false, ""},
|
|
||||||
|
|
||||||
// ModeNone with clamped Budget > 0 and Levels: sets Level to lowest
|
|
||||||
{"mode none clamped with levels", ThinkingConfig{Mode: ModeNone, Budget: 0}, ®istry.ThinkingSupport{Min: 128, Max: 32768, Levels: []string{"low", "high"}, ZeroAllowed: false}, ModeNone, 128, ThinkingLevel("low"), false, ""},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
got, err := ValidateConfig(tt.config, tt.support)
|
|
||||||
if tt.wantErr {
|
|
||||||
if err == nil {
|
|
||||||
t.Fatalf("ValidateConfig(%+v, support) error = nil, want %v", tt.config, tt.wantCode)
|
|
||||||
}
|
|
||||||
thinkingErr, ok := err.(*ThinkingError)
|
|
||||||
if !ok {
|
|
||||||
t.Fatalf("ValidateConfig(%+v, support) error type = %T, want *ThinkingError", tt.config, err)
|
|
||||||
}
|
|
||||||
if thinkingErr.Code != tt.wantCode {
|
|
||||||
t.Errorf("ValidateConfig(%+v, support) code = %v, want %v", tt.config, thinkingErr.Code, tt.wantCode)
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("ValidateConfig(%+v, support) returned error: %v", tt.config, err)
|
|
||||||
}
|
|
||||||
if got == nil {
|
|
||||||
t.Fatalf("ValidateConfig(%+v, support) returned nil config", tt.config)
|
|
||||||
}
|
|
||||||
if got.Mode != tt.wantMode {
|
|
||||||
t.Errorf("ValidateConfig(%+v, support) Mode = %v, want %v", tt.config, got.Mode, tt.wantMode)
|
|
||||||
}
|
|
||||||
if got.Budget != tt.wantBudget {
|
|
||||||
t.Errorf("ValidateConfig(%+v, support) Budget = %d, want %d", tt.config, got.Budget, tt.wantBudget)
|
|
||||||
}
|
|
||||||
if got.Level != tt.wantLevel {
|
|
||||||
t.Errorf("ValidateConfig(%+v, support) Level = %q, want %q", tt.config, got.Level, tt.wantLevel)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestValidationErrorMessages tests error message formatting.
|
|
||||||
//
|
|
||||||
// Error messages should:
|
|
||||||
// - Be lowercase
|
|
||||||
// - Have no trailing period
|
|
||||||
// - Include context with %s/%d
|
|
||||||
//
|
|
||||||
// Depends on: Epic 5 Story 5-4 (validation error messages)
|
|
||||||
func TestValidationErrorMessages(t *testing.T) {
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
getErr func() error
|
|
||||||
wantCode ErrorCode
|
|
||||||
wantContains string
|
|
||||||
}{
|
|
||||||
{"invalid suffix", func() error {
|
|
||||||
_, err := ParseSuffixWithError("model(abc")
|
|
||||||
return err
|
|
||||||
}, ErrInvalidSuffix, "model(abc"},
|
|
||||||
{"level not supported", func() error {
|
|
||||||
_, err := ValidateConfig(ThinkingConfig{Mode: ModeLevel, Level: LevelXHigh}, ®istry.ThinkingSupport{Levels: []string{"low", "medium", "high"}})
|
|
||||||
return err
|
|
||||||
}, ErrLevelNotSupported, "valid levels: low, medium, high"},
|
|
||||||
{"thinking not supported", func() error {
|
|
||||||
_, err := ValidateConfig(ThinkingConfig{Mode: ModeBudget, Budget: 1024}, nil)
|
|
||||||
return err
|
|
||||||
}, ErrThinkingNotSupported, "thinking not supported for this model"},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
err := tt.getErr()
|
|
||||||
if err == nil {
|
|
||||||
t.Fatalf("error = nil, want ThinkingError")
|
|
||||||
}
|
|
||||||
thinkingErr, ok := err.(*ThinkingError)
|
|
||||||
if !ok {
|
|
||||||
t.Fatalf("error type = %T, want *ThinkingError", err)
|
|
||||||
}
|
|
||||||
if thinkingErr.Code != tt.wantCode {
|
|
||||||
t.Errorf("code = %v, want %v", thinkingErr.Code, tt.wantCode)
|
|
||||||
}
|
|
||||||
if thinkingErr.Message == "" {
|
|
||||||
t.Fatalf("message is empty")
|
|
||||||
}
|
|
||||||
first, _ := utf8.DecodeRuneInString(thinkingErr.Message)
|
|
||||||
if unicode.IsLetter(first) && !unicode.IsLower(first) {
|
|
||||||
t.Errorf("message does not start with lowercase: %q", thinkingErr.Message)
|
|
||||||
}
|
|
||||||
if strings.HasSuffix(thinkingErr.Message, ".") {
|
|
||||||
t.Errorf("message has trailing period: %q", thinkingErr.Message)
|
|
||||||
}
|
|
||||||
if !strings.Contains(thinkingErr.Message, tt.wantContains) {
|
|
||||||
t.Errorf("message %q does not contain %q", thinkingErr.Message, tt.wantContains)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestClampingLogging tests that clamping produces correct log entries.
|
|
||||||
//
|
|
||||||
// Clamping behavior:
|
|
||||||
// - Normal clamp (budget outside range) → Debug log
|
|
||||||
// - ZeroAllowed=false + zero request → Warn log
|
|
||||||
//
|
|
||||||
// Depends on: Epic 5 Story 5-1, 5-2
|
|
||||||
func TestClampingLogging(t *testing.T) {
|
|
||||||
tests := []struct {
|
|
||||||
name string
|
|
||||||
useZeroCheck bool
|
|
||||||
budget int
|
|
||||||
min int
|
|
||||||
max int
|
|
||||||
zeroAllowed bool
|
|
||||||
wantLevel log.Level
|
|
||||||
wantReason string
|
|
||||||
wantClamped int
|
|
||||||
}{
|
|
||||||
{"above max - debug", false, 50000, 128, 32768, false, log.DebugLevel, "", 32768},
|
|
||||||
{"below min - debug", false, 50, 128, 32768, false, log.DebugLevel, "", 128},
|
|
||||||
{"zero not allowed - warn", true, 0, 128, 32768, false, log.WarnLevel, "zero_not_allowed", 128},
|
|
||||||
}
|
|
||||||
|
|
||||||
logger := log.StandardLogger()
|
|
||||||
originalLevel := logger.GetLevel()
|
|
||||||
logger.SetLevel(log.DebugLevel)
|
|
||||||
hook := logtest.NewLocal(logger)
|
|
||||||
t.Cleanup(func() {
|
|
||||||
logger.SetLevel(originalLevel)
|
|
||||||
hook.Reset()
|
|
||||||
})
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
hook.Reset()
|
|
||||||
var got int
|
|
||||||
if tt.useZeroCheck {
|
|
||||||
got = ClampBudgetWithZeroCheck(tt.budget, tt.min, tt.max, tt.zeroAllowed)
|
|
||||||
} else {
|
|
||||||
got = ClampBudget(tt.budget, tt.min, tt.max)
|
|
||||||
}
|
|
||||||
if got != tt.wantClamped {
|
|
||||||
t.Fatalf("clamped budget = %d, want %d", got, tt.wantClamped)
|
|
||||||
}
|
|
||||||
|
|
||||||
entry := hook.LastEntry()
|
|
||||||
if entry == nil {
|
|
||||||
t.Fatalf("no log entry captured")
|
|
||||||
}
|
|
||||||
if entry.Level != tt.wantLevel {
|
|
||||||
t.Errorf("log level = %v, want %v", entry.Level, tt.wantLevel)
|
|
||||||
}
|
|
||||||
|
|
||||||
fields := []string{"original_value", "clamped_to", "min", "max"}
|
|
||||||
for _, key := range fields {
|
|
||||||
if _, ok := entry.Data[key]; !ok {
|
|
||||||
t.Errorf("missing field %q", key)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if tt.wantReason != "" {
|
|
||||||
if value, ok := entry.Data["reason"]; !ok || value != tt.wantReason {
|
|
||||||
t.Errorf("reason = %v, want %v", value, tt.wantReason)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,423 +0,0 @@
|
|||||||
package test
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
"testing"
|
|
||||||
"time"
|
|
||||||
|
|
||||||
"github.com/router-for-me/CLIProxyAPI/v6/internal/registry"
|
|
||||||
"github.com/router-for-me/CLIProxyAPI/v6/internal/util"
|
|
||||||
"github.com/tidwall/gjson"
|
|
||||||
)
|
|
||||||
|
|
||||||
// registerGemini3Models loads Gemini 3 models into the registry for testing.
|
|
||||||
func registerGemini3Models(t *testing.T) func() {
|
|
||||||
t.Helper()
|
|
||||||
reg := registry.GetGlobalRegistry()
|
|
||||||
uid := fmt.Sprintf("gemini3-test-%d", time.Now().UnixNano())
|
|
||||||
reg.RegisterClient(uid+"-gemini", "gemini", registry.GetGeminiModels())
|
|
||||||
reg.RegisterClient(uid+"-aistudio", "aistudio", registry.GetAIStudioModels())
|
|
||||||
return func() {
|
|
||||||
reg.UnregisterClient(uid + "-gemini")
|
|
||||||
reg.UnregisterClient(uid + "-aistudio")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestIsGemini3Model(t *testing.T) {
|
|
||||||
cases := []struct {
|
|
||||||
model string
|
|
||||||
expected bool
|
|
||||||
}{
|
|
||||||
{"gemini-3-pro-preview", true},
|
|
||||||
{"gemini-3-flash-preview", true},
|
|
||||||
{"gemini_3_pro_preview", true},
|
|
||||||
{"gemini-3-pro", true},
|
|
||||||
{"gemini-3-flash", true},
|
|
||||||
{"GEMINI-3-PRO-PREVIEW", true},
|
|
||||||
{"gemini-2.5-pro", false},
|
|
||||||
{"gemini-2.5-flash", false},
|
|
||||||
{"gpt-5", false},
|
|
||||||
{"claude-sonnet-4-5", false},
|
|
||||||
{"", false},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, cs := range cases {
|
|
||||||
t.Run(cs.model, func(t *testing.T) {
|
|
||||||
got := util.IsGemini3Model(cs.model)
|
|
||||||
if got != cs.expected {
|
|
||||||
t.Fatalf("IsGemini3Model(%q) = %v, want %v", cs.model, got, cs.expected)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestIsGemini3ProModel(t *testing.T) {
|
|
||||||
cases := []struct {
|
|
||||||
model string
|
|
||||||
expected bool
|
|
||||||
}{
|
|
||||||
{"gemini-3-pro-preview", true},
|
|
||||||
{"gemini_3_pro_preview", true},
|
|
||||||
{"gemini-3-pro", true},
|
|
||||||
{"GEMINI-3-PRO-PREVIEW", true},
|
|
||||||
{"gemini-3-flash-preview", false},
|
|
||||||
{"gemini-3-flash", false},
|
|
||||||
{"gemini-2.5-pro", false},
|
|
||||||
{"", false},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, cs := range cases {
|
|
||||||
t.Run(cs.model, func(t *testing.T) {
|
|
||||||
got := util.IsGemini3ProModel(cs.model)
|
|
||||||
if got != cs.expected {
|
|
||||||
t.Fatalf("IsGemini3ProModel(%q) = %v, want %v", cs.model, got, cs.expected)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestIsGemini3FlashModel(t *testing.T) {
|
|
||||||
cases := []struct {
|
|
||||||
model string
|
|
||||||
expected bool
|
|
||||||
}{
|
|
||||||
{"gemini-3-flash-preview", true},
|
|
||||||
{"gemini_3_flash_preview", true},
|
|
||||||
{"gemini-3-flash", true},
|
|
||||||
{"GEMINI-3-FLASH-PREVIEW", true},
|
|
||||||
{"gemini-3-pro-preview", false},
|
|
||||||
{"gemini-3-pro", false},
|
|
||||||
{"gemini-2.5-flash", false},
|
|
||||||
{"", false},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, cs := range cases {
|
|
||||||
t.Run(cs.model, func(t *testing.T) {
|
|
||||||
got := util.IsGemini3FlashModel(cs.model)
|
|
||||||
if got != cs.expected {
|
|
||||||
t.Fatalf("IsGemini3FlashModel(%q) = %v, want %v", cs.model, got, cs.expected)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestValidateGemini3ThinkingLevel(t *testing.T) {
|
|
||||||
cases := []struct {
|
|
||||||
name string
|
|
||||||
model string
|
|
||||||
level string
|
|
||||||
wantOK bool
|
|
||||||
wantVal string
|
|
||||||
}{
|
|
||||||
// Gemini 3 Pro: supports "low", "high"
|
|
||||||
{"pro-low", "gemini-3-pro-preview", "low", true, "low"},
|
|
||||||
{"pro-high", "gemini-3-pro-preview", "high", true, "high"},
|
|
||||||
{"pro-minimal-invalid", "gemini-3-pro-preview", "minimal", false, ""},
|
|
||||||
{"pro-medium-invalid", "gemini-3-pro-preview", "medium", false, ""},
|
|
||||||
|
|
||||||
// Gemini 3 Flash: supports "minimal", "low", "medium", "high"
|
|
||||||
{"flash-minimal", "gemini-3-flash-preview", "minimal", true, "minimal"},
|
|
||||||
{"flash-low", "gemini-3-flash-preview", "low", true, "low"},
|
|
||||||
{"flash-medium", "gemini-3-flash-preview", "medium", true, "medium"},
|
|
||||||
{"flash-high", "gemini-3-flash-preview", "high", true, "high"},
|
|
||||||
|
|
||||||
// Case insensitivity
|
|
||||||
{"flash-LOW-case", "gemini-3-flash-preview", "LOW", true, "low"},
|
|
||||||
{"flash-High-case", "gemini-3-flash-preview", "High", true, "high"},
|
|
||||||
{"pro-HIGH-case", "gemini-3-pro-preview", "HIGH", true, "high"},
|
|
||||||
|
|
||||||
// Invalid levels
|
|
||||||
{"flash-invalid", "gemini-3-flash-preview", "xhigh", false, ""},
|
|
||||||
{"flash-invalid-auto", "gemini-3-flash-preview", "auto", false, ""},
|
|
||||||
{"flash-empty", "gemini-3-flash-preview", "", false, ""},
|
|
||||||
|
|
||||||
// Non-Gemini 3 models
|
|
||||||
{"non-gemini3", "gemini-2.5-pro", "high", false, ""},
|
|
||||||
{"gpt5", "gpt-5", "high", false, ""},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, cs := range cases {
|
|
||||||
t.Run(cs.name, func(t *testing.T) {
|
|
||||||
got, ok := util.ValidateGemini3ThinkingLevel(cs.model, cs.level)
|
|
||||||
if ok != cs.wantOK {
|
|
||||||
t.Fatalf("ValidateGemini3ThinkingLevel(%q, %q) ok = %v, want %v", cs.model, cs.level, ok, cs.wantOK)
|
|
||||||
}
|
|
||||||
if got != cs.wantVal {
|
|
||||||
t.Fatalf("ValidateGemini3ThinkingLevel(%q, %q) = %q, want %q", cs.model, cs.level, got, cs.wantVal)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestThinkingBudgetToGemini3Level(t *testing.T) {
|
|
||||||
cases := []struct {
|
|
||||||
name string
|
|
||||||
model string
|
|
||||||
budget int
|
|
||||||
wantOK bool
|
|
||||||
wantVal string
|
|
||||||
}{
|
|
||||||
// Gemini 3 Pro: maps to "low" or "high"
|
|
||||||
{"pro-dynamic", "gemini-3-pro-preview", -1, true, "high"},
|
|
||||||
{"pro-zero", "gemini-3-pro-preview", 0, true, "low"},
|
|
||||||
{"pro-small", "gemini-3-pro-preview", 1000, true, "low"},
|
|
||||||
{"pro-medium", "gemini-3-pro-preview", 8000, true, "low"},
|
|
||||||
{"pro-large", "gemini-3-pro-preview", 20000, true, "high"},
|
|
||||||
{"pro-huge", "gemini-3-pro-preview", 50000, true, "high"},
|
|
||||||
|
|
||||||
// Gemini 3 Flash: maps to "minimal", "low", "medium", "high"
|
|
||||||
{"flash-dynamic", "gemini-3-flash-preview", -1, true, "high"},
|
|
||||||
{"flash-zero", "gemini-3-flash-preview", 0, true, "minimal"},
|
|
||||||
{"flash-tiny", "gemini-3-flash-preview", 500, true, "minimal"},
|
|
||||||
{"flash-small", "gemini-3-flash-preview", 1000, true, "low"},
|
|
||||||
{"flash-medium-val", "gemini-3-flash-preview", 8000, true, "medium"},
|
|
||||||
{"flash-large", "gemini-3-flash-preview", 20000, true, "high"},
|
|
||||||
{"flash-huge", "gemini-3-flash-preview", 50000, true, "high"},
|
|
||||||
|
|
||||||
// Non-Gemini 3 models should return false
|
|
||||||
{"gemini25-budget", "gemini-2.5-pro", 8000, false, ""},
|
|
||||||
{"gpt5-budget", "gpt-5", 8000, false, ""},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, cs := range cases {
|
|
||||||
t.Run(cs.name, func(t *testing.T) {
|
|
||||||
got, ok := util.ThinkingBudgetToGemini3Level(cs.model, cs.budget)
|
|
||||||
if ok != cs.wantOK {
|
|
||||||
t.Fatalf("ThinkingBudgetToGemini3Level(%q, %d) ok = %v, want %v", cs.model, cs.budget, ok, cs.wantOK)
|
|
||||||
}
|
|
||||||
if got != cs.wantVal {
|
|
||||||
t.Fatalf("ThinkingBudgetToGemini3Level(%q, %d) = %q, want %q", cs.model, cs.budget, got, cs.wantVal)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestApplyGemini3ThinkingLevelFromMetadata(t *testing.T) {
|
|
||||||
cleanup := registerGemini3Models(t)
|
|
||||||
defer cleanup()
|
|
||||||
|
|
||||||
cases := []struct {
|
|
||||||
name string
|
|
||||||
model string
|
|
||||||
metadata map[string]any
|
|
||||||
inputBody string
|
|
||||||
wantLevel string
|
|
||||||
wantInclude bool
|
|
||||||
wantNoChange bool
|
|
||||||
}{
|
|
||||||
{
|
|
||||||
name: "flash-minimal-from-suffix",
|
|
||||||
model: "gemini-3-flash-preview",
|
|
||||||
metadata: map[string]any{"reasoning_effort": "minimal"},
|
|
||||||
inputBody: `{"generationConfig":{"thinkingConfig":{"includeThoughts":true}}}`,
|
|
||||||
wantLevel: "minimal",
|
|
||||||
wantInclude: true,
|
|
||||||
},
|
|
||||||
{
|
|
||||||
name: "flash-medium-from-suffix",
|
|
||||||
model: "gemini-3-flash-preview",
|
|
||||||
metadata: map[string]any{"reasoning_effort": "medium"},
|
|
||||||
inputBody: `{"generationConfig":{"thinkingConfig":{"includeThoughts":true}}}`,
|
|
||||||
wantLevel: "medium",
|
|
||||||
wantInclude: true,
|
|
||||||
},
|
|
||||||
{
|
|
||||||
name: "pro-high-from-suffix",
|
|
||||||
model: "gemini-3-pro-preview",
|
|
||||||
metadata: map[string]any{"reasoning_effort": "high"},
|
|
||||||
inputBody: `{"generationConfig":{"thinkingConfig":{"includeThoughts":true}}}`,
|
|
||||||
wantLevel: "high",
|
|
||||||
wantInclude: true,
|
|
||||||
},
|
|
||||||
{
|
|
||||||
name: "no-metadata-no-change",
|
|
||||||
model: "gemini-3-flash-preview",
|
|
||||||
metadata: nil,
|
|
||||||
inputBody: `{"generationConfig":{"thinkingConfig":{"includeThoughts":true}}}`,
|
|
||||||
wantNoChange: true,
|
|
||||||
},
|
|
||||||
{
|
|
||||||
name: "non-gemini3-no-change",
|
|
||||||
model: "gemini-2.5-pro",
|
|
||||||
metadata: map[string]any{"reasoning_effort": "high"},
|
|
||||||
inputBody: `{"generationConfig":{"thinkingConfig":{"thinkingBudget":-1}}}`,
|
|
||||||
wantNoChange: true,
|
|
||||||
},
|
|
||||||
{
|
|
||||||
name: "invalid-level-no-change",
|
|
||||||
model: "gemini-3-flash-preview",
|
|
||||||
metadata: map[string]any{"reasoning_effort": "xhigh"},
|
|
||||||
inputBody: `{"generationConfig":{"thinkingConfig":{"includeThoughts":true}}}`,
|
|
||||||
wantNoChange: true,
|
|
||||||
},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, cs := range cases {
|
|
||||||
t.Run(cs.name, func(t *testing.T) {
|
|
||||||
input := []byte(cs.inputBody)
|
|
||||||
result := util.ApplyGemini3ThinkingLevelFromMetadata(cs.model, cs.metadata, input)
|
|
||||||
|
|
||||||
if cs.wantNoChange {
|
|
||||||
if string(result) != cs.inputBody {
|
|
||||||
t.Fatalf("expected no change, but got: %s", string(result))
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
level := gjson.GetBytes(result, "generationConfig.thinkingConfig.thinkingLevel")
|
|
||||||
if !level.Exists() {
|
|
||||||
t.Fatalf("thinkingLevel not set in result: %s", string(result))
|
|
||||||
}
|
|
||||||
if level.String() != cs.wantLevel {
|
|
||||||
t.Fatalf("thinkingLevel = %q, want %q", level.String(), cs.wantLevel)
|
|
||||||
}
|
|
||||||
|
|
||||||
include := gjson.GetBytes(result, "generationConfig.thinkingConfig.includeThoughts")
|
|
||||||
if cs.wantInclude && (!include.Exists() || !include.Bool()) {
|
|
||||||
t.Fatalf("includeThoughts should be true, got: %s", string(result))
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestApplyGemini3ThinkingLevelFromMetadataCLI(t *testing.T) {
|
|
||||||
cleanup := registerGemini3Models(t)
|
|
||||||
defer cleanup()
|
|
||||||
|
|
||||||
cases := []struct {
|
|
||||||
name string
|
|
||||||
model string
|
|
||||||
metadata map[string]any
|
|
||||||
inputBody string
|
|
||||||
wantLevel string
|
|
||||||
wantInclude bool
|
|
||||||
wantNoChange bool
|
|
||||||
}{
|
|
||||||
{
|
|
||||||
name: "flash-minimal-from-suffix-cli",
|
|
||||||
model: "gemini-3-flash-preview",
|
|
||||||
metadata: map[string]any{"reasoning_effort": "minimal"},
|
|
||||||
inputBody: `{"request":{"generationConfig":{"thinkingConfig":{"includeThoughts":true}}}}`,
|
|
||||||
wantLevel: "minimal",
|
|
||||||
wantInclude: true,
|
|
||||||
},
|
|
||||||
{
|
|
||||||
name: "flash-low-from-suffix-cli",
|
|
||||||
model: "gemini-3-flash-preview",
|
|
||||||
metadata: map[string]any{"reasoning_effort": "low"},
|
|
||||||
inputBody: `{"request":{"generationConfig":{"thinkingConfig":{"includeThoughts":true}}}}`,
|
|
||||||
wantLevel: "low",
|
|
||||||
wantInclude: true,
|
|
||||||
},
|
|
||||||
{
|
|
||||||
name: "pro-low-from-suffix-cli",
|
|
||||||
model: "gemini-3-pro-preview",
|
|
||||||
metadata: map[string]any{"reasoning_effort": "low"},
|
|
||||||
inputBody: `{"request":{"generationConfig":{"thinkingConfig":{"includeThoughts":true}}}}`,
|
|
||||||
wantLevel: "low",
|
|
||||||
wantInclude: true,
|
|
||||||
},
|
|
||||||
{
|
|
||||||
name: "no-metadata-no-change-cli",
|
|
||||||
model: "gemini-3-flash-preview",
|
|
||||||
metadata: nil,
|
|
||||||
inputBody: `{"request":{"generationConfig":{"thinkingConfig":{"includeThoughts":true}}}}`,
|
|
||||||
wantNoChange: true,
|
|
||||||
},
|
|
||||||
{
|
|
||||||
name: "non-gemini3-no-change-cli",
|
|
||||||
model: "gemini-2.5-pro",
|
|
||||||
metadata: map[string]any{"reasoning_effort": "high"},
|
|
||||||
inputBody: `{"request":{"generationConfig":{"thinkingConfig":{"thinkingBudget":-1}}}}`,
|
|
||||||
wantNoChange: true,
|
|
||||||
},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, cs := range cases {
|
|
||||||
t.Run(cs.name, func(t *testing.T) {
|
|
||||||
input := []byte(cs.inputBody)
|
|
||||||
result := util.ApplyGemini3ThinkingLevelFromMetadataCLI(cs.model, cs.metadata, input)
|
|
||||||
|
|
||||||
if cs.wantNoChange {
|
|
||||||
if string(result) != cs.inputBody {
|
|
||||||
t.Fatalf("expected no change, but got: %s", string(result))
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
level := gjson.GetBytes(result, "request.generationConfig.thinkingConfig.thinkingLevel")
|
|
||||||
if !level.Exists() {
|
|
||||||
t.Fatalf("thinkingLevel not set in result: %s", string(result))
|
|
||||||
}
|
|
||||||
if level.String() != cs.wantLevel {
|
|
||||||
t.Fatalf("thinkingLevel = %q, want %q", level.String(), cs.wantLevel)
|
|
||||||
}
|
|
||||||
|
|
||||||
include := gjson.GetBytes(result, "request.generationConfig.thinkingConfig.includeThoughts")
|
|
||||||
if cs.wantInclude && (!include.Exists() || !include.Bool()) {
|
|
||||||
t.Fatalf("includeThoughts should be true, got: %s", string(result))
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestNormalizeGeminiThinkingBudget_Gemini3Conversion(t *testing.T) {
|
|
||||||
cleanup := registerGemini3Models(t)
|
|
||||||
defer cleanup()
|
|
||||||
|
|
||||||
cases := []struct {
|
|
||||||
name string
|
|
||||||
model string
|
|
||||||
inputBody string
|
|
||||||
wantLevel string
|
|
||||||
wantBudget bool // if true, expect thinkingBudget instead of thinkingLevel
|
|
||||||
}{
|
|
||||||
{
|
|
||||||
name: "gemini3-flash-budget-to-level",
|
|
||||||
model: "gemini-3-flash-preview",
|
|
||||||
inputBody: `{"generationConfig":{"thinkingConfig":{"thinkingBudget":8000}}}`,
|
|
||||||
wantLevel: "medium",
|
|
||||||
},
|
|
||||||
{
|
|
||||||
name: "gemini3-pro-budget-to-level",
|
|
||||||
model: "gemini-3-pro-preview",
|
|
||||||
inputBody: `{"generationConfig":{"thinkingConfig":{"thinkingBudget":20000}}}`,
|
|
||||||
wantLevel: "high",
|
|
||||||
},
|
|
||||||
{
|
|
||||||
name: "gemini25-keeps-budget",
|
|
||||||
model: "gemini-2.5-pro",
|
|
||||||
inputBody: `{"generationConfig":{"thinkingConfig":{"thinkingBudget":8000}}}`,
|
|
||||||
wantBudget: true,
|
|
||||||
},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, cs := range cases {
|
|
||||||
t.Run(cs.name, func(t *testing.T) {
|
|
||||||
result := util.NormalizeGeminiThinkingBudget(cs.model, []byte(cs.inputBody))
|
|
||||||
|
|
||||||
if cs.wantBudget {
|
|
||||||
budget := gjson.GetBytes(result, "generationConfig.thinkingConfig.thinkingBudget")
|
|
||||||
if !budget.Exists() {
|
|
||||||
t.Fatalf("thinkingBudget should exist for non-Gemini3 model: %s", string(result))
|
|
||||||
}
|
|
||||||
level := gjson.GetBytes(result, "generationConfig.thinkingConfig.thinkingLevel")
|
|
||||||
if level.Exists() {
|
|
||||||
t.Fatalf("thinkingLevel should not exist for non-Gemini3 model: %s", string(result))
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
level := gjson.GetBytes(result, "generationConfig.thinkingConfig.thinkingLevel")
|
|
||||||
if !level.Exists() {
|
|
||||||
t.Fatalf("thinkingLevel should exist for Gemini3 model: %s", string(result))
|
|
||||||
}
|
|
||||||
if level.String() != cs.wantLevel {
|
|
||||||
t.Fatalf("thinkingLevel = %q, want %q", level.String(), cs.wantLevel)
|
|
||||||
}
|
|
||||||
budget := gjson.GetBytes(result, "generationConfig.thinkingConfig.thinkingBudget")
|
|
||||||
if budget.Exists() {
|
|
||||||
t.Fatalf("thinkingBudget should be removed for Gemini3 model: %s", string(result))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,262 +0,0 @@
|
|||||||
package test
|
|
||||||
|
|
||||||
import (
|
|
||||||
"testing"
|
|
||||||
|
|
||||||
"github.com/router-for-me/CLIProxyAPI/v6/internal/thinking"
|
|
||||||
"github.com/router-for-me/CLIProxyAPI/v6/internal/util"
|
|
||||||
"github.com/tidwall/gjson"
|
|
||||||
"github.com/tidwall/sjson"
|
|
||||||
)
|
|
||||||
|
|
||||||
// TestModelAliasThinkingSuffix tests the 32 test cases defined in docs/thinking_suffix_test_cases.md
|
|
||||||
// These tests verify the thinking suffix parsing and application logic across different providers.
|
|
||||||
func TestModelAliasThinkingSuffix(t *testing.T) {
|
|
||||||
tests := []struct {
|
|
||||||
id int
|
|
||||||
name string
|
|
||||||
provider string
|
|
||||||
requestModel string
|
|
||||||
suffixType string
|
|
||||||
expectedField string // "thinkingBudget", "thinkingLevel", "budget_tokens", "reasoning_effort", "enable_thinking"
|
|
||||||
expectedValue any
|
|
||||||
upstreamModel string // The upstream model after alias resolution
|
|
||||||
isAlias bool
|
|
||||||
}{
|
|
||||||
// === 1. Antigravity Provider ===
|
|
||||||
// 1.1 Budget-only models (Gemini 2.5)
|
|
||||||
{1, "antigravity_original_numeric", "antigravity", "gemini-2.5-computer-use-preview-10-2025(1000)", "numeric", "thinkingBudget", 1000, "gemini-2.5-computer-use-preview-10-2025", false},
|
|
||||||
{2, "antigravity_alias_numeric", "antigravity", "gp(1000)", "numeric", "thinkingBudget", 1000, "gemini-2.5-computer-use-preview-10-2025", true},
|
|
||||||
// 1.2 Budget+Levels models (Gemini 3)
|
|
||||||
{3, "antigravity_original_numeric_to_level", "antigravity", "gemini-3-flash-preview(1000)", "numeric", "thinkingLevel", "low", "gemini-3-flash-preview", false},
|
|
||||||
{4, "antigravity_original_level", "antigravity", "gemini-3-flash-preview(low)", "level", "thinkingLevel", "low", "gemini-3-flash-preview", false},
|
|
||||||
{5, "antigravity_alias_numeric_to_level", "antigravity", "gf(1000)", "numeric", "thinkingLevel", "low", "gemini-3-flash-preview", true},
|
|
||||||
{6, "antigravity_alias_level", "antigravity", "gf(low)", "level", "thinkingLevel", "low", "gemini-3-flash-preview", true},
|
|
||||||
|
|
||||||
// === 2. Gemini CLI Provider ===
|
|
||||||
// 2.1 Budget-only models
|
|
||||||
{7, "gemini_cli_original_numeric", "gemini-cli", "gemini-2.5-pro(8192)", "numeric", "thinkingBudget", 8192, "gemini-2.5-pro", false},
|
|
||||||
{8, "gemini_cli_alias_numeric", "gemini-cli", "g25p(8192)", "numeric", "thinkingBudget", 8192, "gemini-2.5-pro", true},
|
|
||||||
// 2.2 Budget+Levels models
|
|
||||||
{9, "gemini_cli_original_numeric_to_level", "gemini-cli", "gemini-3-flash-preview(1000)", "numeric", "thinkingLevel", "low", "gemini-3-flash-preview", false},
|
|
||||||
{10, "gemini_cli_original_level", "gemini-cli", "gemini-3-flash-preview(low)", "level", "thinkingLevel", "low", "gemini-3-flash-preview", false},
|
|
||||||
{11, "gemini_cli_alias_numeric_to_level", "gemini-cli", "gf(1000)", "numeric", "thinkingLevel", "low", "gemini-3-flash-preview", true},
|
|
||||||
{12, "gemini_cli_alias_level", "gemini-cli", "gf(low)", "level", "thinkingLevel", "low", "gemini-3-flash-preview", true},
|
|
||||||
|
|
||||||
// === 3. Vertex Provider ===
|
|
||||||
// 3.1 Budget-only models
|
|
||||||
{13, "vertex_original_numeric", "vertex", "gemini-2.5-pro(16384)", "numeric", "thinkingBudget", 16384, "gemini-2.5-pro", false},
|
|
||||||
{14, "vertex_alias_numeric", "vertex", "vg25p(16384)", "numeric", "thinkingBudget", 16384, "gemini-2.5-pro", true},
|
|
||||||
// 3.2 Budget+Levels models
|
|
||||||
{15, "vertex_original_numeric_to_level", "vertex", "gemini-3-flash-preview(1000)", "numeric", "thinkingLevel", "low", "gemini-3-flash-preview", false},
|
|
||||||
{16, "vertex_original_level", "vertex", "gemini-3-flash-preview(low)", "level", "thinkingLevel", "low", "gemini-3-flash-preview", false},
|
|
||||||
{17, "vertex_alias_numeric_to_level", "vertex", "vgf(1000)", "numeric", "thinkingLevel", "low", "gemini-3-flash-preview", true},
|
|
||||||
{18, "vertex_alias_level", "vertex", "vgf(low)", "level", "thinkingLevel", "low", "gemini-3-flash-preview", true},
|
|
||||||
|
|
||||||
// === 4. AI Studio Provider ===
|
|
||||||
// 4.1 Budget-only models
|
|
||||||
{19, "aistudio_original_numeric", "aistudio", "gemini-2.5-pro(12000)", "numeric", "thinkingBudget", 12000, "gemini-2.5-pro", false},
|
|
||||||
{20, "aistudio_alias_numeric", "aistudio", "ag25p(12000)", "numeric", "thinkingBudget", 12000, "gemini-2.5-pro", true},
|
|
||||||
// 4.2 Budget+Levels models
|
|
||||||
{21, "aistudio_original_numeric_to_level", "aistudio", "gemini-3-flash-preview(1000)", "numeric", "thinkingLevel", "low", "gemini-3-flash-preview", false},
|
|
||||||
{22, "aistudio_original_level", "aistudio", "gemini-3-flash-preview(low)", "level", "thinkingLevel", "low", "gemini-3-flash-preview", false},
|
|
||||||
{23, "aistudio_alias_numeric_to_level", "aistudio", "agf(1000)", "numeric", "thinkingLevel", "low", "gemini-3-flash-preview", true},
|
|
||||||
{24, "aistudio_alias_level", "aistudio", "agf(low)", "level", "thinkingLevel", "low", "gemini-3-flash-preview", true},
|
|
||||||
|
|
||||||
// === 5. Claude Provider ===
|
|
||||||
{25, "claude_original_numeric", "claude", "claude-sonnet-4-5-20250929(16384)", "numeric", "budget_tokens", 16384, "claude-sonnet-4-5-20250929", false},
|
|
||||||
{26, "claude_alias_numeric", "claude", "cs45(16384)", "numeric", "budget_tokens", 16384, "claude-sonnet-4-5-20250929", true},
|
|
||||||
|
|
||||||
// === 6. Codex Provider ===
|
|
||||||
{27, "codex_original_level", "codex", "gpt-5(high)", "level", "reasoning_effort", "high", "gpt-5", false},
|
|
||||||
{28, "codex_alias_level", "codex", "g5(high)", "level", "reasoning_effort", "high", "gpt-5", true},
|
|
||||||
|
|
||||||
// === 7. Qwen Provider ===
|
|
||||||
{29, "qwen_original_level", "qwen", "qwen3-coder-plus(high)", "level", "enable_thinking", true, "qwen3-coder-plus", false},
|
|
||||||
{30, "qwen_alias_level", "qwen", "qcp(high)", "level", "enable_thinking", true, "qwen3-coder-plus", true},
|
|
||||||
|
|
||||||
// === 8. iFlow Provider ===
|
|
||||||
{31, "iflow_original_level", "iflow", "glm-4.7(high)", "level", "reasoning_effort", "high", "glm-4.7", false},
|
|
||||||
{32, "iflow_alias_level", "iflow", "glm(high)", "level", "reasoning_effort", "high", "glm-4.7", true},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(tt.name, func(t *testing.T) {
|
|
||||||
// Step 1: Parse model suffix (simulates SDK layer normalization)
|
|
||||||
// For "gp(1000)" -> requestedModel="gp", metadata={thinking_budget: 1000}
|
|
||||||
requestedModel, metadata := util.NormalizeThinkingModel(tt.requestModel)
|
|
||||||
|
|
||||||
// Verify suffix was parsed
|
|
||||||
if metadata == nil && (tt.suffixType == "numeric" || tt.suffixType == "level") {
|
|
||||||
t.Errorf("Case #%d: NormalizeThinkingModel(%q) metadata is nil", tt.id, tt.requestModel)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// Step 2: Simulate OAuth model mapping
|
|
||||||
// Real flow: applyOAuthModelMapping stores requestedModel (the alias) in metadata
|
|
||||||
if tt.isAlias {
|
|
||||||
if metadata == nil {
|
|
||||||
metadata = make(map[string]any)
|
|
||||||
}
|
|
||||||
metadata[util.ModelMappingOriginalModelMetadataKey] = requestedModel
|
|
||||||
}
|
|
||||||
|
|
||||||
// Step 3: Verify metadata extraction
|
|
||||||
switch tt.suffixType {
|
|
||||||
case "numeric":
|
|
||||||
budget, _, _, matched := util.ThinkingFromMetadata(metadata)
|
|
||||||
if !matched {
|
|
||||||
t.Errorf("Case #%d: ThinkingFromMetadata did not match", tt.id)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
if budget == nil {
|
|
||||||
t.Errorf("Case #%d: expected budget in metadata", tt.id)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
// For thinkingBudget/budget_tokens, verify the parsed budget value
|
|
||||||
if tt.expectedField == "thinkingBudget" || tt.expectedField == "budget_tokens" {
|
|
||||||
expectedBudget := tt.expectedValue.(int)
|
|
||||||
if *budget != expectedBudget {
|
|
||||||
t.Errorf("Case #%d: budget = %d, want %d", tt.id, *budget, expectedBudget)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
// For thinkingLevel (Gemini 3), verify conversion from budget to level
|
|
||||||
if tt.expectedField == "thinkingLevel" {
|
|
||||||
level, ok := util.ThinkingBudgetToGemini3Level(tt.upstreamModel, *budget)
|
|
||||||
if !ok {
|
|
||||||
t.Errorf("Case #%d: ThinkingBudgetToGemini3Level failed", tt.id)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
expectedLevel := tt.expectedValue.(string)
|
|
||||||
if level != expectedLevel {
|
|
||||||
t.Errorf("Case #%d: converted level = %q, want %q", tt.id, level, expectedLevel)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
case "level":
|
|
||||||
_, _, effort, matched := util.ThinkingFromMetadata(metadata)
|
|
||||||
if !matched {
|
|
||||||
t.Errorf("Case #%d: ThinkingFromMetadata did not match", tt.id)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
if effort == nil {
|
|
||||||
t.Errorf("Case #%d: expected effort in metadata", tt.id)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
if tt.expectedField == "thinkingLevel" || tt.expectedField == "reasoning_effort" {
|
|
||||||
expectedEffort := tt.expectedValue.(string)
|
|
||||||
if *effort != expectedEffort {
|
|
||||||
t.Errorf("Case #%d: effort = %q, want %q", tt.id, *effort, expectedEffort)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Step 4: Test Gemini-specific thinkingLevel conversion for Gemini 3 models
|
|
||||||
if tt.expectedField == "thinkingLevel" && util.IsGemini3Model(tt.upstreamModel) {
|
|
||||||
body := []byte(`{"request":{"contents":[]}}`)
|
|
||||||
|
|
||||||
// Build metadata simulating real OAuth flow:
|
|
||||||
// - requestedModel (alias like "gf") is stored in model_mapping_original_model
|
|
||||||
// - upstreamModel is passed as the model parameter
|
|
||||||
testMetadata := make(map[string]any)
|
|
||||||
if tt.isAlias {
|
|
||||||
// Real flow: applyOAuthModelMapping stores requestedModel (the alias)
|
|
||||||
testMetadata[util.ModelMappingOriginalModelMetadataKey] = requestedModel
|
|
||||||
}
|
|
||||||
// Copy parsed metadata (thinking_budget, reasoning_effort, etc.)
|
|
||||||
for k, v := range metadata {
|
|
||||||
testMetadata[k] = v
|
|
||||||
}
|
|
||||||
|
|
||||||
result := util.ApplyGemini3ThinkingLevelFromMetadataCLI(tt.upstreamModel, testMetadata, body)
|
|
||||||
levelVal := gjson.GetBytes(result, "request.generationConfig.thinkingConfig.thinkingLevel")
|
|
||||||
|
|
||||||
expectedLevel := tt.expectedValue.(string)
|
|
||||||
if !levelVal.Exists() {
|
|
||||||
t.Errorf("Case #%d: expected thinkingLevel in result", tt.id)
|
|
||||||
} else if levelVal.String() != expectedLevel {
|
|
||||||
t.Errorf("Case #%d: thinkingLevel = %q, want %q", tt.id, levelVal.String(), expectedLevel)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Step 5: Test Gemini 2.5 thinkingBudget application using thinking.ApplyThinking
|
|
||||||
if tt.expectedField == "thinkingBudget" && util.IsGemini25Model(tt.upstreamModel) {
|
|
||||||
body := []byte(`{"request":{"contents":[]}}`)
|
|
||||||
|
|
||||||
// Build metadata simulating real OAuth flow:
|
|
||||||
// - requestedModel (alias like "gp") is stored in model_mapping_original_model
|
|
||||||
// - upstreamModel is passed as the model parameter
|
|
||||||
testMetadata := make(map[string]any)
|
|
||||||
if tt.isAlias {
|
|
||||||
// Real flow: applyOAuthModelMapping stores requestedModel (the alias)
|
|
||||||
testMetadata[util.ModelMappingOriginalModelMetadataKey] = requestedModel
|
|
||||||
}
|
|
||||||
// Copy parsed metadata (thinking_budget, reasoning_effort, etc.)
|
|
||||||
for k, v := range metadata {
|
|
||||||
testMetadata[k] = v
|
|
||||||
}
|
|
||||||
|
|
||||||
// Merge thinking config from metadata into body
|
|
||||||
body = applyThinkingFromMetadata(body, testMetadata)
|
|
||||||
|
|
||||||
// Use thinking.ApplyThinking for unified thinking config handling
|
|
||||||
// Note: ApplyThinking now takes model string, not *ModelInfo
|
|
||||||
result, _ := thinking.ApplyThinking(body, tt.upstreamModel, "gemini-cli")
|
|
||||||
|
|
||||||
budgetVal := gjson.GetBytes(result, "request.generationConfig.thinkingConfig.thinkingBudget")
|
|
||||||
|
|
||||||
expectedBudget := tt.expectedValue.(int)
|
|
||||||
if !budgetVal.Exists() {
|
|
||||||
t.Errorf("Case #%d: expected thinkingBudget in result", tt.id)
|
|
||||||
} else if int(budgetVal.Int()) != expectedBudget {
|
|
||||||
t.Errorf("Case #%d: thinkingBudget = %d, want %d", tt.id, int(budgetVal.Int()), expectedBudget)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// applyThinkingFromMetadata merges thinking configuration from metadata into the payload.
|
|
||||||
func applyThinkingFromMetadata(payload []byte, metadata map[string]any) []byte {
|
|
||||||
if len(metadata) == 0 {
|
|
||||||
return payload
|
|
||||||
}
|
|
||||||
|
|
||||||
// Merge thinking_budget from metadata if present
|
|
||||||
if budget, ok := metadata["thinking_budget"]; ok {
|
|
||||||
if budgetVal, okNum := parseNumberToInt(budget); okNum {
|
|
||||||
payload, _ = sjson.SetBytes(payload, "request.generationConfig.thinkingConfig.thinkingBudget", budgetVal)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Merge reasoning_effort from metadata if present
|
|
||||||
if effort, ok := metadata["reasoning_effort"]; ok {
|
|
||||||
if effortStr, okStr := effort.(string); okStr && effortStr != "" {
|
|
||||||
payload, _ = sjson.SetBytes(payload, "request.generationConfig.thinkingConfig.thinkingLevel", effortStr)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Merge thinking_include_thoughts from metadata if present
|
|
||||||
if include, ok := metadata["thinking_include_thoughts"]; ok {
|
|
||||||
if includeBool, okBool := include.(bool); okBool {
|
|
||||||
payload, _ = sjson.SetBytes(payload, "request.generationConfig.thinkingConfig.includeThoughts", includeBool)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return payload
|
|
||||||
}
|
|
||||||
|
|
||||||
// parseNumberToInt safely converts various numeric types to int
|
|
||||||
func parseNumberToInt(raw any) (int, bool) {
|
|
||||||
switch v := raw.(type) {
|
|
||||||
case int:
|
|
||||||
return v, true
|
|
||||||
case int32:
|
|
||||||
return int(v), true
|
|
||||||
case int64:
|
|
||||||
return int(v), true
|
|
||||||
case float64:
|
|
||||||
return int(v), true
|
|
||||||
}
|
|
||||||
return 0, false
|
|
||||||
}
|
|
||||||
Reference in New Issue
Block a user