1e4a8c4 Honor explicit reasoning level overrides · zut

M README.md +1 -1


@@ -487,7 +487,7 @@ Place a `models.json` in `$ZOT_HOME` (`$XDG_STATE_HOME/zot/` when set, otherwise
487	487
488	488		Supported fields per model: `id` (required), `name`, `reasoning`, `reasoningLevelMap`, `contextWindow`, `maxTokens`, `baseUrl`, `priceInput`, `priceOutput`, `priceCacheRead`, `priceCacheWrite`.
489	489
490		-	`reasoningLevelMap` is optional. Protocol defaults apply when it is omitted. Add only model-specific exceptions using `minimum`, `low`, `medium`, `high`, `xhigh`, or `max` as keys. Map a key to another level when both inputs are equivalent, or to an empty string or `off` to remove it. The same effective mapping drives `/reasoning` and provider requests.
	490	+	`reasoningLevelMap` is optional. Protocol defaults apply when it is omitted. Add only model-specific exceptions using `minimum`, `low`, `medium`, `high`, `xhigh`, or `max` as keys. Map a key to another level when both inputs are equivalent, use an identity mapping such as `"max": "max"` to enable a level beyond the protocol default, or map it to an empty string or `off` to remove it. The same effective mapping drives `/reasoning` and provider requests.
491	491
492	492		Provider keys are normalized: `openai-codex` and `openai-responses` map to `openai`, `anthropic-messages` maps to `anthropic`, `moonshot`, `moonshot-ai`, and `kimi-code` map to `kimi`, and `deepseek-chat` and `deepseek-ai` map to `deepseek`. Built-in provider ids such as `groq`, `openrouter`, `github-copilot`, `amazon-bedrock`, `google-vertex`, `azure-openai-responses`, `fireworks`, `vercel-ai-gateway`, `mistral`, and `xai` can also be used directly.
493	493


@@ -487,7 +487,7 @@ Place a `models.json` in `$ZOT_HOME` (`$XDG_STATE_HOME/zot/` when set, otherwise
487			487
488		Supported fields per model: `id` (required), `name`, `reasoning`, `reasoningLevelMap`, `contextWindow`, `maxTokens`, `baseUrl`, `priceInput`, `priceOutput`, `priceCacheRead`, `priceCacheWrite`.	488		Supported fields per model: `id` (required), `name`, `reasoning`, `reasoningLevelMap`, `contextWindow`, `maxTokens`, `baseUrl`, `priceInput`, `priceOutput`, `priceCacheRead`, `priceCacheWrite`.
489			489
490	-	`reasoningLevelMap` is optional. Protocol defaults apply when it is omitted. Add only model-specific exceptions using `minimum`, `low`, `medium`, `high`, `xhigh`, or `max` as keys. Map a key to another level when both inputs are equivalent, or to an empty string or `off` to remove it. The same effective mapping drives `/reasoning` and provider requests.	490	+	`reasoningLevelMap` is optional. Protocol defaults apply when it is omitted. Add only model-specific exceptions using `minimum`, `low`, `medium`, `high`, `xhigh`, or `max` as keys. Map a key to another level when both inputs are equivalent, use an identity mapping such as `"max": "max"` to enable a level beyond the protocol default, or map it to an empty string or `off` to remove it. The same effective mapping drives `/reasoning` and provider requests.
491			491
492		Provider keys are normalized: `openai-codex` and `openai-responses` map to `openai`, `anthropic-messages` maps to `anthropic`, `moonshot`, `moonshot-ai`, and `kimi-code` map to `kimi`, and `deepseek-chat` and `deepseek-ai` map to `deepseek`. Built-in provider ids such as `groq`, `openrouter`, `github-copilot`, `amazon-bedrock`, `google-vertex`, `azure-openai-responses`, `fireworks`, `vercel-ai-gateway`, `mistral`, and `xai` can also be used directly.	492		Provider keys are normalized: `openai-codex` and `openai-responses` map to `openai`, `anthropic-messages` maps to `anthropic`, `moonshot`, `moonshot-ai`, and `kimi-code` map to `kimi`, and `deepseek-chat` and `deepseek-ai` map to `deepseek`. Built-in provider ids such as `groq`, `openrouter`, `github-copilot`, `amazon-bedrock`, `google-vertex`, `azure-openai-responses`, `fireworks`, `vercel-ai-gateway`, `mistral`, and `xai` can also be used directly.
493			493

M packages/provider/openai.go +5 -0


@@ -257,6 +257,11 @@ func (c openaiClient) buildRequest(req Request) (oaiRequest, error) {
257	257		// don't clamp zot's "maximum" to "high" for those models.
258	258		effort = OpenAICompatAnthropicEffort(reasoning)
259	259		}
	260	+	if hasReasoningLevelOverride(m, req.Reasoning) {
	261	+	// Explicit model mappings describe the endpoint's actual effort
	262	+	// values and take precedence over conservative protocol defaults.
	263	+	effort = reasoning
	264	+	}
260	265		if effort != "" {
261	266		out.ReasoningEffort = effort
262	267		}


@@ -257,6 +257,11 @@ func (c openaiClient) buildRequest(req Request) (oaiRequest, error) {
257	// don't clamp zot's "maximum" to "high" for those models.	257		// don't clamp zot's "maximum" to "high" for those models.
258	effort = OpenAICompatAnthropicEffort(reasoning)	258		effort = OpenAICompatAnthropicEffort(reasoning)
259	}	259		}
		260	+	if hasReasoningLevelOverride(m, req.Reasoning) {
		261	+	// Explicit model mappings describe the endpoint's actual effort
		262	+	// values and take precedence over conservative protocol defaults.
		263	+	effort = reasoning
		264	+	}
260	if effort != "" {	265		if effort != "" {
261	out.ReasoningEffort = effort	266		out.ReasoningEffort = effort
262	}	267		}

M packages/provider/openai_codex.go +5 -1


@@ -195,7 +195,11 @@ func (c codexClient) buildRequest(req Request) (codexRequest, error) {
195	195		Include: []string{"reasoning.encrypted_content"},
196	196		}
197	197		if m.Reasoning {
198		-	if effort := OpenAICodexReasoningEffort(reasoning, req.Model); effort != "" {
	198	+	effort := OpenAICodexReasoningEffort(reasoning, req.Model)
	199	+	if hasReasoningLevelOverride(m, req.Reasoning) {
	200	+	effort = reasoning
	201	+	}
	202	+	if effort != "" {
199	203		body.Reasoning = &codexReasoningConfig{Effort: effort}
200	204		}
201	205		}

 		Include:           []string{"reasoning.encrypted_content"},
 	}
 	if m.Reasoning {
-		if effort := OpenAICodexReasoningEffort(reasoning, req.Model); effort != "" {
+		effort := OpenAICodexReasoningEffort(reasoning, req.Model)
+		if hasReasoningLevelOverride(m, req.Reasoning) {
+			effort = reasoning
+		}
+		if effort != "" {
 			body.Reasoning = &codexReasoningConfig{Effort: effort}
 		}
 	}

M packages/provider/openai_codex_test.go +21 -0


@@ -125,6 +125,27 @@ func TestGPT56UsesNativeMaxReasoningEffort(t *testing.T) {
125	125		}
126	126		}
127	127
	128	+	func TestResponsesRequestUsesExplicitReasoningLevelMap(t *testing.T) {
	129	+	SetLiveModels([]Model{{
	130	+	Provider: "custom-responses",
	131	+	ID: "reasoning-model",
	132	+	API: APIResponses,
	133	+	Reasoning: true,
	134	+	ReasoningLevelMap: map[string]string{"max": "max"},
	135	+	}})
	136	+	t.Cleanup(func() { SetLiveModels(nil) })
	137	+
	138	+	named := NewOpenAIResponsesNamed("token", "https://example.test/v1", "custom-responses").(*renamedClient)
	139	+	c := named.inner.(*codexClient)
	140	+	wire, err := c.buildRequest(Request{Model: "reasoning-model", Reasoning: "max"})
	141	+	if err != nil {
	142	+	t.Fatal(err)
	143	+	}
	144	+	if wire.Reasoning == nil \|\| wire.Reasoning.Effort != "max" {
	145	+	t.Fatalf("reasoning = %+v", wire.Reasoning)
	146	+	}
	147	+	}
	148	+
128	149		func TestXAIResponsesUsesNamedProviderCatalogAndEndpoint(t *testing.T) {
129	150		named := NewOpenAIResponsesNamed("token", "https://api.x.ai/v1", "xai").(*renamedClient)
130	151		c := named.inner.(*codexClient)


@@ -125,6 +125,27 @@ func TestGPT56UsesNativeMaxReasoningEffort(t *testing.T) {
125	}	125		}
126	}	126		}
127		127
		128	+	func TestResponsesRequestUsesExplicitReasoningLevelMap(t *testing.T) {
		129	+	SetLiveModels([]Model{{
		130	+	Provider: "custom-responses",
		131	+	ID: "reasoning-model",
		132	+	API: APIResponses,
		133	+	Reasoning: true,
		134	+	ReasoningLevelMap: map[string]string{"max": "max"},
		135	+	}})
		136	+	t.Cleanup(func() { SetLiveModels(nil) })
		137	+
		138	+	named := NewOpenAIResponsesNamed("token", "https://example.test/v1", "custom-responses").(*renamedClient)
		139	+	c := named.inner.(*codexClient)
		140	+	wire, err := c.buildRequest(Request{Model: "reasoning-model", Reasoning: "max"})
		141	+	if err != nil {
		142	+	t.Fatal(err)
		143	+	}
		144	+	if wire.Reasoning == nil \|\| wire.Reasoning.Effort != "max" {
		145	+	t.Fatalf("reasoning = %+v", wire.Reasoning)
		146	+	}
		147	+	}
		148	+
