feat(channel): OpenAI 兼容渠道支持双向推理字段改名开关

README.md

@@ -58,6 +58,7 @@ Your application only needs one base URL and one AccessKey. Providers, accounts,
 - **One mechanism for API keys and subscriptions** — Codex, Claude, Antigravity, Grok, and API-key channels share credential management, scheduling, and health handling.
 - **Scheduling and failure isolation built in** — Multi-credential scheduling, configurable weights, retries, cooldown, blacklisting, and session affinity reduce the impact of overloaded or failing credentials.
 - **Observable, self-hosted, and simple to deploy** — Inspect health, routes, logs, usage, and cost estimates in an embedded UI backed by SQLite, MySQL, or PostgreSQL with local credential encryption.
+- **Upstream/downstream compatibility** — OpenAI-compatible channels emit both reasoning field spellings (`reasoning` and `reasoning_content`) in responses so any client can read thinking output, and rename the spelling in outbound requests to match what the upstream expects, so thinking content is never silently lost on either side.
 
 ## Quick start
 

README_CN.md

@@ -58,6 +58,7 @@
 - **统一管理 API Key 与订阅账号** — Codex、Claude、Antigravity、Grok 等订阅渠道与 API Key 渠道共享凭据管理、调度和健康体系。
 - **内置调度与故障隔离** — 多凭据调度、可配置权重、重试、冷却、黑名单与会话亲和，降低单个凭据过载或失效的影响。
 - **可观测、易部署、数据自持** — 提供健康、路由、日志、用量与成本估算；单个 Go 二进制内嵌管理界面，支持 SQLite、MySQL、PostgreSQL 和本地凭据加密。
+- **上下游兼容适配** — OpenAI 兼容渠道在响应中同时输出 `reasoning` 与 `reasoning_content` 两种推理字段拼写，让任意客户端都能读到思考内容；出站请求则按上游所需拼写改名，消除上下游各认一种拼写导致的思考内容丢失与上下文退化。
 
 ## 快速开始
 

README_JP.md

@@ -58,6 +58,7 @@ API キー、サブスクリプションアカウント、トラフィック制
 - **API キーとサブスクリプションを統一管理** — Codex、Claude、Antigravity、Grok と API キーチャネルで、認証情報管理・スケジューリング・健全性管理を共通化します。
 - **スケジューリングと障害分離を内蔵** — 複数認証情報のスケジューリング、設定可能なウェイト、リトライ、クールダウン、ブラックリスト、セッションアフィニティにより、過負荷や失効の影響を抑えます。
 - **可観測で導入しやすく、データを自己管理** — 健全性、ルート、ログ、使用量、コスト概算を確認でき、SQLite、MySQL、PostgreSQL とローカル認証情報暗号化を単一バイナリで利用できます。
+- **上流・下流の互換性アダプテーション** — OpenAI 互換チャネルはレスポンスで推論フィールド `reasoning` と `reasoning_content` の両表記を出力して任意のクライアントでの表示を保証し、送信リクエストでは上流が必要とする表記にリネームでき、表記の違いによる思考出力の欠落や文脈の劣化を解消します。
 
 ## クイックスタート
 

internal/channel/channel.go

