Files
CLIProxyAPI/internal/runtime/executor/helps/payload_finalizer_test.go
Luis Pater 6e6afab99a refactor: migrate gjson, sjson, and base64 to MoeForge/moego
- Replace tidwall/gjson and tidwall/sjson with github.com/MoeForge/moego/ojson
  and encoding/base64 with github.com/MoeForge/moego/base64 across the main
  module and examples
- Introduce cross-method *ojson.Doc request rewriting pipelines across
  thinking, signature, client/codex, runtime/executor/helps, pluginhost, and
  all provider executors with FinalizePayloadDoc as the final semantic barrier
- Convert all consecutive JSON mutations (>= 2 Set/SetRaw/Delete operations)
  to batch edits on ojson.Doc
- Upgrade read-only byte paths to ojson.GetBytesNoCopy,
  ojson.GetManyBytesNoCopy, and util.ParseGJSONBytesNoCopy with explicit
  strings.Clone ownership protection across streaming and persistent state
- Use base64.StdEncoding.ValidateString for zero-allocation signature checks
  and base64.EncodeDataURL for single-allocation data URL construction
2026-11-03 03:05:04 +08:00

411 lines
18 KiB
Go

package helps
import (
"bytes"
"context"
"mime/multipart"
"net/http"
"sync"
"testing"
"github.com/MoeForge/moego/ojson"
"github.com/router-for-me/CLIProxyAPI/v8/internal/config"
cliproxyexecutor "github.com/router-for-me/CLIProxyAPI/v8/sdk/cliproxy/executor"
sdktranslator "github.com/router-for-me/CLIProxyAPI/v8/sdk/translator"
"google.golang.org/protobuf/encoding/protowire"
)
func TestPayloadFinalizerDefaultsUseOriginalAndNormalizeBeforeRules(t *testing.T) {
cfg := &config.Config{Payload: config.PayloadConfig{
Default: []config.PayloadRule{{Models: []config.PayloadModelRule{{Name: "alias", Protocol: "openai", FromProtocol: "claude", Headers: map[string]string{"X-Test": "yes"}}}, Params: map[string]any{"missing": "user default", "present": "not applied"}}},
Override: []config.PayloadRule{{Models: []config.PayloadModelRule{{Name: "alias"}}, Params: map[string]any{"tools.0.function.parameters.properties.count.type": "number"}}},
Filter: []config.PayloadFilterRule{{Models: []config.PayloadModelRule{{Name: "alias"}}, Params: []string{"late"}}},
}}
req := cliproxyexecutor.Request{Model: "alias"}
opts := cliproxyexecutor.Options{SourceFormat: sdktranslator.FormatClaude, Headers: http.Header{"X-Test": {"yes"}, "User-Agent": {"codex-cli/0.1"}}}
finalize := NewPayloadFinalizer(cfg, "openai", "upstream", "openai", "", []byte(`{"present":"caller"}`), req, opts)
body := []byte(`{"missing":"built-in","present":"caller","late":"injected","tools":[{"type":"function","function":{"name":"f","parameters":{"type":"object","properties":{"count":{"type":"integer"}}}}}]}`)
out := FinalizePayload(WithPayloadFinalizer(context.Background(), finalize), body)
if ojson.GetBytes(out, "missing").String() != "user default" || ojson.GetBytes(out, "present").String() != "caller" || ojson.GetBytes(out, "late").Exists() || ojson.GetBytes(out, "tools.0.function.parameters.properties.count.type").String() != "number" {
t.Fatalf("unexpected final payload: %s", out)
}
}
func TestPayloadFinalizerDevinBusinessFieldsAndCredentials(t *testing.T) {
wire := BuildDevinGetChatMessageRequest("secret-token", "device", "model", "system", []DevinPrompt{{MessageID: "id", Source: 1, Content: "hello"}}, []DevinTool{{Name: "f", Parameters: []byte(`{"type":"object"}`)}}, nil, 1024, "session", "cascade", nil)
unchanged, _, errUnchanged := FinalizeDevinPayload(wire, func(body []byte) []byte { return body })
if errUnchanged != nil || !bytes.Equal(unchanged, wire) {
t.Fatalf("no-op changed protobuf: %v", errUnchanged)
}
final, view, errFinalize := FinalizeDevinPayload(wire, func(body []byte) []byte {
doc := ojson.NewDoc(body)
_ = doc.Delete("system_prompt")
_ = doc.Delete("tools")
_ = doc.Set("completion_config.max_tokens", 0)
_ = doc.Set("prompts.0.content", "configured")
return doc.Bytes()
})
if errFinalize != nil {
t.Fatal(errFinalize)
}
if ojson.GetBytes(view, "system_prompt").Exists() || ojson.GetBytes(view, "tools").Exists() {
t.Fatalf("filter undone: %s", view)
}
decoded, errDecode := decodeDevinPayload(final, devinPayloadFields)
if errDecode != nil {
t.Fatal(errDecode)
}
if decoded["completion_config"].(map[string]any)["max_tokens"] != uint64(0) {
t.Fatalf("default was re-injected: %v", decoded)
}
fieldOne := func(wire []byte) []byte {
for len(wire) > 0 {
num, kind, tagLen := protowire.ConsumeTag(wire)
n := protowire.ConsumeFieldValue(num, kind, wire[tagLen:])
if num == 1 {
return wire[:tagLen+n]
}
wire = wire[tagLen+n:]
}
return nil
}
if !bytes.Equal(fieldOne(wire), fieldOne(final)) {
t.Fatal("payload rules changed credentials")
}
}
func TestPayloadFinalizerMultipartPreservesFiles(t *testing.T) {
var buffer bytes.Buffer
writer := multipart.NewWriter(&buffer)
if errWrite := writer.WriteField("model", "original"); errWrite != nil {
t.Fatal(errWrite)
}
file, errFile := writer.CreateFormFile("image", "input.png")
if errFile != nil {
t.Fatal(errFile)
}
if _, errWrite := file.Write([]byte{0, 255, 13, 10}); errWrite != nil {
t.Fatal(errWrite)
}
if errClose := writer.Close(); errClose != nil {
t.Fatal(errClose)
}
cfg := &config.Config{Payload: config.PayloadConfig{Override: []config.PayloadRule{{Models: []config.PayloadModelRule{{Name: "original"}}, Params: map[string]any{"model": "configured"}}}}}
req := cliproxyexecutor.Request{Model: "original", Payload: buffer.Bytes()}
opts := cliproxyexecutor.Options{Headers: http.Header{"Content-Type": {writer.FormDataContentType()}}}
body, contentType, errFinalize := ApplyMediaPayloadConfig(cfg, "openai", "original", "openai", req.Payload, writer.FormDataContentType(), req, opts)
if errFinalize != nil {
t.Fatal(errFinalize)
}
view, _, errView := mediaPayloadJSON(body, contentType)
if errView != nil {
t.Fatal(errView)
}
if ojson.GetBytes(view, "model").String() != "configured" || ojson.GetBytes(view, "image.data").String() != "AP8NCg==" {
t.Fatalf("unexpected multipart business payload: %s", view)
}
}
func TestPayloadRulesMatchFinalBodyAndTrackPaths(t *testing.T) {
cfg := &config.Config{Payload: config.PayloadConfig{
Override: []config.PayloadRule{{Models: []config.PayloadModelRule{{Name: "*", Match: []map[string]any{{"max_tokens": 100}}}}, Params: map[string]any{"unexpected": true}},
{Models: []config.PayloadModelRule{{Name: "*", Match: []map[string]any{{"max_tokens": 300}}}}, Params: map[string]any{"diagnostics.user": true}}},
Filter: []config.PayloadFilterRule{{Models: []config.PayloadModelRule{{Name: "*", Match: []map[string]any{{"max_tokens": 300}}}}, Params: []string{"context_management", "messages.0"}}},
}}
original := []byte(`{"max_tokens":100,"messages":[{},{}]}`)
body, touched := ApplyPayloadConfigWithTrackedPaths(cfg, "model", "claude", "claude", "", []byte(`{"max_tokens":300,"context_management":{"builtin":true},"messages":[{},{},{}]}`), original, "model", "", nil, "diagnostics", "context_management")
if ojson.GetBytes(body, "unexpected").Exists() || !ojson.GetBytes(body, "diagnostics.user").Bool() || ojson.GetBytes(body, "context_management").Exists() || ojson.GetBytes(body, "messages.#").Int() != 2 {
t.Fatalf("rules did not match final body: %s", body)
}
if !touched["diagnostics"] || !touched["context_management"] {
t.Fatalf("final tracking lost: %v", touched)
}
}
func TestFinalizePayloadDocCrossMethodPipeline(t *testing.T) {
original := []byte(`{"model":"gpt-4o","temperature":0.7}`)
cfg := &config.Config{
Payload: config.PayloadConfig{
Default: []config.PayloadRule{{
Models: []config.PayloadModelRule{{Name: "gpt-4o"}},
Params: map[string]any{"temperature": 0.2, "top_p": 0.9},
}},
Override: []config.PayloadRule{{
Models: []config.PayloadModelRule{{Name: "gpt-4o"}},
Params: map[string]any{"max_tokens": 2048},
}},
Filter: []config.PayloadFilterRule{{
Models: []config.PayloadModelRule{{Name: "gpt-4o"}},
Params: []string{"extra"},
}},
},
}
req := cliproxyexecutor.Request{Model: "gpt-4o", Payload: original}
opts := cliproxyexecutor.Options{}
ctx := WithPayloadFinalizer(context.Background(), NewPayloadFinalizer(cfg, "openai", "gpt-4o", "openai", "", original, req, opts))
doc := ojson.NewDoc([]byte(`{"model":"gpt-4o","temperature":0.7,"extra":true}`))
SetStringIfDifferentDoc(doc, "model", "gpt-4o")
SetBoolIfDifferentDoc(doc, "stream", true)
FinalizePayloadDoc(ctx, doc)
out := doc.Bytes()
if got := ojson.GetBytesNoCopy(out, "temperature").Float(); got != 0.7 {
t.Fatalf("temperature = %v, want 0.7 (preserved from original)", got)
}
if got := ojson.GetBytesNoCopy(out, "top_p").Float(); got != 0.9 {
t.Fatalf("top_p = %v, want 0.9", got)
}
if got := ojson.GetBytesNoCopy(out, "max_tokens").Int(); got != 2048 {
t.Fatalf("max_tokens = %d, want 2048", got)
}
if ojson.GetBytesNoCopy(out, "extra").Exists() {
t.Fatalf("expected extra to be filtered out: %s", string(out))
}
}
func TestExecutorHelpersDocCrossMethodPipelines(t *testing.T) {
t.Run("claude doc pipeline", func(t *testing.T) {
raw := []byte(`{"model":"claude-sonnet-5-5","tool_choice":{"type":"tool","name":"calc"},"system":[{"type":"text","text":"x-anthropic-billing-header: cc_version=2.1.280; cc_prev_req=old;"},{"type":"text","text":"secret word here"}],"messages":[{"role":"assistant","content":[{"type":"tool_use","id":"bad id!","name":"calc","input":{}}]},{"role":"user","content":[{"type":"tool_result","tool_use_id":"bad id!","content":"secret word here"}]}]}`)
doc := ojson.NewDoc(raw)
matcher := BuildSensitiveWordMatcher([]string{"secret"})
if !NormalizeClaudeToolChoiceDoc("claude", "claude-sonnet-5-5", doc) {
t.Fatal("expected NormalizeClaudeToolChoiceDoc to mutate doc")
}
if !NormalizeClaudeToolCallIDsDoc(doc) {
t.Fatal("expected NormalizeClaudeToolCallIDsDoc to mutate doc")
}
if !ObfuscateSensitiveWordsDoc(doc, matcher) {
t.Fatal("expected ObfuscateSensitiveWordsDoc to mutate doc")
}
if !StripClaudeBillingTagsDoc(doc) {
t.Fatal("expected StripClaudeBillingTagsDoc to mutate doc")
}
if !InjectClaudeBillingTagsDoc(doc, "prev1", "prompt1") {
t.Fatal("expected InjectClaudeBillingTagsDoc to mutate doc")
}
out := doc.Bytes()
if got := ojson.GetBytesNoCopy(out, "tool_choice.type").String(); got != "auto" {
t.Fatalf("tool_choice.type = %q, want auto", got)
}
if ojson.GetBytesNoCopy(out, "tool_choice.name").Exists() {
t.Fatalf("expected tool_choice.name to be removed: %s", out)
}
useID := ojson.GetBytesNoCopy(out, "messages.0.content.0.id").String()
resID := ojson.GetBytesNoCopy(out, "messages.1.content.0.tool_use_id").String()
if useID == "bad id!" || useID != resID {
t.Fatalf("tool call IDs not normalized consistently: %q vs %q", useID, resID)
}
})
t.Run("openai compat doc pipeline", func(t *testing.T) {
raw := []byte(`{"model":"gpt-4o","max_tokens":512,"messages":[{"role":"tool","tool_call_id":"call_1","content":[{"type":"text","text":"ok"},{"type":"image_url","image_url":{"url":"https://example.com/a.png"}}]}]}`)
doc := ojson.NewDoc(raw)
if !NormalizeOpenAIMaxTokensDoc(doc, true) {
t.Fatal("expected NormalizeOpenAIMaxTokensDoc to mutate doc")
}
if !NormalizeOpenAIToolResultsTextOnlyDoc(doc) {
t.Fatal("expected NormalizeOpenAIToolResultsTextOnlyDoc to mutate doc")
}
out := doc.Bytes()
if ojson.GetBytesNoCopy(out, "max_tokens").Exists() || ojson.GetBytesNoCopy(out, "max_completion_tokens").Int() != 512 {
t.Fatalf("unexpected max_completion_tokens normalization: %s", out)
}
if ojson.GetBytesNoCopy(out, "messages.0.content").Type != ojson.String {
t.Fatalf("expected tool content to be flattened to string: %s", out)
}
})
t.Run("codex and responses doc pipeline", func(t *testing.T) {
raw := []byte(`{"model":"gpt-5","tools":[{"type":"tool_search","execution":"client"},{"type":"web_search","search_content_types":["text"]},{"type":"function","name":"fn","parameters":{"type":"object"}}],"input":[{"type":"message","id":"bad_id","role":"user","content":"hi"},{"type":"tool_search_call","id":"ts_1","call_id":"c1","execution":"client"}]}`)
doc := ojson.NewDoc(raw)
if !StripResponsesToolSearchDoc(doc) {
t.Fatal("expected StripResponsesToolSearchDoc to mutate doc")
}
if !SanitizeCodexInputItemIDsDoc(doc) {
t.Fatal("expected SanitizeCodexInputItemIDsDoc to mutate doc")
}
if !SanitizeMetaWebSearchToolsDoc(doc) {
t.Fatal("expected SanitizeMetaWebSearchToolsDoc to mutate doc")
}
if !EnsureMetaMuseToolNamespaceDoc(doc) {
t.Fatal("expected EnsureMetaMuseToolNamespaceDoc to mutate doc")
}
out := doc.Bytes()
if got := ojson.GetBytesNoCopy(out, "input.0.id").String(); got != "msg_bad_id" {
t.Fatalf("input.0.id = %q, want msg_bad_id", got)
}
if len(ojson.GetBytesNoCopy(out, "input").Array()) != 1 {
t.Fatalf("expected tool_search_call to be stripped: %s", out)
}
if ojson.GetBytesNoCopy(out, "tools.0.search_content_types").Exists() {
t.Fatalf("expected search_content_types to be stripped: %s", out)
}
})
t.Run("gemini and vertex doc pipeline", func(t *testing.T) {
raw := []byte(`{"contents":[{"role":"model","parts":[{"functionCall":{"id":"call_1","name":"fn","args":{}}},{"thought":true,"text":"thinking"}]},{"role":"model","parts":[{"thought":true,"text":"trailing thought"}]}]}`)
doc := ojson.NewDoc(raw)
if !DropGeminiTrailingThoughtOnlyContentDoc(doc, "contents") {
t.Fatal("expected DropGeminiTrailingThoughtOnlyContentDoc to mutate doc")
}
if !StripVertexOpenAIResponsesToolCallIDsDoc(doc, "openai-response") {
t.Fatal("expected StripVertexOpenAIResponsesToolCallIDsDoc to mutate doc")
}
if !EnsureGeminiBoundaryUserContentDoc(doc, "contents") {
t.Fatal("expected EnsureGeminiBoundaryUserContentDoc to mutate doc")
}
out := doc.Bytes()
contents := ojson.GetBytesNoCopy(out, "contents").Array()
if len(contents) != 3 {
t.Fatalf("len(contents) = %d, want 3: %s", len(contents), out)
}
if contents[0].Get("role").String() != "user" || contents[2].Get("role").String() != "user" {
t.Fatalf("expected leading and trailing user turns: %s", out)
}
if contents[1].Get("parts.0.functionCall.id").Exists() {
t.Fatalf("expected functionCall.id to be stripped: %s", out)
}
})
}
func TestFinalizeDocCustomWrapperCalledOnceAndPreservesOriginalFromBody(t *testing.T) {
cfg := &config.Config{
Payload: config.PayloadConfig{
Default: []config.PayloadRule{{
Models: []config.PayloadModelRule{{Name: "devin-model"}},
Params: map[string]any{
"completion_config.max_tokens": 9999,
"system_prompt": "default-system",
},
}},
},
}
req := cliproxyexecutor.Request{
Model: "devin-model",
Payload: []byte(`{"max_tokens":2048}`),
}
opts := cliproxyexecutor.Options{}
callCount := 0
wrapper := PayloadFinalizer(func(body []byte) []byte {
callCount++
original := body
if !ojson.GetBytesNoCopy(req.Payload, "max_tokens").Exists() {
original, _ = ojson.DeleteBytes(original, "completion_config.max_tokens")
}
return NewPayloadFinalizer(cfg, "devin", "devin-model", "openai", "", original, req, opts)(body)
})
doc := ojson.NewDoc([]byte(`{"completion_config":{"max_tokens":2048}}`))
wrapper.FinalizeDoc(doc)
if callCount != 1 {
t.Fatalf("custom PayloadFinalizer callCount = %d, want 1", callCount)
}
out := doc.Bytes()
if got := ojson.GetBytesNoCopy(out, "completion_config.max_tokens").Int(); got != 2048 {
t.Fatalf("completion_config.max_tokens = %d, want 2048 (preserved from body-derived original): %s", got, out)
}
if got := ojson.GetBytesNoCopy(out, "system_prompt").String(); got != "default-system" {
t.Fatalf("system_prompt = %q, want default-system: %s", got, out)
}
}
func TestApplyPayloadConfigDocSequentialDefaultObjectAndNestedField(t *testing.T) {
cfg := &config.Config{
Payload: config.PayloadConfig{
Default: []config.PayloadRule{
{
Models: []config.PayloadModelRule{{Name: "gpt-5"}},
Params: map[string]any{"metadata": map[string]any{"x": 1}},
},
{
Models: []config.PayloadModelRule{{Name: "gpt-5"}},
Params: map[string]any{"metadata.x": 2, "metadata.y": 3},
},
},
},
}
raw := []byte(`{"model":"gpt-5"}`)
want := ApplyPayloadConfigWithRoot(cfg, "gpt-5", "openai", "", raw, nil, "", "")
doc := ojson.NewDoc(raw)
ApplyPayloadConfigWithRootDoc(cfg, "gpt-5", "openai", "", doc, nil, "", "")
got := doc.Bytes()
if ojson.GetBytesNoCopy(got, "metadata.x").Int() != ojson.GetBytesNoCopy(want, "metadata.x").Int() {
t.Fatalf("doc metadata.x = %d, want %d (got=%s want=%s)",
ojson.GetBytesNoCopy(got, "metadata.x").Int(),
ojson.GetBytesNoCopy(want, "metadata.x").Int(),
got, want)
}
if ojson.GetBytesNoCopy(got, "metadata.y").Int() != 3 {
t.Fatalf("doc metadata.y = %d, want 3: %s", ojson.GetBytesNoCopy(got, "metadata.y").Int(), got)
}
arrCfg := &config.Config{
Payload: config.PayloadConfig{
Default: []config.PayloadRule{
{
Models: []config.PayloadModelRule{{Name: "gpt-5"}},
Params: map[string]any{"items.2": 2},
},
{
Models: []config.PayloadModelRule{{Name: "gpt-5"}},
Params: map[string]any{"items.0": 1},
},
},
},
}
arrRaw := []byte(`{"model":"gpt-5","items":[]}`)
arrWant := ApplyPayloadConfigWithRoot(arrCfg, "gpt-5", "openai", "", arrRaw, nil, "", "")
arrDoc := ojson.NewDoc(arrRaw)
ApplyPayloadConfigWithRootDoc(arrCfg, "gpt-5", "openai", "", arrDoc, nil, "", "")
arrGot := arrDoc.Bytes()
if ojson.GetBytesNoCopy(arrGot, "items.0").Int() != 1 || ojson.GetBytesNoCopy(arrGot, "items.2").Int() != 2 || !bytes.Equal(arrGot, arrWant) {
t.Fatalf("sparse array default mismatch:\ngot %s\nwant %s", arrGot, arrWant)
}
hugeArrCfg := &config.Config{
Payload: config.PayloadConfig{
Default: []config.PayloadRule{
{
Models: []config.PayloadModelRule{{Name: "gpt-5"}},
Params: map[string]any{"items.1000000000": 1},
},
},
},
}
hugeArrRaw := []byte(`{"model":"gpt-5","items":[]}`)
hugeArrDoc := ojson.NewDoc(hugeArrRaw)
ApplyPayloadConfigWithRootDoc(hugeArrCfg, "gpt-5", "openai", "", hugeArrDoc, nil, "", "")
if got := string(hugeArrDoc.Bytes()); got != string(hugeArrRaw) {
t.Fatalf("huge index array default should be ignored without OOM: got %s, want %s", got, hugeArrRaw)
}
}
func TestFinalizeDocConcurrentWithNewPayloadFinalizer(t *testing.T) {
builtinFinalizerCodePtr.Store(0)
cfg := &config.Config{}
req := cliproxyexecutor.Request{Model: "gpt-4o", Payload: []byte(`{"model":"gpt-4o"}`)}
opts := cliproxyexecutor.Options{}
var wg sync.WaitGroup
for i := 0; i < 8; i++ {
wg.Add(2)
go func() {
defer wg.Done()
custom := PayloadFinalizer(func(body []byte) []byte { return body })
doc := ojson.NewDoc([]byte(`{"model":"gpt-4o"}`))
custom.FinalizeDoc(doc)
}()
go func() {
defer wg.Done()
fn := NewPayloadFinalizer(cfg, "openai", "gpt-4o", "openai", "", req.Payload, req, opts)
doc := ojson.NewDoc([]byte(`{"model":"gpt-4o"}`))
fn.FinalizeDoc(doc)
}()
}
wg.Wait()
}