128	func TestXAIResponsesUsesNamedProviderCatalogAndEndpoint(t *testing.T) {	149		func TestXAIResponsesUsesNamedProviderCatalogAndEndpoint(t *testing.T) {
129	named := NewOpenAIResponsesNamed("token", "https://api.x.ai/v1", "xai").(*renamedClient)	150		named := NewOpenAIResponsesNamed("token", "https://api.x.ai/v1", "xai").(*renamedClient)
130	c := named.inner.(*codexClient)	151		c := named.inner.(*codexClient)

M packages/provider/reasoning.go +7 -5


@@ -5,8 +5,8 @@ import "strings"
5	5		var reasoningLevelOrder = []string{"", "minimum", "low", "medium", "high", "xhigh", "max"}
6	6
7	7		// AvailableReasoningLevels returns the distinct reasoning levels supported by
8		-	// a model. Protocol defaults are adjusted by optional per-model overrides. The
9		-	// empty string represents off.
	8	+	// a model. Optional per-model overrides can remove, remap, or extend protocol
	9	+	// defaults. The empty string represents off.
10	10		func AvailableReasoningLevels(model Model) []string {
11	11		defaults := defaultReasoningLevels(model)
12	12		if !model.Reasoning \|\| len(model.ReasoningLevelMap) == 0 {

@@ -24,9 +24,6 @@ func AvailableReasoningLevels(model Model) []string {
24	24		if mapped, overridden := model.ReasoningLevelMap[level]; overridden {
25	25		effective = NormalizeReasoning(mapped)
26	26		}
27		-	if effective != "" && !containsReasoningLevel(defaults, effective) {
28		-	effective = nearestReasoningLevel(defaults, effective)
29		-	}
30	27		if reasoningLevelRank(effective) > 0 {
31	28		available[effective] = true
32	29		}

@@ -90,6 +87,11 @@ func containsReasoningLevel(levels []string, target string) bool {
90	87		return false
91	88		}
92	89
	90	+	func hasReasoningLevelOverride(model Model, level string) bool {
	91	+	_, ok := model.ReasoningLevelMap[NormalizeReasoning(level)]
	92	+	return ok
	93	+	}
	94	+
93	95		// ClampReasoningForModel maps a configured level to the nearest level exposed
94	96		// for the active model. Ties prefer the higher level.
95	97		func ClampReasoningForModel(model Model, level string) string {

 var reasoningLevelOrder = []string{"", "minimum", "low", "medium", "high", "xhigh", "max"}
 // AvailableReasoningLevels returns the distinct reasoning levels supported by
-// a model. Protocol defaults are adjusted by optional per-model overrides. The
+// a model. Optional per-model overrides can remove, remap, or extend protocol
-// empty string represents off.
+// defaults. The empty string represents off.
 func AvailableReasoningLevels(model Model) []string {
 	defaults := defaultReasoningLevels(model)
 	if !model.Reasoning || len(model.ReasoningLevelMap) == 0 {
 		if mapped, overridden := model.ReasoningLevelMap[level]; overridden {
 			effective = NormalizeReasoning(mapped)
 		}
-		if effective != "" && !containsReasoningLevel(defaults, effective) {
-			effective = nearestReasoningLevel(defaults, effective)
-		}
 		if reasoningLevelRank(effective) > 0 {
 			available[effective] = true
 		}
 	return false
 }
+func hasReasoningLevelOverride(model Model, level string) bool {
+	_, ok := model.ReasoningLevelMap[NormalizeReasoning(level)]
+	return ok
+}
 // ClampReasoningForModel maps a configured level to the nearest level exposed
 // for the active model. Ties prefer the higher level.
 func ClampReasoningForModel(model Model, level string) string {

M packages/provider/reasoning_test.go +34 -10


@@ -29,7 +29,17 @@ func TestAvailableReasoningLevels(t *testing.T) {
29	29		Provider: "anthropic", Reasoning: true,
30	30		ReasoningLevelMap: map[string]string{"minimum": "low", "high": "", "max": "max"},
31	31		},
32		-	want: []string{"", "low", "medium", "xhigh"},
	32	+	want: []string{"", "low", "medium", "xhigh", "max"},
	33	+	},
	34	+	{
	35	+	name: "explicit levels extend generic defaults",
	36	+	model: Model{
	37	+	Provider: "custom", Reasoning: true,
	38	+	ReasoningLevelMap: map[string]string{
	39	+	"minimum": "", "low": "", "medium": "", "high": "high", "xhigh": "xhigh", "max": "max",
	40	+	},
	41	+	},
	42	+	want: []string{"", "high", "xhigh", "max"},
33	43		},
34	44		}
35	45		for _, tt := range tests {

@@ -59,6 +69,12 @@ func TestClampReasoningForModel(t *testing.T) {
59	69		level: "minimum",
60	70		want: "high",
61	71		},
	72	+	{
	73	+	name: "explicit max extends generic defaults",
	74	+	model: Model{Reasoning: true, ReasoningLevelMap: map[string]string{"max": "max"}},
	75	+	level: "max",
	76	+	want: "max",
	77	+	},
62	78		}
63	79		for _, tt := range tests {
64	80		t.Run(tt.name, func(t *testing.T) {

@@ -71,20 +87,28 @@ func TestClampReasoningForModel(t *testing.T) {
71	87
72	88		func TestOpenAIRequestUsesReasoningLevelMap(t *testing.T) {
73	89		SetLiveModels([]Model{{
74		-	Provider: "openai",
	90	+	Provider: "custom",
75	91		ID: "mapped-reasoning-model",
76	92		Reasoning: true,
77		-	ReasoningLevelMap: map[string]string{"high": "low"},
	93	+	ReasoningLevelMap: map[string]string{"high": "low", "max": "max"},
78	94		}})
79	95		t.Cleanup(func() { SetLiveModels(nil) })
80	96
81		-	client := NewOpenAI("test", "").(*openaiClient)
82		-	request, err := client.buildRequest(Request{Model: "mapped-reasoning-model", Reasoning: "high"})
83		-	if err != nil {
84		-	t.Fatal(err)
85		-	}
86		-	if request.ReasoningEffort != "low" {
87		-	t.Fatalf("reasoning effort = %q, want low", request.ReasoningEffort)
	97	+	client := NewOpenAICompat("custom", "test", "", "").(*openaiClient)
	98	+	for _, tt := range []struct {
	99	+	requested string
	100	+	want string
	101	+	}{
	102	+	{requested: "high", want: "low"},
	103	+	{requested: "max", want: "max"},
	104	+	} {
	105	+	request, err := client.buildRequest(Request{Model: "mapped-reasoning-model", Reasoning: tt.requested})
	106	+	if err != nil {
	107	+	t.Fatal(err)
	108	+	}
	109	+	if request.ReasoningEffort != tt.want {
	110	+	t.Errorf("reasoning effort for %q = %q, want %q", tt.requested, request.ReasoningEffort, tt.want)
	111	+	}
88	112		}
89	113		}
90	114

 				Provider: "anthropic", Reasoning: true,
 				ReasoningLevelMap: map[string]string{"minimum": "low", "high": "", "max": "max"},
 			},
-			want: []string{"", "low", "medium", "xhigh"},
+			want: []string{"", "low", "medium", "xhigh", "max"},
+		},
+		{
+			name: "explicit levels extend generic defaults",
+			model: Model{
+				Provider: "custom", Reasoning: true,
+				ReasoningLevelMap: map[string]string{
+					"minimum": "", "low": "", "medium": "", "high": "high", "xhigh": "xhigh", "max": "max",
+				},
+			},
+			want: []string{"", "high", "xhigh", "max"},
 		},
 	}
 	for _, tt := range tests {
 			level: "minimum",
 			want:  "high",
 		},
+		{
+			name:  "explicit max extends generic defaults",
+			model: Model{Reasoning: true, ReasoningLevelMap: map[string]string{"max": "max"}},
+			level: "max",
+			want:  "max",
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 func TestOpenAIRequestUsesReasoningLevelMap(t *testing.T) {
 	SetLiveModels([]Model{{
-		Provider:          "openai",
+		Provider:          "custom",
 		ID:                "mapped-reasoning-model",
 		Reasoning:         true,
-		ReasoningLevelMap: map[string]string{"high": "low"},
+		ReasoningLevelMap: map[string]string{"high": "low", "max": "max"},
 	}})
 	t.Cleanup(func() { SetLiveModels(nil) })
-	client := NewOpenAI("test", "").(*openaiClient)
+	client := NewOpenAICompat("custom", "test", "", "").(*openaiClient)
-	request, err := client.buildRequest(Request{Model: "mapped-reasoning-model", Reasoning: "high"})
+	for _, tt := range []struct {
-	if err != nil {
+		requested string
-		t.Fatal(err)
+		want      string
-	}
+	}{
-	if request.ReasoningEffort != "low" {
+		{requested: "high", want: "low"},
-		t.Fatalf("reasoning effort = %q, want low", request.ReasoningEffort)
+		{requested: "max", want: "max"},
+	} {
+		request, err := client.buildRequest(Request{Model: "mapped-reasoning-model", Reasoning: tt.requested})
+		if err != nil {
+			t.Fatal(err)
+		}
+		if request.ReasoningEffort != tt.want {
+			t.Errorf("reasoning effort for %q = %q, want %q", tt.requested, request.ReasoningEffort, tt.want)
+		}
 	}
 }