fix(codex): allow hosted image_generation injection on standard Responses without reasoning

- gate automatic image_generation tool injection for use_responses_lite catalog models on actual Responses-Lite routing (including credential and model header overrides) or presence of reasoning effort
- retract untouched auto-injected image_generation tools during single-pass payload finalization when user payload rules configure reasoning effort or switch to an incompatible route
- update Codex executor and payload barrier regression tests across HTTP and WebSocket streaming and non-streaming paths

Closes: #7384
Co-authored-by: Dylan <1990016@gmail.com>
This commit is contained in:
Luis Pater
2026-11-10 04:00:07 +08:00
parent 19a0a8541f
commit 714f052618
10 changed files with 863 additions and 45 deletions

View File

@@ -65,7 +65,7 @@ func (e *CodexExecutor) Execute(ctx context.Context, auth *cliproxyauth.Auth, re
return resp, err
}
ctx = helps.WithPayloadFinalizer(ctx, helps.NewPayloadFinalizer(e.cfg, e.Identifier(), baseModel, to.String(), "", originalTranslated, req, opts))
ctx = helps.WithPayloadFinalizer(ctx, helps.NewPayloadFinalizer(e.cfg, e.Identifier(), baseModel, to.String(), "", originalTranslated, req, opts, auth))
helps.SetStringIfDifferentDoc(doc, "model", baseModel)
helps.SetBoolIfDifferentDoc(doc, "stream", true)
_ = doc.Delete("previous_response_id")
@@ -80,7 +80,11 @@ func (e *CodexExecutor) Execute(ctx context.Context, auth *cliproxyauth.Auth, re
if !useSIWC {
normalizeCodexInstructionsDoc(doc, helps.IsNativeCodexRequest(req.Payload, opts))
if e.cfg == nil || e.cfg.DisableImageGeneration == config.DisableImageGenerationOff {
ensureImageGenerationToolDoc(doc, baseModel, auth, opts.Headers)
checkModel := req.Model
if strings.TrimSpace(checkModel) == "" {
checkModel = baseModel
}
ensureImageGenerationToolDoc(doc, checkModel, auth, opts.Headers)
if !codexAuthUsesAPIKey(auth) {
normalizeCodexImageGenerationToolsDoc(doc)
}

View File

@@ -11,6 +11,8 @@ import (
"github.com/MoeForge/moego/ojson"
"github.com/gorilla/websocket"
"github.com/router-for-me/CLIProxyAPI/v8/internal/config"
"github.com/router-for-me/CLIProxyAPI/v8/internal/registry"
"github.com/router-for-me/CLIProxyAPI/v8/internal/runtime/executor/helps"
cliproxyauth "github.com/router-for-me/CLIProxyAPI/v8/sdk/cliproxy/auth"
cliproxyexecutor "github.com/router-for-me/CLIProxyAPI/v8/sdk/cliproxy/executor"
sdktranslator "github.com/router-for-me/CLIProxyAPI/v8/sdk/translator"
@@ -152,8 +154,14 @@ func TestEnsureImageGenerationTool_ResponsesLiteFalseMetadataStillInjectsTool(t
liteHeaders := make(http.Header)
liteHeaders.Set(codexResponsesLiteHeader, "false")
liteResult := ensureImageGenerationTool(liteBody, liteModel, nil, liteHeaders)
if ojson.GetBytes(liteResult, "tools").Exists() {
t.Fatalf("for %s: expected no auto-injected tools even when responses-lite is explicitly false, got %s", liteModel, liteResult)
if got := ojson.GetBytes(liteResult, "tools.0.type").String(); got != "image_generation" {
t.Fatalf("for %s: tools.0.type = %q, want image_generation when responses-lite is false and reasoning is absent; body=%s", liteModel, got, liteResult)
}
reasoningBody := []byte(`{"model":"` + liteModel + `","reasoning":{"effort":"medium"},"client_metadata":{"ws_request_header_x_openai_internal_codex_responses_lite":"false"},"input":"hello"}`)
reasoningResult := ensureImageGenerationTool(reasoningBody, liteModel, nil, liteHeaders)
if ojson.GetBytes(reasoningResult, "tools").Exists() {
t.Fatalf("for %s: expected no auto-injected tools when reasoning.effort is present, got %s", liteModel, reasoningResult)
}
}
}
@@ -300,7 +308,7 @@ func TestEnsureImageGenerationTool_FreeCodexAuthDoesNotInjectTool(t *testing.T)
}
func TestEnsureImageGenerationTool_ResponsesLiteModelsDoNotInjectToolByDefault(t *testing.T) {
for _, model := range []string{
liteModels := []string{
"gpt-6-astra",
"gpt-6-sol",
"gpt-6.1-sol",
@@ -312,21 +320,56 @@ func TestEnsureImageGenerationTool_ResponsesLiteModelsDoNotInjectToolByDefault(t
"gpt-5.6-luna",
"gpt-reserve",
"codex-auto-review",
}
for _, model := range liteModels {
t.Run("standard_without_reasoning/"+model, func(t *testing.T) {
body := []byte(`{"model":"` + model + `","input":"hello"}`)
result := ensureImageGenerationTool(body, model, nil, nil)
if got := ojson.GetBytes(result, "tools.0.type").String(); got != "image_generation" {
t.Fatalf("for %s without reasoning: tools.0.type = %q, want image_generation; body=%s", model, got, result)
}
withFunctionTool := []byte(`{"model":"` + model + `","input":"Generate a photorealistic image of a mountain lake at sunset.","tools":[{"type":"function","name":"get_weather","description":"Get current weather","parameters":{"type":"object","properties":{"city":{"type":"string"}}}}]}`)
withFunctionResult := ensureImageGenerationTool(withFunctionTool, model, nil, nil)
if got := ojson.GetBytes(withFunctionResult, "tools.1.type").String(); got != "image_generation" {
t.Fatalf("for %s with function tool and no reasoning: tools.1.type = %q, want image_generation; body=%s", model, got, withFunctionResult)
}
})
t.Run("with_reasoning_effort/"+model, func(t *testing.T) {
body := []byte(`{"model":"` + model + `","reasoning":{"effort":"medium"},"input":"hello"}`)
result := ensureImageGenerationTool(body, model, nil, nil)
if ojson.GetBytes(result, "tools").Exists() {
t.Fatalf("expected no auto-injected tools for %s with reasoning.effort, got %s", model, result)
}
})
t.Run("with_configuration_update_reasoning/"+model, func(t *testing.T) {
body := []byte(`{"model":"` + model + `","input":[{"type":"configuration_update","reasoning":{"effort":"high"}},{"type":"message","role":"user","content":[{"type":"input_text","text":"hello"}]}]}`)
result := ensureImageGenerationTool(body, model, nil, nil)
if ojson.GetBytes(result, "tools").Exists() {
t.Fatalf("expected no auto-injected tools for %s with configuration_update reasoning, got %s", model, result)
}
})
}
for _, suffixedModel := range []string{
"codex/gpt-6-astra(medium)",
"codex/gpt-5.6-sol(high)",
} {
t.Run(model, func(t *testing.T) {
body := []byte(`{"model":"` + model + `","input":"hello"}`)
result := ensureImageGenerationTool(body, model, nil, nil)
t.Run("with_thinking_suffix/"+suffixedModel, func(t *testing.T) {
body := []byte(`{"model":"` + suffixedModel + `","input":"hello"}`)
result := ensureImageGenerationTool(body, suffixedModel, nil, nil)
if ojson.GetBytes(result, "tools").Exists() {
t.Fatalf("expected no auto-injected tools for %s, got %s", model, result)
t.Fatalf("expected no auto-injected tools for %s, got %s", suffixedModel, result)
}
})
}
for _, nonLiteModel := range []string{"gpt-5.5", "gpt-5.4"} {
t.Run("non-lite/"+nonLiteModel, func(t *testing.T) {
body := []byte(`{"model":"` + nonLiteModel + `","input":"hello"}`)
body := []byte(`{"model":"` + nonLiteModel + `","reasoning":{"effort":"medium"},"input":"hello"}`)
result := ensureImageGenerationTool(body, nonLiteModel, nil, nil)
if got := ojson.GetBytes(result, "tools.0.type").String(); got != "image_generation" {
t.Fatalf("for %s: tools.0.type = %q, want image_generation; body=%s", nonLiteModel, got, result)
@@ -335,6 +378,473 @@ func TestEnsureImageGenerationTool_ResponsesLiteModelsDoNotInjectToolByDefault(t
}
}
func TestCodexExecutorStandardResponsesInjectsImageGenerationWithoutReasoningAndSkipsWithReasoning(t *testing.T) {
for _, transport := range []string{"http", "websocket"} {
for _, stream := range []bool{false, true} {
streamLabel := "false"
if stream {
streamLabel = "true"
}
for _, tc := range []struct {
name string
model string
sourceFmt sdktranslator.Format
payload string
reqMetadata map[string]any
reqHeaders http.Header
authAttrs map[string]string
cfg config.Config
overrideHeaders map[string]string
wantTools int
wantImgIdx string
wantToolType string
wantEffort string
}{
{
name: "standard_responses_with_function_tool_no_reasoning",
model: "gpt-6-astra",
sourceFmt: sdktranslator.FormatOpenAIResponse,
payload: `{"model":"gpt-6-astra","input":"Generate a photorealistic image of a mountain lake at sunset.","tools":[{"type":"function","name":"get_weather","description":"Get current weather","parameters":{"type":"object","properties":{"city":{"type":"string"}}}}]}`,
wantTools: 2,
wantImgIdx: "tools.1.type",
},
{
name: "standard_responses_bare_no_reasoning",
model: "gpt-6-astra",
sourceFmt: sdktranslator.FormatOpenAIResponse,
payload: `{"model":"gpt-6-astra","input":"Generate a photorealistic image of a mountain lake at sunset."}`,
wantTools: 1,
wantImgIdx: "tools.0.type",
},
{
name: "standard_responses_with_reasoning_effort",
model: "gpt-6-astra",
sourceFmt: sdktranslator.FormatOpenAIResponse,
payload: `{"model":"gpt-6-astra","reasoning":{"effort":"medium"},"input":"Generate a photorealistic image of a mountain lake at sunset."}`,
wantTools: 0,
},
{
name: "standard_responses_with_model_thinking_suffix",
model: "gpt-6-astra(medium)",
sourceFmt: sdktranslator.FormatOpenAIResponse,
payload: `{"model":"gpt-6-astra(medium)","input":"Generate a photorealistic image of a mountain lake at sunset."}`,
wantTools: 0,
},
{
name: "openai_chat_completions_defaults_reasoning_effort",
model: "gpt-6-astra",
sourceFmt: sdktranslator.FormatOpenAI,
payload: `{"model":"gpt-6-astra","messages":[{"role":"user","content":"Generate a photorealistic image of a mountain lake at sunset."}]}`,
wantTools: 0,
},
{
name: "payload_default_sets_reasoning_effort_skips_auto_injection",
model: "gpt-6-astra",
sourceFmt: sdktranslator.FormatOpenAIResponse,
payload: `{"model":"gpt-6-astra","input":"hello"}`,
cfg: config.Config{
Payload: config.PayloadConfig{
Default: []config.PayloadRule{
{
Models: []config.PayloadModelRule{{Name: "gpt-6-astra"}},
Params: map[string]any{"reasoning.effort": "medium"},
},
},
},
},
wantTools: 0,
wantEffort: "medium",
},
{
name: "payload_override_sets_reasoning_effort_with_function_tool_skips_auto_injection",
model: "gpt-6-astra",
sourceFmt: sdktranslator.FormatOpenAIResponse,
payload: `{"model":"gpt-6-astra","input":"hello","tools":[{"type":"function","name":"get_weather","description":"Get current weather","parameters":{"type":"object","properties":{"city":{"type":"string"}}}}]}`,
cfg: config.Config{
Payload: config.PayloadConfig{
Override: []config.PayloadRule{
{
Models: []config.PayloadModelRule{{Name: "gpt-6-astra"}},
Params: map[string]any{"reasoning.effort": "high"},
},
},
},
},
wantTools: 1,
wantImgIdx: "tools.0.type",
wantToolType: "function",
wantEffort: "high",
},
{
name: "payload_conditional_exist_tools_sets_reasoning_effort_skips_auto_injection",
model: "gpt-6-astra",
sourceFmt: sdktranslator.FormatOpenAIResponse,
payload: `{"model":"gpt-6-astra","input":"hello"}`,
cfg: config.Config{
Payload: config.PayloadConfig{
Override: []config.PayloadRule{
{
Models: []config.PayloadModelRule{{Name: "gpt-6-astra", Exist: []string{"tools"}}},
Params: map[string]any{"reasoning.effort": "medium"},
},
},
},
},
wantTools: 0,
wantEffort: "medium",
},
{
name: "payload_conditional_exist_prompt_cache_key_sets_reasoning_effort_skips_auto_injection",
model: "gpt-6-astra",
sourceFmt: sdktranslator.FormatOpenAIResponse,
payload: `{"model":"gpt-6-astra","input":"hello"}`,
reqMetadata: map[string]any{cliproxyexecutor.ExecutionSessionMetadataKey: "sess-prompt-cache-7384"},
cfg: config.Config{
Payload: config.PayloadConfig{
Override: []config.PayloadRule{
{
Models: []config.PayloadModelRule{{Name: "gpt-6-astra", Exist: []string{"prompt_cache_key"}}},
Params: map[string]any{"reasoning.effort": "medium"},
},
},
},
},
wantTools: 0,
wantEffort: "medium",
},
{
name: "payload_override_switches_to_lite_model_with_reasoning_skips_auto_injection",
model: "gpt-5.4",
sourceFmt: sdktranslator.FormatOpenAIResponse,
payload: `{"model":"gpt-5.4","reasoning":{"effort":"medium"},"input":"hello"}`,
cfg: config.Config{
Payload: config.PayloadConfig{
Override: []config.PayloadRule{
{
Models: []config.PayloadModelRule{{Name: "gpt-5.4"}},
Params: map[string]any{"model": "gpt-6-astra"},
},
},
},
},
wantTools: 0,
wantEffort: "medium",
},
{
name: "model_override_header_enables_responses_lite_skips_auto_injection",
model: "gpt-6-astra",
sourceFmt: sdktranslator.FormatOpenAIResponse,
payload: `{"model":"gpt-6-astra","input":"hello"}`,
overrideHeaders: map[string]string{codexResponsesLiteHeader: "true"},
wantTools: 0,
},
{
name: "payload_override_sets_reasoning_effort_and_tool_choice_auto_skips_auto_injection",
model: "gpt-6-astra",
sourceFmt: sdktranslator.FormatOpenAIResponse,
payload: `{"model":"gpt-6-astra","input":"hello"}`,
cfg: config.Config{
Payload: config.PayloadConfig{
Override: []config.PayloadRule{
{
Models: []config.PayloadModelRule{{Name: "gpt-6-astra"}},
Params: map[string]any{
"reasoning.effort": "medium",
"tool_choice": "auto",
},
},
},
},
},
wantTools: 0,
wantEffort: "medium",
},
{
name: "client_lite_header_overridden_false_by_auth_with_payload_rule_keeps_auto_injection",
model: "gpt-6-astra",
sourceFmt: sdktranslator.FormatOpenAIResponse,
payload: `{"model":"gpt-6-astra","input":"hello"}`,
reqHeaders: http.Header{codexResponsesLiteHeader: []string{"true"}},
authAttrs: map[string]string{"header:" + codexResponsesLiteHeader: "false"},
cfg: config.Config{
Payload: config.PayloadConfig{
Override: []config.PayloadRule{
{
Models: []config.PayloadModelRule{{Name: "gpt-6-astra"}},
Params: map[string]any{"service_tier": "default"},
},
},
},
},
wantTools: 1,
wantImgIdx: "tools.0.type",
},
{
name: "payload_default_image_tool_choice_overridden_to_auto_with_reasoning_skips_auto_injection",
model: "gpt-6-astra",
sourceFmt: sdktranslator.FormatOpenAIResponse,
payload: `{"model":"gpt-6-astra","input":"hello"}`,
cfg: config.Config{
Payload: config.PayloadConfig{
Default: []config.PayloadRule{
{
Models: []config.PayloadModelRule{{Name: "gpt-6-astra"}},
Params: map[string]any{"tool_choice": map[string]any{"type": "image_generation"}},
},
},
Override: []config.PayloadRule{
{
Models: []config.PayloadModelRule{{Name: "gpt-6-astra"}},
Params: map[string]any{
"tool_choice": "auto",
"reasoning.effort": "medium",
},
},
},
},
},
wantTools: 0,
wantEffort: "medium",
},
{
name: "auth_lite_header_true_overridden_false_by_initial_model_then_switched_to_model_without_override_skips_auto_injection",
model: "gpt-6-astra",
sourceFmt: sdktranslator.FormatOpenAIResponse,
payload: `{"model":"gpt-6-astra","input":"hello"}`,
authAttrs: map[string]string{"header:" + codexResponsesLiteHeader: "true"},
overrideHeaders: map[string]string{codexResponsesLiteHeader: "false"},
cfg: config.Config{
Payload: config.PayloadConfig{
Override: []config.PayloadRule{
{
Models: []config.PayloadModelRule{{Name: "gpt-6-astra"}},
Params: map[string]any{"model": "gpt-5.5"},
},
},
},
},
wantTools: 0,
},
{
name: "payload_override_function_tool_then_filter_deletes_it_with_reasoning_skips_auto_injection",
model: "gpt-6-astra",
sourceFmt: sdktranslator.FormatOpenAIResponse,
payload: `{"model":"gpt-6-astra","input":"hello","tools":[{"type":"function","name":"get_weather","description":"Get current weather","parameters":{"type":"object"}}]}`,
cfg: config.Config{
Payload: config.PayloadConfig{
Override: []config.PayloadRule{
{
Models: []config.PayloadModelRule{{Name: "gpt-6-astra"}},
Params: map[string]any{
"tools.0.description": "Updated weather",
"reasoning.effort": "medium",
},
},
},
Filter: []config.PayloadFilterRule{
{
Models: []config.PayloadModelRule{{Name: "gpt-6-astra"}},
Params: []string{"tools.0"},
},
},
},
},
wantTools: 0,
wantEffort: "medium",
},
{
name: "payload_override_image_tool_then_filter_deletes_earlier_tool_with_reasoning_keeps_configured_image_tool",
model: "gpt-6-astra",
sourceFmt: sdktranslator.FormatOpenAIResponse,
payload: `{"model":"gpt-6-astra","input":"hello","tools":[{"type":"function","name":"get_weather","description":"Get current weather","parameters":{"type":"object"}}]}`,
cfg: config.Config{
Payload: config.PayloadConfig{
Override: []config.PayloadRule{
{
Models: []config.PayloadModelRule{{Name: "gpt-6-astra"}},
Params: map[string]any{
"tools.1.output_format": "webp",
"reasoning.effort": "medium",
},
},
},
Filter: []config.PayloadFilterRule{
{
Models: []config.PayloadModelRule{{Name: "gpt-6-astra"}},
Params: []string{"tools.0"},
},
},
},
},
wantTools: 1,
wantImgIdx: "tools.0.type",
wantEffort: "medium",
},
{
name: "payload_override_raw_escaped_configuration_update_reasoning_skips_auto_injection",
model: "gpt-6-astra",
sourceFmt: sdktranslator.FormatOpenAIResponse,
payload: `{"model":"gpt-6-astra","input":"hello"}`,
cfg: config.Config{
Payload: config.PayloadConfig{
OverrideRaw: []config.PayloadRule{
{
Models: []config.PayloadModelRule{{Name: "gpt-6-astra"}},
Params: map[string]any{
"input.-1": `{"type":"\u0063onfiguration_update","reasoning":{"effort":"medium"}}`,
},
},
},
},
},
wantTools: 0,
},
} {
t.Run(tc.name+"/"+transport+"/stream="+streamLabel, func(t *testing.T) {
capturedBody := make(chan []byte, 1)
completedEvent := []byte(`{"type":"response.completed","response":{"id":"resp_7384","object":"response","status":"completed","model":"gpt-6-astra","output":[],"usage":{"input_tokens":10,"output_tokens":5,"total_tokens":15}}}`)
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if transport == "websocket" {
upgrader := websocket.Upgrader{}
conn, errUpgrade := upgrader.Upgrade(w, r, nil)
if errUpgrade != nil {
t.Errorf("upgrade websocket: %v", errUpgrade)
return
}
defer func() {
_ = conn.Close()
}()
_, msg, errRead := conn.ReadMessage()
if errRead != nil {
t.Errorf("read websocket message: %v", errRead)
return
}
capturedBody <- msg
if errWrite := conn.WriteMessage(websocket.TextMessage, completedEvent); errWrite != nil {
t.Errorf("write websocket message: %v", errWrite)
}
return
}
body, errRead := io.ReadAll(r.Body)
if errRead != nil {
t.Errorf("read http body: %v", errRead)
return
}
capturedBody <- body
w.Header().Set("Content-Type", "text/event-stream")
_, _ = w.Write(append(append([]byte("data: "), completedEvent...), '\n', '\n'))
}))
defer server.Close()
cfg := tc.cfg
var exec cliproxyauth.ProviderExecutor = NewCodexExecutor(&cfg)
if transport == "websocket" {
exec = NewCodexWebsocketsExecutor(&cfg)
}
if len(tc.overrideHeaders) > 0 {
reg := registry.GetGlobalRegistry()
clientID := t.Name() + "/override-header"
reg.RegisterClient(clientID, "codex", []*registry.ModelInfo{{
ID: tc.model,
Type: "codex",
Config: &registry.ModelConfig{OverrideHeader: tc.overrideHeaders},
}})
t.Cleanup(func() { reg.UnregisterClient(clientID) })
}
attrs := map[string]string{
"base_url": server.URL,
"plan_type": "pro",
}
for k, v := range tc.authAttrs {
attrs[k] = v
}
auth := &cliproxyauth.Auth{
ID: t.Name(),
Provider: "codex",
Attributes: attrs,
Metadata: map[string]any{
"access_token": "test-token",
"account_id": "acct-1",
},
}
req := cliproxyexecutor.Request{
Model: tc.model,
Payload: []byte(tc.payload),
Metadata: tc.reqMetadata,
}
finalized := 0
var headers http.Header
if tc.reqHeaders != nil {
headers = make(http.Header, len(tc.reqHeaders))
for k, vals := range tc.reqHeaders {
for _, v := range vals {
headers.Add(k, v)
}
}
}
opts := cliproxyexecutor.Options{
SourceFormat: tc.sourceFmt,
Stream: stream,
Headers: headers,
Metadata: map[string]any{
cliproxyexecutor.FinalizedResponseFormatCallbackMetadataKey: func(string) { finalized++ },
},
}
evalsBefore := helps.PayloadConfigEvaluationCount()
var errExec error
if stream {
var res *cliproxyexecutor.StreamResult
res, errExec = exec.ExecuteStream(context.Background(), auth, req, opts)
if res != nil {
for chunk := range res.Chunks {
if chunk.Err != nil {
errExec = chunk.Err
}
}
}
} else {
_, errExec = exec.Execute(context.Background(), auth, req, opts)
}
if gotEvals := helps.PayloadConfigEvaluationCount() - evalsBefore; gotEvals != 1 {
t.Fatalf("payload rule engine evaluated %d times, want 1", gotEvals)
}
if finalized != 1 {
t.Fatalf("payload finalizer evaluated %d times, want 1", finalized)
}
if errExec != nil {
t.Fatalf("execute error = %v", errExec)
}
gotBody := <-capturedBody
if tc.wantEffort != "" {
if gotEffort := ojson.GetBytes(gotBody, "reasoning.effort").String(); gotEffort != tc.wantEffort {
t.Fatalf("reasoning.effort = %q, want %q; body=%s", gotEffort, tc.wantEffort, gotBody)
}
}
tools := ojson.GetBytes(gotBody, "tools")
if tc.wantTools == 0 {
if tools.Exists() {
t.Fatalf("expected no tools, got %s (body=%s)", tools.Raw, gotBody)
}
return
}
if !tools.IsArray() || len(tools.Array()) != tc.wantTools {
t.Fatalf("tools count = %d, want %d; body=%s", len(tools.Array()), tc.wantTools, gotBody)
}
wantType := tc.wantToolType
if wantType == "" {
wantType = "image_generation"
}
if gotType := ojson.GetBytes(gotBody, tc.wantImgIdx).String(); gotType != wantType {
t.Fatalf("%s = %q, want %s; body=%s", tc.wantImgIdx, gotType, wantType, gotBody)
}
})
}
}
}
}
func TestCodexExecutorHostedImageGenerationSIWCAndAPIKeyPreserveUpstreamModelAndParams(t *testing.T) {
for _, credKind := range []string{"api_key", "siwc"} {
for _, transport := range []string{"http", "websocket"} {

View File

@@ -808,29 +808,61 @@ func ensureImageGenerationTool(body []byte, baseModel string, auth *cliproxyauth
return doc.Bytes()
}
func ensureImageGenerationToolDoc(doc *ojson.Doc, baseModel string, auth *cliproxyauth.Auth, headers http.Header) bool {
if doc == nil || isCodexResponsesLiteRequestDoc(doc, headers) || isCodexResponsesLiteModel(baseModel) {
return false
}
if strings.HasSuffix(baseModel, "spark") {
return false
}
if isCodexFreePlanAuth(auth) {
return false
}
func codexRequestHasReasoningForHostedImageDoc(doc *ojson.Doc, model string) bool {
return helps.CodexRequestHasReasoningForHostedImageDoc(doc, model)
}
func isCodexResponsesLiteRequestForAuthDoc(doc *ojson.Doc, modelName string, auth *cliproxyauth.Auth, headers http.Header) bool {
return helps.CodexResponsesLiteRequestForAuthDoc(doc, modelName, auth, headers)
}
func codexToolsAlreadyContainImageGenDoc(doc *ojson.Doc) bool {
if doc == nil {
return false
}
tools := doc.Get("tools")
if !tools.Exists() || !tools.IsArray() {
return false
}
for _, t := range tools.Array() {
if t.Get("type").String() == "image_generation" || isImageGenerationFunctionTool(t) {
return true
}
}
return false
}
func appendImageGenerationToolDoc(doc *ojson.Doc) bool {
if doc == nil {
return false
}
tools := doc.Get("tools")
if !tools.Exists() || !tools.IsArray() {
return doc.SetRawBytes("tools", imageGenToolArrayJSON) == nil
}
for _, t := range tools.Array() {
if t.Get("type").String() == "image_generation" || isImageGenerationFunctionTool(t) {
return false
}
}
return doc.SetRawBytes("tools.-1", imageGenToolJSON) == nil
}
func ensureImageGenerationToolDoc(doc *ojson.Doc, baseModel string, auth *cliproxyauth.Auth, headers http.Header) bool {
if doc == nil || isCodexFreePlanAuth(auth) || codexToolsAlreadyContainImageGenDoc(doc) {
return false
}
modelName := strings.TrimSpace(thinking.ParseSuffix(baseModel).ModelName)
if modelName == "" {
modelName = strings.TrimSpace(thinking.ParseSuffix(doc.Get("model").String()).ModelName)
}
if isCodexResponsesLiteRequestForAuthDoc(doc, modelName, auth, headers) {
return false
}
if isCodexResponsesLiteModel(modelName) && codexRequestHasReasoningForHostedImageDoc(doc, baseModel) {
return false
}
if strings.HasSuffix(strings.ToLower(modelName), "spark") {
return false
}
return appendImageGenerationToolDoc(doc)
}
func resolveCodexGPTImage2BaseModel(cfg *config.Config) string {
if cfg == nil {
return codexOpenAIImagesMainModel

View File

@@ -69,7 +69,7 @@ func (e *CodexExecutor) ExecuteStream(ctx context.Context, auth *cliproxyauth.Au
return nil, err
}
ctx = helps.WithPayloadFinalizer(ctx, helps.NewPayloadFinalizer(e.cfg, e.Identifier(), baseModel, to.String(), "", originalTranslated, req, opts))
ctx = helps.WithPayloadFinalizer(ctx, helps.NewPayloadFinalizer(e.cfg, e.Identifier(), baseModel, to.String(), "", originalTranslated, req, opts, auth))
_ = doc.Delete("previous_response_id")
_ = doc.Delete("generate")
_ = doc.Delete("prompt_cache_retention")
@@ -92,7 +92,11 @@ func (e *CodexExecutor) ExecuteStream(ctx context.Context, auth *cliproxyauth.Au
if !useSIWC {
normalizeCodexInstructionsDoc(doc, preserveNativeOutput)
if e.cfg == nil || e.cfg.DisableImageGeneration == config.DisableImageGenerationOff {
ensureImageGenerationToolDoc(doc, baseModel, auth, opts.Headers)
checkModel := req.Model
if strings.TrimSpace(checkModel) == "" {
checkModel = baseModel
}
ensureImageGenerationToolDoc(doc, checkModel, auth, opts.Headers)
if !codexAuthUsesAPIKey(auth) {
normalizeCodexImageGenerationToolsDoc(doc)
}

View File

@@ -72,7 +72,7 @@ func (e *CodexWebsocketsExecutor) Execute(ctx context.Context, auth *cliproxyaut
instructionsResult := ojson.GetBytesNoCopy(req.Payload, "instructions")
hasExplicitInstructions := instructionsResult.Exists() && strings.TrimSpace(instructionsResult.String()) != ""
ctx = helps.WithPayloadFinalizer(ctx, helps.NewPayloadFinalizer(e.cfg, "codex-websockets", baseModel, to.String(), "", originalTranslated, req, opts))
ctx = helps.WithPayloadFinalizer(ctx, helps.NewPayloadFinalizer(e.cfg, "codex-websockets", baseModel, to.String(), "", originalTranslated, req, opts, auth))
helps.SetStringIfDifferentDoc(doc, "model", baseModel)
helps.SetBoolIfDifferentDoc(doc, "stream", true)
_ = doc.Delete("prompt_cache_retention")
@@ -81,7 +81,11 @@ func (e *CodexWebsocketsExecutor) Execute(ctx context.Context, auth *cliproxyaut
if !useSIWC {
normalizeCodexInstructionsDoc(doc, nativeRequest)
if e.cfg == nil || e.cfg.DisableImageGeneration == config.DisableImageGenerationOff {
ensureImageGenerationToolDoc(doc, baseModel, auth, opts.Headers)
checkModel := req.Model
if strings.TrimSpace(checkModel) == "" {
checkModel = baseModel
}
ensureImageGenerationToolDoc(doc, checkModel, auth, opts.Headers)
if !codexAuthUsesAPIKey(auth) {
normalizeCodexImageGenerationToolsDoc(doc)
}

View File

@@ -900,13 +900,17 @@ func (e *CodexWebsocketsExecutor) prepareCodexWebsocketStream(ctx context.Contex
instructionsResult := ojson.GetBytesNoCopy(req.Payload, "instructions")
hasExplicitInstructions := instructionsResult.Exists() && strings.TrimSpace(instructionsResult.String()) != ""
ctx = helps.WithPayloadFinalizer(ctx, helps.NewPayloadFinalizer(e.cfg, "codex-websockets", baseModel, to.String(), "", originalTranslated, req, opts))
ctx = helps.WithPayloadFinalizer(ctx, helps.NewPayloadFinalizer(e.cfg, "codex-websockets", baseModel, to.String(), "", originalTranslated, req, opts, auth))
helps.SetStringIfDifferentDoc(doc, "model", baseModel)
ensureWebSearchToolForHistoryDoc(doc, opts.Headers)
if !useSIWC {
normalizeCodexInstructionsDoc(doc, preserveNativeOutput)
if e.cfg == nil || e.cfg.DisableImageGeneration == config.DisableImageGenerationOff {
ensureImageGenerationToolDoc(doc, baseModel, auth, opts.Headers)
checkModel := req.Model
if strings.TrimSpace(checkModel) == "" {
checkModel = baseModel
}
ensureImageGenerationToolDoc(doc, checkModel, auth, opts.Headers)
if !codexAuthUsesAPIKey(auth) {
normalizeCodexImageGenerationToolsDoc(doc)
}

View File

@@ -1,6 +1,7 @@
package helps
import (
"context"
"net/http"
"strings"
@@ -8,9 +9,12 @@ import (
"github.com/router-for-me/CLIProxyAPI/v8/internal/config"
"github.com/router-for-me/CLIProxyAPI/v8/internal/registry"
"github.com/router-for-me/CLIProxyAPI/v8/internal/thinking"
"github.com/router-for-me/CLIProxyAPI/v8/internal/util"
cliproxyauth "github.com/router-for-me/CLIProxyAPI/v8/sdk/cliproxy/auth"
)
const codexResponsesLiteHeaderName = "X-OpenAI-Internal-Codex-Responses-Lite"
// CodexModelUsesResponsesLite identifies models whose native Codex route uses Responses Lite.
func CodexModelUsesResponsesLite(model string) bool {
slug := strings.ToLower(strings.TrimSpace(thinking.ParseSuffix(model).ModelName))
@@ -22,7 +26,7 @@ func CodexModelUsesResponsesLite(model string) bool {
// CodexResponsesLiteRequestDoc reads the route hints without changing the payload.
func CodexResponsesLiteRequestDoc(doc *ojson.Doc, headers http.Header) bool {
if strings.EqualFold(strings.TrimSpace(headers.Get("X-OpenAI-Internal-Codex-Responses-Lite")), "true") {
if strings.EqualFold(strings.TrimSpace(headers.Get(codexResponsesLiteHeaderName)), "true") {
return true
}
if doc == nil {
@@ -32,15 +36,82 @@ func CodexResponsesLiteRequestDoc(doc *ojson.Doc, headers http.Header) bool {
return value.Type == ojson.True || (value.Type == ojson.String && strings.EqualFold(strings.TrimSpace(value.String()), "true"))
}
// CodexResponsesLiteRequestForAuthDoc reports whether the request uses the
// Codex Responses-Lite protocol after resolving client_metadata, client
// headers, credential header: attributes, and models.json override_header.
func CodexResponsesLiteRequestForAuthDoc(doc *ojson.Doc, modelName string, auth *cliproxyauth.Auth, headers http.Header) bool {
if CodexResponsesLiteRequestDoc(doc, nil) {
return true
}
var effective string
if headers != nil {
effective = strings.TrimSpace(headers.Get(codexResponsesLiteHeaderName))
}
if auth != nil && len(auth.Attributes) > 0 {
resolved := (&http.Request{Header: http.Header{}}).WithContext(context.Background())
util.ApplyCustomHeadersFromAttrs(resolved, auth.Attributes, headers)
if opLite := strings.TrimSpace(resolved.Header.Get(codexResponsesLiteHeaderName)); opLite != "" {
effective = opLite
}
}
if overrides := registry.ModelOverrideHeaders(modelName); len(overrides) > 0 {
for key, value := range overrides {
if strings.EqualFold(strings.TrimSpace(key), codexResponsesLiteHeaderName) {
effective = strings.TrimSpace(value)
}
}
}
return strings.EqualFold(effective, "true")
}
// CodexRequestHasReasoningForHostedImageDoc reports whether the request carries
// a reasoning configuration (top-level reasoning.effort, configuration_update
// input item, or model thinking suffix). Upstream Codex /responses binds hosted
// image_generation to gpt-image-2-codex, which rejects complexity whenever
// reasoning effort is present on Responses-Lite models (#7270), whereas
// standard Responses requests without reasoning effort succeed (#7384).
func CodexRequestHasReasoningForHostedImageDoc(doc *ojson.Doc, model string) bool {
if thinking.HasThinkingSuffix(model) {
return true
}
if doc == nil {
return false
}
if thinking.HasThinkingSuffix(doc.Get("model").String()) {
return true
}
if reasoning := doc.Get("reasoning"); reasoning.Exists() && reasoning.Type != ojson.Null {
if reasoning.IsObject() {
if effort := reasoning.Get("effort"); effort.Exists() && effort.Type != ojson.Null && strings.TrimSpace(effort.String()) != "" {
return true
}
} else if strings.TrimSpace(reasoning.String()) != "" {
return true
}
}
if input := doc.Get("input"); input.IsArray() {
for _, item := range input.Array() {
if strings.TrimSpace(item.Get("type").String()) != "configuration_update" {
continue
}
if effort := item.Get("reasoning.effort"); effort.Exists() && effort.Type != ojson.Null && strings.TrimSpace(effort.String()) != "" {
return true
}
}
}
return false
}
// ValidateCodexHostedImageGenerationDoc checks the final, configured Responses payload
// after all outbound headers, including credential and model overrides, are resolved.
// Native Codex Responses Lite cannot serve forced hosted images. API-key, SIWC,
// Native Codex Responses Lite cannot serve forced hosted images, while API-key, SIWC,
// explicit passthrough, and standalone Images API requests retain their own contracts.
func ValidateCodexHostedImageGenerationDoc(doc *ojson.Doc, upstreamHeaders http.Header, cfg *config.Config, nativeCodex bool) error {
if !nativeCodex || doc == nil || (cfg != nil && cfg.DisableImageGeneration == config.DisableImageGenerationPassthrough) {
return nil
}
if !CodexModelUsesResponsesLite(doc.Get("model").String()) && !CodexResponsesLiteRequestDoc(doc, upstreamHeaders) {
model := doc.Get("model").String()
if !CodexModelUsesResponsesLite(model) && !CodexResponsesLiteRequestDoc(doc, upstreamHeaders) {
return nil
}
if !codexRequestForcesImageGenerationDoc(doc) {

View File

@@ -9,6 +9,7 @@ import (
"github.com/MoeForge/moego/ojson"
"github.com/router-for-me/CLIProxyAPI/v8/internal/config"
cliproxyauth "github.com/router-for-me/CLIProxyAPI/v8/sdk/cliproxy/auth"
cliproxyexecutor "github.com/router-for-me/CLIProxyAPI/v8/sdk/cliproxy/executor"
)
@@ -47,11 +48,15 @@ func (f PayloadFinalizer) FinalizeDoc(doc *ojson.Doc) {
}
// NewPayloadFinalizer snapshots matching context before built-in request mutations.
func NewPayloadFinalizer(cfg *config.Config, executor, model, protocol, root string, original []byte, req cliproxyexecutor.Request, opts cliproxyexecutor.Options) PayloadFinalizer {
func NewPayloadFinalizer(cfg *config.Config, executor, model, protocol, root string, original []byte, req cliproxyexecutor.Request, opts cliproxyexecutor.Options, auths ...*cliproxyauth.Auth) PayloadFinalizer {
requestedModel := PayloadRequestedModel(opts, req.Model)
requestPath := PayloadRequestPath(opts)
headers := opts.Headers.Clone()
source := append([]byte(nil), original...)
var auth *cliproxyauth.Auth
if len(auths) > 0 {
auth = auths[0]
}
var formatCallback func(string)
if opts.Metadata != nil {
formatCallback, _ = opts.Metadata[cliproxyexecutor.FinalizedResponseFormatCallbackMetadataKey].(func(string))
@@ -61,7 +66,7 @@ func NewPayloadFinalizer(cfg *config.Config, executor, model, protocol, root str
key := &body[:1][0]
if v, ok := payloadDocProbes.LoadAndDelete(key); ok {
if doc, okDoc := v.(*ojson.Doc); okDoc && doc != nil {
ApplyPayloadConfigWithRequestForExecutorDoc(cfg, executor, model, protocol, opts.SourceFormat.String(), root, doc, source, requestedModel, requestPath, headers)
applyPayloadConfigWithTrackedPathsForExecutorAndAuthDoc(cfg, executor, model, protocol, opts.SourceFormat.String(), root, doc, source, requestedModel, requestPath, headers, auth)
if formatCallback != nil {
formatCallback(strings.Clone(strings.TrimSpace(doc.Get(buildPayloadPath(root, "response_format")).String())))
}
@@ -69,7 +74,12 @@ func NewPayloadFinalizer(cfg *config.Config, executor, model, protocol, root str
return nil
}
}
out := ApplyPayloadConfigWithRequestForExecutor(cfg, executor, model, protocol, opts.SourceFormat.String(), root, body, source, requestedModel, requestPath, headers)
doc := ojson.NewDoc(body)
_, mutated := applyPayloadConfigWithTrackedPathsForExecutorAndAuthDoc(cfg, executor, model, protocol, opts.SourceFormat.String(), root, doc, source, requestedModel, requestPath, headers, auth)
out := body
if mutated {
out = doc.Bytes()
}
if formatCallback != nil {
formatCallback(strings.Clone(strings.TrimSpace(ojson.GetBytesNoCopy(out, buildPayloadPath(root, "response_format")).String())))
}

View File

@@ -6,14 +6,24 @@ import (
"reflect"
"strconv"
"strings"
"sync/atomic"
"github.com/MoeForge/moego/ojson"
"github.com/router-for-me/CLIProxyAPI/v8/internal/config"
"github.com/router-for-me/CLIProxyAPI/v8/internal/thinking"
"github.com/router-for-me/CLIProxyAPI/v8/internal/util"
cliproxyauth "github.com/router-for-me/CLIProxyAPI/v8/sdk/cliproxy/auth"
cliproxyexecutor "github.com/router-for-me/CLIProxyAPI/v8/sdk/cliproxy/executor"
)
var payloadConfigEvaluations atomic.Int64
// PayloadConfigEvaluationCount returns the cumulative number of payload rule
// engine evaluations across the process.
func PayloadConfigEvaluationCount() int64 {
return payloadConfigEvaluations.Load()
}
// ApplyPayloadConfigWithRoot behaves like applyPayloadConfig but treats all parameter
// paths as relative to the provided root path and restricts matches to the given
// protocol when supplied. Defaults are checked
@@ -91,6 +101,11 @@ func ApplyPayloadConfigWithTrackedPathsForExecutorDoc(cfg *config.Config, target
}
func applyPayloadConfigWithTrackedPathsForExecutorDoc(cfg *config.Config, targetExecutor, model, protocol, fromProtocol, root string, doc *ojson.Doc, original []byte, requestedModel, requestPath string, headers http.Header, trackedPaths ...string) (map[string]bool, bool) {
return applyPayloadConfigWithTrackedPathsForExecutorAndAuthDoc(cfg, targetExecutor, model, protocol, fromProtocol, root, doc, original, requestedModel, requestPath, headers, nil, trackedPaths...)
}
func applyPayloadConfigWithTrackedPathsForExecutorAndAuthDoc(cfg *config.Config, targetExecutor, model, protocol, fromProtocol, root string, doc *ojson.Doc, original []byte, requestedModel, requestPath string, headers http.Header, auth *cliproxyauth.Auth, trackedPaths ...string) (map[string]bool, bool) {
payloadConfigEvaluations.Add(1)
touched := make(map[string]bool)
if doc == nil || doc.Len() == 0 {
return touched, false
@@ -133,6 +148,59 @@ func applyPayloadConfigWithTrackedPathsForExecutorDoc(cfg *config.Config, target
model = strings.TrimSpace(model)
requestedModel = strings.TrimSpace(requestedModel)
if model != "" || requestedModel != "" {
toolsPath := buildPayloadPath(root, "tools")
toolChoicePath := buildPayloadPath(root, "tool_choice")
autoInjectedToolIdx := -1
if isCodexTargetExecutor(targetExecutor) &&
cfg.DisableImageGeneration == config.DisableImageGenerationOff &&
len(original) > 0 &&
!rawToolsContainImageGeneration(original, toolsPath) {
autoInjectedToolIdx = findLastImageGenerationToolIndexDoc(doc, toolsPath)
}
origTools := ojson.GetBytesNoCopy(original, toolsPath)
originalHadEmptyTools := len(original) > 0 && origTools.Exists() && origTools.IsArray() && len(origTools.Array()) == 0
userWroteToolChoice := false
noteRuleWrite := func(resolvedPath string) {
markTouched(resolvedPath)
if toolChoicePath != "" && payloadRuleTargetsPath(resolvedPath, toolChoicePath) {
userWroteToolChoice = true
return
}
if autoInjectedToolIdx < 0 || toolsPath == "" || !payloadRuleTargetsPath(resolvedPath, toolsPath) {
return
}
if resolvedPath == toolsPath {
autoInjectedToolIdx = -1
return
}
rest := strings.TrimPrefix(resolvedPath, toolsPath+".")
if idx := strings.IndexByte(rest, '.'); idx >= 0 {
rest = rest[:idx]
}
if elemIdx, errIdx := strconv.Atoi(rest); errIdx == nil && elemIdx == autoInjectedToolIdx {
autoInjectedToolIdx = -1
}
}
noteRuleDelete := func(resolvedPath string) {
if autoInjectedToolIdx < 0 || toolsPath == "" || !payloadRuleTargetsPath(resolvedPath, toolsPath) {
return
}
if resolvedPath == toolsPath {
autoInjectedToolIdx = -1
return
}
rest := strings.TrimPrefix(resolvedPath, toolsPath+".")
if strings.Contains(rest, ".") {
return
}
if delIdx, errIdx := strconv.Atoi(rest); errIdx == nil {
if delIdx == autoInjectedToolIdx {
autoInjectedToolIdx = -1
} else if delIdx >= 0 && delIdx < autoInjectedToolIdx {
autoInjectedToolIdx--
}
}
}
candidates := payloadModelCandidates(model, requestedModel)
appliedDefaults := make(map[string]struct{})
var createdByDefault map[string]struct{}
@@ -223,7 +291,7 @@ func applyPayloadConfigWithTrackedPathsForExecutorDoc(cfg *config.Config, target
}
mutated = true
appliedDefaults[resolvedPath] = struct{}{}
markTouched(resolvedPath)
noteRuleWrite(resolvedPath)
}
}
}
@@ -255,7 +323,7 @@ func applyPayloadConfigWithTrackedPathsForExecutorDoc(cfg *config.Config, target
}
mutated = true
appliedDefaults[resolvedPath] = struct{}{}
markTouched(resolvedPath)
noteRuleWrite(resolvedPath)
}
}
}
@@ -276,7 +344,7 @@ func applyPayloadConfigWithTrackedPathsForExecutorDoc(cfg *config.Config, target
mutated = true
}
if applied {
markTouched(resolvedPath)
noteRuleWrite(resolvedPath)
}
}
}
@@ -302,7 +370,7 @@ func applyPayloadConfigWithTrackedPathsForExecutorDoc(cfg *config.Config, target
mutated = true
}
if applied {
markTouched(resolvedPath)
noteRuleWrite(resolvedPath)
}
}
}
@@ -327,16 +395,126 @@ func applyPayloadConfigWithTrackedPathsForExecutorDoc(cfg *config.Config, target
}
if existed {
mutated = true
noteRuleDelete(resolvedPath)
}
markTouched(resolvedPath)
}
}
}
if autoInjectedToolIdx >= 0 && !(userWroteToolChoice && docToolChoiceSelectsImageGeneration(doc, toolChoicePath)) {
if codexConfiguredPayloadIncompatibleWithAutoImageGenDoc(doc, root, model, auth, headers) {
if retractAutoInjectedImageGenerationToolAtIndexDoc(doc, toolsPath, autoInjectedToolIdx, originalHadEmptyTools) {
mutated = true
}
}
}
}
}
return touched, mutated
}
func findLastImageGenerationToolIndexDoc(doc *ojson.Doc, toolsPath string) int {
if doc == nil {
return -1
}
tools := doc.Get(toolsPath)
if !tools.Exists() || !tools.IsArray() {
return -1
}
items := tools.Array()
for idx := len(items) - 1; idx >= 0; idx-- {
if strings.TrimSpace(items[idx].Get("type").String()) == "image_generation" {
return idx
}
}
return -1
}
func rawToolsContainImageGeneration(raw []byte, toolsPath string) bool {
if len(raw) == 0 {
return false
}
tools := ojson.GetBytesNoCopy(raw, toolsPath)
if !tools.Exists() || !tools.IsArray() {
return false
}
for _, tool := range tools.Array() {
if strings.TrimSpace(tool.Get("type").String()) == "image_generation" {
return true
}
}
return false
}
func docToolChoiceSelectsImageGeneration(doc *ojson.Doc, toolChoicePath string) bool {
if doc == nil || toolChoicePath == "" {
return false
}
choice := doc.Get(toolChoicePath)
if !choice.Exists() {
return false
}
if choice.Type == ojson.String {
return strings.EqualFold(strings.TrimSpace(choice.String()), "image_generation")
}
if !choice.IsObject() {
return false
}
switch strings.ToLower(strings.TrimSpace(choice.Get("type").String())) {
case "image_generation":
return true
case "tool":
return strings.EqualFold(strings.TrimSpace(choice.Get("name").String()), "image_generation")
case "allowed_tools":
allowed := choice.Get("tools")
if !allowed.IsArray() {
return false
}
for _, tool := range allowed.Array() {
if strings.EqualFold(strings.TrimSpace(tool.Get("type").String()), "image_generation") {
return true
}
}
}
return false
}
func codexConfiguredPayloadIncompatibleWithAutoImageGenDoc(doc *ojson.Doc, root, fallbackModel string, auth *cliproxyauth.Auth, headers http.Header) bool {
if doc == nil {
return false
}
configuredModel := strings.TrimSpace(doc.Get(buildPayloadPath(root, "model")).String())
if configuredModel == "" {
configuredModel = strings.TrimSpace(fallbackModel)
}
modelName := strings.TrimSpace(thinking.ParseSuffix(configuredModel).ModelName)
if CodexResponsesLiteRequestForAuthDoc(doc, modelName, auth, headers) {
return true
}
if strings.HasSuffix(strings.ToLower(modelName), "spark") {
return true
}
return CodexModelUsesResponsesLite(modelName) && CodexRequestHasReasoningForHostedImageDoc(doc, configuredModel)
}
func retractAutoInjectedImageGenerationToolAtIndexDoc(doc *ojson.Doc, toolsPath string, targetIdx int, originalHadEmptyTools bool) bool {
tools := doc.Get(toolsPath)
if !tools.Exists() || !tools.IsArray() {
return false
}
toolItems := tools.Array()
if targetIdx < 0 || targetIdx >= len(toolItems) {
return false
}
if strings.TrimSpace(toolItems[targetIdx].Get("type").String()) != "image_generation" {
return false
}
if len(toolItems) == 1 && !originalHadEmptyTools {
return doc.Delete(toolsPath) == nil
}
return doc.Delete(toolsPath+"."+strconv.Itoa(targetIdx)) == nil
}
// ApplyPayloadConfigWithRequestTracked applies payload config and reports whether
// an applied rule targeted trackedPath or one of its descendants.
func ApplyPayloadConfigWithRequestTracked(cfg *config.Config, model, protocol, fromProtocol, root string, payload, original []byte, requestedModel string, requestPath string, headers http.Header, trackedPath string) ([]byte, bool) {

View File

@@ -21,7 +21,7 @@ import (
func TestPayloadBarrierCodexImageFilter(t *testing.T) {
for _, transport := range []string{"http", "websocket"} {
for _, stream := range []bool{false, true} {
for _, model := range []string{"gpt-5.4", "gpt-5.5"} {
for _, model := range []string{"gpt-5.4", "gpt-5.5", "gpt-6-astra", "gpt-6-sol"} {
t.Run(transport+"/"+model+map[bool]string{false: "/execute", true: "/stream"}[stream], func(t *testing.T) {
captured := make(chan []byte, 1)
completed := []byte(`{"type":"response.completed","response":{"id":"resp_barrier","status":"completed","output":[],"usage":{"input_tokens":0,"output_tokens":0,"total_tokens":0}}}`)
@@ -59,7 +59,7 @@ func TestPayloadBarrierCodexImageFilter(t *testing.T) {
_, _ = w.Write(append(append([]byte("data: "), completed...), '\n', '\n'))
}))
defer server.Close()
cfg := &config.Config{Payload: config.PayloadConfig{Filter: []config.PayloadFilterRule{{Models: []config.PayloadModelRule{{Name: "gpt-5.4"}}, Params: []string{`tools.#(type=="image_generation")#`, "instructions", "prompt_cache_key"}}}}}
cfg := &config.Config{Payload: config.PayloadConfig{Filter: []config.PayloadFilterRule{{Models: []config.PayloadModelRule{{Name: "gpt-5.4"}, {Name: "gpt-6-astra"}}, Params: []string{`tools.#(type=="image_generation")#`, "instructions", "prompt_cache_key"}}}}}
var executor cliproxyauth.ProviderExecutor = NewCodexExecutor(cfg)
if transport == "websocket" {
executor = NewCodexWebsocketsExecutor(cfg)
@@ -81,11 +81,12 @@ func TestPayloadBarrierCodexImageFilter(t *testing.T) {
t.Fatal(errExecute)
}
body := <-captured
filteredModel := model == "gpt-5.4" || model == "gpt-6-astra"
image := ojson.GetBytes(body, `tools.#(type=="image_generation")`).Exists()
if image != (model == "gpt-5.5") {
if image != !filteredModel {
t.Fatalf("image tool presence = %v: %s", image, body)
}
if model == "gpt-5.4" && (ojson.GetBytes(body, "instructions").Exists() || ojson.GetBytes(body, "prompt_cache_key").Exists()) {
if filteredModel && (ojson.GetBytes(body, "instructions").Exists() || ojson.GetBytes(body, "prompt_cache_key").Exists()) {
t.Fatalf("late injection undid filter: %s", body)
}
})