Add files via upload

internal/reasoning/eino.go

@@ -0,0 +1,428 @@
+// Package reasoning maps user/config intent to CloudWeGo Eino OpenAI ChatModel fields
+// (ReasoningEffort, ExtraFields such as thinking / reasoning_effort / output_config).
+package reasoning
+
+import (
+	"strings"
+
+	"cyberstrike-ai/internal/config"
+
+	einoopenai "github.com/cloudwego/eino-ext/components/model/openai"
+)
+
+// ClientIntent is optional per-request override from ChatRequest.reasoning.
+type ClientIntent struct {
+	Mode   string
+	Effort string
+}
+
+type wireProfile int
+
+const (
+	wireNone wireProfile = iota
+	wireClaude
+	wireDeepseek
+	wireOpenAI
+	wireOutputConfig
+)
+
+// ApplyPlanExecutePlannerModelConfig configures the plan_execute planner/replanner
+// ChatModel. Those Eino agents call WithToolChoice(Forced); several gateways reject
+// thinking / reasoning fields on the same request (tool_choice required/object).
+// Executor should keep the normal ApplyToEinoChatModelConfig path.
+func ApplyPlanExecutePlannerModelConfig(cfg *einoopenai.ChatModelConfig, oa *config.OpenAIConfig) {
+	if cfg == nil || oa == nil {
+		return
+	}
+	mergeExtraRequestFields(cfg, oa.Reasoning.ExtraRequestFields)
+	clearReasoningFromChatModelConfig(cfg)
+	if resolveWireProfile(oa, &oa.Reasoning) == wireDeepseek || oa.IsDeepSeekEndpointOrModel() {
+		// DeepSeek enables thinking by default, so omission would not actually
+		// disable it for the planner's forced tool-choice requests.
+		applyThinkingDisabled(cfg)
+	}
+}
+
+func clearReasoningFromChatModelConfig(cfg *einoopenai.ChatModelConfig) {
+	if cfg == nil {
+		return
+	}
+	cfg.ReasoningEffort = ""
+	if cfg.ExtraFields != nil {
+		for _, key := range []string{"thinking", "reasoning_effort", "output_config", "reasoning"} {
+			delete(cfg.ExtraFields, key)
+		}
+		if len(cfg.ExtraFields) == 0 {
+			cfg.ExtraFields = nil
+		}
+	}
+}
+
+func mergeExtraRequestFields(cfg *einoopenai.ChatModelConfig, fields map[string]interface{}) {
+	if cfg == nil || len(fields) == 0 {
+		return
+	}
+	if cfg.ExtraFields == nil {
+		cfg.ExtraFields = make(map[string]any, len(fields))
+	}
+	for k, v := range fields {
+		cfg.ExtraFields[k] = v
+	}
+}
+
+// ApplyToEinoChatModelConfig merges reasoning-related options into cfg.
+// Precondition: cfg already has APIKey, BaseURL, Model, HTTPClient set.
+func ApplyToEinoChatModelConfig(cfg *einoopenai.ChatModelConfig, oa *config.OpenAIConfig, client *ClientIntent) {
+	if cfg == nil || oa == nil {
+		return
+	}
+	sr := &oa.Reasoning
+	allowClient := sr.AllowClientReasoningEffective()
+	mode := effectiveMode(sr, client, allowClient)
+
+	// Admin-defined root fields are independent of the selected reasoning wire
+	// profile. Merge them first so mode=off can remove only reasoning controls
+	// while preserving unrelated gateway options.
+	mergeExtraRequestFields(cfg, sr.ExtraRequestFields)
+	if mode == "off" {
+		clearReasoningFromChatModelConfig(cfg)
+		// Strict OpenAI endpoints reject unknown `thinking` fields, whereas the
+		// DeepSeek API enables thinking by default and requires an explicit
+		// thinking.type=disabled switch. Detect the actual DeepSeek target even
+		// when the configured reasoning profile was left as openai_compat.
+		if resolveWireProfile(oa, sr) == wireDeepseek || oa.IsDeepSeekEndpointOrModel() {
+			applyThinkingDisabled(cfg)
+		}
+		return
+	}
+
+	// Claude (Anthropic): merge admin extras first; optional extended thinking maps to top-level `thinking`
+	// (see internal/openai convertOpenAIToClaude). DeepSeek/OpenAI-style fields are not sent.
+	if strings.EqualFold(strings.TrimSpace(oa.Provider), "claude") ||
+		strings.EqualFold(strings.TrimSpace(oa.Provider), "anthropic") {
+		applyClaudeExtendedThinking(cfg, mode, effectiveEffort(sr, client, allowClient), oa.Model)
+		return
+	}
+
+	effort := effectiveEffort(sr, client, allowClient)
+	prof := resolveWireProfile(oa, sr)
+
+	switch prof {
+	case wireClaude, wireNone:
+		return
+	case wireDeepseek:
+		applyDeepseek(cfg, mode, effort)
+	case wireOutputConfig:
+		applyOutputConfigEffort(cfg, mode, effort)
+	default: // wireOpenAI
+		applyOpenAICompat(cfg, mode, effort)
+	}
+}
+
+// AgenticOpenAIExtraFields returns reasoning-related request fields for
+// agenticopenai.ChatConfig. The agentic chat backend currently exposes provider
+// extensions through ExtraFields instead of typed ReasoningEffort fields.
+func AgenticOpenAIExtraFields(oa *config.OpenAIConfig, client *ClientIntent) map[string]any {
+	if oa == nil {
+		return nil
+	}
+	sr := &oa.Reasoning
+	allowClient := sr.AllowClientReasoningEffective()
+	mode := effectiveMode(sr, client, allowClient)
+	fields := cloneExtraRequestFields(sr.ExtraRequestFields)
+	if mode == "off" {
+		clearReasoningExtraFields(fields)
+		if resolveWireProfile(oa, sr) == wireDeepseek || oa.IsDeepSeekEndpointOrModel() {
+			if fields == nil {
+				fields = make(map[string]any)
+			}
+			fields["thinking"] = map[string]any{"type": "disabled"}
+		}
+		return fields
+	}
+	if strings.EqualFold(strings.TrimSpace(oa.Provider), "claude") ||
+		strings.EqualFold(strings.TrimSpace(oa.Provider), "anthropic") {
+		return fields
+	}
+	effort := effectiveEffort(sr, client, allowClient)
+	switch resolveWireProfile(oa, sr) {
+	case wireDeepseek:
+		if mode == "auto" || mode == "on" {
+			if fields == nil {
+				fields = make(map[string]any)
+			}
+			fields["thinking"] = map[string]any{"type": "enabled"}
+		}
+		if effort != "" {
+			if fields == nil {
+				fields = make(map[string]any)
+			}
+			fields["reasoning_effort"] = effortStringForAPI(effort)
+		}
+	case wireOutputConfig:
+		e := effort
+		if mode == "on" && e == "" {
+			e = "high"
+		}
+		if e != "" {
+			if fields == nil {
+				fields = make(map[string]any)
+			}
+			fields["output_config"] = map[string]any{"effort": effortStringForAPI(e)}
+		}
+	default:
+		e := effort
+		if mode == "on" && e == "" {
+			e = "medium"
+		}
+		if e != "" {
+			if fields == nil {
+				fields = make(map[string]any)
+			}
+			fields["reasoning_effort"] = effortStringForAPI(e)
+		}
+	}
+	return fields
+}
+
+// AgenticOpenAIPlannerExtraFields mirrors ApplyPlanExecutePlannerModelConfig for
+// agenticopenai.ChatConfig: keep admin extras, strip reasoning controls, and
+// explicitly disable DeepSeek thinking where omission would still think.
+func AgenticOpenAIPlannerExtraFields(oa *config.OpenAIConfig) map[string]any {
+	if oa == nil {
+		return nil
+	}
+	fields := cloneExtraRequestFields(oa.Reasoning.ExtraRequestFields)
+	clearReasoningExtraFields(fields)
+	if resolveWireProfile(oa, &oa.Reasoning) == wireDeepseek || oa.IsDeepSeekEndpointOrModel() {
+		if fields == nil {
+			fields = make(map[string]any)
+		}
+		fields["thinking"] = map[string]any{"type": "disabled"}
+	}
+	return fields
+}
+
+func cloneExtraRequestFields(fields map[string]interface{}) map[string]any {
+	if len(fields) == 0 {
+		return nil
+	}
+	out := make(map[string]any, len(fields))
+	for k, v := range fields {
+		out[k] = v
+	}
+	return out
+}
+
+func clearReasoningExtraFields(fields map[string]any) {
+	for _, key := range []string{"thinking", "reasoning_effort", "output_config", "reasoning"} {
+		delete(fields, key)
+	}
+}
+
+// applyClaudeExtendedThinking sets Anthropic Messages API fields per official guidance:
+//   - Adaptive models (4.6+): thinking.type=adaptive; output_config.effort only when user sets effort (API default is high).
+//   - Sonnet 3.7: thinking.type=enabled + budget_tokens=10000 (doc example); effort is not mapped — use extra_request_fields for custom budget.
+func applyClaudeExtendedThinking(cfg *einoopenai.ChatModelConfig, mode, effort, model string) {
+	if cfg == nil || mode == "off" {
+		return
+	}
+	if cfg.ExtraFields == nil {
+		cfg.ExtraFields = make(map[string]any)
+	}
+	m := strings.ToLower(strings.TrimSpace(model))
+	sonnet37 := isClaudeSonnet37(m)
+
+	if _, exists := cfg.ExtraFields["thinking"]; !exists {
+		cfg.ExtraFields["thinking"] = claudeThinkingForModel(m, sonnet37)
+	}
+
+	applyClaudeOutputConfigEffort(cfg, effort, sonnet37)
+}
+
+// claudeSonnet37DefaultBudgetTokens matches Anthropic extended-thinking documentation examples (budget_tokens with max_tokens 16000).
+const claudeSonnet37DefaultBudgetTokens = 10000
+
+func isClaudeSonnet37(m string) bool {
+	return strings.Contains(m, "claude-3-7-sonnet") ||
+		strings.Contains(m, "3-7-sonnet") ||
+		strings.Contains(m, "sonnet-3.7")
+}
+
+func claudeThinkingForModel(m string, sonnet37 bool) map[string]any {
+	if sonnet37 {
+		return map[string]any{
+			"type":          "enabled",
+			"budget_tokens": claudeSonnet37DefaultBudgetTokens,
+			"display":       "summarized",
+		}
+	}
+	// Opus 4.7+: manual enabled+budget rejected — adaptive only.
+	if strings.Contains(m, "opus-4-7") || strings.Contains(m, "opus-4.7") {
+		return map[string]any{
+			"type":    "adaptive",
+			"display": "summarized",
+		}
+	}
+	return map[string]any{
+		"type":    "adaptive",
+		"display": "summarized",
+	}
+}
+
+// applyClaudeOutputConfigEffort sets top-level output_config.effort only when effort is explicitly configured.
+// Omitted effort uses the API default (high); do not inject effort on mode:on alone.
+func applyClaudeOutputConfigEffort(cfg *einoopenai.ChatModelConfig, effort string, sonnet37 bool) {
+	if cfg == nil || sonnet37 {
+		return
+	}
+	if _, exists := cfg.ExtraFields["output_config"]; exists {
+		return
+	}
+	e := effortStringForAPI(effort)
+	if e == "" {
+		return
+	}
+	cfg.ExtraFields["output_config"] = map[string]any{"effort": e}
+}
+
+func effectiveMode(sr *config.OpenAIReasoningConfig, client *ClientIntent, allowClient bool) string {
+	server := strings.ToLower(strings.TrimSpace(sr.ModeEffective()))
+	if server == "" || server == "default" {
+		server = "auto"
+	}
+	if !allowClient || client == nil {
+		return server
+	}
+	cm := strings.ToLower(strings.TrimSpace(client.Mode))
+	if cm == "" || cm == "default" {
+		return server
+	}
+	return cm
+}
+
+func effectiveEffort(sr *config.OpenAIReasoningConfig, client *ClientIntent, allowClient bool) string {
+	se := normalizeEffort(sr.Effort)
+	if !allowClient || client == nil {
+		return se
+	}
+	ce := normalizeEffort(client.Effort)
+	if ce != "" {
+		return ce
+	}
+	return se
+}
+
+func normalizeEffort(s string) string {
+	e := strings.ToLower(strings.TrimSpace(s))
+	switch e {
+	case "low", "medium", "high", "max", "xhigh":
+		return e
+	default:
+		return ""
+	}
+}
+
+// usesExtraFieldsReasoningEffort 为 Eino 无枚举的最高档 effort，经 ExtraFields 原样下发（max / xhigh 由网关自行识别，不做互转）。
+func usesExtraFieldsReasoningEffort(e string) bool {
+	return e == "max" || e == "xhigh"
+}
+
+func resolveWireProfile(oa *config.OpenAIConfig, sr *config.OpenAIReasoningConfig) wireProfile {
+	provider := strings.TrimSpace(oa.Provider)
+	if strings.EqualFold(provider, "claude") || strings.EqualFold(provider, "anthropic") {
+		return wireClaude
+	}
+	p := strings.ToLower(strings.TrimSpace(sr.ProfileEffective()))
+	switch p {
+	case "output_config", "output_config_effort":
+		return wireOutputConfig
+	case "openai", "openai_compat":
+		return wireOpenAI
+	case "deepseek", "deepseek_compat":
+		return wireDeepseek
+	case "auto", "":
+		if oa.IsDeepSeekEndpointOrModel() {
+			return wireDeepseek
+		}
+		return wireOpenAI
+	default:
+		return wireOpenAI
+	}
+}
+
+func applyThinkingDisabled(cfg *einoopenai.ChatModelConfig) {
+	if cfg == nil {
+		return
+	}
+	if cfg.ExtraFields == nil {
+		cfg.ExtraFields = make(map[string]any)
+	}
+	cfg.ExtraFields["thinking"] = map[string]any{"type": "disabled"}
+}
+
+func applyDeepseek(cfg *einoopenai.ChatModelConfig, mode, effort string) {
+	// auto: enable thinking for DeepSeek line; on: same; auto without effort still opens thinking.
+	if mode == "auto" || mode == "on" {
+		if cfg.ExtraFields == nil {
+			cfg.ExtraFields = make(map[string]any)
+		}
+		cfg.ExtraFields["thinking"] = map[string]any{"type": "enabled"}
+	}
+	if effort != "" {
+		if cfg.ExtraFields == nil {
+			cfg.ExtraFields = make(map[string]any)
+		}
+		cfg.ExtraFields["reasoning_effort"] = effortStringForAPI(effort)
+	}
+}
+
+func applyOpenAICompat(cfg *einoopenai.ChatModelConfig, mode, effort string) {
+	if mode == "auto" && effort == "" {
+		return
+	}
+	e := effort
+	if mode == "on" && e == "" {
+		e = "medium"
+	}
+	if e == "" {
+		return
+	}
+	if usesExtraFieldsReasoningEffort(e) {
+		if cfg.ExtraFields == nil {
+			cfg.ExtraFields = make(map[string]any)
+		}
+		cfg.ExtraFields["reasoning_effort"] = effortStringForAPI(e)
+		return
+	}
+	switch e {
+	case "low":
+		cfg.ReasoningEffort = einoopenai.ReasoningEffortLevelLow
+	case "medium":
+		cfg.ReasoningEffort = einoopenai.ReasoningEffortLevelMedium
+	case "high":
+		cfg.ReasoningEffort = einoopenai.ReasoningEffortLevelHigh
+	}
+}
+
+func applyOutputConfigEffort(cfg *einoopenai.ChatModelConfig, mode, effort string) {
+	if mode == "auto" && effort == "" {
+		return
+	}
+	e := effort
+	if mode == "on" && e == "" {
+		e = "high"
+	}
+	if e == "" {
+		return
+	}
+	if cfg.ExtraFields == nil {
+		cfg.ExtraFields = make(map[string]any)
+	}
+	cfg.ExtraFields["output_config"] = map[string]any{"effort": effortStringForAPI(e)}
+}
+
+func effortStringForAPI(e string) string {
+	// 原样透传：OpenAI 官方多为 xhigh，部分兼容网关为 max，由配置/对话 effort 选择。
+	return strings.ToLower(strings.TrimSpace(e))
+}