@@ -54,13 +54,15 @@ const (
 	InputText   = spec.InputText
 	InputURL    = spec.InputURL
 	InputSecret = spec.InputSecret
+	InputSelect = spec.InputSelect
 )
 
 // FieldDescriptor is the public, value-free schema for one channel field.
 type FieldDescriptor struct {
 	Key          string    `json:"key"`
 	Label        string    `json:"label"`
 	InputKind    InputKind `json:"input_kind"`
+	Options      []string  `json:"options,omitempty"`
 	Required     bool      `json:"required"`
 	Sensitive    bool      `json:"sensitive"`
 	DefaultValue *string   `json:"default_value"`
@@ -739,7 +741,7 @@ func validateDefinition(definition definition) error {
 		seen := make(map[string]struct{}, len(schema))
 		for _, field := range schema {
 			key := field.descriptor.Key
-			if key == "" || field.normalize == nil || (field.descriptor.InputKind != InputText && field.descriptor.InputKind != InputURL && field.descriptor.InputKind != InputSecret) {
+			if key == "" || field.normalize == nil || !field.descriptor.InputKind.Valid() {
 				return fmt.Errorf("channel %q has invalid %s field", id, name)
 			}
 			if _, duplicate := seen[key]; duplicate {

internal/channel/compiler.go

@@ -3,6 +3,7 @@ package channel
 import (
 	"encoding/json"
 	"fmt"
+	"slices"
 	"strings"
 
 	"gpt-load/internal/channel/spec"
@@ -254,9 +255,27 @@ func compileSchema(channelID string, name string, fields []spec.Field) (objectSc
 			return nil, fmt.Errorf("channel %q has duplicate %s field %q", channelID, name, field.Key)
 		}
 		seen[field.Key] = struct{}{}
-		if field.InputKind != spec.InputText && field.InputKind != spec.InputURL && field.InputKind != spec.InputSecret {
+		if !field.InputKind.Valid() {
 			return nil, fmt.Errorf("channel %q has invalid %s field %q input kind", channelID, name, field.Key)
 		}
+		var optionSeen map[string]struct{}
+		if field.InputKind == spec.InputSelect {
+			optionSeen = make(map[string]struct{}, len(field.Options))
+			for _, option := range field.Options {
+				if option == "" {
+					return nil, fmt.Errorf("channel %q has an empty select option for %s field %q", channelID, name, field.Key)
+				}
+				if _, duplicate := optionSeen[option]; duplicate {
+					return nil, fmt.Errorf("channel %q has duplicate select option %q for %s field %q", channelID, name, option, field.Key)
+				}
+				optionSeen[option] = struct{}{}
+			}
+			if len(optionSeen) == 0 {
+				return nil, fmt.Errorf("channel %q has select %s field %q without options", channelID, name, field.Key)
+			}
+		} else if len(field.Options) > 0 {
+			return nil, fmt.Errorf("channel %q has select options on non-select %s field %q", channelID, name, field.Key)
+		}
 		if field.Sensitive != (field.InputKind == spec.InputSecret) {
 			return nil, fmt.Errorf("channel %q has inconsistent %s field %q sensitivity", channelID, name, field.Key)
 		}
@@ -271,12 +290,18 @@ func compileSchema(channelID string, name string, fields []spec.Field) (objectSc
 			if err != nil {
 				return nil, fmt.Errorf("channel %q has invalid default for %s field %q: %w", channelID, name, field.Key, err)
 			}
+			if field.InputKind == spec.InputSelect {
+				if _, valid := optionSeen[defaultValue]; !valid {
+					return nil, fmt.Errorf("channel %q has a default outside the options of %s field %q", channelID, name, field.Key)
+				}
+			}
 			value := defaultValue
 			publicDefault = &value
 		}
 		result = append(result, fieldSpec{
 			descriptor: FieldDescriptor{
 				Key: field.Key, Label: field.Label, InputKind: field.InputKind,
+				Options:  slices.Clone(field.Options),
 				Required: field.Required, Sensitive: field.Sensitive, DefaultValue: publicDefault,
 			},
 			defaultValue: defaultValue,

internal/channel/modules/openai_compatible.go

@@ -19,10 +19,24 @@ func OpenAICompatible() spec.Module {
 				Type:            spec.ConnectionAPIKey,
 				CredentialInput: "batch_text",
 			},
-			Params: []spec.Field{{
-				Key: "base_url", Label: "Base URL", InputKind: spec.InputURL,
-				Required: true, Normalizer: spec.NormalizeBaseURL,
-			}},
+			Params: []spec.Field{
+				{
+					Key: "base_url", Label: "Base URL", InputKind: spec.InputURL,
+					Required: true, Normalizer: spec.NormalizeBaseURL,
+				},
+				// Key names are part of the stored group params contract;
+				// renaming them invalidates persisted rows.
+				{
+					Key: "reasoning_content_alias", Label: "Response Reasoning Alias",
+					InputKind: spec.InputSelect, Options: spec.ReasoningAliasResponseOptions,
+					Normalizer: spec.NormalizeResponseReasoningAlias,
+				},
+				{
+					Key: "request_reasoning_alias", Label: "Request Reasoning Alias",
+					InputKind: spec.InputSelect, Options: spec.ReasoningAliasOptions,
+					Normalizer: spec.NormalizeReasoningAlias,
+				},
+			},
 			Credentials: []spec.Field{{
 				Key: "api_key", Label: "API Key", InputKind: spec.InputSecret,
 				Required: true, Sensitive: true, Normalizer: spec.NormalizeNonEmpty,

internal/channel/reasoning_alias_params_test.go

@@ -0,0 +1,79 @@
+package channel
+
+import (
+	"encoding/json"
+	"testing"
+)
+
+func TestOpenAICompatibleReasoningAliasParamsNormalizeBothDirections(t *testing.T) {
+	registry := NewRegistry()
+	cases := []struct {
+		name   string
+		raw    string
+		key    string
+		want   string
+		wantOK bool
+	}{
+		{
+			name:   "request canonical rename direction",
+			raw:    `{"base_url":"https://example.com/v1","request_reasoning_alias":"reasoning_content_to_reasoning"}`,
+			key:    "request_reasoning_alias",
+			want:   "reasoning_content_to_reasoning",
+			wantOK: true,
+		},
+		{
+			name:   "request empty stays omitted",
+			raw:    `{"base_url":"https://example.com/v1","request_reasoning_alias":"  "}`,
+			key:    "request_reasoning_alias",
+			want:   "",
+			wantOK: false,
+		},
+		{
+			name:   "response duplicate accepted",
+			raw:    `{"base_url":"https://example.com/v1","reasoning_content_alias":"duplicate"}`,
+			key:    "reasoning_content_alias",
+			want:   "duplicate",
+			wantOK: true,
+		},
+		{
+			name:   "response off kept explicit",
+			raw:    `{"base_url":"https://example.com/v1","reasoning_content_alias":"off"}`,
+			key:    "reasoning_content_alias",
+			want:   "off",
+			wantOK: true,
+		},
+	}
+	for _, test := range cases {
+		t.Run(test.name, func(t *testing.T) {
+			params, err := registry.ValidateParams(OpenAICompatible, json.RawMessage(test.raw))
+			if err != nil {
+				t.Fatalf("ValidateParams error = %v", err)
+			}
+			got, ok := params.Value(test.key)
+			if ok != test.wantOK || got != test.want {
+				t.Fatalf("Value(%s) = %q, %t; want %q, %t", test.key, got, ok, test.want, test.wantOK)
+			}
+		})
+	}
+}
+
+func TestOpenAICompatibleReasoningAliasParamsRejectJunk(t *testing.T) {
+	registry := NewRegistry()
+	for _, raw := range []string{
+		`{"base_url":"https://example.com/v1","reasoning_content_alias":"maybe"}`,
+		`{"base_url":"https://example.com/v1","reasoning_content_alias":"true"}`,
+		`{"base_url":"https://example.com/v1","reasoning_content_alias":"reasoning_to_content"}`,
+		`{"base_url":"https://example.com/v1","request_reasoning_alias":"content_to_reasoning"}`,
+		`{"base_url":"https://example.com/v1","request_reasoning_alias":"duplicate"}`,
+		`{"base_url":"https://example.com/v1","request_reasoning_alias":"true"}`,
+		`{"base_url":"https://example.com/v1","request_reasoning_alias":"false"}`,
+		`{"base_url":"https://example.com/v1","request_reasoning_alias":true}`,
+		`{"base_url":"https://example.com/v1","reasoning_content_alias":"reasoning_content_to_reasoningx"}`,
+		`{"base_url":"https://example.com/v1","reasoning_content_alias":true}`,
+		`{"base_url":"https://example.com/v1","request_reasoning_alias":{"mode":"off"}}`,
+	} {
+		if _, err := registry.ValidateParams(OpenAICompatible, json.RawMessage(raw)); err == nil {
+			t.Fatalf("ValidateParams(%s) error = nil", raw)
+		}
+	}
+}

internal/channel/registry_test.go

@@ -141,12 +141,25 @@ func TestRegistryPublicDescriptorsContainSchemasButNoInternalOrSecretValues(t *t
 		t.Fatalf("openai credential field = %#v", credentialField)
 	}
 	compatible, ok := registry.Get(OpenAICompatible)
-	if !ok || len(compatible.ParamFields) != 1 {
+	if !ok || len(compatible.ParamFields) != 3 {
 		t.Fatalf("Get(openai_compatible) = %#v, %t", compatible, ok)
 	}
 	if field := compatible.ParamFields[0]; field.Key != "base_url" || field.InputKind != InputURL || !field.Required || field.Sensitive {
 		t.Fatalf("openai compatible param field = %#v", field)
 	}
+	for index, key := range []string{"reasoning_content_alias", "request_reasoning_alias"} {
+		field := compatible.ParamFields[index+1]
+		if field.Key != key || field.InputKind != InputSelect || field.Required || field.Sensitive {
+			t.Fatalf("openai compatible alias param %d = %#v", index, field)
+		}
+		expected := spec.ReasoningAliasOptions
+		if key == "reasoning_content_alias" {
+			expected = spec.ReasoningAliasResponseOptions
+		}
+		if strings.Join(field.Options, ",") != strings.Join(expected, ",") {
+			t.Fatalf("openai compatible alias param %d options = %v", index, field.Options)
+		}
+	}
 	encoded, err := json.Marshal(compatible)
 	if err != nil {
 		t.Fatalf("json.Marshal(descriptor) error = %v", err)

internal/channel/spec/definition.go

@@ -137,8 +137,54 @@ const (
 	InputText   InputKind = "text"
 	InputURL    InputKind = "url"
 	InputSecret InputKind = "secret"
+	InputSelect InputKind = "select"
 )
 
+// Valid reports whether the input kind is part of the public field contract.
+func (kind InputKind) Valid() bool {
+	switch kind {
+	case InputText, InputURL, InputSecret, InputSelect:
+		return true
+	default:
+		return false
+	}
+}
+
+// Canonical values shared by the OpenAI-compatible reasoning alias select
+// parameters. The strings are persisted in group params and read back by the
+// execution layer, so they are part of the on-disk contract. Renaming stays
+// on the request direction where the admin knows the one upstream spelling;
+// responses only ever see off and duplicate.
+const (
+	// ReasoningAliasOff forwards reasoning fields untouched in one direction.
+	ReasoningAliasOff = "off"
+	// ReasoningAliasReasoningToContent renames reasoning to reasoning_content
+	// in outbound requests.
+	ReasoningAliasReasoningToContent = "reasoning_to_content"
+	// ReasoningAliasContentToReasoning renames reasoning_content to reasoning
+	// in outbound requests.
+	ReasoningAliasContentToReasoning = "reasoning_content_to_reasoning"
+	// ReasoningAliasDuplicate copies whichever spelling is present to the
+	// other one so both survive in responses.
+	ReasoningAliasDuplicate = "duplicate"
+)
+
+// ReasoningAliasOptions lists the accepted canonical values of the request
+// reasoning alias select parameter, in presentation order.
+var ReasoningAliasOptions = []string{
+	ReasoningAliasOff,
+	ReasoningAliasReasoningToContent,
+	ReasoningAliasContentToReasoning,
+}
+
+// ReasoningAliasResponseOptions is the response select's option list. The
+// client spelling is unknown per request, so a rename forces a guess;
+// duplicate emits both instead.
+var ReasoningAliasResponseOptions = []string{
+	ReasoningAliasOff,
+	ReasoningAliasDuplicate,
+}
+
 // ValueNormalizer canonicalizes one field without retaining its input.
 type ValueNormalizer func(string) (string, error)
 
@@ -147,6 +193,7 @@ type Field struct {
 	Key        string
 	Label      string
 	InputKind  InputKind
+	Options    []string
 	Required   bool
 	Sensitive  bool
 	Default    string

internal/channel/spec/normalize.go

@@ -70,6 +70,37 @@ func NormalizeOptionalHTTPSBaseURL(value string) (string, error) {
 	return NormalizeHTTPSBaseURL(value)
 }
 
+// normalizeReasoningAliasOption canonicalizes one reasoning alias select
+// parameter to one of the given canonical options. An empty value stays
+// empty so the option can be omitted, which the execution layer treats as
+// off.
+func normalizeReasoningAliasOption(value string, options []string) (string, error) {
+	normalized := strings.ToLower(strings.TrimSpace(value))
+	if normalized == "" {
+		return "", nil
+	}
+	for _, option := range options {
+		if normalized == option {
+			return option, nil
+		}
+	}
+	return "", fmt.Errorf("must be one of %s", strings.Join(options, ", "))
+}
+
+// NormalizeReasoningAlias canonicalizes the request reasoning alias select
+// parameter to one of the ReasoningAliasOptions values. Duplicate is rejected
+// on this direction: the outbound upstream spelling is known, so emitting
+// both adds nothing a rename does not already cover.
+func NormalizeReasoningAlias(value string) (string, error) {
+	return normalizeReasoningAliasOption(value, ReasoningAliasOptions)
+}
+
+// NormalizeResponseReasoningAlias canonicalizes the response reasoning alias
+// select parameter to off or duplicate.
+func NormalizeResponseReasoningAlias(value string) (string, error) {
+	return normalizeReasoningAliasOption(value, ReasoningAliasResponseOptions)
+}
+
 // NormalizeCloudIdentifier rejects whitespace and control characters in a
 // provider-owned cloud configuration value.
 func NormalizeCloudIdentifier(value string) (string, error) {

internal/execution/bifrost/executor.go

@@ -22,6 +22,7 @@ import (
 	"gpt-load/internal/dialect"
 	"gpt-load/internal/execution"
 	"gpt-load/internal/execution/geminiimage"
+	"gpt-load/internal/execution/responsealias"
 	"gpt-load/internal/protocol"
 	"gpt-load/internal/reasoning"
 )
@@ -622,6 +623,13 @@ func (r *Runtime) prepare(spec execution.AttemptSpec, stream bool) (preparedAtte
 			}
 			return preparedAttempt{}, &failure
 		}
+		// Rename reasoning spellings in the outbound chat completions body
+		// before it reaches the passthrough transport. The typed request path
+		// rebuilds messages through the SDK and has no equivalent hook.
+		// Converted image requests carry a Gemini payload and never match.
+		if !convertedImages && needsRequestReasoningAlias(spec) {
+			body = responsealias.RewriteRequestMessages(body, requestReasoningAliasMode(spec))
+		}
 		passthroughPath := ""
 		if convertedImages {
 			body, err = geminiimage.ConvertRequest(body)