internal/reasoning/eino_test.go

@@ -0,0 +1,424 @@
+package reasoning
+
+import (
+	"context"
+	"encoding/json"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"cyberstrike-ai/internal/config"
+
+	einoopenai "github.com/cloudwego/eino-ext/components/model/openai"
+	"github.com/cloudwego/eino/schema"
+)
+
+var reasoningPayloadKeysForTest = []string{"thinking", "reasoning_effort", "output_config", "reasoning"}
+
+func assertNoReasoningFields(t *testing.T, cfg *einoopenai.ChatModelConfig) {
+	t.Helper()
+	if cfg.ReasoningEffort != "" {
+		t.Fatalf("expected ReasoningEffort omitted, got %q", cfg.ReasoningEffort)
+	}
+	for _, key := range reasoningPayloadKeysForTest {
+		if _, ok := cfg.ExtraFields[key]; ok {
+			t.Fatalf("expected %q omitted, got %#v", key, cfg.ExtraFields)
+		}
+	}
+}
+
+func TestEffortStringForAPI_passthrough(t *testing.T) {
+	cases := map[string]string{
+		"max":    "max",
+		"xhigh":  "xhigh",
+		"HIGH":   "high",
+		"Medium": "medium",
+	}
+	for in, want := range cases {
+		if got := effortStringForAPI(in); got != want {
+			t.Fatalf("%q -> %q, want %q", in, got, want)
+		}
+	}
+}
+
+func TestNormalizeEffort_maxAndXhigh(t *testing.T) {
+	if normalizeEffort("xhigh") != "xhigh" {
+		t.Fatal("xhigh not accepted")
+	}
+	if normalizeEffort("max") != "max" {
+		t.Fatal("max not accepted")
+	}
+}
+
+func TestApplyOpenAICompat_xhighExtraField(t *testing.T) {
+	cfg := &einoopenai.ChatModelConfig{}
+	oa := &config.OpenAIConfig{
+		Reasoning: config.OpenAIReasoningConfig{
+			Profile: "openai_compat",
+			Mode:    "on",
+			Effort:  "xhigh",
+		},
+	}
+	ApplyToEinoChatModelConfig(cfg, oa, nil)
+	if cfg.ExtraFields == nil {
+		t.Fatal("expected ExtraFields")
+	}
+	if got, _ := cfg.ExtraFields["reasoning_effort"].(string); got != "xhigh" {
+		t.Fatalf("reasoning_effort=%q", got)
+	}
+}
+
+func TestAgenticOpenAIExtraFields_openAICompatReasoningEffort(t *testing.T) {
+	oa := &config.OpenAIConfig{
+		Reasoning: config.OpenAIReasoningConfig{
+			Profile: "openai_compat",
+			Mode:    "on",
+			Effort:  "high",
+			ExtraRequestFields: map[string]interface{}{
+				"vendor_option": true,
+			},
+		},
+	}
+	got := AgenticOpenAIExtraFields(oa, nil)
+	if got["reasoning_effort"] != "high" {
+		t.Fatalf("reasoning_effort=%#v, want high in %#v", got["reasoning_effort"], got)
+	}
+	if got["vendor_option"] != true {
+		t.Fatalf("vendor option not preserved: %#v", got)
+	}
+}
+
+func TestAgenticOpenAIExtraFields_reasoningOffPreservesUnrelatedFields(t *testing.T) {
+	oa := &config.OpenAIConfig{
+		Model: "gpt-4o-mini",
+		Reasoning: config.OpenAIReasoningConfig{
+			Profile: "openai_compat",
+			Mode:    "off",
+			Effort:  "high",
+			ExtraRequestFields: map[string]interface{}{
+				"reasoning_effort": "high",
+				"thinking":         map[string]any{"type": "enabled"},
+				"vendor_option":    true,
+			},
+		},
+	}
+	got := AgenticOpenAIExtraFields(oa, nil)
+	for _, key := range reasoningPayloadKeysForTest {
+		if _, ok := got[key]; ok {
+			t.Fatalf("agentic fields unexpectedly contain %q: %#v", key, got)
+		}
+	}
+	if got["vendor_option"] != true {
+		t.Fatalf("vendor option not preserved: %#v", got)
+	}
+}
+
+func TestAgenticOpenAIPlannerExtraFields_deepseekDisablesThinking(t *testing.T) {
+	oa := &config.OpenAIConfig{
+		BaseURL: "https://api.deepseek.com",
+		Model:   "deepseek-chat",
+		Reasoning: config.OpenAIReasoningConfig{
+			Profile: "auto",
+			Mode:    "on",
+			ExtraRequestFields: map[string]interface{}{
+				"reasoning_effort": "high",
+				"vendor_option":    true,
+			},
+		},
+	}
+	got := AgenticOpenAIPlannerExtraFields(oa)
+	if got["reasoning_effort"] != nil {
+		t.Fatalf("planner should strip reasoning_effort: %#v", got)
+	}
+	thinking, ok := got["thinking"].(map[string]any)
+	if !ok || thinking["type"] != "disabled" {
+		t.Fatalf("expected deepseek thinking disabled, got %#v", got)
+	}
+	if got["vendor_option"] != true {
+		t.Fatalf("vendor option not preserved: %#v", got)
+	}
+}
+
+func TestAgenticOpenAIPlannerExtraFields_deepseekEndpointWinsOverOpenAIProfile(t *testing.T) {
+	oa := &config.OpenAIConfig{
+		BaseURL: "https://api.deepseek.com/v1",
+		Model:   "deepseek-v4-flash",
+		Reasoning: config.OpenAIReasoningConfig{
+			Profile: "openai_compat",
+			Mode:    "on",
+			Effort:  "high",
+			ExtraRequestFields: map[string]interface{}{
+				"reasoning_effort": "high",
+				"vendor_option":    true,
+			},
+		},
+	}
+	got := AgenticOpenAIPlannerExtraFields(oa)
+	if _, ok := got["reasoning_effort"]; ok {
+		t.Fatalf("planner should strip reasoning_effort: %#v", got)
+	}
+	thinking, ok := got["thinking"].(map[string]any)
+	if !ok || thinking["type"] != "disabled" {
+		t.Fatalf("expected deepseek thinking disabled despite openai_compat profile, got %#v", got)
+	}
+	if got["vendor_option"] != true {
+		t.Fatalf("vendor option not preserved: %#v", got)
+	}
+}
+
+func TestApplyPlanExecutePlannerModelConfig_stripsReasoningWhenGlobalOn(t *testing.T) {
+	cfg := &einoopenai.ChatModelConfig{ExtraFields: map[string]any{
+		"thinking":         map[string]any{"type": "enabled"},
+		"reasoning_effort": "high",
+		"vendor_option":    true,
+	}}
+	oa := &config.OpenAIConfig{
+		BaseURL: "https://antchat.example.com/v1",
+		Model:   "minimax-m3",
+		Reasoning: config.OpenAIReasoningConfig{
+			Profile: "openai_compat",
+			Mode:    "on",
+			Effort:  "high",
+		},
+	}
+	ApplyPlanExecutePlannerModelConfig(cfg, oa)
+	assertNoReasoningFields(t, cfg)
+	if cfg.ExtraFields["vendor_option"] != true {
+		t.Fatalf("expected unrelated extra field preserved, got %#v", cfg.ExtraFields)
+	}
+}
+
+func TestApplyPlanExecutePlannerModelConfig_deepseekEndpointWinsOverOpenAIProfile(t *testing.T) {
+	cfg := &einoopenai.ChatModelConfig{ExtraFields: map[string]any{
+		"thinking":         map[string]any{"type": "enabled"},
+		"reasoning_effort": "high",
+		"vendor_option":    true,
+	}}
+	oa := &config.OpenAIConfig{
+		BaseURL: "https://api.deepseek.com/v1",
+		Model:   "deepseek-v4-flash",
+		Reasoning: config.OpenAIReasoningConfig{
+			Profile: "openai_compat",
+			Mode:    "on",
+			Effort:  "high",
+		},
+	}
+	ApplyPlanExecutePlannerModelConfig(cfg, oa)
+	if cfg.ReasoningEffort != "" {
+		t.Fatalf("expected ReasoningEffort omitted, got %q", cfg.ReasoningEffort)
+	}
+	if _, ok := cfg.ExtraFields["reasoning_effort"]; ok {
+		t.Fatalf("expected reasoning_effort omitted, got %#v", cfg.ExtraFields)
+	}
+	thinking, ok := cfg.ExtraFields["thinking"].(map[string]any)
+	if !ok || thinking["type"] != "disabled" {
+		t.Fatalf("expected deepseek thinking disabled despite openai_compat profile, got %#v", cfg.ExtraFields)
+	}
+	if cfg.ExtraFields["vendor_option"] != true {
+		t.Fatalf("expected unrelated extra field preserved, got %#v", cfg.ExtraFields)
+	}
+}
+
+func TestApplyReasoningOff_omitsAllReasoningFields(t *testing.T) {
+	cfg := &einoopenai.ChatModelConfig{ExtraFields: map[string]any{
+		"thinking":      map[string]any{"type": "enabled"},
+		"output_config": map[string]any{"effort": "high"},
+	}}
+	oa := &config.OpenAIConfig{
+		BaseURL: "https://api.openai.com/v1",
+		Model:   "gpt-4o-mini",
+		Reasoning: config.OpenAIReasoningConfig{
+			Mode:    "off",
+			Effort:  "high",
+			Profile: "openai_compat",
+			ExtraRequestFields: map[string]interface{}{
+				"thinking":      map[string]any{"type": "disabled"},
+				"reasoning":     map[string]any{"effort": "high"},
+				"vendor_option": true,
+			},
+		},
+	}
+	ApplyToEinoChatModelConfig(cfg, oa, nil)
+	assertNoReasoningFields(t, cfg)
+	if cfg.ExtraFields["vendor_option"] != true {
+		t.Fatalf("expected unrelated extra field preserved, got %#v", cfg.ExtraFields)
+	}
+}
+
+func TestApplyReasoningOff_clientOverrideOmit(t *testing.T) {
+	cfg := &einoopenai.ChatModelConfig{}
+	oa := &config.OpenAIConfig{Reasoning: config.OpenAIReasoningConfig{
+		Mode: "on", Effort: "high", Profile: "openai_compat",
+	}}
+	ApplyToEinoChatModelConfig(cfg, oa, &ClientIntent{Mode: "off", Effort: "high"})
+	assertNoReasoningFields(t, cfg)
+}
+
+func TestApplyReasoningOff_deepseekExplicitlyDisablesDefaultThinking(t *testing.T) {
+	for _, profile := range []string{"deepseek_compat", "auto", "openai_compat"} {
+		t.Run(profile, func(t *testing.T) {
+			cfg := &einoopenai.ChatModelConfig{ExtraFields: map[string]any{
+				"reasoning_effort": "high",
+				"vendor_option":    true,
+			}}
+			oa := &config.OpenAIConfig{
+				BaseURL: "https://api.deepseek.com",
+				Model:   "deepseek-v4-pro",
+				Reasoning: config.OpenAIReasoningConfig{
+					Mode: "off", Effort: "high", Profile: profile,
+				},
+			}
+			ApplyToEinoChatModelConfig(cfg, oa, nil)
+			if cfg.ReasoningEffort != "" {
+				t.Fatalf("expected ReasoningEffort omitted, got %q", cfg.ReasoningEffort)
+			}
+			if _, ok := cfg.ExtraFields["reasoning_effort"]; ok {
+				t.Fatalf("expected reasoning_effort omitted, got %#v", cfg.ExtraFields)
+			}
+			thinking, ok := cfg.ExtraFields["thinking"].(map[string]any)
+			if !ok || thinking["type"] != "disabled" {
+				t.Fatalf("expected DeepSeek thinking disabled, got %#v", cfg.ExtraFields)
+			}
+			if cfg.ExtraFields["vendor_option"] != true {
+				t.Fatalf("expected unrelated extra field preserved, got %#v", cfg.ExtraFields)
+			}
+		})
+	}
+}
+
+func TestApplyReasoningOff_wirePayloadOmitsThinking(t *testing.T) {
+	var requestBody map[string]any
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		defer r.Body.Close()
+		body, err := io.ReadAll(r.Body)
+		if err != nil {
+			t.Errorf("read request body: %v", err)
+		}
+		if err := json.Unmarshal(body, &requestBody); err != nil {
+			t.Errorf("decode request body: %v; body=%s", err, body)
+		}
+		w.Header().Set("Content-Type", "application/json")
+		_, _ = io.WriteString(w, `{"id":"chatcmpl-test","object":"chat.completion","created":1,"model":"gpt-4o-mini","choices":[{"index":0,"message":{"role":"assistant","content":"ok"},"finish_reason":"stop"}],"usage":{"prompt_tokens":1,"completion_tokens":1,"total_tokens":2}}`)
+	}))
+	defer srv.Close()
+
+	cfg := &einoopenai.ChatModelConfig{
+		APIKey:  "test-key",
+		BaseURL: srv.URL,
+		Model:   "gpt-4o-mini",
+	}
+	oa := &config.OpenAIConfig{
+		BaseURL: "https://api.openai.com/v1",
+		Model:   "gpt-4o-mini",
+		Reasoning: config.OpenAIReasoningConfig{
+			Mode: "off", Effort: "high", Profile: "openai_compat",
+		},
+	}
+	ApplyToEinoChatModelConfig(cfg, oa, nil)
+	model, err := einoopenai.NewChatModel(context.Background(), cfg)
+	if err != nil {
+		t.Fatalf("new chat model: %v", err)
+	}
+	if _, err := model.Generate(context.Background(), []*schema.Message{schema.UserMessage("hello")}); err != nil {
+		t.Fatalf("generate: %v", err)
+	}
+	for _, key := range reasoningPayloadKeysForTest {
+		if _, ok := requestBody[key]; ok {
+			t.Fatalf("wire payload unexpectedly contains %q: %#v", key, requestBody)
+		}
+	}
+}
+
+func TestApplyOpenAICompat_maxPassthrough(t *testing.T) {
+	cfg := &einoopenai.ChatModelConfig{}
+	oa := &config.OpenAIConfig{
+		Reasoning: config.OpenAIReasoningConfig{
+			Profile: "openai_compat",
+			Mode:    "on",
+			Effort:  "max",
+		},
+	}
+	ApplyToEinoChatModelConfig(cfg, oa, nil)
+	got, _ := cfg.ExtraFields["reasoning_effort"].(string)
+	if got != "max" {
+		t.Fatalf("max effort wire=%q, want max", got)
+	}
+}
+
+func TestApplyClaude_adaptiveOutputConfigEffort(t *testing.T) {
+	cfg := &einoopenai.ChatModelConfig{}
+	oa := &config.OpenAIConfig{
+		Provider: "claude",
+		Model:    "claude-opus-4-8",
+		Reasoning: config.OpenAIReasoningConfig{
+			Mode:   "on",
+			Effort: "xhigh",
+		},
+	}
+	ApplyToEinoChatModelConfig(cfg, oa, nil)
+	th, ok := cfg.ExtraFields["thinking"].(map[string]any)
+	if !ok || th["type"] != "adaptive" {
+		t.Fatalf("thinking=%#v", cfg.ExtraFields["thinking"])
+	}
+	oc, ok := cfg.ExtraFields["output_config"].(map[string]any)
+	if !ok {
+		t.Fatal("expected output_config")
+	}
+	if oc["effort"] != "xhigh" {
+		t.Fatalf("effort=%v", oc["effort"])
+	}
+}
+
+func TestApplyClaude_sonnet37OfficialBudget(t *testing.T) {
+	cfg := &einoopenai.ChatModelConfig{}
+	oa := &config.OpenAIConfig{
+		Provider: "claude",
+		Model:    "claude-3-7-sonnet-latest",
+		Reasoning: config.OpenAIReasoningConfig{
+			Mode:   "on",
+			Effort: "low", // 3.7 has no output_config.effort; effort is not mapped to budget_tokens
+		},
+	}
+	ApplyToEinoChatModelConfig(cfg, oa, nil)
+	th, ok := cfg.ExtraFields["thinking"].(map[string]any)
+	if !ok || th["type"] != "enabled" {
+		t.Fatalf("thinking=%#v", cfg.ExtraFields["thinking"])
+	}
+	if th["budget_tokens"] != claudeSonnet37DefaultBudgetTokens {
+		t.Fatalf("budget_tokens=%v, want official example %d", th["budget_tokens"], claudeSonnet37DefaultBudgetTokens)
+	}
+	if _, hasOC := cfg.ExtraFields["output_config"]; hasOC {
+		t.Fatal("sonnet 3.7 should not set output_config")
+	}
+}
+
+func TestApplyClaude_onWithoutEffortOmitsOutputConfig(t *testing.T) {
+	cfg := &einoopenai.ChatModelConfig{}
+	oa := &config.OpenAIConfig{
+		Provider: "claude",
+		Model:    "claude-sonnet-4-6",
+		Reasoning: config.OpenAIReasoningConfig{
+			Mode: "on",
+		},
+	}
+	ApplyToEinoChatModelConfig(cfg, oa, nil)
+	if _, hasOC := cfg.ExtraFields["output_config"]; hasOC {
+		t.Fatal("on without explicit effort should omit output_config (API default high)")
+	}
+}
+
+func TestApplyClaude_autoWithoutEffortSkipsOutputConfig(t *testing.T) {
+	cfg := &einoopenai.ChatModelConfig{}
+	oa := &config.OpenAIConfig{
+		Provider: "claude",
+		Model:    "claude-sonnet-4-6",
+		Reasoning: config.OpenAIReasoningConfig{
+			Mode: "auto",
+		},
+	}
+	ApplyToEinoChatModelConfig(cfg, oa, nil)
+	if _, hasOC := cfg.ExtraFields["output_config"]; hasOC {
+		t.Fatal("auto without effort should omit output_config")
+	}
+}